home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume39 / makepatch / part01 / makepatch.pl < prev    next >
Encoding:
Perl Script  |  1993-09-12  |  11.4 KB  |  449 lines
  1. #!/usr/local/bin/perl
  2. # makepatch.pl -- generate batch of patches.
  3. # SCCS Status     : @(#)@ makepatch.pl    1.8
  4. # Author          : Johan Vromans
  5. # Created On      : Tue Jul  7 20:39:39 1992
  6. # Last Modified By: Johan Vromans
  7. # Last Modified On: Sat Sep 11 23:00:27 1993
  8. # Update Count    : 129
  9. # Status          : Released to USEnet.
  10. #
  11. # Generate a patch from two files or directories.
  12. #
  13. # Resembles "diff -c -r -N", but:
  14. #
  15. #   - always recursive
  16. #   - handles 'patchlevel.h' first
  17. #   - supplies 'Index:' and 'Prereq:' lines
  18. #   - can use manifest file
  19. #   - generates shell commands to remove files
  20. #   - manipulates manifest files
  21. #
  22. ################################################################
  23. #
  24. # Usage:
  25. # 
  26. #   makepatch <old-dir> <new-dir
  27. # 
  28. #     This will compare all files in <new-dir> against the files in
  29. #     <old-dir>, and generate a bunch of patches to transform every
  30. #     file in <old-dir> into the corresponding one in <new-dir>.
  31. #     Files that appear in <new-dir> but not in <old-dir> are created.
  32. #     For files that appear in <old-dir> but not in <new-dir>
  33. #     'rm'-commands are generated at the beginning of the patch.
  34. # 
  35. # Using MANIFEST files:
  36. # 
  37. #   makepatch -oldmanifest <oldmanifest> -newmanifest <newmanifest> \
  38. #           <new-dir> <old-dir>
  39. # 
  40. #     <oldmanifest> and <newmanifest> list the files in <old-dir>
  41. #     and <new-dir> that are to be examined.
  42. #     Only the files that are named will be examined. 
  43. #     <oldmanifest> should contain the names of the files relative to
  44. #     <old-dir> and <newmanifest> should contain the names of the files
  45. #     relative to <new-dir>.
  46. # 
  47. #   makepatch -manifest <manifest> <new-dir> <old-dir>
  48. # 
  49. #     This is a simplified form of the above example.
  50. #     <manifest> applies to both <old-dir> and <new-dir>.
  51. # 
  52. #   makepatch -filelist [ -prefix xxx ] manifest
  53. #
  54. #     The filenames are extracted from the manifest file,
  55. #     optionally prefixed, sorted and written to standard output.
  56. #
  57. # Examples:
  58. # 
  59. #   % makepatch -verbose emacs-18.58 emacs-18.59 > emacs-18.58-18.59.diff
  60. # 
  61. #   % (cd emacs-18.58; find . -type f -print > MANIFEST)
  62. #   % (cd emacs-18.59; find . -type f -print > MANIFEST)
  63. #   % makepatch -verbose \
  64. #         -oldmanifest emacs-18.58/MANIFEST \
  65. #         -newmanifest emacs-18.59/MANIFEST \
  66. #         emacs-18.58 emacs-18.59 > emacs-18.58-18.59.diff
  67. #
  68. #   % makepatch -filelist -prefix emacs-18.59/ emacs-18.59/MANIFEST |
  69. #    gtar -zcvf emacs-18.59.tar.Z -T -
  70. #
  71. ################################################################
  72.  
  73. &stdio;
  74. &options;
  75. ($old, $new) = @ARGV;
  76.  
  77. print STDERR ("This is makepatch.pl version 1.8\n") if $opt_verbose;
  78.  
  79. if ( defined $opt_filelist ) {
  80.     @new = &domanifest (shift (@ARGV));
  81.     foreach ( @new ) {
  82.     print STDOUT ($opt_prefix, $_, "\n");
  83.     }
  84.     exit (0);
  85. }
  86.  
  87. $tmpfile = $ENV{"TMPDIR"} || "/usr/tmp";
  88. $thepatch = "$tmpfile/mp$$.p";
  89. $tmpfile .= "/mp$$.t";
  90. open (PATCH, ">$thepatch") || die ("$thepatch: $!\n");
  91. $patched = $created = 0;
  92. &doit ($old, $new);
  93. &wrapup;
  94. exit (0);
  95.  
  96. ################ Subroutines ################
  97.  
  98. sub doit {
  99.     local ($old, $new) = @_;
  100.  
  101.     if ( -f $old && -f $new ) {
  102.     # Two files.
  103.     if ( $opt_verbose ) {
  104.         print STDERR ("Old file = $old.\n",
  105.               "New file = $new.\n");
  106.     }
  107.     &dodiff ("", $old, "", $new);
  108.     }
  109.     elsif ( -f $old && -d $new ) {
  110.     # File and dir -> File and dir/File.
  111.     $new = ( $new =~ m|^\./?$| ) ? "" : "$new/";
  112.     if ( $opt_verbose ) {
  113.         print STDERR ("Old file = $old.\n",
  114.               "New file = $new$old.\n");
  115.     }
  116.     &dodiff ("", $old, $new, $old);
  117.     }
  118.     elsif ( -f $new && -d $old ) {
  119.     $old = ( $old =~ m|^\./?$| ) ? "" : "$old/";
  120.     if ( $opt_verbose ) {
  121.         print STDERR ("Old file = $old$new.\n",
  122.               "New file = $new.\n");
  123.     }
  124.     &dodiff ($old, $new, "", $new);
  125.     }
  126.     else {
  127.     # Should be two directories.
  128.     local (@old, @new);
  129.     if ( defined $opt_oldmanifest ) {
  130.         @old = &domanifest ($opt_oldmanifest);
  131.     }
  132.     else {
  133.         @old = &make_filelist ($old);
  134.     }
  135.     if ( defined $opt_newmanifest ) {
  136.         @new = &domanifest ($opt_newmanifest);
  137.     }
  138.     else {
  139.         @new = &make_filelist ($new);
  140.     }
  141.  
  142.     $new = ( $new =~ m|^\./?$| ) ? "" : "$new/";
  143.     $old = ( $old =~ m|^\./?$| ) ? "" : "$old/";
  144.  
  145.     if ( $opt_verbose ) {
  146.         local ($old) = $old; chop ($old);
  147.         local ($new) = $new; chop ($new);
  148.         print STDERR ("Old dir = $old, file list = ",
  149.               defined $opt_oldmanifest ? $opt_oldmanifest : "<*>",
  150.               ", ", 0+@old, " files.\n");
  151.         print STDERR ("New dir = $new, file list = ",
  152.               defined $opt_newmanifest ? $opt_newmanifest : "<*>",
  153.               ", ", 0+@new, " files.\n");
  154.     }
  155.     if ( $opt_debug ) {
  156.         print STDERR ("Old: @old\nNew: @new\n");
  157.     }
  158.  
  159.     # Handle patchlevel file first.
  160.     $opt_patchlevel = (grep (/patchlevel\.h/, @new))[0]
  161.         unless defined $opt_patchlevel;
  162.  
  163.     if ( defined $opt_patchlevel && $opt_patchlevel ne "" ) {
  164.         if ( ! -f "$new$opt_patchlevel" ) {
  165.         die ("$new$opt_patchlevel: $!\n");
  166.         }
  167.         if ( -f "$old$opt_patchlevel" ) {
  168.         &dodiff ($old, $opt_patchlevel, $new, $opt_patchlevel);
  169.         }
  170.         else {
  171.         $created++;
  172.         &dodiff ("", "/dev/null", $new, $opt_patchlevel);
  173.         }
  174.     }
  175.     else {
  176.         undef $opt_patchlevel;
  177.     }
  178.  
  179.     # Process the filelists.
  180.     while ( @old + @new ) {
  181.  
  182.         $o = shift (@old) unless defined $o;
  183.         $n = shift (@new) unless defined $n;
  184.         
  185.         if ( !defined $o || $o gt $n ) {
  186.         # New file.
  187.         if ( defined $opt_patchlevel && $n eq $opt_patchlevel ) {
  188.             undef $opt_patchlevel;
  189.         }
  190.         else {
  191.             $created++;
  192.             &dodiff ("", "/dev/null", $new, $n);
  193.         }
  194.         undef $n;
  195.         }
  196.         elsif ( !defined $n || $o lt $n ) {
  197.         # Obsolete (removed) file.
  198.         push (@goners, $o);
  199.         undef $o;
  200.         }
  201.         elsif ( $o eq $n ) {
  202.         # Same file.
  203.         if ( defined $opt_patchlevel && $n eq $opt_patchlevel ) {
  204.             undef $opt_patchlevel;
  205.         }
  206.         else {
  207.             &dodiff ($old, $o, $new, $n);
  208.         }
  209.         undef $n;
  210.         undef $o;
  211.         }
  212.     }
  213.     }
  214. }
  215.  
  216. sub make_filelist {
  217.     local ($dir, $disp) = @_;
  218.  
  219.     # Return a list of files, sorted, for this directory.
  220.     # Recurses.
  221.  
  222.     local (@ret);
  223.     local (*DIR);
  224.     local (@tmp);
  225.     local ($fname);
  226.  
  227.     $disp = "" unless defined $disp;
  228.  
  229.     print STDERR ("+ recurse $dir\n") if $opt_trace;
  230.     opendir (DIR, $dir) || die ("$dir: $!\n");
  231.     @tmp = sort (readdir (DIR));
  232.     closedir (DIR);
  233.     print STDERR ("Dir $dir: ", 0+@tmp, " entries\n") if $opt_debug;
  234.  
  235.     @ret = ();
  236.     foreach $file ( @tmp ) {
  237.  
  238.     # Skip unwanted files.
  239.     next if $file =~ /^\.\.?$/; # dot and dotdot
  240.     next if $file =~ /~$/;    # editor backup files
  241.  
  242.     # Push on the list.
  243.     $fname = "$dir/$file";
  244.     if ( -d $fname && ( $opt_follow || ! -l $fname ) ) {
  245.         # Recurse.
  246.         push (@ret, &make_filelist ($fname, "$disp$file/"));
  247.     }
  248.     elsif ( -f _ ) {
  249.         push (@ret, $disp . $file);
  250.     }
  251.     else {
  252.         print STDERR ("Ignored $fname: not a file\n");
  253.     }
  254.     }
  255.     @ret;
  256. }
  257.  
  258. sub domanifest {
  259.     local ($man) = @_;
  260.     local (*MAN);
  261.     local (@ret) = ();
  262.  
  263.     open (MAN, $man) || die ("$man: $!\n");
  264.     while ( <MAN> ) {
  265.     if ( $. == 2 && /^[-=_\s]*$/ ) {
  266.         @ret = ();
  267.         next;
  268.     }
  269.     next if /^#/;
  270.     next unless /\S/;
  271.     $_ = $` if /\s/;
  272.     push (@ret, $_);
  273.     }
  274.     close (MAN);
  275.     @ret = sort @ret unless defined $opt_nosort;
  276.     @ret;
  277. }
  278.  
  279. sub dodiff {
  280.     local ($olddir, $old, $newdir, $new) = @_;
  281.  
  282.     # Produce a patch hunk.
  283.  
  284.     local ($cmd) = "$opt_diff '$olddir$old' '$newdir$new'";
  285.     print STDERR ("+ ", $cmd, "\n") if $opt_trace;
  286.     $result = system ("$cmd > $tmpfile");
  287.     printf STDERR ("+> result = 0x%x\n", $result) 
  288.     if $result && $opt_debug;
  289.  
  290.     return unless $result == 0x100;    # no diffs
  291.     $patched++;
  292.  
  293.     # print PATCH ($cmd, "\n");
  294.     print PATCH ("Index: ", $new, "\n");
  295.  
  296.     # Try to find a prereq.
  297.     # The RCS code is based on a suggestion by jima@netcom.com, who also
  298.     # pointed out that patch requires blanks around the prereq string.
  299.     open (OLD, $olddir . $old);
  300.     while ( <OLD> ) {
  301.     next unless (/\@\(\#\)/        # SCCS header
  302.              || /\$Header:/     # RCS Header
  303.              || /\$Id:/);     # RCS Header
  304.     next unless $' =~ /\s\d+(\.\d+)*\s/; # e.g. 5.4
  305.     print PATCH ("Prereq: $&\n");
  306.     last;
  307.     }
  308.     close (OLD);
  309.  
  310.     # Copy patch.
  311.     open (TMP, $tmpfile);
  312.     print PATCH <TMP>;
  313.     close (TMP);
  314. }
  315.  
  316. sub wrapup {
  317.     if ( $opt_verbose ) {
  318.     local ($goners) = scalar (@goners);
  319.     print STDERR ("Collecting: $patched patch",
  320.               $patched == 1 ? "" : "es");
  321.     print STDERR (" ($created new file", 
  322.               $created == 1 ? "" : "s", ")") if $created;
  323.     print STDERR (", $goners goner", 
  324.               $goners == 1 ? "" : "s") if $goners;
  325.     print STDERR (".\n");
  326.     }
  327.     if ( @goners ) {
  328.     print STDOUT 
  329.         ("# Please remove the following file",
  330.          @goners == 1 ? "" : "s", " before applying this patch.\n",
  331.          "# (You can feed this patch to 'sh' to do so.)\n",
  332.          "\n");
  333.     foreach ( @goners ) {
  334.         print STDOUT ("rm -f ", $_, "\n");
  335.     }
  336.     print STDOUT ("exit\n\n");
  337.     }
  338.  
  339.     # Copy patch.
  340.     open (PATCH, $thepatch);
  341.     print while <PATCH>;
  342.     close (PATCH);
  343.  
  344.     # Cleanup.
  345.     unlink ($tmpfile, $thepatch);
  346. }
  347.  
  348. sub stdio {
  349.     # Since output to STDERR seems to be character based (and slow),
  350.     # we connect STDERR to STDOUT if they both point to the terminal.
  351.     if ( -t STDOUT && -t STDERR ) {
  352.     close (STDERR);
  353.     open (STDERR, '>&STDOUT');
  354.     select (STDERR); $| = 1;
  355.     select (STDOUT);
  356.     }
  357. }
  358.  
  359. sub options {
  360.     local ($opt_manifest);
  361.     local ($opt_quiet);
  362.  
  363.     # Defaults...
  364.     $opt_diff = "diff -c";
  365.     $opt_verbose = 1;
  366.     $opt_follow = 0;
  367.  
  368.     # Process options, if any...
  369.     if ( $ARGV[0] =~ /^-/ ) {
  370.     require "newgetopt.pl";
  371.  
  372.     # Aliases.
  373.     *opt_man = *opt_manifest;
  374.     *opt_oldman = *opt_oldmanifest;
  375.     *opt_newman = *opt_newmanifest;
  376.     *opt_v = *opt_verbose;
  377.     *opt_list = *opt_filelist;
  378.  
  379.     if ( ! &NGetOpt ("patchlevel=s", "diff=s", 
  380.              "manifest=s", "newmanifest=s", "oldmanifest=s",
  381.              "man=s", "newman=s", "oldman=s", "follow",
  382.              "list", "filelist", "prefix=s", "nosort",
  383.              "quiet", "verbose", "v", "help", "debug", "trace")
  384.         || defined $opt_help ) {
  385.         &usage;
  386.     }
  387.     $opt_trace = 1 if defined $opt_debug;
  388.     $opt_verbose = 0 if defined $opt_quiet;
  389.     if ( defined $opt_prefix ) {
  390.         die ("$0: option \"-prefix\" requires \"-filelist\"\n")
  391.         unless defined $opt_filelist;
  392.     }
  393.     if ( defined $opt_nosort ) {
  394.         die ("$0: option \"-nosort\" requires \"-filelist\"\n")
  395.         unless defined $opt_filelist;
  396.     }
  397.     if ( defined $opt_filelist ) {
  398.         die ("$0: option \"-filelist\" only uses \"-manifest\"\n")
  399.         if defined $opt_oldmanifest || defined $opt_newmanifest;
  400.     }
  401.     if ( defined $opt_manifest ) {
  402.         die ("$0: do not use \"-manifest\" with \"-oldmanifest\"".
  403.          " or \"-newmanifest\"\n")
  404.         if defined $opt_newmanifest || defined $opt_oldmanifest;
  405.         $opt_newmanifest = $opt_oldmanifest = $opt_manifest;
  406.     }
  407.     }
  408.  
  409.     # Argument check.
  410.     if ( defined $opt_filelist ) {
  411.     if ( defined $opt_manifest ) {
  412.         &usage if @ARGV;
  413.         @ARGV = ( $opt_manifest );
  414.     }
  415.     else {
  416.         &usage unless @ARGV == 1;
  417.     }
  418.     }
  419.     else {
  420.     &usage unless @ARGV == 2;
  421.     }
  422. }
  423.  
  424. sub usage {
  425.     print STDERR <<EoU;
  426. This is makepatch.pl version 1.8
  427.  
  428. Usage: $0 [options] old new
  429. Usage: $0 -filelist [ -prefix XXX ] [ -nosort ] [ -manifest ] file
  430.  
  431. Makepatch options:
  432.    -diff cmd        diff command to use, default \"$opt_diff\"
  433.    -patchlevel file    file to use as patchlevel.h
  434.    -man[ifest] file    list of files for old and new dir
  435.    -newman[ifest] file    list of files for new dir
  436.    -oldman[ifest] file    list of files for old dir
  437.    -follow        follow symbolic links
  438. Filelist options:
  439.    -[file]list        extract filenames from manifest file
  440.    -prefix XXX        add a prefix to these filenames
  441.    -nosort        do not sort manifest entries
  442. General options:
  443.    -verbose        verbose output (default)
  444.    -quiet        no verbose output
  445.    -help        this message
  446. EoU
  447.     exit (1);
  448. }
  449.