git.marmaro.de Git - mmh/blob - docs/historical/mh-6.8.5/miscellany/patch-2.0.12u8/patch.c

   1 char rcsid[] =
   2         "$Header: patch.c,v 2.0.2.0 90/05/01 22:17:50 davison Locked $";
   3
   4 /* patch - a program to apply diffs to original files
   5  *
   6  * Copyright 1986, Larry Wall
   7  *
   8  * This program may be copied as long as you don't try to make any
   9  * money off of it, or pretend that you wrote it.
  10  *
  11  * $Log:        patch.c,v $
  12  * Revision 2.0.2.0  90/05/01  22:17:50  davison
  13  * patch12u: unidiff support added
  14  *
  15  * Revision 2.0.1.6  88/06/22  20:46:39  lwall
  16  * patch12: rindex() wasn't declared
  17  *
  18  * Revision 2.0.1.5  88/06/03  15:09:37  lwall
  19  * patch10: exit code improved.
  20  * patch10: better support for non-flexfilenames.
  21  *
  22  * Revision 2.0.1.4  87/02/16  14:00:04  lwall
  23  * Short replacement caused spurious "Out of sync" message.
  24  *
  25  * Revision 2.0.1.3  87/01/30  22:45:50  lwall
  26  * Improved diagnostic on sync error.
  27  * Moved do_ed_script() to pch.c.
  28  *
  29  * Revision 2.0.1.2  86/11/21  09:39:15  lwall
  30  * Fuzz factor caused offset of installed lines.
  31  *
  32  * Revision 2.0.1.1  86/10/29  13:10:22  lwall
  33  * Backwards search could terminate prematurely.
  34  *
  35  * Revision 2.0  86/09/17  15:37:32  lwall
  36  * Baseline for netwide release.
  37  *
  38  * Revision 1.5  86/08/01  20:53:24  lwall
  39  * Changed some %d's to %ld's.
  40  * Linted.
  41  *
  42  * Revision 1.4  86/08/01  19:17:29  lwall
  43  * Fixes for machines that can't vararg.
  44  * Added fuzz factor.
  45  * Generalized -p.
  46  * General cleanup.
  47  *
  48  * 85/08/15 van%ucbmonet@berkeley
  49  * Changes for 4.3bsd diff -c.
  50  *
  51  * Revision 1.3  85/03/26  15:07:43  lwall
  52  * Frozen.
  53  *
  54  * Revision 1.2.1.9  85/03/12  17:03:35  lwall
  55  * Changed pfp->_file to fileno(pfp).
  56  *
  57  * Revision 1.2.1.8  85/03/12  16:30:43  lwall
  58  * Check i_ptr and i_womp to make sure they aren't null before freeing.
  59  * Also allow ed output to be suppressed.
  60  *
  61  * Revision 1.2.1.7  85/03/12  15:56:13  lwall
  62  * Added -p option from jromine@uci-750a.
  63  *
  64  * Revision 1.2.1.6  85/03/12  12:12:51  lwall
  65  * Now checks for normalness of file to patch.
  66  *
  67  * Revision 1.2.1.5  85/03/12  11:52:12  lwall
  68  * Added -D (#ifdef) option from joe@fluke.
  69  *
  70  * Revision 1.2.1.4  84/12/06  11:14:15  lwall
  71  * Made smarter about SCCS subdirectories.
  72  *
  73  * Revision 1.2.1.3  84/12/05  11:18:43  lwall
  74  * Added -l switch to do loose string comparison.
  75  *
  76  * Revision 1.2.1.2  84/12/04  09:47:13  lwall
  77  * Failed hunk count not reset on multiple patch file.
  78  *
  79  * Revision 1.2.1.1  84/12/04  09:42:37  lwall
  80  * Branch for sdcrdcf changes.
  81  *
  82  * Revision 1.2  84/11/29  13:29:51  lwall
  83  * Linted.  Identifiers uniqified.  Fixed i_ptr malloc() bug.  Fixed
  84  * multiple calls to mktemp().  Will now work on machines that can only
  85  * read 32767 chars.  Added -R option for diffs with new and old swapped.
  86  * Various cosmetic changes.
  87  *
  88  * Revision 1.1  84/11/09  17:03:58  lwall
  89  * Initial revision
  90  *
  91  */
  92
  93 #include "INTERN.h"
  94 #include "common.h"
  95 #include "EXTERN.h"
  96 #include "version.h"
  97 #include "util.h"
  98 #include "pch.h"
  99 #include "inp.h"
 100 #include "backupfile.h"
 101
 102 /* procedures */
 103
 104 void reinitialize_almost_everything();
 105 void get_some_switches();
 106 LINENUM locate_hunk();
 107 void abort_hunk();
 108 void apply_hunk();
 109 void init_output();
 110 void init_reject();
 111 void copy_till();
 112 void spew_output();
 113 void dump_line();
 114 bool patch_match();
 115 bool similar();
 116 void re_input();
 117 void my_exit();
 118
 119 /* TRUE if -E was specified on command line.  */
 120 static int remove_empty_files = FALSE;
 121
 122 /* TRUE if -R was specified on command line.  */
 123 static int reverse_flag_specified = FALSE;
 124
 125 /* Apply a set of diffs as appropriate. */
 126
 127 int
 128 main(argc,argv)
 129 int argc;
 130 char **argv;
 131 {
 132     LINENUM where;
 133     LINENUM newwhere;
 134     LINENUM fuzz;
 135     LINENUM mymaxfuzz;
 136     int hunk = 0;
 137     int failed = 0;
 138     int failtotal = 0;
 139     int i;
 140
 141     setbuf(stderr, serrbuf);
 142     for (i = 0; i<MAXFILEC; i++)
 143         filearg[i] = Nullch;
 144
 145     myuid = getuid();
 146
 147     /* Cons up the names of the temporary files.  */
 148     {
 149       /* Directory for temporary files.  */
 150       char *tmpdir;
 151       int tmpname_len;
 152
 153       tmpdir = getenv ("TMPDIR");
 154       if (tmpdir == NULL) {
 155         tmpdir = "/tmp";
 156       }
 157       tmpname_len = strlen (tmpdir) + 20;
 158
 159       TMPOUTNAME = (char *) malloc (tmpname_len);
 160       strcpy (TMPOUTNAME, tmpdir);
 161       strcat (TMPOUTNAME, "/patchoXXXXXX");
 162       Mktemp(TMPOUTNAME);
 163
 164       TMPINNAME = (char *) malloc (tmpname_len);
 165       strcpy (TMPINNAME, tmpdir);
 166       strcat (TMPINNAME, "/patchiXXXXXX");
 167       Mktemp(TMPINNAME);
 168
 169       TMPREJNAME = (char *) malloc (tmpname_len);
 170       strcpy (TMPREJNAME, tmpdir);
 171       strcat (TMPREJNAME, "/patchrXXXXXX");
 172       Mktemp(TMPREJNAME);
 173
 174       TMPPATNAME = (char *) malloc (tmpname_len);
 175       strcpy (TMPPATNAME, tmpdir);
 176       strcat (TMPPATNAME, "/patchpXXXXXX");
 177       Mktemp(TMPPATNAME);
 178     }
 179
 180     {
 181       char *v;
 182
 183       v = getenv ("SIMPLE_BACKUP_SUFFIX");
 184       if (v)
 185         simple_backup_suffix = v;
 186       else
 187         simple_backup_suffix = ORIGEXT;
 188 #ifndef NODIR
 189       v = getenv ("VERSION_CONTROL");
 190       backup_type = get_version (v); /* OK to pass NULL. */
 191 #endif
 192     }
 193
 194     /* parse switches */
 195     Argc = argc;
 196     Argv = argv;
 197     get_some_switches();
 198
 199     /* make sure we clean up /tmp in case of disaster */
 200     set_signals(0);
 201
 202     for (
 203         open_patch_file(filearg[1]);
 204         there_is_another_patch();
 205         reinitialize_almost_everything()
 206     ) {                                 /* for each patch in patch file */
 207
 208         if (outname == Nullch)
 209             outname = savestr(filearg[0]);
 210
 211         /* for ed script just up and do it and exit */
 212         if (diff_type == ED_DIFF) {
 213             do_ed_script();
 214             continue;
 215         }
 216
 217         /* initialize the patched file */
 218         if (!skip_rest_of_patch)
 219             init_output(TMPOUTNAME);
 220
 221         /* initialize reject file */
 222         init_reject(TMPREJNAME);
 223
 224         /* find out where all the lines are */
 225         if (!skip_rest_of_patch)
 226             scan_input(filearg[0]);
 227
 228         /* from here on, open no standard i/o files, because malloc */
 229         /* might misfire and we can't catch it easily */
 230
 231         /* apply each hunk of patch */
 232         hunk = 0;
 233         failed = 0;
 234         out_of_mem = FALSE;
 235         while (another_hunk()) {
 236             hunk++;
 237             fuzz = Nulline;
 238             mymaxfuzz = pch_context();
 239             if (maxfuzz < mymaxfuzz)
 240                 mymaxfuzz = maxfuzz;
 241             if (!skip_rest_of_patch) {
 242                 do {
 243                     where = locate_hunk(fuzz);
 244                     if (hunk == 1 && where == Nulline && !force) {
 245                                                 /* dwim for reversed patch? */
 246                         if (!pch_swap()) {
 247                             if (fuzz == Nulline)
 248                                 say1(
 249 "Not enough memory to try swapped hunk!  Assuming unswapped.\n");
 250                             continue;
 251                         }
 252                         reverse = !reverse;
 253                         where = locate_hunk(fuzz);  /* try again */
 254                         if (where == Nulline) {     /* didn't find it swapped */
 255                             if (!pch_swap())         /* put it back to normal */
 256                                 fatal1("lost hunk on alloc error!\n");
 257                             reverse = !reverse;
 258                         }
 259                         else if (noreverse) {
 260                             if (!pch_swap())         /* put it back to normal */
 261                                 fatal1("lost hunk on alloc error!\n");
 262                             reverse = !reverse;
 263                             say1(
 264 "Ignoring previously applied (or reversed) patch.\n");
 265                             skip_rest_of_patch = TRUE;
 266                         }
 267                         else if (batch) {
 268                             if (verbose)
 269                                 say3(
 270 "%seversed (or previously applied) patch detected!  %s -R.",
 271                                 reverse ? "R" : "Unr",
 272                                 reverse ? "Assuming" : "Ignoring");
 273                         }
 274                         else {
 275                             ask3(
 276 "%seversed (or previously applied) patch detected!  %s -R? [y] ",
 277                                 reverse ? "R" : "Unr",
 278                                 reverse ? "Assume" : "Ignore");
 279                             if (*buf == 'n') {
 280                                 ask1("Apply anyway? [n] ");
 281                                 if (*buf != 'y')
 282                                     skip_rest_of_patch = TRUE;
 283                                 where = Nulline;
 284                                 reverse = !reverse;
 285                                 if (!pch_swap())  /* put it back to normal */
 286                                     fatal1("lost hunk on alloc error!\n");
 287                             }
 288                         }
 289                     }
 290                 } while (!skip_rest_of_patch && where == Nulline &&
 291                     ++fuzz <= mymaxfuzz);
 292
 293                 if (skip_rest_of_patch) {               /* just got decided */
 294                     Fclose(ofp);
 295                     ofp = Nullfp;
 296                 }
 297             }
 298
 299             newwhere = pch_newfirst() + last_offset;
 300             if (skip_rest_of_patch) {
 301                 abort_hunk();
 302                 failed++;
 303                 if (verbose)
 304                     say3("Hunk #%d ignored at %ld.\n", hunk, newwhere);
 305             }
 306             else if (where == Nulline) {
 307                 abort_hunk();
 308                 failed++;
 309                 if (verbose)
 310                     say3("Hunk #%d failed at %ld.\n", hunk, newwhere);
 311             }
 312             else {
 313                 apply_hunk(where);
 314                 if (verbose) {
 315                     say3("Hunk #%d succeeded at %ld", hunk, newwhere);
 316                     if (fuzz)
 317                         say2(" with fuzz %ld", fuzz);
 318                     if (last_offset)
 319                         say3(" (offset %ld line%s)",
 320                             last_offset, last_offset==1L?"":"s");
 321                     say1(".\n");
 322                 }
 323             }
 324         }
 325
 326         if (out_of_mem && using_plan_a) {
 327             Argc = Argc_last;
 328             Argv = Argv_last;
 329             say1("\n\nRan out of memory using Plan A--trying again...\n\n");
 330             if (ofp)
 331                 Fclose(ofp);
 332             ofp = Nullfp;
 333             if (rejfp)
 334                 Fclose(rejfp);
 335             rejfp = Nullfp;
 336             continue;
 337         }
 338
 339         assert(hunk);
 340
 341         /* finish spewing out the new file */
 342         if (!skip_rest_of_patch)
 343             spew_output();
 344
 345         /* and put the output where desired */
 346         ignore_signals();
 347         if (!skip_rest_of_patch) {
 348             struct stat statbuf;
 349             char *realout = outname;
 350
 351             if (move_file(TMPOUTNAME, outname) < 0) {
 352                 toutkeep = TRUE;
 353                 realout = TMPOUTNAME;
 354                 chmod(TMPOUTNAME, filemode);
 355             }
 356             else
 357                 chmod(outname, filemode);
 358
 359             if (remove_empty_files && stat(realout, &statbuf) == 0
 360                 && statbuf.st_size == 0) {
 361                 if (verbose)
 362                     say2("Removing %s (empty after patching).\n", realout);
 363                 while (unlink(realout) >= 0) ; /* while is for Eunice.  */
 364             }
 365         }
 366         Fclose(rejfp);
 367         rejfp = Nullfp;
 368         if (failed) {
 369             failtotal += failed;
 370             if (!*rejname) {
 371                 Strcpy(rejname, outname);
 372 #ifndef FLEXFILENAMES
 373                 {
 374                     char *s = rindex(rejname,'/');
 375
 376                     if (!s)
 377                         s = rejname;
 378                     if (strlen(s) > 13)
 379                         if (s[12] == '.')       /* try to preserve difference */
 380                             s[12] = s[13];      /* between .h, .c, .y, etc. */
 381                         s[13] = '\0';
 382                 }
 383 #endif
 384                 Strcat(rejname, REJEXT);
 385             }
 386             if (skip_rest_of_patch) {
 387                 say4("%d out of %d hunks ignored--saving rejects to %s\n",
 388                     failed, hunk, rejname);
 389             }
 390             else {
 391                 say4("%d out of %d hunks failed--saving rejects to %s\n",
 392                     failed, hunk, rejname);
 393             }
 394             if (move_file(TMPREJNAME, rejname) < 0)
 395                 trejkeep = TRUE;
 396         }
 397         set_signals(1);
 398     }
 399     my_exit(failtotal);
 400 }
 401
 402 /* Prepare to find the next patch to do in the patch file. */
 403
 404 void
 405 reinitialize_almost_everything()
 406 {
 407     re_patch();
 408     re_input();
 409
 410     input_lines = 0;
 411     last_frozen_line = 0;
 412
 413     filec = 0;
 414     if (filearg[0] != Nullch && !out_of_mem) {
 415         free(filearg[0]);
 416         filearg[0] = Nullch;
 417     }
 418
 419     if (outname != Nullch) {
 420         free(outname);
 421         outname = Nullch;
 422     }
 423
 424     last_offset = 0;
 425
 426     diff_type = 0;
 427
 428     if (revision != Nullch) {
 429         free(revision);
 430         revision = Nullch;
 431     }
 432
 433     reverse = reverse_flag_specified;
 434     skip_rest_of_patch = FALSE;
 435
 436     get_some_switches();
 437
 438     if (filec >= 2)
 439         fatal1("you may not change to a different patch file\n");
 440 }
 441
 442 static char *
 443 nextarg()
 444 {
 445     if (!--Argc)
 446         fatal2("missing argument after `%s'\n", *Argv);
 447     return *++Argv;
 448 }
 449
 450 /* Process switches and filenames up to next '+' or end of list. */
 451
 452 void
 453 get_some_switches()
 454 {
 455     Reg1 char *s;
 456
 457     rejname[0] = '\0';
 458     Argc_last = Argc;
 459     Argv_last = Argv;
 460     if (!Argc)
 461         return;
 462     for (Argc--,Argv++; Argc; Argc--,Argv++) {
 463         s = Argv[0];
 464         if (strEQ(s, "+")) {
 465             return;                     /* + will be skipped by for loop */
 466         }
 467         if (*s != '-' || !s[1]) {
 468             if (filec == MAXFILEC)
 469                 fatal1("too many file arguments\n");
 470             filearg[filec++] = savestr(s);
 471         }
 472         else {
 473             switch (*++s) {
 474             case 'b':
 475                 simple_backup_suffix = savestr(nextarg());
 476                 break;
 477             case 'B':
 478                 origprae = savestr(nextarg());
 479                 break;
 480             case 'c':
 481                 diff_type = CONTEXT_DIFF;
 482                 break;
 483             case 'd':
 484                 if (!*++s)
 485                     s = nextarg();
 486                 if (chdir(s) < 0)
 487                     pfatal2("can't cd to %s", s);
 488                 break;
 489             case 'D':
 490                 do_defines = TRUE;
 491                 if (!*++s)
 492                     s = nextarg();
 493                 if (!isalpha(*s) && '_' != *s)
 494                     fatal1("argument to -D is not an identifier\n");
 495                 Sprintf(if_defined, "#ifdef %s\n", s);
 496                 Sprintf(not_defined, "#ifndef %s\n", s);
 497                 Sprintf(end_defined, "#endif /* %s */\n", s);
 498                 break;
 499             case 'e':
 500                 diff_type = ED_DIFF;
 501                 break;
 502             case 'E':
 503                 remove_empty_files = TRUE;
 504                 break;
 505             case 'f':
 506                 force = TRUE;
 507                 break;
 508             case 'F':
 509                 if (*++s == '=')
 510                     s++;
 511                 maxfuzz = atoi(s);
 512                 break;
 513             case 'l':
 514                 canonicalize = TRUE;
 515                 break;
 516             case 'n':
 517                 diff_type = NORMAL_DIFF;
 518                 break;
 519             case 'N':
 520                 noreverse = TRUE;
 521                 break;
 522             case 'o':
 523                 outname = savestr(nextarg());
 524                 break;
 525             case 'p':
 526                 if (*++s == '=')
 527                     s++;
 528                 strippath = atoi(s);
 529                 break;
 530             case 'r':
 531                 Strcpy(rejname, nextarg());
 532                 break;
 533             case 'R':
 534                 reverse = TRUE;
 535                 reverse_flag_specified = TRUE;
 536                 break;
 537             case 's':
 538                 verbose = FALSE;
 539                 break;
 540             case 'S':
 541                 skip_rest_of_patch = TRUE;
 542                 break;
 543             case 't':
 544                 batch = TRUE;
 545                 break;
 546             case 'u':
 547                 diff_type = UNI_DIFF;
 548                 break;
 549             case 'v':
 550                 version();
 551                 break;
 552             case 'V':
 553 #ifndef NODIR
 554                 backup_type = get_version (nextarg ());
 555 #endif
 556                 break;
 557 #ifdef DEBUGGING
 558             case 'x':
 559                 debug = atoi(s+1);
 560                 break;
 561 #endif
 562             default:
 563                 fprintf(stderr, "patch: unrecognized option `%s'\n", Argv[0]);
 564                 fprintf(stderr, "\
 565 Usage: patch [options] [origfile [patchfile]] [+ [options] [origfile]]...\n\
 566 Options:\n\
 567        [-ceEflnNRsStuv] [-b backup-ext] [-B backup-prefix] [-d directory]\n\
 568        [-D symbol] [-Fmax-fuzz] [-o out-file] [-p[strip-count]]\n\
 569        [-r rej-name] [-V {numbered,existing,simple}]\n");
 570                 my_exit(1);
 571             }
 572         }
 573     }
 574 }
 575
 576 /* Attempt to find the right place to apply this hunk of patch. */
 577
 578 LINENUM
 579 locate_hunk(fuzz)
 580 LINENUM fuzz;
 581 {
 582     Reg1 LINENUM first_guess = pch_first() + last_offset;
 583     Reg2 LINENUM offset;
 584     LINENUM pat_lines = pch_ptrn_lines();
 585     Reg3 LINENUM max_pos_offset = input_lines - first_guess
 586                                 - pat_lines + 1;
 587     Reg4 LINENUM max_neg_offset = first_guess - last_frozen_line - 1
 588                                 + pch_context();
 589
 590     if (!pat_lines)                     /* null range matches always */
 591         return first_guess;
 592     if (max_neg_offset >= first_guess)  /* do not try lines < 0 */
 593         max_neg_offset = first_guess - 1;
 594     if (first_guess <= input_lines && patch_match(first_guess, Nulline, fuzz))
 595         return first_guess;
 596     for (offset = 1; ; offset++) {
 597         Reg5 bool check_after = (offset <= max_pos_offset);
 598         Reg6 bool check_before = (offset <= max_neg_offset);
 599
 600         if (check_after && patch_match(first_guess, offset, fuzz)) {
 601 #ifdef DEBUGGING
 602             if (debug & 1)
 603                 say3("Offset changing from %ld to %ld\n", last_offset, offset);
 604 #endif
 605             last_offset = offset;
 606             return first_guess+offset;
 607         }
 608         else if (check_before && patch_match(first_guess, -offset, fuzz)) {
 609 #ifdef DEBUGGING
 610             if (debug & 1)
 611                 say3("Offset changing from %ld to %ld\n", last_offset, -offset);
 612 #endif
 613             last_offset = -offset;
 614             return first_guess-offset;
 615         }
 616         else if (!check_before && !check_after)
 617             return Nulline;
 618     }
 619 }
 620
 621 /* We did not find the pattern, dump out the hunk so they can handle it. */
 622
 623 void
 624 abort_hunk()
 625 {
 626     Reg1 LINENUM i;
 627     Reg2 LINENUM pat_end = pch_end();
 628     /* add in last_offset to guess the same as the previous successful hunk */
 629     LINENUM oldfirst = pch_first() + last_offset;
 630     LINENUM newfirst = pch_newfirst() + last_offset;
 631     LINENUM oldlast = oldfirst + pch_ptrn_lines() - 1;
 632     LINENUM newlast = newfirst + pch_repl_lines() - 1;
 633     char *stars = (diff_type >= NEW_CONTEXT_DIFF ? " ****" : "");
 634     char *minuses = (diff_type >= NEW_CONTEXT_DIFF ? " ----" : " -----");
 635
 636     fprintf(rejfp, "***************\n");
 637     for (i=0; i<=pat_end; i++) {
 638         switch (pch_char(i)) {
 639         case '*':
 640             if (oldlast < oldfirst)
 641                 fprintf(rejfp, "*** 0%s\n", stars);
 642             else if (oldlast == oldfirst)
 643                 fprintf(rejfp, "*** %ld%s\n", oldfirst, stars);
 644             else
 645                 fprintf(rejfp, "*** %ld,%ld%s\n", oldfirst, oldlast, stars);
 646             break;
 647         case '=':
 648             if (newlast < newfirst)
 649                 fprintf(rejfp, "--- 0%s\n", minuses);
 650             else if (newlast == newfirst)
 651                 fprintf(rejfp, "--- %ld%s\n", newfirst, minuses);
 652             else
 653                 fprintf(rejfp, "--- %ld,%ld%s\n", newfirst, newlast, minuses);
 654             break;
 655         case '\n':
 656             fprintf(rejfp, "%s", pfetch(i));
 657             break;
 658         case ' ': case '-': case '+': case '!':
 659             fprintf(rejfp, "%c %s", pch_char(i), pfetch(i));
 660             break;
 661         default:
 662             fatal1("fatal internal error in abort_hunk\n");
 663         }
 664     }
 665 }
 666
 667 /* We found where to apply it (we hope), so do it. */
 668
 669 void
 670 apply_hunk(where)
 671 LINENUM where;
 672 {
 673     Reg1 LINENUM old = 1;
 674     Reg2 LINENUM lastline = pch_ptrn_lines();
 675     Reg3 LINENUM new = lastline+1;
 676 #define OUTSIDE 0
 677 #define IN_IFNDEF 1
 678 #define IN_IFDEF 2
 679 #define IN_ELSE 3
 680     Reg4 int def_state = OUTSIDE;
 681     Reg5 bool R_do_defines = do_defines;
 682     Reg6 LINENUM pat_end = pch_end();
 683
 684     where--;
 685     while (pch_char(new) == '=' || pch_char(new) == '\n')
 686         new++;
 687
 688     while (old <= lastline) {
 689         if (pch_char(old) == '-') {
 690             copy_till(where + old - 1);
 691             if (R_do_defines) {
 692                 if (def_state == OUTSIDE) {
 693                     fputs(not_defined, ofp);
 694                     def_state = IN_IFNDEF;
 695                 }
 696                 else if (def_state == IN_IFDEF) {
 697                     fputs(else_defined, ofp);
 698                     def_state = IN_ELSE;
 699                 }
 700                 fputs(pfetch(old), ofp);
 701             }
 702             last_frozen_line++;
 703             old++;
 704         }
 705         else if (new > pat_end) {
 706             break;
 707         }
 708         else if (pch_char(new) == '+') {
 709             copy_till(where + old - 1);
 710             if (R_do_defines) {
 711                 if (def_state == IN_IFNDEF) {
 712                     fputs(else_defined, ofp);
 713                     def_state = IN_ELSE;
 714                 }
 715                 else if (def_state == OUTSIDE) {
 716                     fputs(if_defined, ofp);
 717                     def_state = IN_IFDEF;
 718                 }
 719             }
 720             fputs(pfetch(new), ofp);
 721             new++;
 722         }
 723         else if (pch_char(new) != pch_char(old)) {
 724             say3("Out-of-sync patch, lines %ld,%ld--mangled text or line numbers, maybe?\n",
 725                 pch_hunk_beg() + old,
 726                 pch_hunk_beg() + new);
 727 #ifdef DEBUGGING
 728             say3("oldchar = '%c', newchar = '%c'\n",
 729                 pch_char(old), pch_char(new));
 730 #endif
 731             my_exit(1);
 732         }
 733         else if (pch_char(new) == '!') {
 734             copy_till(where + old - 1);
 735             if (R_do_defines) {
 736                fputs(not_defined, ofp);
 737                def_state = IN_IFNDEF;
 738             }
 739             while (pch_char(old) == '!') {
 740                 if (R_do_defines) {
 741                     fputs(pfetch(old), ofp);
 742                 }
 743                 last_frozen_line++;
 744                 old++;
 745             }
 746             if (R_do_defines) {
 747                 fputs(else_defined, ofp);
 748                 def_state = IN_ELSE;
 749             }
 750             while (pch_char(new) == '!') {
 751                 fputs(pfetch(new), ofp);
 752                 new++;
 753             }
 754         }
 755         else {
 756             assert(pch_char(new) == ' ');
 757             old++;
 758             new++;
 759             if (R_do_defines && def_state != OUTSIDE) {
 760                 fputs(end_defined, ofp);
 761                 def_state = OUTSIDE;
 762             }
 763         }
 764     }
 765     if (new <= pat_end && pch_char(new) == '+') {
 766         copy_till(where + old - 1);
 767         if (R_do_defines) {
 768             if (def_state == OUTSIDE) {
 769                 fputs(if_defined, ofp);
 770                 def_state = IN_IFDEF;
 771             }
 772             else if (def_state == IN_IFNDEF) {
 773                 fputs(else_defined, ofp);
 774                 def_state = IN_ELSE;
 775             }
 776         }
 777         while (new <= pat_end && pch_char(new) == '+') {
 778             fputs(pfetch(new), ofp);
 779             new++;
 780         }
 781     }
 782     if (R_do_defines && def_state != OUTSIDE) {
 783         fputs(end_defined, ofp);
 784     }
 785 }
 786
 787 /* Open the new file. */
 788
 789 void
 790 init_output(name)
 791 char *name;
 792 {
 793     ofp = fopen(name, "w");
 794     if (ofp == Nullfp)
 795         pfatal2("can't create %s", name);
 796 }
 797
 798 /* Open a file to put hunks we can't locate. */
 799
 800 void
 801 init_reject(name)
 802 char *name;
 803 {
 804     rejfp = fopen(name, "w");
 805     if (rejfp == Nullfp)
 806         pfatal2("can't create %s", name);
 807 }
 808
 809 /* Copy input file to output, up to wherever hunk is to be applied. */
 810
 811 void
 812 copy_till(lastline)
 813 Reg1 LINENUM lastline;
 814 {
 815     Reg2 LINENUM R_last_frozen_line = last_frozen_line;
 816
 817     if (R_last_frozen_line > lastline)
 818         fatal1("misordered hunks! output would be garbled\n");
 819     while (R_last_frozen_line < lastline) {
 820         dump_line(++R_last_frozen_line);
 821     }
 822     last_frozen_line = R_last_frozen_line;
 823 }
 824
 825 /* Finish copying the input file to the output file. */
 826
 827 void
 828 spew_output()
 829 {
 830 #ifdef DEBUGGING
 831     if (debug & 256)
 832         say3("il=%ld lfl=%ld\n",input_lines,last_frozen_line);
 833 #endif
 834     if (input_lines)
 835         copy_till(input_lines);         /* dump remainder of file */
 836     Fclose(ofp);
 837     ofp = Nullfp;
 838 }
 839
 840 /* Copy one line from input to output. */
 841
 842 void
 843 dump_line(line)
 844 LINENUM line;
 845 {
 846     Reg1 char *s;
 847     Reg2 char R_newline = '\n';
 848
 849     /* Note: string is not null terminated. */
 850     for (s=ifetch(line, 0); putc(*s, ofp) != R_newline; s++) ;
 851 }
 852
 853 /* Does the patch pattern match at line base+offset? */
 854
 855 bool
 856 patch_match(base, offset, fuzz)
 857 LINENUM base;
 858 LINENUM offset;
 859 LINENUM fuzz;
 860 {
 861     Reg1 LINENUM pline = 1 + fuzz;
 862     Reg2 LINENUM iline;
 863     Reg3 LINENUM pat_lines = pch_ptrn_lines() - fuzz;
 864
 865     for (iline=base+offset+fuzz; pline <= pat_lines; pline++,iline++) {
 866         if (canonicalize) {
 867             if (!similar(ifetch(iline, (offset >= 0)),
 868                          pfetch(pline),
 869                          pch_line_len(pline) ))
 870                 return FALSE;
 871         }
 872         else if (strnNE(ifetch(iline, (offset >= 0)),
 873                    pfetch(pline),
 874                    pch_line_len(pline) ))
 875             return FALSE;
 876     }
 877     return TRUE;
 878 }
 879
 880 /* Do two lines match with canonicalized white space? */
 881
 882 bool
 883 similar(a,b,len)
 884 Reg1 char *a;
 885 Reg2 char *b;
 886 Reg3 int len;
 887 {
 888     while (len) {
 889         if (isspace(*b)) {              /* whitespace (or \n) to match? */
 890             if (!isspace(*a))           /* no corresponding whitespace? */
 891                 return FALSE;
 892             while (len && isspace(*b) && *b != '\n')
 893                 b++,len--;              /* skip pattern whitespace */
 894             while (isspace(*a) && *a != '\n')
 895                 a++;                    /* skip target whitespace */
 896             if (*a == '\n' || *b == '\n')
 897                 return (*a == *b);      /* should end in sync */
 898         }
 899         else if (*a++ != *b++)          /* match non-whitespace chars */
 900             return FALSE;
 901         else
 902             len--;                      /* probably not necessary */
 903     }
 904     return TRUE;                        /* actually, this is not reached */
 905                                         /* since there is always a \n */
 906 }
 907
 908 /* Exit with cleanup. */
 909
 910 void
 911 my_exit(status)
 912 int status;
 913 {
 914     Unlink(TMPINNAME);
 915     if (!toutkeep) {
 916         Unlink(TMPOUTNAME);
 917     }
 918     if (!trejkeep) {
 919         Unlink(TMPREJNAME);
 920     }
 921     Unlink(TMPPATNAME);
 922     exit(status);
 923 }