Added -clobber switch to mhstore(1) [Bug #11160].
[mmh] / 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 }