contrib/patch/patch.c

   1 /* patch - a program to apply diffs to original files */
   2
   3 /* $Id: patch.c,v 1.23 1997/07/05 10:32:23 eggert Exp $ */
   4
   5 /*
   6 Copyright 1984, 1985, 1986, 1987, 1988 Larry Wall
   7 Copyright 1989, 1990, 1991, 1992, 1993, 1997 Free Software Foundation, Inc.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; see the file COPYING.
  21 If not, write to the Free Software Foundation,
  22 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23 */
  24
  25 #define XTERN
  26 #include <common.h>
  27 #undef XTERN
  28 #define XTERN extern
  29 #include <argmatch.h>
  30 #include <backupfile.h>
  31 #include <getopt.h>
  32 #include <inp.h>
  33 #include <pch.h>
  34 #include <util.h>
  35 #include <version.h>
  36
  37 #if HAVE_UTIME_H
  38 # include <utime.h>
  39 #endif
  40 /* Some nonstandard hosts don't declare this structure even in <utime.h>.  */
  41 #if ! HAVE_STRUCT_UTIMBUF
  42 struct utimbuf
  43 {
  44   time_t actime;
  45   time_t modtime;
  46 };
  47 #endif
  48
  49 /* Output stream state.  */
  50 struct outstate
  51 {
  52   FILE *ofp;
  53   int after_newline;
  54   int zero_output;
  55 };
  56
  57 /* procedures */
  58
  59 static FILE *create_output_file PARAMS ((char const *));
  60 static LINENUM locate_hunk PARAMS ((LINENUM));
  61 static bool apply_hunk PARAMS ((struct outstate *, LINENUM));
  62 static bool copy_till PARAMS ((struct outstate *, LINENUM));
  63 static bool patch_match PARAMS ((LINENUM, LINENUM, LINENUM, LINENUM));
  64 static bool similar PARAMS ((char const *, size_t, char const *, size_t));
  65 static bool spew_output PARAMS ((struct outstate *));
  66 static char const *make_temp PARAMS ((int));
  67 static int numeric_string PARAMS ((char const *, int, char const *));
  68 static void abort_hunk PARAMS ((void));
  69 static void cleanup PARAMS ((void));
  70 static void get_some_switches PARAMS ((void));
  71 static void init_output PARAMS ((char const *, struct outstate *));
  72 static void init_reject PARAMS ((char const *));
  73 static void reinitialize_almost_everything PARAMS ((void));
  74 static void usage PARAMS ((FILE *, int)) __attribute__((noreturn));
  75
  76 static int make_backups;
  77 static int backup_if_mismatch;
  78 static char const *version_control;
  79 static int remove_empty_files;
  80
  81 /* TRUE if -R was specified on command line.  */
  82 static int reverse_flag_specified;
  83
  84 /* how many input lines have been irretractably output */
  85 static LINENUM last_frozen_line;
  86
  87 static char const *do_defines; /* symbol to patch using ifdef, ifndef, etc. */
  88 static char const if_defined[] = "\n#ifdef %s\n";
  89 static char const not_defined[] = "#ifndef %s\n";
  90 static char const else_defined[] = "\n#else\n";
  91 static char const end_defined[] = "\n#endif /* %s */\n";
  92
  93 static int Argc;
  94 static char * const *Argv;
  95
  96 static FILE *rejfp;  /* reject file pointer */
  97
  98 static char const *patchname;
  99 static char *rejname;
 100 static char const * volatile TMPREJNAME;
 101
 102 static LINENUM last_offset;
 103 static LINENUM maxfuzz = 2;
 104
 105 static char serrbuf[BUFSIZ];
 106
 107 char const program_name[] = "patch";
 108
 109 /* Apply a set of diffs as appropriate. */
 110
 111 int main PARAMS ((int, char **));
 112
 113 int
 114 main(argc,argv)
 115 int argc;
 116 char **argv;
 117 {
 118     char const *val;
 119     bool somefailed = FALSE;
 120     struct outstate outstate;
 121
 122     init_time ();
 123
 124     setbuf(stderr, serrbuf);
 125
 126     bufsize = 8 * 1024;
 127     buf = xmalloc (bufsize);
 128
 129     strippath = INT_MAX;
 130
 131     posixly_correct = getenv ("POSIXLY_CORRECT") != 0;
 132     backup_if_mismatch = ! posixly_correct;
 133     patch_get = ((val = getenv ("PATCH_GET"))
 134                  ? numeric_string (val, 1, "PATCH_GET value")
 135                  : posixly_correct - 1);
 136
 137     {
 138       char const *v = getenv ("SIMPLE_BACKUP_SUFFIX");
 139       if (v && *v)
 140         simple_backup_suffix = v;
 141     }
 142
 143     version_control = getenv ("PATCH_VERSION_CONTROL");
 144     if (! version_control)
 145       version_control = getenv ("VERSION_CONTROL");
 146
 147     /* Cons up the names of the global temporary files.
 148        Do this before `cleanup' can possibly be called (e.g. by `pfatal').  */
 149     TMPOUTNAME = make_temp ('o');
 150     TMPINNAME = make_temp ('i');
 151     TMPREJNAME = make_temp ('r');
 152     TMPPATNAME = make_temp ('p');
 153
 154     /* parse switches */
 155     Argc = argc;
 156     Argv = argv;
 157     get_some_switches();
 158
 159     if (make_backups | backup_if_mismatch)
 160       backup_type = get_version (version_control);
 161
 162     init_output (outfile, &outstate);
 163
 164     /* Make sure we clean up in case of disaster.  */
 165     set_signals(0);
 166
 167     for (
 168         open_patch_file (patchname);
 169         there_is_another_patch();
 170         reinitialize_almost_everything()
 171     ) {                                 /* for each patch in patch file */
 172       int hunk = 0;
 173       int failed = 0;
 174       int mismatch = 0;
 175       char *outname = outfile ? outfile : inname;
 176
 177       if (!skip_rest_of_patch)
 178         get_input_file (inname, outname);
 179
 180       if (diff_type == ED_DIFF) {
 181         outstate.zero_output = 0;
 182         if (! dry_run)
 183           {
 184             do_ed_script (outstate.ofp);
 185             if (! outfile)
 186               {
 187                 struct stat statbuf;
 188                 if (stat (TMPOUTNAME, &statbuf) != 0)
 189                   pfatal ("%s", TMPOUTNAME);
 190                 outstate.zero_output = statbuf.st_size == 0;
 191               }
 192           }
 193       } else {
 194         int got_hunk;
 195         int apply_anyway = 0;
 196
 197         /* initialize the patched file */
 198         if (! skip_rest_of_patch && ! outfile)
 199           init_output (TMPOUTNAME, &outstate);
 200
 201         /* initialize reject file */
 202         init_reject(TMPREJNAME);
 203
 204         /* find out where all the lines are */
 205         if (!skip_rest_of_patch)
 206             scan_input (inname);
 207
 208         /* from here on, open no standard i/o files, because malloc */
 209         /* might misfire and we can't catch it easily */
 210
 211         /* apply each hunk of patch */
 212         while (0 < (got_hunk = another_hunk (diff_type, reverse))) {
 213             LINENUM where = 0; /* Pacify `gcc -Wall'.  */
 214             LINENUM newwhere;
 215             LINENUM fuzz = 0;
 216             LINENUM prefix_context = pch_prefix_context ();
 217             LINENUM suffix_context = pch_suffix_context ();
 218             LINENUM context = (prefix_context < suffix_context
 219                                ? suffix_context : prefix_context);
 220             LINENUM mymaxfuzz = (maxfuzz < context ? maxfuzz : context);
 221             hunk++;
 222             if (!skip_rest_of_patch) {
 223                 do {
 224                     where = locate_hunk(fuzz);
 225                     if (! where || fuzz || last_offset)
 226                       mismatch = 1;
 227                     if (hunk == 1 && ! where && ! (force | apply_anyway)
 228                         && reverse == reverse_flag_specified) {
 229                                                 /* dwim for reversed patch? */
 230                         if (!pch_swap()) {
 231                             say (
 232 "Not enough memory to try swapped hunk!  Assuming unswapped.\n");
 233                             continue;
 234                         }
 235                         /* Try again.  */
 236                         where = locate_hunk (fuzz);
 237                         if (where
 238                             && (ok_to_reverse
 239                                 ("%s patch detected!",
 240                                  (reverse
 241                                   ? "Unreversed"
 242                                   : "Reversed (or previously applied)"))))
 243                           reverse ^= 1;
 244                         else
 245                           {
 246                             /* Put it back to normal.  */
 247                             if (! pch_swap ())
 248                               fatal ("lost hunk on alloc error!");
 249                             if (where)
 250                               {
 251                                 apply_anyway = 1;
 252                                 fuzz--; /* Undo `++fuzz' below.  */
 253                                 where = 0;
 254                               }
 255                           }
 256                     }
 257                 } while (!skip_rest_of_patch && !where
 258                          && ++fuzz <= mymaxfuzz);
 259
 260                 if (skip_rest_of_patch) {               /* just got decided */
 261                   if (outstate.ofp && ! outfile)
 262                     {
 263                       fclose (outstate.ofp);
 264                       outstate.ofp = 0;
 265                     }
 266                 }
 267             }
 268
 269             newwhere = pch_newfirst() + last_offset;
 270             if (skip_rest_of_patch) {
 271                 abort_hunk();
 272                 failed++;
 273                 if (verbosity == VERBOSE)
 274                     say ("Hunk #%d ignored at %ld.\n", hunk, newwhere);
 275             }
 276             else if (!where
 277                      || (where == 1 && pch_says_nonexistent (reverse)
 278                          && instat.st_size)) {
 279                 if (where)
 280                   say ("Patch attempted to create file `%s', which already exists.\n", inname);
 281                 abort_hunk();
 282                 failed++;
 283                 if (verbosity != SILENT)
 284                     say ("Hunk #%d FAILED at %ld.\n", hunk, newwhere);
 285             }
 286             else if (! apply_hunk (&outstate, where)) {
 287                 abort_hunk ();
 288                 failed++;
 289                 if (verbosity != SILENT)
 290                     say ("Hunk #%d FAILED at %ld.\n", hunk, newwhere);
 291             } else {
 292                 if (verbosity == VERBOSE
 293                     || (verbosity != SILENT && (fuzz || last_offset))) {
 294                     say ("Hunk #%d succeeded at %ld", hunk, newwhere);
 295                     if (fuzz)
 296                         say (" with fuzz %ld", fuzz);
 297                     if (last_offset)
 298                         say (" (offset %ld line%s)",
 299                             last_offset, last_offset==1?"":"s");
 300                     say (".\n");
 301                 }
 302             }
 303         }
 304
 305         if (got_hunk < 0  &&  using_plan_a) {
 306             if (outfile)
 307               fatal ("out of memory using Plan A");
 308             say ("\n\nRan out of memory using Plan A -- trying again...\n\n");
 309             if (outstate.ofp)
 310               {
 311                 fclose (outstate.ofp);
 312                 outstate.ofp = 0;
 313               }
 314             fclose (rejfp);
 315             continue;
 316         }
 317
 318         /* finish spewing out the new file */
 319         if (!skip_rest_of_patch)
 320           {
 321             assert (hunk);
 322             if (! spew_output (&outstate))
 323               {
 324                 say ("Skipping patch.\n");
 325                 skip_rest_of_patch = TRUE;
 326               }
 327           }
 328       }
 329
 330       /* and put the output where desired */
 331       ignore_signals ();
 332       if (! skip_rest_of_patch && ! outfile) {
 333           if (outstate.zero_output
 334               && (remove_empty_files
 335                   || (pch_says_nonexistent (reverse ^ 1) == 2
 336                       && ! posixly_correct)))
 337             {
 338               if (verbosity == VERBOSE)
 339                 say ("Removing file `%s'%s.\n", outname,
 340                      dry_run ? " and any empty ancestor directories" : "");
 341               if (! dry_run)
 342                 {
 343                   move_file ((char *) 0, outname, (mode_t) 0,
 344                              (make_backups
 345                               || (backup_if_mismatch && (mismatch | failed))));
 346                   removedirs (outname);
 347                 }
 348             }
 349           else
 350             {
 351               if (! outstate.zero_output
 352                   && pch_says_nonexistent (reverse ^ 1))
 353                 {
 354                   mismatch = 1;
 355                   if (verbosity != SILENT)
 356                     say ("File `%s' is not empty after patch, as expected.\n",
 357                          outname);
 358                 }
 359
 360               if (! dry_run)
 361                 {
 362                   time_t t;
 363
 364                   move_file (TMPOUTNAME, outname, instat.st_mode,
 365                              (make_backups
 366                               || (backup_if_mismatch && (mismatch | failed))));
 367
 368                   if ((set_time | set_utc)
 369                       && (t = pch_timestamp (reverse ^ 1)) != (time_t) -1)
 370                     {
 371                       struct utimbuf utimbuf;
 372                       utimbuf.actime = utimbuf.modtime = t;
 373
 374                       if (! force && ! inerrno
 375                           && ! pch_says_nonexistent (reverse)
 376                           && (t = pch_timestamp (reverse)) != (time_t) -1
 377                           && t != instat.st_mtime)
 378                         say ("not setting time of file `%s' (time mismatch)\n",
 379                              outname);
 380                       else if (! force && (mismatch | failed))
 381                         say ("not setting time of file `%s' (contents mismatch)\n",
 382                              outname);
 383                       else if (utime (outname, &utimbuf) != 0)
 384                         pfatal ("can't set timestamp on file `%s'", outname);
 385                     }
 386
 387                   if (! inerrno && chmod (outname, instat.st_mode) != 0)
 388                     pfatal ("can't set permissions on file `%s'", outname);
 389                 }
 390             }
 391       }
 392       if (diff_type != ED_DIFF) {
 393         if (fclose (rejfp) != 0)
 394             write_fatal ();
 395         if (failed) {
 396             somefailed = TRUE;
 397             say ("%d out of %d hunk%s %s", failed, hunk, "s" + (hunk == 1),
 398                  skip_rest_of_patch ? "ignored" : "FAILED");
 399             if (outname) {
 400                 char *rej = rejname;
 401                 if (!rejname) {
 402                     rej = xmalloc (strlen (outname) + 5);
 403                     strcpy (rej, outname);
 404                     addext (rej, ".rej", '#');
 405                 }
 406                 say (" -- saving rejects to %s", rej);
 407                 if (! dry_run)
 408                   {
 409                     move_file (TMPREJNAME, rej, instat.st_mode, FALSE);
 410                     if (! inerrno
 411                         && (chmod (rej, (instat.st_mode
 412                                          & ~(S_IXUSR|S_IXGRP|S_IXOTH)))
 413                             != 0))
 414                       pfatal ("can't set permissions on file `%s'", rej);
 415                   }
 416                 if (!rejname)
 417                     free (rej);
 418             }
 419             say ("\n");
 420         }
 421       }
 422       set_signals (1);
 423     }
 424     if (outstate.ofp && (ferror (outstate.ofp) || fclose (outstate.ofp) != 0))
 425       write_fatal ();
 426     cleanup ();
 427     if (somefailed)
 428       exit (1);
 429     return 0;
 430 }
 431
 432 /* Prepare to find the next patch to do in the patch file. */
 433
 434 static void
 435 reinitialize_almost_everything()
 436 {
 437     re_patch();
 438     re_input();
 439
 440     input_lines = 0;
 441     last_frozen_line = 0;
 442
 443     if (inname) {
 444         free (inname);
 445         inname = 0;
 446     }
 447
 448     last_offset = 0;
 449
 450     diff_type = NO_DIFF;
 451
 452     if (revision) {
 453         free(revision);
 454         revision = 0;
 455     }
 456
 457     reverse = reverse_flag_specified;
 458     skip_rest_of_patch = FALSE;
 459 }
 460
 461 static char const shortopts[] = "bB:cd:D:eEfF:g:i:lnNo:p:r:RstTuvV:x:Y:z:Z";
 462 static struct option const longopts[] =
 463 {
 464   {"backup", no_argument, NULL, 'b'},
 465   {"prefix", required_argument, NULL, 'B'},
 466   {"context", no_argument, NULL, 'c'},
 467   {"directory", required_argument, NULL, 'd'},
 468   {"ifdef", required_argument, NULL, 'D'},
 469   {"ed", no_argument, NULL, 'e'},
 470   {"remove-empty-files", no_argument, NULL, 'E'},
 471   {"force", no_argument, NULL, 'f'},
 472   {"fuzz", required_argument, NULL, 'F'},
 473   {"get", no_argument, NULL, 'g'},
 474   {"input", required_argument, NULL, 'i'},
 475   {"ignore-whitespace", no_argument, NULL, 'l'},
 476   {"normal", no_argument, NULL, 'n'},
 477   {"forward", no_argument, NULL, 'N'},
 478   {"output", required_argument, NULL, 'o'},
 479   {"strip", required_argument, NULL, 'p'},
 480   {"reject-file", required_argument, NULL, 'r'},
 481   {"reverse", no_argument, NULL, 'R'},
 482   {"quiet", no_argument, NULL, 's'},
 483   {"silent", no_argument, NULL, 's'},
 484   {"batch", no_argument, NULL, 't'},
 485   {"set-time", no_argument, NULL, 'T'},
 486   {"unified", no_argument, NULL, 'u'},
 487   {"version", no_argument, NULL, 'v'},
 488   {"version-control", required_argument, NULL, 'V'},
 489   {"debug", required_argument, NULL, 'x'},
 490   {"basename-prefix", required_argument, NULL, 'Y'},
 491   {"suffix", required_argument, NULL, 'z'},
 492   {"set-utc", no_argument, NULL, 'Z'},
 493   {"dry-run", no_argument, NULL, 129},
 494   {"verbose", no_argument, NULL, 130},
 495   {"binary", no_argument, NULL, 131},
 496   {"help", no_argument, NULL, 132},
 497   {"backup-if-mismatch", no_argument, NULL, 133},
 498   {"no-backup-if-mismatch", no_argument, NULL, 134},
 499   {NULL, no_argument, NULL, 0}
 500 };
 501
 502 static char const *const option_help[] =
 503 {
 504 "Input options:",
 505 "",
 506 "  -p NUM  --strip=NUM  Strip NUM leading components from file names.",
 507 "  -F LINES  --fuzz LINES  Set the fuzz factor to LINES for inexact matching.",
 508 "  -l  --ignore-whitespace  Ignore white space changes between patch and input.",
 509 "",
 510 "  -c  --context  Interpret the patch as a context difference.",
 511 "  -e  --ed  Interpret the patch as an ed script.",
 512 "  -n  --normal  Interpret the patch as a normal difference.",
 513 "  -u  --unified  Interpret the patch as a unified difference.",
 514 "",
 515 "  -N  --forward  Ignore patches that appear to be reversed or already applied.",
 516 "  -R  --reverse  Assume patches were created with old and new files swapped.",
 517 "",
 518 "  -i PATCHFILE  --input=PATCHFILE  Read patch from PATCHFILE instead of stdin.",
 519 "",
 520 "Output options:",
 521 "",
 522 "  -o FILE  --output=FILE  Output patched files to FILE.",
 523 "  -r FILE  --reject-file=FILE  Output rejects to FILE.",
 524 "",
 525 "  -D NAME  --ifdef=NAME  Make merged if-then-else output using NAME.",
 526 "  -E  --remove-empty-files  Remove output files that are empty after patching.",
 527 "",
 528 "  -Z  --set-utc  Set times of patched files, assuming diff uses UTC (GMT).",
 529 "  -T  --set-time  Likewise, assuming local time.",
 530 "",
 531 "Backup and version control options:",
 532 "",
 533 "  -b  --backup  Back up the original contents of each file.",
 534 "  --backup-if-mismatch  Back up if the patch does not match exactly.",
 535 "  --no-backup-if-mismatch  Back up mismatches only if otherwise requested.",
 536 "",
 537 "  -V STYLE  --version-control=STYLE  Use STYLE version control.",
 538 "       STYLE is either 'simple', 'numbered', or 'existing'.",
 539 "  -B PREFIX  --prefix=PREFIX  Prepend PREFIX to backup file names.",
 540 "  -Y PREFIX  --basename-prefix=PREFIX  Prepend PREFIX to backup file basenames.",
 541 "  -z SUFFIX  --suffix=SUFFIX  Append SUFFIX to backup file names.",
 542 "",
 543 "  -g NUM  --get=NUM  Get files from RCS or SCCS if positive; ask if negative.",
 544 "",
 545 "Miscellaneous options:",
 546 "",
 547 "  -t  --batch  Ask no questions; skip bad-Prereq patches; assume reversed.",
 548 "  -f  --force  Like -t, but ignore bad-Prereq patches, and assume unreversed.",
 549 "  -s  --quiet  --silent  Work silently unless an error occurs.",
 550 "  --verbose  Output extra information about the work being done.",
 551 "  --dry-run  Do not actually change any files; just print what would happen.",
 552 "",
 553 "  -d DIR  --directory=DIR  Change the working directory to DIR first.",
 554 #if HAVE_SETMODE
 555 "  --binary  Read and write data in binary mode.",
 556 #else
 557 "  --binary  Read and write data in binary mode (no effect on this platform).",
 558 #endif
 559 "",
 560 "  -v  --version  Output version info.",
 561 "  --help  Output this help.",
 562 "",
 563 "Report bugs to <bug-gnu-utils@prep.ai.mit.edu>.",
 564 0
 565 };
 566
 567 static void
 568 usage (stream, status)
 569      FILE *stream;
 570      int status;
 571 {
 572   char const * const *p;
 573
 574   if (status != 0)
 575     {
 576       fprintf (stream, "%s: Try `%s --help' for more information.\n",
 577                program_name, Argv[0]);
 578     }
 579   else
 580     {
 581       fprintf (stream, "Usage: %s [OPTION]... [ORIGFILE [PATCHFILE]]\n\n",
 582                Argv[0]);
 583       for (p = option_help;  *p;  p++)
 584         fprintf (stream, "%s\n", *p);
 585     }
 586
 587   exit (status);
 588 }
 589
 590 /* Process switches and filenames.  */
 591
 592 static void
 593 get_some_switches()
 594 {
 595     register int optc;
 596
 597     if (rejname)
 598         free (rejname);
 599     rejname = 0;
 600     if (optind == Argc)
 601         return;
 602     while ((optc = getopt_long (Argc, Argv, shortopts, longopts, (int *) 0))
 603            != -1) {
 604         switch (optc) {
 605             case 'b':
 606                 make_backups = 1;
 607                  /* Special hack for backward compatibility with CVS 1.9.
 608                     If the last 4 args are `-b SUFFIX ORIGFILE PATCHFILE',
 609                     treat `-b' as if it were `-b -z'.  */
 610                 if (Argc - optind == 3
 611                     && strcmp (Argv[optind - 1], "-b") == 0
 612                     && ! (Argv[optind + 0][0] == '-' && Argv[optind + 0][1])
 613                     && ! (Argv[optind + 1][0] == '-' && Argv[optind + 1][1])
 614                     && ! (Argv[optind + 2][0] == '-' && Argv[optind + 2][1]))
 615                   {
 616                     optarg = Argv[optind++];
 617                     if (verbosity != SILENT)
 618                       say ("warning: the `-b %s' option is obsolete; use `-b -z %s' instead\n",
 619                            optarg, optarg);
 620                     goto case_z;
 621                   }
 622                 break;
 623             case 'B':
 624                 if (!*optarg)
 625                   fatal ("backup prefix is empty");
 626                 origprae = savestr (optarg);
 627                 break;
 628             case 'c':
 629                 diff_type = CONTEXT_DIFF;
 630                 break;
 631             case 'd':
 632                 if (chdir(optarg) < 0)
 633                   pfatal ("can't change directory to `%s'", optarg);
 634                 break;
 635             case 'D':
 636                 do_defines = savestr (optarg);
 637                 break;
 638             case 'e':
 639                 diff_type = ED_DIFF;
 640                 break;
 641             case 'E':
 642                 remove_empty_files = TRUE;
 643                 break;
 644             case 'f':
 645                 force = TRUE;
 646                 break;
 647             case 'F':
 648                 maxfuzz = numeric_string (optarg, 0, "fuzz factor");
 649                 break;
 650             case 'g':
 651                 patch_get = numeric_string (optarg, 1, "get option value");
 652                 break;
 653             case 'i':
 654                 patchname = savestr (optarg);
 655                 break;
 656             case 'l':
 657                 canonicalize = TRUE;
 658                 break;
 659             case 'n':
 660                 diff_type = NORMAL_DIFF;
 661                 break;
 662             case 'N':
 663                 noreverse = TRUE;
 664                 break;
 665             case 'o':
 666                 if (strcmp (optarg, "-") == 0)
 667                   fatal ("can't output patches to standard output");
 668                 outfile = savestr (optarg);
 669                 break;
 670             case 'p':
 671                 strippath = numeric_string (optarg, 0, "strip count");
 672                 break;
 673             case 'r':
 674                 rejname = savestr (optarg);
 675                 break;
 676             case 'R':
 677                 reverse = 1;
 678                 reverse_flag_specified = 1;
 679                 break;
 680             case 's':
 681                 verbosity = SILENT;
 682                 break;
 683             case 't':
 684                 batch = TRUE;
 685                 break;
 686             case 'T':
 687                 set_time = 1;
 688                 break;
 689             case 'u':
 690                 diff_type = UNI_DIFF;
 691                 break;
 692             case 'v':
 693                 version();
 694                 exit (0);
 695                 break;
 696             case 'V':
 697                 version_control = optarg;
 698                 break;
 699 #if DEBUGGING
 700             case 'x':
 701                 debug = numeric_string (optarg, 1, "debugging option");
 702                 break;
 703 #endif
 704             case 'Y':
 705                 if (!*optarg)
 706                   fatal ("backup basename prefix is empty");
 707                 origbase = savestr (optarg);
 708                 break;
 709             case 'z':
 710             case_z:
 711                 if (!*optarg)
 712                   fatal ("backup suffix is empty");
 713                 simple_backup_suffix = savestr (optarg);
 714                 break;
 715             case 'Z':
 716                 set_utc = 1;
 717                 break;
 718             case 129:
 719                 dry_run = TRUE;
 720                 break;
 721             case 130:
 722                 verbosity = VERBOSE;
 723                 break;
 724             case 131:
 725 #if HAVE_SETMODE
 726                 binary_transput = O_BINARY;
 727 #endif
 728                 break;
 729             case 132:
 730                 usage (stdout, 0);
 731             case 133:
 732                 backup_if_mismatch = 1;
 733                 break;
 734             case 134:
 735                 backup_if_mismatch = 0;
 736                 break;
 737             default:
 738                 usage (stderr, 2);
 739         }
 740     }
 741
 742     /* Process any filename args.  */
 743     if (optind < Argc)
 744       {
 745         inname = savestr (Argv[optind++]);
 746         invc = -1;
 747         if (optind < Argc)
 748           {
 749             patchname = savestr (Argv[optind++]);
 750             if (optind < Argc)
 751               {
 752                 fprintf (stderr, "%s: extra operand `%s'\n",
 753                          program_name, Argv[optind]);
 754                 usage (stderr, 2);
 755               }
 756           }
 757       }
 758 }
 759
 760 /* Handle STRING (possibly negative if NEGATIVE_ALLOWED is nonzero)
 761    of type ARGTYPE_MSGID by converting it to an integer,
 762    returning the result.  */
 763 static int
 764 numeric_string (string, negative_allowed, argtype_msgid)
 765      char const *string;
 766      int negative_allowed;
 767      char const *argtype_msgid;
 768 {
 769   int value = 0;
 770   char const *p = string;
 771   int sign = *p == '-' ? -1 : 1;
 772
 773   p += *p == '-' || *p == '+';
 774
 775   do
 776     {
 777       int v10 = value * 10;
 778       int digit = *p - '0';
 779       int signed_digit = sign * digit;
 780       int next_value = v10 + signed_digit;
 781
 782       if (9 < (unsigned) digit)
 783         fatal ("%s `%s' is not a number", argtype_msgid, string);
 784
 785       if (v10 / 10 != value || (next_value < v10) != (signed_digit < 0))
 786         fatal ("%s `%s' is too large", argtype_msgid, string);
 787
 788       value = next_value;
 789     }
 790   while (*++p);
 791
 792   if (value < 0 && ! negative_allowed)
 793     fatal ("%s `%s' is negative", argtype_msgid, string);
 794
 795   return value;
 796 }
 797
 798 /* Attempt to find the right place to apply this hunk of patch. */
 799
 800 static LINENUM
 801 locate_hunk(fuzz)
 802 LINENUM fuzz;
 803 {
 804     register LINENUM first_guess = pch_first () + last_offset;
 805     register LINENUM offset;
 806     LINENUM pat_lines = pch_ptrn_lines();
 807     LINENUM prefix_context = pch_prefix_context ();
 808     LINENUM suffix_context = pch_suffix_context ();
 809     LINENUM context = (prefix_context < suffix_context
 810                        ? suffix_context : prefix_context);
 811     LINENUM prefix_fuzz = fuzz + prefix_context - context;
 812     LINENUM suffix_fuzz = fuzz + suffix_context - context;
 813     LINENUM max_where = input_lines - (pat_lines - suffix_fuzz) + 1;
 814     LINENUM min_where = last_frozen_line + 1 - (prefix_context - prefix_fuzz);
 815     LINENUM max_pos_offset = max_where - first_guess;
 816     LINENUM max_neg_offset = first_guess - min_where;
 817     LINENUM max_offset = (max_pos_offset < max_neg_offset
 818                           ? max_neg_offset : max_pos_offset);
 819
 820     if (!pat_lines)                     /* null range matches always */
 821         return first_guess;
 822
 823     /* Do not try lines <= 0.  */
 824     if (first_guess <= max_neg_offset)
 825         max_neg_offset = first_guess - 1;
 826
 827     if (prefix_fuzz < 0)
 828       {
 829         /* Can only match start of file.  */
 830
 831         if (suffix_fuzz < 0)
 832           /* Can only match entire file.  */
 833           if (pat_lines != input_lines || prefix_context < last_frozen_line)
 834             return 0;
 835
 836         offset = 1 - first_guess;
 837         if (last_frozen_line <= prefix_context
 838             && offset <= max_pos_offset
 839             && patch_match (first_guess, offset, (LINENUM) 0, suffix_fuzz))
 840           {
 841             last_offset = offset;
 842             return first_guess + offset;
 843           }
 844         else
 845           return 0;
 846       }
 847
 848     if (suffix_fuzz < 0)
 849       {
 850         /* Can only match end of file.  */
 851         offset = first_guess - (input_lines - pat_lines + 1);
 852         if (offset <= max_neg_offset
 853             && patch_match (first_guess, -offset, prefix_fuzz, (LINENUM) 0))
 854           {
 855             last_offset = - offset;
 856             return first_guess - offset;
 857           }
 858         else
 859           return 0;
 860       }
 861
 862     for (offset = 0;  offset <= max_offset;  offset++) {
 863         if (offset <= max_pos_offset
 864             && patch_match (first_guess, offset, prefix_fuzz, suffix_fuzz)) {
 865             if (debug & 1)
 866                 say ("Offset changing from %ld to %ld\n", last_offset, offset);
 867             last_offset = offset;
 868             return first_guess+offset;
 869         }
 870         if (0 < offset && offset <= max_neg_offset
 871             && patch_match (first_guess, -offset, prefix_fuzz, suffix_fuzz)) {
 872             if (debug & 1)
 873                 say ("Offset changing from %ld to %ld\n", last_offset, -offset);
 874             last_offset = -offset;
 875             return first_guess-offset;
 876         }
 877     }
 878     return 0;
 879 }
 880
 881 /* We did not find the pattern, dump out the hunk so they can handle it. */
 882
 883 static void
 884 abort_hunk()
 885 {
 886     register LINENUM i;
 887     register LINENUM pat_end = pch_end ();
 888     /* add in last_offset to guess the same as the previous successful hunk */
 889     LINENUM oldfirst = pch_first() + last_offset;
 890     LINENUM newfirst = pch_newfirst() + last_offset;
 891     LINENUM oldlast = oldfirst + pch_ptrn_lines() - 1;
 892     LINENUM newlast = newfirst + pch_repl_lines() - 1;
 893     char const *stars =
 894       (int) NEW_CONTEXT_DIFF <= (int) diff_type ? " ****" : "";
 895     char const *minuses =
 896       (int) NEW_CONTEXT_DIFF <= (int) diff_type ? " ----" : " -----";
 897
 898     fprintf(rejfp, "***************\n");
 899     for (i=0; i<=pat_end; i++) {
 900         switch (pch_char(i)) {
 901         case '*':
 902             if (oldlast < oldfirst)
 903                 fprintf(rejfp, "*** 0%s\n", stars);
 904             else if (oldlast == oldfirst)
 905                 fprintf(rejfp, "*** %ld%s\n", oldfirst, stars);
 906             else
 907                 fprintf(rejfp, "*** %ld,%ld%s\n", oldfirst, oldlast, stars);
 908             break;
 909         case '=':
 910             if (newlast < newfirst)
 911                 fprintf(rejfp, "--- 0%s\n", minuses);
 912             else if (newlast == newfirst)
 913                 fprintf(rejfp, "--- %ld%s\n", newfirst, minuses);
 914             else
 915                 fprintf(rejfp, "--- %ld,%ld%s\n", newfirst, newlast, minuses);
 916             break;
 917         case ' ': case '-': case '+': case '!':
 918             fprintf (rejfp, "%c ", pch_char (i));
 919             /* fall into */
 920         case '\n':
 921             pch_write_line (i, rejfp);
 922             break;
 923         default:
 924             fatal ("fatal internal error in abort_hunk");
 925         }
 926         if (ferror (rejfp))
 927           write_fatal ();
 928     }
 929 }
 930
 931 /* We found where to apply it (we hope), so do it. */
 932
 933 static bool
 934 apply_hunk (outstate, where)
 935      struct outstate *outstate;
 936      LINENUM where;
 937 {
 938     register LINENUM old = 1;
 939     register LINENUM lastline = pch_ptrn_lines ();
 940     register LINENUM new = lastline+1;
 941     register enum {OUTSIDE, IN_IFNDEF, IN_IFDEF, IN_ELSE} def_state = OUTSIDE;
 942     register char const *R_do_defines = do_defines;
 943     register LINENUM pat_end = pch_end ();
 944     register FILE *fp = outstate->ofp;
 945
 946     where--;
 947     while (pch_char(new) == '=' || pch_char(new) == '\n')
 948         new++;
 949
 950     while (old <= lastline) {
 951         if (pch_char(old) == '-') {
 952             assert (outstate->after_newline);
 953             if (! copy_till (outstate, where + old - 1))
 954                 return FALSE;
 955             if (R_do_defines) {
 956                 if (def_state == OUTSIDE) {
 957                     fprintf (fp, outstate->after_newline + if_defined,
 958                              R_do_defines);
 959                     def_state = IN_IFNDEF;
 960                 }
 961                 else if (def_state == IN_IFDEF) {
 962                     fprintf (fp, outstate->after_newline + else_defined);
 963                     def_state = IN_ELSE;
 964                 }
 965                 if (ferror (fp))
 966                   write_fatal ();
 967                 outstate->after_newline = pch_write_line (old, fp);
 968                 outstate->zero_output = 0;
 969             }
 970             last_frozen_line++;
 971             old++;
 972         }
 973         else if (new > pat_end) {
 974             break;
 975         }
 976         else if (pch_char(new) == '+') {
 977             if (! copy_till (outstate, where + old - 1))
 978                 return FALSE;
 979             if (R_do_defines) {
 980                 if (def_state == IN_IFNDEF) {
 981                     fprintf (fp, outstate->after_newline + else_defined);
 982                     def_state = IN_ELSE;
 983                 }
 984                 else if (def_state == OUTSIDE) {
 985                     fprintf (fp, outstate->after_newline + if_defined,
 986                              R_do_defines);
 987                     def_state = IN_IFDEF;
 988                 }
 989                 if (ferror (fp))
 990                   write_fatal ();
 991             }
 992             outstate->after_newline = pch_write_line (new, fp);
 993             outstate->zero_output = 0;
 994             new++;
 995         }
 996         else if (pch_char(new) != pch_char(old)) {
 997             if (debug & 1)
 998               say ("oldchar = '%c', newchar = '%c'\n",
 999                    pch_char (old), pch_char (new));
1000             fatal ("Out-of-sync patch, lines %ld,%ld -- mangled text or line numbers, maybe?",
1001                 pch_hunk_beg() + old,
1002                 pch_hunk_beg() + new);
1003         }
1004         else if (pch_char(new) == '!') {
1005             assert (outstate->after_newline);
1006             if (! copy_till (outstate, where + old - 1))
1007                 return FALSE;
1008             assert (outstate->after_newline);
1009             if (R_do_defines) {
1010                fprintf (fp, not_defined, R_do_defines);
1011                if (ferror (fp))
1012                 write_fatal ();
1013                def_state = IN_IFNDEF;
1014             }
1015
1016             do
1017               {
1018                 if (R_do_defines) {
1019                     outstate->after_newline = pch_write_line (old, fp);
1020                 }
1021                 last_frozen_line++;
1022                 old++;
1023               }
1024             while (pch_char (old) == '!');
1025
1026             if (R_do_defines) {
1027                 fprintf (fp, outstate->after_newline + else_defined);
1028                 if (ferror (fp))
1029                   write_fatal ();
1030                 def_state = IN_ELSE;
1031             }
1032
1033             do
1034               {
1035                 outstate->after_newline = pch_write_line (new, fp);
1036                 new++;
1037               }
1038             while (pch_char (new) == '!');
1039             outstate->zero_output = 0;
1040         }
1041         else {
1042             assert(pch_char(new) == ' ');
1043             old++;
1044             new++;
1045             if (R_do_defines && def_state != OUTSIDE) {
1046                 fprintf (fp, outstate->after_newline + end_defined,
1047                          R_do_defines);
1048                 if (ferror (fp))
1049                   write_fatal ();
1050                 outstate->after_newline = 1;
1051                 def_state = OUTSIDE;
1052             }
1053         }
1054     }
1055     if (new <= pat_end && pch_char(new) == '+') {
1056         if (! copy_till (outstate, where + old - 1))
1057             return FALSE;
1058         if (R_do_defines) {
1059             if (def_state == OUTSIDE) {
1060                 fprintf (fp, outstate->after_newline + if_defined,
1061                          R_do_defines);
1062                 def_state = IN_IFDEF;
1063             }
1064             else if (def_state == IN_IFNDEF) {
1065                 fprintf (fp, outstate->after_newline + else_defined);
1066                 def_state = IN_ELSE;
1067             }
1068             if (ferror (fp))
1069               write_fatal ();
1070             outstate->zero_output = 0;
1071         }
1072
1073         do
1074           {
1075             if (! outstate->after_newline  &&  putc ('\n', fp) == EOF)
1076               write_fatal ();
1077             outstate->after_newline = pch_write_line (new, fp);
1078             outstate->zero_output = 0;
1079             new++;
1080           }
1081         while (new <= pat_end && pch_char (new) == '+');
1082     }
1083     if (R_do_defines && def_state != OUTSIDE) {
1084         fprintf (fp, outstate->after_newline + end_defined, R_do_defines);
1085         if (ferror (fp))
1086           write_fatal ();
1087         outstate->after_newline = 1;
1088     }
1089     return TRUE;
1090 }
1091
1092 /* Create an output file.  */
1093
1094 static FILE *
1095 create_output_file (name)
1096      char const *name;
1097 {
1098   int fd = create_file (name, O_WRONLY | binary_transput, instat.st_mode);
1099   FILE *f = fdopen (fd, binary_transput ? "wb" : "w");
1100   if (! f)
1101     pfatal ("can't create `%s'", name);
1102   return f;
1103 }
1104
1105 /* Open the new file. */
1106
1107 static void
1108 init_output (name, outstate)
1109      char const *name;
1110      struct outstate *outstate;
1111 {
1112   outstate->ofp = name ? create_output_file (name) : (FILE *) 0;
1113   outstate->after_newline = 1;
1114   outstate->zero_output = 1;
1115 }
1116
1117 /* Open a file to put hunks we can't locate. */
1118
1119 static void
1120 init_reject(name)
1121      char const *name;
1122 {
1123   rejfp = create_output_file (name);
1124 }
1125
1126 /* Copy input file to output, up to wherever hunk is to be applied. */
1127
1128 static bool
1129 copy_till (outstate, lastline)
1130      register struct outstate *outstate;
1131      register LINENUM lastline;
1132 {
1133     register LINENUM R_last_frozen_line = last_frozen_line;
1134     register FILE *fp = outstate->ofp;
1135     register char const *s;
1136     size_t size;
1137
1138     if (R_last_frozen_line > lastline)
1139       {
1140         say ("misordered hunks! output would be garbled\n");
1141         return FALSE;
1142       }
1143     while (R_last_frozen_line < lastline)
1144       {
1145         s = ifetch (++R_last_frozen_line, 0, &size);
1146         if (size)
1147           {
1148             if ((! outstate->after_newline  &&  putc ('\n', fp) == EOF)
1149                 || ! fwrite (s, sizeof *s, size, fp))
1150               write_fatal ();
1151             outstate->after_newline = s[size - 1] == '\n';
1152             outstate->zero_output = 0;
1153           }
1154       }
1155     last_frozen_line = R_last_frozen_line;
1156     return TRUE;
1157 }
1158
1159 /* Finish copying the input file to the output file. */
1160
1161 static bool
1162 spew_output (outstate)
1163      struct outstate *outstate;
1164 {
1165     if (debug & 256)
1166       say ("il=%ld lfl=%ld\n", input_lines, last_frozen_line);
1167
1168     if (last_frozen_line < input_lines)
1169       if (! copy_till (outstate, input_lines))
1170         return FALSE;
1171
1172     if (outstate->ofp && ! outfile)
1173       {
1174         if (fclose (outstate->ofp) != 0)
1175           write_fatal ();
1176         outstate->ofp = 0;
1177       }
1178
1179     return TRUE;
1180 }
1181
1182 /* Does the patch pattern match at line base+offset? */
1183
1184 static bool
1185 patch_match (base, offset, prefix_fuzz, suffix_fuzz)
1186 LINENUM base;
1187 LINENUM offset;
1188 LINENUM prefix_fuzz;
1189 LINENUM suffix_fuzz;
1190 {
1191     register LINENUM pline = 1 + prefix_fuzz;
1192     register LINENUM iline;
1193     register LINENUM pat_lines = pch_ptrn_lines () - suffix_fuzz;
1194     size_t size;
1195     register char const *p;
1196
1197     for (iline=base+offset+prefix_fuzz; pline <= pat_lines; pline++,iline++) {
1198         p = ifetch (iline, offset >= 0, &size);
1199         if (canonicalize) {
1200             if (!similar(p, size,
1201                          pfetch(pline),
1202                          pch_line_len(pline) ))
1203                 return FALSE;
1204         }
1205         else if (size != pch_line_len (pline)
1206                  || memcmp (p, pfetch (pline), size) != 0)
1207             return FALSE;
1208     }
1209     return TRUE;
1210 }
1211
1212 /* Do two lines match with canonicalized white space? */
1213
1214 static bool
1215 similar (a, alen, b, blen)
1216      register char const *a;
1217      register size_t alen;
1218      register char const *b;
1219      register size_t blen;
1220 {
1221   /* Ignore presence or absence of trailing newlines.  */
1222   alen  -=  alen && a[alen - 1] == '\n';
1223   blen  -=  blen && b[blen - 1] == '\n';
1224
1225   for (;;)
1226     {
1227       if (!blen || (*b == ' ' || *b == '\t'))
1228         {
1229           while (blen && (*b == ' ' || *b == '\t'))
1230             b++, blen--;
1231           if (alen)
1232             {
1233               if (!(*a == ' ' || *a == '\t'))
1234                 return FALSE;
1235               do a++, alen--;
1236               while (alen && (*a == ' ' || *a == '\t'));
1237             }
1238           if (!alen || !blen)
1239             return alen == blen;
1240         }
1241       else if (!alen || *a++ != *b++)
1242         return FALSE;
1243       else
1244         alen--, blen--;
1245     }
1246 }
1247
1248 /* Make a temporary file.  */
1249
1250 #if HAVE_MKTEMP
1251 char *mktemp PARAMS ((char *));
1252 #endif
1253
1254 #ifndef TMPDIR
1255 #define TMPDIR "/tmp"
1256 #endif
1257
1258 static char const *
1259 make_temp (letter)
1260      int letter;
1261 {
1262   char *r;
1263 #if HAVE_MKTEMP
1264   char const *tmpdir = getenv ("TMPDIR");       /* Unix tradition */
1265   if (!tmpdir) tmpdir = getenv ("TMP");         /* DOS tradition */
1266   if (!tmpdir) tmpdir = getenv ("TEMP");        /* another DOS tradition */
1267   if (!tmpdir) tmpdir = TMPDIR;
1268   r = xmalloc (strlen (tmpdir) + 10);
1269   sprintf (r, "%s/p%cXXXXXX", tmpdir, letter);
1270   mktemp (r);
1271   if (!*r)
1272     pfatal ("mktemp");
1273 #else
1274   r = xmalloc (L_tmpnam);
1275   if (! (tmpnam (r) == r && *r))
1276     pfatal ("tmpnam");
1277 #endif
1278   return r;
1279 }
1280
1281 /* Fatal exit with cleanup. */
1282
1283 void
1284 fatal_exit (sig)
1285      int sig;
1286 {
1287   cleanup ();
1288
1289   if (sig)
1290     exit_with_signal (sig);
1291
1292   exit (2);
1293 }
1294
1295 static void
1296 cleanup ()
1297 {
1298   unlink (TMPINNAME);
1299   unlink (TMPOUTNAME);
1300   unlink (TMPPATNAME);
1301   unlink (TMPREJNAME);
1302 }