Improve portability of patch(1):
[dragonfly.git] / usr.bin / patch / patch.c
1 /*
2  * $OpenBSD: patch.c,v 1.43 2004/11/19 20:08:11 otto Exp $
3  * $DragonFly: src/usr.bin/patch/patch.c,v 1.5 2006/04/10 08:11:43 joerg Exp $
4  */
5
6 /*
7  * patch - a program to apply diffs to original files
8  * 
9  * Copyright 1986, Larry Wall
10  * 
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following condition is met:
13  * 1. Redistributions of source code must retain the above copyright notice,
14  * this condition and the following disclaimer.
15  * 
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
20  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
23  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  * 
28  * -C option added in 1998, original code by Marc Espie, based on FreeBSD
29  * behaviour
30  */
31
32 #include <sys/types.h>
33 #include <sys/stat.h>
34
35 #include <ctype.h>
36 #include <getopt.h>
37 #include <limits.h>
38 #include <stdio.h>
39 #include <string.h>
40 #include <stdlib.h>
41 #include <unistd.h>
42
43 #include "common.h"
44 #include "util.h"
45 #include "pch.h"
46 #include "inp.h"
47 #include "backupfile.h"
48 #include "pathnames.h"
49
50 int             filemode = 0644;
51
52 char            buf[MAXLINELEN];        /* general purpose buffer */
53
54 bool            using_plan_a = true;    /* try to keep everything in memory */
55 bool            out_of_mem = false;     /* ran out of memory in plan a */
56
57 #define MAXFILEC 2
58
59 char            *filearg[MAXFILEC];
60 bool            ok_to_create_file = false;
61 char            *outname = NULL;
62 char            *origprae = NULL;
63 char            *TMPOUTNAME;
64 char            *TMPINNAME;
65 char            *TMPREJNAME;
66 char            *TMPPATNAME;
67 bool            toutkeep = false;
68 bool            trejkeep = false;
69 bool            warn_on_invalid_line;
70 bool            last_line_missing_eol;
71
72 #ifdef DEBUGGING
73 int             debug = 0;
74 #endif
75
76 bool            force = false;
77 bool            batch = false;
78 bool            verbose = true;
79 bool            reverse = false;
80 bool            noreverse = false;
81 bool            skip_rest_of_patch = false;
82 int             strippath = 957;
83 bool            canonicalize = false;
84 bool            check_only = false;
85 int             diff_type = 0;
86 char            *revision = NULL;       /* prerequisite revision, if any */
87 LINENUM         input_lines = 0;        /* how long is input file in lines */
88 int             posix = 0;              /* strict POSIX mode? */
89
90 static void     reinitialize_almost_everything(void);
91 static void     get_some_switches(void);
92 static LINENUM  locate_hunk(LINENUM);
93 static void     abort_context_hunk(void);
94 static void     rej_line(int, LINENUM);
95 static void     abort_hunk(void);
96 static void     apply_hunk(LINENUM);
97 static void     init_output(const char *);
98 static void     init_reject(const char *);
99 static void     copy_till(LINENUM, bool);
100 static void     spew_output(void);
101 static void     dump_line(LINENUM, bool);
102 static bool     patch_match(LINENUM, LINENUM, LINENUM);
103 static bool     similar(const char *, const char *, int);
104 static void     usage(void);
105
106 /* true if -E was specified on command line.  */
107 static bool     remove_empty_files = false;
108
109 /* true if -R was specified on command line.  */
110 static bool     reverse_flag_specified = false;
111
112 /* buffer holding the name of the rejected patch file. */
113 static char     rejname[NAME_MAX + 1];
114
115 /* buffer for stderr */
116 static char     serrbuf[BUFSIZ];
117
118 /* how many input lines have been irretractibly output */
119 static LINENUM  last_frozen_line = 0;
120
121 static int      Argc;           /* guess */
122 static char     **Argv;
123 static int      Argc_last;      /* for restarting plan_b */
124 static char     **Argv_last;
125
126 static FILE     *ofp = NULL;    /* output file pointer */
127 static FILE     *rejfp = NULL;  /* reject file pointer */
128
129 static int      filec = 0;      /* how many file arguments? */
130 static LINENUM  last_offset = 0;
131 static LINENUM  maxfuzz = 2;
132
133 /* patch using ifdef, ifndef, etc. */
134 static bool             do_defines = false;
135 /* #ifdef xyzzy */
136 static char             if_defined[128];
137 /* #ifndef xyzzy */
138 static char             not_defined[128];
139 /* #else */
140 static const char       else_defined[] = "#else\n";
141 /* #endif xyzzy */
142 static char             end_defined[128];
143
144
145 /* Apply a set of diffs as appropriate. */
146
147 int
148 main(int argc, char *argv[])
149 {
150         int     error = 0, hunk, failed, i, fd;
151         LINENUM where = 0, newwhere, fuzz, mymaxfuzz;
152         const   char *tmpdir;
153         char    *v;
154
155         setbuf(stderr, serrbuf);
156         for (i = 0; i < MAXFILEC; i++)
157                 filearg[i] = NULL;
158
159         /* Cons up the names of the temporary files.  */
160         if ((tmpdir = getenv("TMPDIR")) == NULL || *tmpdir == '\0')
161                 tmpdir = _PATH_TMP;
162         for (i = strlen(tmpdir) - 1; i > 0 && tmpdir[i] == '/'; i--)
163                 ;
164         i++;
165         if (asprintf(&TMPOUTNAME, "%.*s/patchoXXXXXXXXXX", i, tmpdir) == -1)
166                 fatal("cannot allocate memory");
167         if ((fd = mkstemp(TMPOUTNAME)) < 0)
168                 pfatal("can't create %s", TMPOUTNAME);
169         close(fd);
170
171         if (asprintf(&TMPINNAME, "%.*s/patchiXXXXXXXXXX", i, tmpdir) == -1)
172                 fatal("cannot allocate memory");
173         if ((fd = mkstemp(TMPINNAME)) < 0)
174                 pfatal("can't create %s", TMPINNAME);
175         close(fd);
176
177         if (asprintf(&TMPREJNAME, "%.*s/patchrXXXXXXXXXX", i, tmpdir) == -1)
178                 fatal("cannot allocate memory");
179         if ((fd = mkstemp(TMPREJNAME)) < 0)
180                 pfatal("can't create %s", TMPREJNAME);
181         close(fd);
182
183         if (asprintf(&TMPPATNAME, "%.*s/patchpXXXXXXXXXX", i, tmpdir) == -1)
184                 fatal("cannot allocate memory");
185         if ((fd = mkstemp(TMPPATNAME)) < 0)
186                 pfatal("can't create %s", TMPPATNAME);
187         close(fd);
188
189         v = getenv("SIMPLE_BACKUP_SUFFIX");
190         if (v)
191                 simple_backup_suffix = v;
192         else
193                 simple_backup_suffix = ORIGEXT;
194
195         /* parse switches */
196         Argc = argc;
197         Argv = argv;
198         get_some_switches();
199
200         if (backup_type == none) {
201                 if ((v = getenv("PATCH_VERSION_CONTROL")) == NULL)
202                         v = getenv("VERSION_CONTROL");
203                 if (v != NULL || !posix)
204                         backup_type = get_version(v);   /* OK to pass NULL. */
205         }
206
207         /* make sure we clean up /tmp in case of disaster */
208         set_signals(0);
209
210         for (open_patch_file(filearg[1]); there_is_another_patch();
211             reinitialize_almost_everything()) {
212                 /* for each patch in patch file */
213
214                 warn_on_invalid_line = true;
215
216                 if (outname == NULL)
217                         outname = savestr(filearg[0]);
218
219                 /* for ed script just up and do it and exit */
220                 if (diff_type == ED_DIFF) {
221                         do_ed_script();
222                         continue;
223                 }
224                 /* initialize the patched file */
225                 if (!skip_rest_of_patch)
226                         init_output(TMPOUTNAME);
227
228                 /* initialize reject file */
229                 init_reject(TMPREJNAME);
230
231                 /* find out where all the lines are */
232                 if (!skip_rest_of_patch)
233                         scan_input(filearg[0]);
234
235                 /* from here on, open no standard i/o files, because malloc */
236                 /* might misfire and we can't catch it easily */
237
238                 /* apply each hunk of patch */
239                 hunk = 0;
240                 failed = 0;
241                 out_of_mem = false;
242                 while (another_hunk()) {
243                         hunk++;
244                         fuzz = 0;
245                         mymaxfuzz = pch_context();
246                         if (maxfuzz < mymaxfuzz)
247                                 mymaxfuzz = maxfuzz;
248                         if (!skip_rest_of_patch) {
249                                 do {
250                                         where = locate_hunk(fuzz);
251                                         if (hunk == 1 && where == 0 && !force) {
252                                                 /* dwim for reversed patch? */
253                                                 if (!pch_swap()) {
254                                                         if (fuzz == 0)
255                                                                 say("Not enough memory to try swapped hunk!  Assuming unswapped.\n");
256                                                         continue;
257                                                 }
258                                                 reverse = !reverse;
259                                                 /* try again */
260                                                 where = locate_hunk(fuzz);
261                                                 if (where == 0) {
262                                                         /* didn't find it swapped */
263                                                         if (!pch_swap())
264                                                                 /* put it back to normal */
265                                                                 fatal("lost hunk on alloc error!\n");
266                                                         reverse = !reverse;
267                                                 } else if (noreverse) {
268                                                         if (!pch_swap())
269                                                                 /* put it back to normal */
270                                                                 fatal("lost hunk on alloc error!\n");
271                                                         reverse = !reverse;
272                                                         say("Ignoring previously applied (or reversed) patch.\n");
273                                                         skip_rest_of_patch = true;
274                                                 } else if (batch) {
275                                                         if (verbose)
276                                                                 say("%seversed (or previously applied) patch detected!  %s -R.",
277                                                                     reverse ? "R" : "Unr",
278                                                                     reverse ? "Assuming" : "Ignoring");
279                                                 } else {
280                                                         ask("%seversed (or previously applied) patch detected!  %s -R? [y] ",
281                                                             reverse ? "R" : "Unr",
282                                                             reverse ? "Assume" : "Ignore");
283                                                         if (*buf == 'n') {
284                                                                 ask("Apply anyway? [n] ");
285                                                                 if (*buf != 'y')
286                                                                         skip_rest_of_patch = true;
287                                                                 where = 0;
288                                                                 reverse = !reverse;
289                                                                 if (!pch_swap())
290                                                                         /* put it back to normal */
291                                                                         fatal("lost hunk on alloc error!\n");
292                                                         }
293                                                 }
294                                         }
295                                 } while (!skip_rest_of_patch && where == 0 &&
296                                     ++fuzz <= mymaxfuzz);
297
298                                 if (skip_rest_of_patch) {       /* just got decided */
299                                         fclose(ofp);
300                                         ofp = NULL;
301                                 }
302                         }
303                         newwhere = pch_newfirst() + last_offset;
304                         if (skip_rest_of_patch) {
305                                 abort_hunk();
306                                 failed++;
307                                 if (verbose)
308                                         say("Hunk #%d ignored at %ld.\n",
309                                             hunk, newwhere);
310                         } else if (where == 0) {
311                                 abort_hunk();
312                                 failed++;
313                                 if (verbose)
314                                         say("Hunk #%d failed at %ld.\n",
315                                             hunk, newwhere);
316                         } else {
317                                 apply_hunk(where);
318                                 if (verbose) {
319                                         say("Hunk #%d succeeded at %ld",
320                                             hunk, newwhere);
321                                         if (fuzz != 0)
322                                                 say(" with fuzz %ld", fuzz);
323                                         if (last_offset)
324                                                 say(" (offset %ld line%s)",
325                                                     last_offset,
326                                                     last_offset == 1L ? "" : "s");
327                                         say(".\n");
328                                 }
329                         }
330                 }
331
332                 if (out_of_mem && using_plan_a) {
333                         Argc = Argc_last;
334                         Argv = Argv_last;
335                         say("\n\nRan out of memory using Plan A--trying again...\n\n");
336                         if (ofp)
337                                 fclose(ofp);
338                         ofp = NULL;
339                         if (rejfp)
340                                 fclose(rejfp);
341                         rejfp = NULL;
342                         continue;
343                 }
344                 if (hunk == 0)
345                         fatal("Internal error: hunk should not be 0\n");
346
347                 /* finish spewing out the new file */
348                 if (!skip_rest_of_patch)
349                         spew_output();
350
351                 /* and put the output where desired */
352                 ignore_signals();
353                 if (!skip_rest_of_patch) {
354                         struct stat     statbuf;
355                         char    *realout = outname;
356
357                         if (!check_only) {
358                                 if (move_file(TMPOUTNAME, outname) < 0) {
359                                         toutkeep = true;
360                                         realout = TMPOUTNAME;
361                                         chmod(TMPOUTNAME, filemode);
362                                 } else
363                                         chmod(outname, filemode);
364
365                                 if (remove_empty_files &&
366                                     stat(realout, &statbuf) == 0 &&
367                                     statbuf.st_size == 0) {
368                                         if (verbose)
369                                                 say("Removing %s (empty after patching).\n",
370                                                     realout);
371                                         unlink(realout);
372                                 }
373                         }
374                 }
375                 fclose(rejfp);
376                 rejfp = NULL;
377                 if (failed) {
378                         error = 1;
379                         if (*rejname == '\0') {
380                                 if (strlcpy(rejname, outname,
381                                     sizeof(rejname)) >= sizeof(rejname))
382                                         fatal("filename %s is too long\n", outname);
383                                 if (strlcat(rejname, REJEXT,
384                                     sizeof(rejname)) >= sizeof(rejname))
385                                         fatal("filename %s is too long\n", outname);
386                         }
387                         if (skip_rest_of_patch) {
388                                 say("%d out of %d hunks ignored--saving rejects to %s\n",
389                                     failed, hunk, rejname);
390                         } else {
391                                 say("%d out of %d hunks failed--saving rejects to %s\n",
392                                     failed, hunk, rejname);
393                         }
394                         if (!check_only && move_file(TMPREJNAME, rejname) < 0)
395                                 trejkeep = true;
396                 }
397                 set_signals(1);
398         }
399         my_exit(error);
400         /* NOTREACHED */
401 }
402
403 /* Prepare to find the next patch to do in the patch file. */
404
405 static void
406 reinitialize_almost_everything(void)
407 {
408         re_patch();
409         re_input();
410
411         input_lines = 0;
412         last_frozen_line = 0;
413
414         filec = 0;
415         if (!out_of_mem) {
416                 free(filearg[0]);
417                 filearg[0] = NULL;
418         }
419
420         free(outname);
421         outname = NULL;
422
423         last_offset = 0;
424         diff_type = 0;
425
426         free(revision);
427         revision = NULL;
428
429         reverse = reverse_flag_specified;
430         skip_rest_of_patch = false;
431
432         get_some_switches();
433 }
434
435 /* Process switches and filenames. */
436
437 static void
438 get_some_switches(void)
439 {
440         const char *options = "b::B:cCd:D:eEfF:i:lnNo:p:r:RstuvV:x:z:";
441         static struct option longopts[] = {
442                 {"backup",              no_argument,            0,      'b'},
443                 {"batch",               no_argument,            0,      't'},
444                 {"check",               no_argument,            0,      'C'},
445                 {"context",             no_argument,            0,      'c'},
446                 {"debug",               required_argument,      0,      'x'},
447                 {"directory",           required_argument,      0,      'd'},
448                 {"ed",                  no_argument,            0,      'e'},
449                 {"force",               no_argument,            0,      'f'},
450                 {"forward",             no_argument,            0,      'N'},
451                 {"fuzz",                required_argument,      0,      'F'},
452                 {"ifdef",               required_argument,      0,      'D'},
453                 {"input",               required_argument,      0,      'i'},
454                 {"ignore-whitespace",   no_argument,            0,      'l'},
455                 {"normal",              no_argument,            0,      'n'},
456                 {"output",              required_argument,      0,      'o'},
457                 {"prefix",              required_argument,      0,      'B'},
458                 {"quiet",               no_argument,            0,      's'},
459                 {"reject-file",         required_argument,      0,      'r'},
460                 {"remove-empty-files",  no_argument,            0,      'E'},
461                 {"reverse",             no_argument,            0,      'R'},
462                 {"silent",              no_argument,            0,      's'},
463                 {"strip",               required_argument,      0,      'p'},
464                 {"suffix",              required_argument,      0,      'z'},
465                 {"unified",             no_argument,            0,      'u'},
466                 {"version",             no_argument,            0,      'v'},
467                 {"version-control",     required_argument,      0,      'V'},
468                 {"posix",               no_argument,            &posix, 1},
469                 {NULL,                  0,                      0,      0}
470         };
471         int ch;
472
473         rejname[0] = '\0';
474         Argc_last = Argc;
475         Argv_last = Argv;
476         if (!Argc)
477                 return;
478         optreset = optind = 1;
479         while ((ch = getopt_long(Argc, Argv, options, longopts, NULL)) != -1) {
480                 switch (ch) {
481                 case 'b':
482                         if (backup_type == none)
483                                 backup_type = numbered_existing;
484                         if (optarg == NULL)
485                                 break;
486                         if (verbose)
487                                 say("Warning, the ``-b suffix'' option has been"
488                                     " obsoleted by the -z option.\n");
489                         /* FALLTHROUGH */
490                 case 'z':
491                         /* must directly follow 'b' case for backwards compat */
492                         simple_backup_suffix = savestr(optarg);
493                         break;
494                 case 'B':
495                         origprae = savestr(optarg);
496                         break;
497                 case 'c':
498                         diff_type = CONTEXT_DIFF;
499                         break;
500                 case 'C':
501                         check_only = true;
502                         break;
503                 case 'd':
504                         if (chdir(optarg) < 0)
505                                 pfatal("can't cd to %s", optarg);
506                         break;
507                 case 'D':
508                         do_defines = true;
509                         if (!isalpha((unsigned char)*optarg) && *optarg != '_')
510                                 fatal("argument to -D is not an identifier\n");
511                         snprintf(if_defined, sizeof if_defined,
512                             "#ifdef %s\n", optarg);
513                         snprintf(not_defined, sizeof not_defined,
514                             "#ifndef %s\n", optarg);
515                         snprintf(end_defined, sizeof end_defined,
516                             "#endif /* %s */\n", optarg);
517                         break;
518                 case 'e':
519                         diff_type = ED_DIFF;
520                         break;
521                 case 'E':
522                         remove_empty_files = true;
523                         break;
524                 case 'f':
525                         force = true;
526                         break;
527                 case 'F':
528                         maxfuzz = atoi(optarg);
529                         break;
530                 case 'i':
531                         if (++filec == MAXFILEC)
532                                 fatal("too many file arguments\n");
533                         filearg[filec] = savestr(optarg);
534                         break;
535                 case 'l':
536                         canonicalize = true;
537                         break;
538                 case 'n':
539                         diff_type = NORMAL_DIFF;
540                         break;
541                 case 'N':
542                         noreverse = true;
543                         break;
544                 case 'o':
545                         outname = savestr(optarg);
546                         break;
547                 case 'p':
548                         strippath = atoi(optarg);
549                         break;
550                 case 'r':
551                         if (strlcpy(rejname, optarg,
552                             sizeof(rejname)) >= sizeof(rejname))
553                                 fatal("argument for -r is too long\n");
554                         break;
555                 case 'R':
556                         reverse = true;
557                         reverse_flag_specified = true;
558                         break;
559                 case 's':
560                         verbose = false;
561                         break;
562                 case 't':
563                         batch = true;
564                         break;
565                 case 'u':
566                         diff_type = UNI_DIFF;
567                         break;
568                 case 'v':
569                         version();
570                         break;
571                 case 'V':
572                         backup_type = get_version(optarg);
573                         break;
574 #ifdef DEBUGGING
575                 case 'x':
576                         debug = atoi(optarg);
577                         break;
578 #endif
579                 default:
580                         if (ch != '\0')
581                                 usage();
582                         break;
583                 }
584         }
585         Argc -= optind;
586         Argv += optind;
587
588         if (Argc > 0) {
589                 filearg[0] = savestr(*Argv++);
590                 Argc--;
591                 while (Argc > 0) {
592                         if (++filec == MAXFILEC)
593                                 fatal("too many file arguments\n");
594                         filearg[filec] = savestr(*Argv++);
595                         Argc--;
596                 }
597         }
598
599         if (getenv("POSIXLY_CORRECT") != NULL)
600                 posix = 1;
601 }
602
603 static void
604 usage(void)
605 {
606         fprintf(stderr,
607 "usage: patch [-bcCeEflnNRstuv] [-B backup-prefix] [-d directory] [-D symbol]\n"
608 "             [-F max-fuzz] [-i patchfile] [-o out-file] [-p strip-count]\n"
609 "             [-r rej-name] [-V {numbered,existing,simple}] [-z backup-ext]\n"
610 "             [origfile [patchfile]]\n");
611         my_exit(EXIT_SUCCESS);
612 }
613
614 /*
615  * Attempt to find the right place to apply this hunk of patch.
616  */
617 static LINENUM
618 locate_hunk(LINENUM fuzz)
619 {
620         LINENUM first_guess = pch_first() + last_offset;
621         LINENUM offset;
622         LINENUM pat_lines = pch_ptrn_lines();
623         LINENUM max_pos_offset = input_lines - first_guess - pat_lines + 1;
624         LINENUM max_neg_offset = first_guess - last_frozen_line - 1 + pch_context();
625
626         if (pat_lines == 0) {           /* null range matches always */
627                 if (verbose && fuzz == 0 && (diff_type == CONTEXT_DIFF
628                     || diff_type == NEW_CONTEXT_DIFF
629                     || diff_type == UNI_DIFF)) {
630                         say("Empty context always matches.\n");
631                 }
632                 if (diff_type == CONTEXT_DIFF
633                     || diff_type == NEW_CONTEXT_DIFF
634                     || diff_type == UNI_DIFF) {
635                         if (fuzz == 0)
636                                 return (input_lines == 0 ? first_guess : 0);
637                 } else
638                         return (first_guess);
639         }
640         if (max_neg_offset >= first_guess)      /* do not try lines < 0 */
641                 max_neg_offset = first_guess - 1;
642         if (first_guess <= input_lines && patch_match(first_guess, 0, fuzz))
643                 return first_guess;
644         for (offset = 1; ; offset++) {
645                 bool    check_after = (offset <= max_pos_offset);
646                 bool    check_before = (offset <= max_neg_offset);
647
648                 if (check_after && patch_match(first_guess, offset, fuzz)) {
649 #ifdef DEBUGGING
650                         if (debug & 1)
651                                 say("Offset changing from %ld to %ld\n",
652                                     last_offset, offset);
653 #endif
654                         last_offset = offset;
655                         return first_guess + offset;
656                 } else if (check_before && patch_match(first_guess, -offset, fuzz)) {
657 #ifdef DEBUGGING
658                         if (debug & 1)
659                                 say("Offset changing from %ld to %ld\n",
660                                     last_offset, -offset);
661 #endif
662                         last_offset = -offset;
663                         return first_guess - offset;
664                 } else if (!check_before && !check_after)
665                         return 0;
666         }
667 }
668
669 /* We did not find the pattern, dump out the hunk so they can handle it. */
670
671 static void
672 abort_context_hunk(void)
673 {
674         LINENUM i;
675         const LINENUM   pat_end = pch_end();
676         /*
677          * add in last_offset to guess the same as the previous successful
678          * hunk
679          */
680         const LINENUM   oldfirst = pch_first() + last_offset;
681         const LINENUM   newfirst = pch_newfirst() + last_offset;
682         const LINENUM   oldlast = oldfirst + pch_ptrn_lines() - 1;
683         const LINENUM   newlast = newfirst + pch_repl_lines() - 1;
684         const char      *stars = (diff_type >= NEW_CONTEXT_DIFF ? " ****" : "");
685         const char      *minuses = (diff_type >= NEW_CONTEXT_DIFF ? " ----" : " -----");
686
687         fprintf(rejfp, "***************\n");
688         for (i = 0; i <= pat_end; i++) {
689                 switch (pch_char(i)) {
690                 case '*':
691                         if (oldlast < oldfirst)
692                                 fprintf(rejfp, "*** 0%s\n", stars);
693                         else if (oldlast == oldfirst)
694                                 fprintf(rejfp, "*** %ld%s\n", oldfirst, stars);
695                         else
696                                 fprintf(rejfp, "*** %ld,%ld%s\n", oldfirst,
697                                     oldlast, stars);
698                         break;
699                 case '=':
700                         if (newlast < newfirst)
701                                 fprintf(rejfp, "--- 0%s\n", minuses);
702                         else if (newlast == newfirst)
703                                 fprintf(rejfp, "--- %ld%s\n", newfirst, minuses);
704                         else
705                                 fprintf(rejfp, "--- %ld,%ld%s\n", newfirst,
706                                     newlast, minuses);
707                         break;
708                 case '\n':
709                         fprintf(rejfp, "%s", pfetch(i));
710                         break;
711                 case ' ':
712                 case '-':
713                 case '+':
714                 case '!':
715                         fprintf(rejfp, "%c %s", pch_char(i), pfetch(i));
716                         break;
717                 default:
718                         fatal("fatal internal error in abort_context_hunk\n");
719                 }
720         }
721 }
722
723 static void
724 rej_line(int ch, LINENUM i)
725 {
726         size_t len;
727         const char *line = pfetch(i);
728
729         len = strlen(line);
730
731         fprintf(rejfp, "%c%s", ch, line);
732         if (len == 0 || line[len-1] != '\n')
733                 fprintf(rejfp, "\n\\ No newline at end of file\n");
734 }
735
736 static void
737 abort_hunk(void)
738 {
739         LINENUM         i, j, split;
740         int             ch1, ch2;
741         const LINENUM   pat_end = pch_end();
742         const LINENUM   oldfirst = pch_first() + last_offset;
743         const LINENUM   newfirst = pch_newfirst() + last_offset;
744
745         if (diff_type != UNI_DIFF) {
746                 abort_context_hunk();
747                 return;
748         }
749         split = -1;
750         for (i = 0; i <= pat_end; i++) {
751                 if (pch_char(i) == '=') {
752                         split = i;
753                         break;
754                 }
755         }
756         if (split == -1) {
757                 fprintf(rejfp, "malformed hunk: no split found\n");
758                 return;
759         }
760         i = 0;
761         j = split + 1;
762         fprintf(rejfp, "@@ -%ld,%ld +%ld,%ld @@\n",
763             pch_ptrn_lines() ? oldfirst : 0,
764             pch_ptrn_lines(), newfirst, pch_repl_lines());
765         while (i < split || j <= pat_end) {
766                 ch1 = i < split ? pch_char(i) : -1;
767                 ch2 = j <= pat_end ? pch_char(j) : -1;
768                 if (ch1 == '-') {
769                         rej_line('-', i);
770                         i++;
771                 } else if (ch1 == ' ' && ch2 == ' ') {
772                         rej_line(' ', i);
773                         i++;
774                         j++;
775                 } else if (ch1 == '!' && ch2 == '!') {
776                         while (i < split && ch1 == '!') {
777                                 rej_line('-', i);
778                                 i++;
779                                 ch1 = i < split ? pch_char(i) : -1;
780                         }
781                         while (j <= pat_end && ch2 == '!') {
782                                 rej_line('+', j);
783                                 j++;
784                                 ch2 = j <= pat_end ? pch_char(j) : -1;
785                         }
786                 } else if (ch1 == '*') {
787                         i++;
788                 } else if (ch2 == '+' || ch2 == ' ') {
789                         rej_line(ch2, j);
790                         j++;
791                 } else {
792                         fprintf(rejfp, "internal error on (%ld %ld %ld)\n",
793                             i, split, j);
794                         rej_line(ch1, i);
795                         rej_line(ch2, j);
796                         return;
797                 }
798         }
799 }
800
801 /* We found where to apply it (we hope), so do it. */
802
803 static void
804 apply_hunk(LINENUM where)
805 {
806         LINENUM         old = 1;
807         const LINENUM   lastline = pch_ptrn_lines();
808         LINENUM         new = lastline + 1;
809 #define OUTSIDE 0
810 #define IN_IFNDEF 1
811 #define IN_IFDEF 2
812 #define IN_ELSE 3
813         int             def_state = OUTSIDE;
814         const LINENUM   pat_end = pch_end();
815
816         where--;
817         while (pch_char(new) == '=' || pch_char(new) == '\n')
818                 new++;
819
820         while (old <= lastline) {
821                 if (pch_char(old) == '-') {
822                         copy_till(where + old - 1, false);
823                         if (do_defines) {
824                                 if (def_state == OUTSIDE) {
825                                         fputs(not_defined, ofp);
826                                         def_state = IN_IFNDEF;
827                                 } else if (def_state == IN_IFDEF) {
828                                         fputs(else_defined, ofp);
829                                         def_state = IN_ELSE;
830                                 }
831                                 fputs(pfetch(old), ofp);
832                         }
833                         last_frozen_line++;
834                         old++;
835                 } else if (new > pat_end) {
836                         break;
837                 } else if (pch_char(new) == '+') {
838                         copy_till(where + old - 1, false);
839                         if (do_defines) {
840                                 if (def_state == IN_IFNDEF) {
841                                         fputs(else_defined, ofp);
842                                         def_state = IN_ELSE;
843                                 } else if (def_state == OUTSIDE) {
844                                         fputs(if_defined, ofp);
845                                         def_state = IN_IFDEF;
846                                 }
847                         }
848                         fputs(pfetch(new), ofp);
849                         new++;
850                 } else if (pch_char(new) != pch_char(old)) {
851                         say("Out-of-sync patch, lines %ld,%ld--mangled text or line numbers, maybe?\n",
852                             pch_hunk_beg() + old,
853                             pch_hunk_beg() + new);
854 #ifdef DEBUGGING
855                         say("oldchar = '%c', newchar = '%c'\n",
856                             pch_char(old), pch_char(new));
857 #endif
858                         my_exit(2);
859                 } else if (pch_char(new) == '!') {
860                         copy_till(where + old - 1, false);
861                         if (do_defines) {
862                                 fputs(not_defined, ofp);
863                                 def_state = IN_IFNDEF;
864                         }
865                         while (pch_char(old) == '!') {
866                                 if (do_defines) {
867                                         fputs(pfetch(old), ofp);
868                                 }
869                                 last_frozen_line++;
870                                 old++;
871                         }
872                         if (do_defines) {
873                                 fputs(else_defined, ofp);
874                                 def_state = IN_ELSE;
875                         }
876                         while (pch_char(new) == '!') {
877                                 fputs(pfetch(new), ofp);
878                                 new++;
879                         }
880                 } else {
881                         if (pch_char(new) != ' ')
882                                 fatal("Internal error: expected ' '\n");
883                         old++;
884                         new++;
885                         if (do_defines && def_state != OUTSIDE) {
886                                 fputs(end_defined, ofp);
887                                 def_state = OUTSIDE;
888                         }
889                 }
890         }
891         if (new <= pat_end && pch_char(new) == '+') {
892                 copy_till(where + old - 1, false);
893                 if (do_defines) {
894                         if (def_state == OUTSIDE) {
895                                 fputs(if_defined, ofp);
896                                 def_state = IN_IFDEF;
897                         } else if (def_state == IN_IFNDEF) {
898                                 fputs(else_defined, ofp);
899                                 def_state = IN_ELSE;
900                         }
901                 }
902                 while (new <= pat_end && pch_char(new) == '+') {
903                         fputs(pfetch(new), ofp);
904                         new++;
905                 }
906         }
907         if (do_defines && def_state != OUTSIDE) {
908                 fputs(end_defined, ofp);
909         }
910 }
911
912 /*
913  * Open the new file.
914  */
915 static void
916 init_output(const char *name)
917 {
918         ofp = fopen(name, "w");
919         if (ofp == NULL)
920                 pfatal("can't create %s", name);
921 }
922
923 /*
924  * Open a file to put hunks we can't locate.
925  */
926 static void
927 init_reject(const char *name)
928 {
929         rejfp = fopen(name, "w");
930         if (rejfp == NULL)
931                 pfatal("can't create %s", name);
932 }
933
934 /*
935  * Copy input file to output, up to wherever hunk is to be applied.
936  * If endoffile is true, treat the last line specially since it may
937  * lack a newline.
938  */
939 static void
940 copy_till(LINENUM lastline, bool endoffile)
941 {
942         if (last_frozen_line > lastline)
943                 fatal("misordered hunks! output would be garbled\n");
944         while (last_frozen_line < lastline) {
945                 if (++last_frozen_line == lastline && endoffile)
946                         dump_line(last_frozen_line, !last_line_missing_eol);
947                 else
948                         dump_line(last_frozen_line, true);
949         }
950 }
951
952 /*
953  * Finish copying the input file to the output file.
954  */
955 static void
956 spew_output(void)
957 {
958 #ifdef DEBUGGING
959         if (debug & 256)
960                 say("il=%ld lfl=%ld\n", input_lines, last_frozen_line);
961 #endif
962         if (input_lines)
963                 copy_till(input_lines, true);   /* dump remainder of file */
964         fclose(ofp);
965         ofp = NULL;
966 }
967
968 /*
969  * Copy one line from input to output.
970  */
971 static void
972 dump_line(LINENUM line, bool write_newline)
973 {
974         char    *s;
975
976         s = ifetch(line, 0);
977         if (s == NULL)
978                 return;
979         /* Note: string is not NUL terminated. */
980         for (; *s != '\n'; s++)
981                 putc(*s, ofp);
982         if (write_newline)
983                 putc('\n', ofp);
984 }
985
986 /*
987  * Does the patch pattern match at line base+offset?
988  */
989 static bool
990 patch_match(LINENUM base, LINENUM offset, LINENUM fuzz)
991 {
992         LINENUM         pline = 1 + fuzz;
993         LINENUM         iline;
994         LINENUM         pat_lines = pch_ptrn_lines() - fuzz;
995         const char      *ilineptr;
996         const char      *plineptr;
997         short           plinelen;
998
999         for (iline = base + offset + fuzz; pline <= pat_lines; pline++, iline++) {
1000                 ilineptr = ifetch(iline, offset >= 0);
1001                 if (ilineptr == NULL)
1002                         return false;
1003                 plineptr = pfetch(pline);
1004                 plinelen = pch_line_len(pline);
1005                 if (canonicalize) {
1006                         if (!similar(ilineptr, plineptr, plinelen))
1007                                 return false;
1008                 } else if (strnNE(ilineptr, plineptr, plinelen))
1009                         return false;
1010                 if (iline == input_lines) {
1011                         /*
1012                          * We are looking at the last line of the file.
1013                          * If the file has no eol, the patch line should
1014                          * not have one either and vice-versa. Note that
1015                          * plinelen > 0.
1016                          */
1017                         if (last_line_missing_eol) {
1018                                 if (plineptr[plinelen - 1] == '\n')
1019                                         return false;
1020                         } else {
1021                                 if (plineptr[plinelen - 1] != '\n')
1022                                         return false;
1023                         }
1024                 }
1025         }
1026         return true;
1027 }
1028
1029 /*
1030  * Do two lines match with canonicalized white space?
1031  */
1032 static bool
1033 similar(const char *a, const char *b, int len)
1034 {
1035         while (len) {
1036                 if (isspace((unsigned char)*b)) {       /* whitespace (or \n) to match? */
1037                         if (!isspace((unsigned char)*a))        /* no corresponding whitespace? */
1038                                 return false;
1039                         while (len && isspace((unsigned char)*b) && *b != '\n')
1040                                 b++, len--;     /* skip pattern whitespace */
1041                         while (isspace((unsigned char)*a) && *a != '\n')
1042                                 a++;    /* skip target whitespace */
1043                         if (*a == '\n' || *b == '\n')
1044                                 return (*a == *b);      /* should end in sync */
1045                 } else if (*a++ != *b++)        /* match non-whitespace chars */
1046                         return false;
1047                 else
1048                         len--;  /* probably not necessary */
1049         }
1050         return true;            /* actually, this is not reached */
1051         /* since there is always a \n */
1052 }