ShortenFiles.pl
上传用户:zhuqijet
上传日期:2013-06-25
资源大小:10074k
文件大小:6k
源码类别:

词法分析

开发平台:

Visual C++

  1. #!/usr/bin/perl
  2. #
  3. # ShortenFiles.pl
  4. #
  5. # Shorten file names to fit Mac HFS 31 character name limit. Names
  6. # are shortened using a table of hints.
  7. #
  8. #
  9. # $Log: ShortenFiles.pl,v $
  10. # Revision 1.6  2001/10/19 20:55:41  jberry
  11. # Add new file name shortening hints; chmod +x
  12. #
  13. # Revision 1.5  2001/06/10 19:37:40  jberry
  14. # Neaten formatting of output.
  15. #
  16. # Revision 1.4  2000/09/06 21:55:40  jberry
  17. # Allow ShortenFiles to work even when the destination directory already exists
  18. #
  19. #
  20. use Config;
  21. use FindBin;
  22. use File::Find;
  23. use File::Path;
  24. # Constants
  25. $kMaxLength = 31;
  26. # Globals
  27. $gScriptBase = $FindBin::RealBin;
  28. $gPathSep = GetPathSeparator();
  29. $gSrcBase = $gScriptBase.$gPathSep."src";
  30. $gDstBase = $gScriptBase.$gPathSep."MacSrc";
  31. # Map from unshortened to shortened name
  32. %gBadMap;
  33. # Hints for shortening names.
  34. # Hints are considered in order of occurance in list
  35. # until the name is adaquately shortened or there
  36. # are no more hints, in which case the name is
  37. # more rudely truncated.
  38. @gHints =
  39. (
  40. ["Exception", "Except" ],
  41. ["Implementation", "Impl" ],
  42. ["Reference", "Ref" ],
  43. ["Documentation", "Doc" ],
  44. ["Document", "Doc" ],
  45. ["Definition", "Def" ],
  46. ["Count", "Cnt" ],
  47. ["Entity", "Ent" ],
  48. ["Character", "Char" ],
  49. ["Processing", "Proc" ],
  50. ["Instruction", "Instr" ],
  51. ["Parent", "Par" ],
  52. ["Fragment", "Frag" ],
  53. ["Construction", "Constr" ],
  54. ["Default", "Def" ],
  55. ["Processor", "Proc" ],
  56. ["Compare", "Comp" ],
  57. ["Execution", "Exe" ],
  58. ["Functor", "Func" ],
  59. ["Collation", "Col" ],
  60. ["Element", "El" ],
  61. ["Datatype", "DT" ],
  62. ["Numeric", "Num" ],
  63. );
  64. sub GetPathSeparator
  65. {
  66. if ($^O eq 'MSWin32')
  67. {
  68. return '\';
  69. }
  70. elsif ($^O eq 'MacOS')
  71. {
  72. return ':';
  73. }
  74. else
  75. {
  76. return '/';
  77. }
  78. }
  79. sub ShortenName
  80. {
  81. $newName = $_;
  82. LOOP:
  83. while (length($newName) > $kMaxLength)
  84. {
  85. foreach $hint (@gHints)
  86. {
  87. $pattern = $hint->[0];
  88. $replacement = $hint->[1];
  89. if ($newName =~ s/$pattern/$replacement/)
  90. {
  91. #print "tmatched ".$hint->[0]."; replaced with ".$hint->[1]."n";
  92. next LOOP;
  93. }
  94. }
  95. # No hint found, so we need to shorten the name manually
  96. $kill = length($newName) - $kMaxLength + 1;
  97. substr($newName, $kMaxLength / 2, $kill) = "_";
  98. #print "tshorten manuallyn";
  99. }
  100. return $newName;
  101. }
  102. sub Gather
  103. {
  104. $path = $File::Find::name;
  105. $name = $_;
  106. if (-f $path)
  107. {
  108. if (length($name) > $kMaxLength)
  109. {
  110. #print "$name is too longn";
  111. $newName = ShortenName($name);
  112. #print "--> ".$newName."n";
  113. # Add an entry to our bad map
  114. $gBadMap{$name} = $newName
  115. }
  116. }
  117. else
  118. {
  119. #print "NOT A FILE: $File::Find::dir".$_."n";
  120. }
  121. }
  122. sub GatherBadFiles
  123. {
  124. find(&Gather, $gSrcBase);
  125. }
  126. sub Copy
  127. {
  128. # Caller wants $_ the same across this call
  129. $save_ = $_;
  130. $_ = "" if ($_ eq '.');
  131.  
  132. # remap the destination name as needed
  133. $srcName = $_;
  134. $dstName = $srcName;
  135. if (exists $gBadMap{$srcName})
  136. {
  137. $dstName = $gBadMap{$srcName};
  138. print "Renaming file $srcNament--> $dstNamen";
  139. }
  140. $srcPath = $File::Find::name;
  141. $dstPath = $srcPath;
  142. # Interpolate paths
  143. $dstPath =~ s/$srcName$/$dstName/;
  144. $dstPath =~ s/^$gSrcBase/$gDstBase/;
  145. #print "srcName $srcName, dstName $dstName, srcPath $srcPath, dstPath $dstPathn";
  146. if (-d $srcPath)
  147. {
  148. # make the dst directory if it doesn't already exist
  149. if (not -e $dstPath)
  150. {
  151. print "Making directory $dstPathn";
  152. mkpath($dstPath);
  153. }
  154. }
  155. else
  156. {
  157. # Copy the file, fixing up includes as we go
  158. # Open files
  159. open(SRC, "< $srcPath")         or die "can't open $srcPath: $!";
  160. open(DST, "> $dstPath")         or die "can't open $dstPath: $!";
  161. # Copy the file a line at a time
  162. while (<SRC>)
  163. {
  164. # Look for an include line
  165. if ( /^(s*)#(s*)include(s*)<(s*)(.*)(s*)>(.*)/
  166.  || /^(s*)#(s*)include(s*)"(s*)(.*)(s*)"(.*)/
  167.    )
  168. {
  169. # We've got the include file name (path).
  170. # Now isolate just the leaf of that
  171. $includePath = $5;
  172. $includePath =~ /^([^/]*/)*([^/]+)$/;
  173. $includeLeaf = $2;
  174. # Check for the include file in our bad map, replacing
  175. # it as necessary
  176. if (exists $gBadMap{$includeLeaf})
  177. {
  178. $dup = $_;
  179. $was = $includeLeaf;
  180. $sub = $gBadMap{$was};
  181. s/^(.*)include(.*)$was(.*)/$1include$2$sub$3/;
  182. print "file $srcName: changed include $includePathnt--> $_";
  183. #print "Change $dup to $_";
  184. }
  185. }
  186. # Output the modified (or not) line
  187. (print DST $_) or die "can't write to $dstPath: $!";
  188. }
  189. # Close 'dem files
  190. close(SRC)                  or die "can't close $srcPath: $!";
  191. close(DST)                   or die "can't close $dstPath: $!";
  192. }
  193. $_ = $save_;
  194. }
  195. sub CopyFiles
  196. {
  197. find(&Copy, $gSrcBase);
  198. }
  199. # Tell what we know:
  200. print "n";
  201. print "Script:                $0n";
  202. print "Source Directory:      $gSrcBasen";
  203. print "Destination Directory: $gDstBasen";
  204. print "n";
  205. #-- Scan phase
  206. #NOTE: we actually don't limit our processing to the file types listed here!!!
  207. #for each .cpp or .hpp or .c or .cc file in tree
  208. # if name too long
  209. # shorten the name
  210. # store it in a map
  211. # end if
  212. #end for
  213. # Gather up the bad files into global map gBadMap
  214. print "Scanning...n";
  215. undef %gBadMap;
  216. GatherBadFiles($srcBase);
  217. # Print bad map
  218. #print "BadMap:n";
  219. #foreach $key (sort(keys %gBadMap)) {
  220. # print $key, '=', $gBadMap{$key}, "n";
  221. #}
  222. #-- Copy/Modify phase
  223. #for each file in tree
  224. # copy file to new directory, scanning for include as we go
  225. # if include contains a name from the map
  226. # then replace it
  227. #end for
  228. print "Copying...n";
  229. CopyFiles($srcBase, $dstBase);
  230. print "nDonen";