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