Added -clobber switch to mhstore(1) [Bug #11160].
[mmh] / docs / historical / mh-6.8.5 / miscellany / patch-2.0.12u8 / pch.c
1 /* $Header: pch.c,v 2.0.1.7 88/06/03 15:13:28 lwall Locked $
2  *
3  * $Log:        pch.c,v $
4  * Revision 2.0.2.0  90/05/01  22:17:51  davison
5  * patch12u: unidiff support added
6  *
7  * Revision 2.0.1.7  88/06/03  15:13:28  lwall
8  * patch10: Can now find patches in shar scripts.
9  * patch10: Hunks that swapped and then swapped back could core dump.
10  * 
11  * Revision 2.0.1.6  87/06/04  16:18:13  lwall
12  * pch_swap didn't swap p_bfake and p_efake.
13  * 
14  * Revision 2.0.1.5  87/01/30  22:47:42  lwall
15  * Improved responses to mangled patches.
16  * 
17  * Revision 2.0.1.4  87/01/05  16:59:53  lwall
18  * New-style context diffs caused double call to free().
19  * 
20  * Revision 2.0.1.3  86/11/14  10:08:33  lwall
21  * Fixed problem where a long pattern wouldn't grow the hunk.
22  * Also restored p_input_line when backtracking so error messages are right.
23  * 
24  * Revision 2.0.1.2  86/11/03  17:49:52  lwall
25  * New-style delete triggers spurious assertion error.
26  * 
27  * Revision 2.0.1.1  86/10/29  15:52:08  lwall
28  * Could falsely report new-style context diff.
29  * 
30  * Revision 2.0  86/09/17  15:39:37  lwall
31  * Baseline for netwide release.
32  * 
33  */
34
35 #include "EXTERN.h"
36 #include "common.h"
37 #include "util.h"
38 #include "INTERN.h"
39 #include "pch.h"
40
41 /* Patch (diff listing) abstract type. */
42
43 static long p_filesize;                 /* size of the patch file */
44 static LINENUM p_first;                 /* 1st line number */
45 static LINENUM p_newfirst;              /* 1st line number of replacement */
46 static LINENUM p_ptrn_lines;            /* # lines in pattern */
47 static LINENUM p_repl_lines;            /* # lines in replacement text */
48 static LINENUM p_end = -1;              /* last line in hunk */
49 static LINENUM p_max;                   /* max allowed value of p_end */
50 static LINENUM p_context = 3;           /* # of context lines */
51 static LINENUM p_input_line = 0;        /* current line # from patch file */
52 static char **p_line = Null(char**);    /* the text of the hunk */
53 static short *p_len = Null(short*);     /* length of each line */
54 static char *p_char = Nullch;           /* +, -, and ! */
55 static int hunkmax = INITHUNKMAX;       /* size of above arrays to begin with */
56 static int p_indent;                    /* indent to patch */
57 static LINENUM p_base;                  /* where to intuit this time */
58 static LINENUM p_bline;                 /* line # of p_base */
59 static LINENUM p_start;                 /* where intuit found a patch */
60 static LINENUM p_sline;                 /* and the line number for it */
61 static LINENUM p_hunk_beg;              /* line number of current hunk */
62 static LINENUM p_efake = -1;            /* end of faked up lines--don't free */
63 static LINENUM p_bfake = -1;            /* beg of faked up lines */
64
65 /* Prepare to look for the next patch in the patch file. */
66
67 void
68 re_patch()
69 {
70     p_first = Nulline;
71     p_newfirst = Nulline;
72     p_ptrn_lines = Nulline;
73     p_repl_lines = Nulline;
74     p_end = (LINENUM)-1;
75     p_max = Nulline;
76     p_indent = 0;
77 }
78
79 /* Open the patch file at the beginning of time. */
80
81 void
82 open_patch_file(filename)
83 char *filename;
84 {
85     if (filename == Nullch || !*filename || strEQ(filename, "-")) {
86         pfp = fopen(TMPPATNAME, "w");
87         if (pfp == Nullfp)
88             pfatal2("can't create %s", TMPPATNAME);
89         while (fgets(buf, sizeof buf, stdin) != Nullch)
90             fputs(buf, pfp);
91         Fclose(pfp);
92         filename = TMPPATNAME;
93     }
94     pfp = fopen(filename, "r");
95     if (pfp == Nullfp)
96         pfatal2("patch file %s not found", filename);
97     Fstat(fileno(pfp), &filestat);
98     p_filesize = filestat.st_size;
99     next_intuit_at(0L,1L);                      /* start at the beginning */
100     set_hunkmax();
101 }
102
103 /* Make sure our dynamically realloced tables are malloced to begin with. */
104
105 void
106 set_hunkmax()
107 {
108 #ifndef lint
109     if (p_line == Null(char**))
110         p_line = (char**) malloc((MEM)hunkmax * sizeof(char *));
111     if (p_len == Null(short*))
112         p_len  = (short*) malloc((MEM)hunkmax * sizeof(short));
113 #endif
114     if (p_char == Nullch)
115         p_char = (char*)  malloc((MEM)hunkmax * sizeof(char));
116 }
117
118 /* Enlarge the arrays containing the current hunk of patch. */
119
120 void
121 grow_hunkmax()
122 {
123     hunkmax *= 2;
124     /* 
125      * Note that on most systems, only the p_line array ever gets fresh memory
126      * since p_len can move into p_line's old space, and p_char can move into
127      * p_len's old space.  Not on PDP-11's however.  But it doesn't matter.
128      */
129     assert(p_line != Null(char**) && p_len != Null(short*) && p_char != Nullch);
130 #ifndef lint
131     p_line = (char**) realloc((char*)p_line, (MEM)hunkmax * sizeof(char *));
132     p_len  = (short*) realloc((char*)p_len,  (MEM)hunkmax * sizeof(short));
133     p_char = (char*)  realloc((char*)p_char, (MEM)hunkmax * sizeof(char));
134 #endif
135     if (p_line != Null(char**) && p_len != Null(short*) && p_char != Nullch)
136         return;
137     if (!using_plan_a)
138         fatal1("out of memory\n");
139     out_of_mem = TRUE;          /* whatever is null will be allocated again */
140                                 /* from within plan_a(), of all places */
141 }
142
143 /* True if the remainder of the patch file contains a diff of some sort. */
144
145 bool
146 there_is_another_patch()
147 {
148     if (p_base != 0L && p_base >= p_filesize) {
149         if (verbose)
150             say1("done\n");
151         return FALSE;
152     }
153     if (verbose)
154         say1("Hmm...");
155     diff_type = intuit_diff_type();
156     if (!diff_type) {
157         if (p_base != 0L) {
158             if (verbose)
159                 say1("  Ignoring the trailing garbage.\ndone\n");
160         }
161         else
162             say1("  I can't seem to find a patch in there anywhere.\n");
163         return FALSE;
164     }
165     if (verbose)
166         say3("  %sooks like %s to me...\n",
167             (p_base == 0L ? "L" : "The next patch l"),
168             diff_type == UNI_DIFF ? "a unified diff" :
169             diff_type == CONTEXT_DIFF ? "a context diff" :
170             diff_type == NEW_CONTEXT_DIFF ? "a new-style context diff" :
171             diff_type == NORMAL_DIFF ? "a normal diff" :
172             "an ed script" );
173     if (p_indent && verbose)
174         say3("(Patch is indented %d space%s.)\n", p_indent, p_indent==1?"":"s");
175     skip_to(p_start,p_sline);
176     while (filearg[0] == Nullch) {
177         if (force || batch) {
178             say1("No file to patch.  Skipping...\n");
179             filearg[0] = savestr(bestguess);
180             return TRUE;
181         }
182         ask1("File to patch: ");
183         if (*buf != '\n') {
184             if (bestguess)
185                 free(bestguess);
186             bestguess = savestr(buf);
187             filearg[0] = fetchname(buf, 0, FALSE);
188         }
189         if (filearg[0] == Nullch) {
190             ask1("No file found--skip this patch? [n] ");
191             if (*buf != 'y') {
192                 continue;
193             }
194             if (verbose)
195                 say1("Skipping patch...\n");
196             filearg[0] = fetchname(bestguess, 0, TRUE);
197             skip_rest_of_patch = TRUE;
198             return TRUE;
199         }
200     }
201     return TRUE;
202 }
203
204 /* Determine what kind of diff is in the remaining part of the patch file. */
205
206 int
207 intuit_diff_type()
208 {
209     Reg4 long this_line = 0;
210     Reg5 long previous_line;
211     Reg6 long first_command_line = -1;
212     long fcl_line;
213     Reg7 bool last_line_was_command = FALSE;
214     Reg8 bool this_is_a_command = FALSE;
215     Reg9 bool stars_last_line = FALSE;
216     Reg10 bool stars_this_line = FALSE;
217     Reg3 int indent;
218     Reg1 char *s;
219     Reg2 char *t;
220     char *indtmp = Nullch;
221     char *oldtmp = Nullch;
222     char *newtmp = Nullch;
223     char *indname = Nullch;
224     char *oldname = Nullch;
225     char *newname = Nullch;
226     Reg11 int retval;
227     bool no_filearg = (filearg[0] == Nullch);
228
229     ok_to_create_file = FALSE;
230     Fseek(pfp, p_base, 0);
231     p_input_line = p_bline - 1;
232     for (;;) {
233         previous_line = this_line;
234         last_line_was_command = this_is_a_command;
235         stars_last_line = stars_this_line;
236         this_line = ftell(pfp);
237         indent = 0;
238         p_input_line++;
239         if (fgets(buf, sizeof buf, pfp) == Nullch) {
240             if (first_command_line >= 0L) {
241                                         /* nothing but deletes!? */
242                 p_start = first_command_line;
243                 p_sline = fcl_line;
244                 retval = ED_DIFF;
245                 goto scan_exit;
246             }
247             else {
248                 p_start = this_line;
249                 p_sline = p_input_line;
250                 retval = 0;
251                 goto scan_exit;
252             }
253         }
254         for (s = buf; *s == ' ' || *s == '\t' || *s == 'X'; s++) {
255             if (*s == '\t')
256                 indent += 8 - (indent % 8);
257             else
258                 indent++;
259         }
260         for (t=s; isdigit(*t) || *t == ','; t++) ; 
261         this_is_a_command = (isdigit(*s) &&
262           (*t == 'd' || *t == 'c' || *t == 'a') );
263         if (first_command_line < 0L && this_is_a_command) { 
264             first_command_line = this_line;
265             fcl_line = p_input_line;
266             p_indent = indent;          /* assume this for now */
267         }
268         if (!stars_last_line && strnEQ(s, "*** ", 4))
269             oldtmp = savestr(s+4);
270         else if (strnEQ(s, "--- ", 4))
271             newtmp = savestr(s+4);
272         else if (strnEQ(s, "+++ ", 4))
273             oldtmp = savestr(s+4);      /* pretend it is the old name */
274         else if (strnEQ(s, "Index:", 6))
275             indtmp = savestr(s+6);
276         else if (strnEQ(s, "Prereq:", 7)) {
277             for (t=s+7; isspace(*t); t++) ;
278             revision = savestr(t);
279             for (t=revision; *t && !isspace(*t); t++) ;
280             *t = '\0';
281             if (!*revision) {
282                 free(revision);
283                 revision = Nullch;
284             }
285         }
286         if ((!diff_type || diff_type == ED_DIFF) &&
287           first_command_line >= 0L &&
288           strEQ(s, ".\n") ) {
289             p_indent = indent;
290             p_start = first_command_line;
291             p_sline = fcl_line;
292             retval = ED_DIFF;
293             goto scan_exit;
294         }
295         if ((!diff_type || diff_type == UNI_DIFF) && strnEQ(s, "@@ -", 4)) {
296             if (!atol(s+3))
297                 ok_to_create_file = TRUE;
298             p_indent = indent;
299             p_start = this_line;
300             p_sline = p_input_line;
301             retval = UNI_DIFF;
302             goto scan_exit;
303         }
304         stars_this_line = strnEQ(s, "********", 8);
305         if ((!diff_type || diff_type == CONTEXT_DIFF) && stars_last_line &&
306                  strnEQ(s, "*** ", 4)) {
307             if (!atol(s+4))
308                 ok_to_create_file = TRUE;
309             /* if this is a new context diff the character just before */
310             /* the newline is a '*'. */
311             while (*s != '\n')
312                 s++;
313             p_indent = indent;
314             p_start = previous_line;
315             p_sline = p_input_line - 1;
316             retval = (*(s-1) == '*' ? NEW_CONTEXT_DIFF : CONTEXT_DIFF);
317             goto scan_exit;
318         }
319         if ((!diff_type || diff_type == NORMAL_DIFF) && 
320           last_line_was_command &&
321           (strnEQ(s, "< ", 2) || strnEQ(s, "> ", 2)) ) {
322             p_start = previous_line;
323             p_sline = p_input_line - 1;
324             p_indent = indent;
325             retval = NORMAL_DIFF;
326             goto scan_exit;
327         }
328     }
329   scan_exit:
330     if (no_filearg) {
331         if (indtmp != Nullch)
332             indname = fetchname(indtmp, strippath, ok_to_create_file);
333         if (oldtmp != Nullch)
334             oldname = fetchname(oldtmp, strippath, ok_to_create_file);
335         if (newtmp != Nullch)
336             newname = fetchname(newtmp, strippath, ok_to_create_file);
337         if (oldname && newname) {
338             if (strlen(oldname) < strlen(newname))
339                 filearg[0] = savestr(oldname);
340             else
341                 filearg[0] = savestr(newname);
342         }
343         else if (oldname)
344             filearg[0] = savestr(oldname);
345         else if (newname)
346             filearg[0] = savestr(newname);
347         else if (indname)
348             filearg[0] = savestr(indname);
349     }
350     if (bestguess) {
351         free(bestguess);
352         bestguess = Nullch;
353     }
354     if (filearg[0] != Nullch)
355         bestguess = savestr(filearg[0]);
356     else if (indtmp != Nullch)
357         bestguess = fetchname(indtmp, strippath, TRUE);
358     else {
359         if (oldtmp != Nullch)
360             oldname = fetchname(oldtmp, strippath, TRUE);
361         if (newtmp != Nullch)
362             newname = fetchname(newtmp, strippath, TRUE);
363         if (oldname && newname) {
364             if (strlen(oldname) < strlen(newname))
365                 bestguess = savestr(oldname);
366             else
367                 bestguess = savestr(newname);
368         }
369         else if (oldname)
370             bestguess = savestr(oldname);
371         else if (newname)
372             bestguess = savestr(newname);
373     }
374     if (indtmp != Nullch)
375         free(indtmp);
376     if (oldtmp != Nullch)
377         free(oldtmp);
378     if (newtmp != Nullch)
379         free(newtmp);
380     if (indname != Nullch)
381         free(indname);
382     if (oldname != Nullch)
383         free(oldname);
384     if (newname != Nullch)
385         free(newname);
386     return retval;
387 }
388
389 /* Remember where this patch ends so we know where to start up again. */
390
391 void
392 next_intuit_at(file_pos,file_line)
393 long file_pos;
394 long file_line;
395 {
396     p_base = file_pos;
397     p_bline = file_line;
398 }
399
400 /* Basically a verbose fseek() to the actual diff listing. */
401
402 void
403 skip_to(file_pos,file_line)
404 long file_pos;
405 long file_line;
406 {
407     char *ret;
408
409     assert(p_base <= file_pos);
410     if (verbose && p_base < file_pos) {
411         Fseek(pfp, p_base, 0);
412         say1("The text leading up to this was:\n--------------------------\n");
413         while (ftell(pfp) < file_pos) {
414             ret = fgets(buf, sizeof buf, pfp);
415             assert(ret != Nullch);
416             say2("|%s", buf);
417         }
418         say1("--------------------------\n");
419     }
420     else
421         Fseek(pfp, file_pos, 0);
422     p_input_line = file_line - 1;
423 }
424
425 /* Make this a function for better debugging.  */
426 static void
427 malformed ()
428 {
429     fatal3("malformed patch at line %ld: %s", p_input_line, buf);
430                 /* about as informative as "Syntax error" in C */
431 }
432
433 /* True if there is more of the current diff listing to process. */
434
435 bool
436 another_hunk()
437 {
438     Reg1 char *s;
439     Reg8 char *ret;
440     Reg2 int context = 0;
441
442     while (p_end >= 0) {
443         if (p_end == p_efake)
444             p_end = p_bfake;            /* don't free twice */
445         else
446             free(p_line[p_end]);
447         p_end--;
448     }
449     assert(p_end == -1);
450     p_efake = -1;
451
452     p_max = hunkmax;                    /* gets reduced when --- found */
453     if (diff_type == CONTEXT_DIFF || diff_type == NEW_CONTEXT_DIFF) {
454         long line_beginning = ftell(pfp);
455                                         /* file pos of the current line */
456         LINENUM repl_beginning = 0;     /* index of --- line */
457         Reg4 LINENUM fillcnt = 0;       /* #lines of missing ptrn or repl */
458         Reg5 LINENUM fillsrc;           /* index of first line to copy */
459         Reg6 LINENUM filldst;           /* index of first missing line */
460         bool ptrn_spaces_eaten = FALSE; /* ptrn was slightly misformed */
461         Reg9 bool repl_could_be_missing = TRUE;
462                                         /* no + or ! lines in this hunk */
463         bool repl_missing = FALSE;      /* we are now backtracking */
464         long repl_backtrack_position = 0;
465                                         /* file pos of first repl line */
466         LINENUM repl_patch_line;        /* input line number for same */
467         Reg7 LINENUM ptrn_copiable = 0;
468                                         /* # of copiable lines in ptrn */
469
470         ret = pgets(buf, sizeof buf, pfp);
471         p_input_line++;
472         if (ret == Nullch || strnNE(buf, "********", 8)) {
473             next_intuit_at(line_beginning,p_input_line);
474             return FALSE;
475         }
476         p_context = 100;
477         p_hunk_beg = p_input_line + 1;
478         while (p_end < p_max) {
479             line_beginning = ftell(pfp);
480             ret = pgets(buf, sizeof buf, pfp);
481             p_input_line++;
482             if (ret == Nullch) {
483                 if (p_max - p_end < 4)
484                     Strcpy(buf, "  \n");  /* assume blank lines got chopped */
485                 else {
486                     if (repl_beginning && repl_could_be_missing) {
487                         repl_missing = TRUE;
488                         goto hunk_done;
489                     }
490                     fatal1("unexpected end of file in patch\n");
491                 }
492             }
493             p_end++;
494             assert(p_end < hunkmax);
495             p_char[p_end] = *buf;
496 #ifdef zilog
497             p_line[(short)p_end] = Nullch;
498 #else
499             p_line[p_end] = Nullch;
500 #endif
501             switch (*buf) {
502             case '*':
503                 if (strnEQ(buf, "********", 8)) {
504                     if (repl_beginning && repl_could_be_missing) {
505                         repl_missing = TRUE;
506                         goto hunk_done;
507                     }
508                     else
509                         fatal2("unexpected end of hunk at line %ld\n",
510                             p_input_line);
511                 }
512                 if (p_end != 0) {
513                     if (repl_beginning && repl_could_be_missing) {
514                         repl_missing = TRUE;
515                         goto hunk_done;
516                     }
517                     fatal3("unexpected *** at line %ld: %s", p_input_line, buf);
518                 }
519                 context = 0;
520                 p_line[p_end] = savestr(buf);
521                 if (out_of_mem) {
522                     p_end--;
523                     return FALSE;
524                 }
525                 for (s=buf; *s && !isdigit(*s); s++) ;
526                 if (!*s)
527                     malformed ();
528                 if (strnEQ(s,"0,0",3))
529                     strcpy(s,s+2);
530                 p_first = (LINENUM) atol(s);
531                 while (isdigit(*s)) s++;
532                 if (*s == ',') {
533                     for (; *s && !isdigit(*s); s++) ;
534                     if (!*s)
535                         malformed ();
536                     p_ptrn_lines = ((LINENUM)atol(s)) - p_first + 1;
537                 }
538                 else if (p_first)
539                     p_ptrn_lines = 1;
540                 else {
541                     p_ptrn_lines = 0;
542                     p_first = 1;
543                 }
544                 p_max = p_ptrn_lines + 6;       /* we need this much at least */
545                 while (p_max >= hunkmax)
546                     grow_hunkmax();
547                 p_max = hunkmax;
548                 break;
549             case '-':
550                 if (buf[1] == '-') {
551                     if (repl_beginning ||
552                         (p_end != p_ptrn_lines + 1 + (p_char[p_end-1] == '\n')))
553                     {
554                         if (p_end == 1) {
555                             /* `old' lines were omitted - set up to fill */
556                             /* them in from 'new' context lines. */
557                             p_end = p_ptrn_lines + 1;
558                             fillsrc = p_end + 1;
559                             filldst = 1;
560                             fillcnt = p_ptrn_lines;
561                         }
562                         else {
563                             if (repl_beginning) {
564                                 if (repl_could_be_missing){
565                                     repl_missing = TRUE;
566                                     goto hunk_done;
567                                 }
568                                 fatal3(
569 "duplicate \"---\" at line %ld--check line numbers at line %ld\n",
570                                     p_input_line, p_hunk_beg + repl_beginning);
571                             }
572                             else {
573                                 fatal4(
574 "%s \"---\" at line %ld--check line numbers at line %ld\n",
575                                     (p_end <= p_ptrn_lines
576                                         ? "Premature"
577                                         : "Overdue" ),
578                                     p_input_line, p_hunk_beg);
579                             }
580                         }
581                     }
582                     repl_beginning = p_end;
583                     repl_backtrack_position = ftell(pfp);
584                     repl_patch_line = p_input_line;
585                     p_line[p_end] = savestr(buf);
586                     if (out_of_mem) {
587                         p_end--;
588                         return FALSE;
589                     }
590                     p_char[p_end] = '=';
591                     for (s=buf; *s && !isdigit(*s); s++) ;
592                     if (!*s)
593                         malformed ();
594                     p_newfirst = (LINENUM) atol(s);
595                     while (isdigit(*s)) s++;
596                     if (*s == ',') {
597                         for (; *s && !isdigit(*s); s++) ;
598                         if (!*s)
599                             malformed ();
600                         p_repl_lines = ((LINENUM)atol(s)) - p_newfirst + 1;
601                     }
602                     else if (p_newfirst)
603                         p_repl_lines = 1;
604                     else {
605                         p_repl_lines = 0;
606                         p_newfirst = 1;
607                     }
608                     p_max = p_repl_lines + p_end;
609                     if (p_max > MAXHUNKSIZE)
610                         fatal4("hunk too large (%ld lines) at line %ld: %s",
611                               p_max, p_input_line, buf);
612                     while (p_max >= hunkmax)
613                         grow_hunkmax();
614                     if (p_repl_lines != ptrn_copiable
615                      && (p_context != 0 || p_repl_lines != 1))
616                         repl_could_be_missing = FALSE;
617                     break;
618                 }
619                 goto change_line;
620             case '+':  case '!':
621                 repl_could_be_missing = FALSE;
622               change_line:
623                 if (buf[1] == '\n' && canonicalize)
624                     strcpy(buf+1," \n");
625                 if (!isspace(buf[1]) && buf[1] != '>' && buf[1] != '<' &&
626                   repl_beginning && repl_could_be_missing) {
627                     repl_missing = TRUE;
628                     goto hunk_done;
629                 }
630                 if (context >= 0) {
631                     if (context < p_context)
632                         p_context = context;
633                     context = -1000;
634                 }
635                 p_line[p_end] = savestr(buf+2);
636                 if (out_of_mem) {
637                     p_end--;
638                     return FALSE;
639                 }
640                 break;
641             case '\t': case '\n':       /* assume the 2 spaces got eaten */
642                 if (repl_beginning && repl_could_be_missing &&
643                   (!ptrn_spaces_eaten || diff_type == NEW_CONTEXT_DIFF) ) {
644                     repl_missing = TRUE;
645                     goto hunk_done;
646                 }
647                 p_line[p_end] = savestr(buf);
648                 if (out_of_mem) {
649                     p_end--;
650                     return FALSE;
651                 }
652                 if (p_end != p_ptrn_lines + 1) {
653                     ptrn_spaces_eaten |= (repl_beginning != 0);
654                     context++;
655                     if (!repl_beginning)
656                         ptrn_copiable++;
657                     p_char[p_end] = ' ';
658                 }
659                 break;
660             case ' ':
661                 if (!isspace(buf[1]) &&
662                   repl_beginning && repl_could_be_missing) {
663                     repl_missing = TRUE;
664                     goto hunk_done;
665                 }
666                 context++;
667                 if (!repl_beginning)
668                     ptrn_copiable++;
669                 p_line[p_end] = savestr(buf+2);
670                 if (out_of_mem) {
671                     p_end--;
672                     return FALSE;
673                 }
674                 break;
675             default:
676                 if (repl_beginning && repl_could_be_missing) {
677                     repl_missing = TRUE;
678                     goto hunk_done;
679                 }
680                 malformed ();
681             }
682             /* set up p_len for strncmp() so we don't have to */
683             /* assume null termination */
684             if (p_line[p_end])
685                 p_len[p_end] = strlen(p_line[p_end]);
686             else
687                 p_len[p_end] = 0;
688         }
689         
690     hunk_done:
691         if (p_end >=0 && !repl_beginning)
692             fatal2("no --- found in patch at line %ld\n", pch_hunk_beg());
693
694         if (repl_missing) {
695             
696             /* reset state back to just after --- */
697             p_input_line = repl_patch_line;
698             for (p_end--; p_end > repl_beginning; p_end--)
699                 free(p_line[p_end]);
700             Fseek(pfp, repl_backtrack_position, 0);
701             
702             /* redundant 'new' context lines were omitted - set */
703             /* up to fill them in from the old file context */
704             if (!p_context && p_repl_lines == 1) {
705                 p_repl_lines = 0;
706                 p_max--;
707             }
708             fillsrc = 1;
709             filldst = repl_beginning+1;
710             fillcnt = p_repl_lines;
711             p_end = p_max;
712         }
713         else if (!p_context && fillcnt == 1) {
714             /* the first hunk was a null hunk with no context */
715             /* and we were expecting one line -- fix it up. */
716             while (filldst < p_end) {
717                 p_line[filldst] = p_line[filldst+1];
718                 p_char[filldst] = p_char[filldst+1];
719                 p_len[filldst] = p_len[filldst+1];
720                 filldst++;
721             }
722 #if 0
723             repl_beginning--;           /* this doesn't need to be fixed */
724 #endif
725             p_end--;
726             p_first++;                  /* do append rather than insert */
727             fillcnt = 0;
728             p_ptrn_lines = 0;
729         }
730
731         if (diff_type == CONTEXT_DIFF &&
732           (fillcnt || (p_first > 1 && ptrn_copiable > 2*p_context)) ) {
733             if (verbose)
734                 say4("%s\n%s\n%s\n",
735 "(Fascinating--this is really a new-style context diff but without",
736 "the telltale extra asterisks on the *** line that usually indicate",
737 "the new style...)");
738             diff_type = NEW_CONTEXT_DIFF;
739         }
740         
741         /* if there were omitted context lines, fill them in now */
742         if (fillcnt) {
743             p_bfake = filldst;          /* remember where not to free() */
744             p_efake = filldst + fillcnt - 1;
745             while (fillcnt-- > 0) {
746                 while (fillsrc <= p_end && p_char[fillsrc] != ' ')
747                     fillsrc++;
748                 if (fillsrc > p_end)
749                     fatal2("replacement text or line numbers mangled in hunk at line %ld\n",
750                         p_hunk_beg);
751                 p_line[filldst] = p_line[fillsrc];
752                 p_char[filldst] = p_char[fillsrc];
753                 p_len[filldst] = p_len[fillsrc];
754                 fillsrc++; filldst++;
755             }
756             while (fillsrc <= p_end && fillsrc != repl_beginning &&
757               p_char[fillsrc] != ' ')
758                 fillsrc++;
759 #ifdef DEBUGGING
760             if (debug & 64)
761                 printf("fillsrc %ld, filldst %ld, rb %ld, e+1 %ld\n",
762                     fillsrc,filldst,repl_beginning,p_end+1);
763 #endif
764             assert(fillsrc==p_end+1 || fillsrc==repl_beginning);
765             assert(filldst==p_end+1 || filldst==repl_beginning);
766         }
767     }
768     else if (diff_type == UNI_DIFF) {
769         long line_beginning = ftell(pfp);
770                                         /* file pos of the current line */
771         Reg4 LINENUM fillsrc;           /* index of old lines */
772         Reg5 LINENUM filldst;           /* index of new lines */
773         char ch;
774
775         ret = pgets(buf, sizeof buf, pfp);
776         p_input_line++;
777         if (ret == Nullch || strnNE(buf, "@@ -", 4)) {
778             next_intuit_at(line_beginning,p_input_line);
779             return FALSE;
780         }
781         s = buf+4;
782         if (!*s)
783             malformed ();
784         p_first = (LINENUM) atol(s);
785         while (isdigit(*s)) s++;
786         if (*s == ',') {
787             p_ptrn_lines = (LINENUM) atol(++s);
788             while (isdigit(*s)) s++;
789         } else
790             p_ptrn_lines = 1;
791         if (*s == ' ') s++;
792         if (*s != '+' || !*++s)
793             malformed ();
794         p_newfirst = (LINENUM) atol(s);
795         while (isdigit(*s)) s++;
796         if (*s == ',') {
797             p_repl_lines = (LINENUM) atol(++s);
798             while (isdigit(*s)) s++;
799         } else
800             p_repl_lines = 1;
801         if (*s == ' ') s++;
802         if (*s != '@')
803             malformed ();
804         if (!p_ptrn_lines)
805             p_first++;                  /* do append rather than insert */
806         p_max = p_ptrn_lines + p_repl_lines + 1;
807         while (p_max >= hunkmax)
808             grow_hunkmax();
809         fillsrc = 1;
810         filldst = fillsrc + p_ptrn_lines;
811         p_end = filldst + p_repl_lines;
812         Sprintf(buf,"*** %ld,%ld ****\n",p_first,p_first + p_ptrn_lines - 1);
813         p_line[0] = savestr(buf);
814         if (out_of_mem) {
815             p_end = -1;
816             return FALSE;
817         }
818         p_char[0] = '*';
819         Sprintf(buf,"--- %ld,%ld ----\n",p_newfirst,p_newfirst+p_repl_lines-1);
820         p_line[filldst] = savestr(buf);
821         if (out_of_mem) {
822             p_end = 0;
823             return FALSE;
824         }
825         p_char[filldst++] = '=';
826         p_context = 100;
827         context = 0;
828         p_hunk_beg = p_input_line + 1;
829         while (fillsrc <= p_ptrn_lines || filldst <= p_end) {
830             line_beginning = ftell(pfp);
831             ret = pgets(buf, sizeof buf, pfp);
832             p_input_line++;
833             if (ret == Nullch) {
834                 if (p_max - filldst < 3)
835                     Strcpy(buf, " \n");  /* assume blank lines got chopped */
836                 else {
837                     fatal1("unexpected end of file in patch\n");
838                 }
839             }
840             if (*buf == '\t' || *buf == '\n') {
841                 ch = ' ';               /* assume the space got eaten */
842                 s = savestr(buf);
843             }
844             else {
845                 ch = *buf;
846                 s = savestr(buf+1);
847             }
848             if (out_of_mem) {
849                 while (--filldst > p_ptrn_lines)
850                     free(p_line[filldst]);
851                 p_end = fillsrc-1;
852                 return FALSE;
853             }
854             switch (ch) {
855             case '-':
856                 if (fillsrc > p_ptrn_lines) {
857                     free(s);
858                     p_end = filldst-1;
859                     malformed ();
860                 }
861                 p_char[fillsrc] = ch;
862                 p_line[fillsrc] = s;
863                 p_len[fillsrc++] = strlen(s);
864                 break;
865             case '=':
866                 ch = ' ';
867                 /* FALL THROUGH */
868             case ' ':
869                 if (fillsrc > p_ptrn_lines) {
870                     free(s);
871                     while (--filldst > p_ptrn_lines)
872                         free(p_line[filldst]);
873                     p_end = fillsrc-1;
874                     malformed ();
875                 }
876                 context++;
877                 p_char[fillsrc] = ch;
878                 p_line[fillsrc] = s;
879                 p_len[fillsrc++] = strlen(s);
880                 s = savestr(s);
881                 if (out_of_mem) {
882                     while (--filldst > p_ptrn_lines)
883                         free(p_line[filldst]);
884                     p_end = fillsrc-1;
885                     return FALSE;
886                 }
887                 /* FALL THROUGH */
888             case '+':
889                 if (filldst > p_end) {
890                     free(s);
891                     while (--filldst > p_ptrn_lines)
892                         free(p_line[filldst]);
893                     p_end = fillsrc-1;
894                     malformed ();
895                 }
896                 p_char[filldst] = ch;
897                 p_line[filldst] = s;
898                 p_len[filldst++] = strlen(s);
899                 break;
900             default:
901                 p_end = filldst;
902                 malformed ();
903             }
904             if (ch != ' ' && context > 0) {
905                 if (context < p_context)
906                     p_context = context;
907                 context = -1000;
908             }
909         }/* while */
910     }
911     else {                              /* normal diff--fake it up */
912         char hunk_type;
913         Reg3 int i;
914         LINENUM min, max;
915         long line_beginning = ftell(pfp);
916
917         p_context = 0;
918         ret = pgets(buf, sizeof buf, pfp);
919         p_input_line++;
920         if (ret == Nullch || !isdigit(*buf)) {
921             next_intuit_at(line_beginning,p_input_line);
922             return FALSE;
923         }
924         p_first = (LINENUM)atol(buf);
925         for (s=buf; isdigit(*s); s++) ;
926         if (*s == ',') {
927             p_ptrn_lines = (LINENUM)atol(++s) - p_first + 1;
928             while (isdigit(*s)) s++;
929         }
930         else
931             p_ptrn_lines = (*s != 'a');
932         hunk_type = *s;
933         if (hunk_type == 'a')
934             p_first++;                  /* do append rather than insert */
935         min = (LINENUM)atol(++s);
936         for (; isdigit(*s); s++) ;
937         if (*s == ',')
938             max = (LINENUM)atol(++s);
939         else
940             max = min;
941         if (hunk_type == 'd')
942             min++;
943         p_end = p_ptrn_lines + 1 + max - min + 1;
944         if (p_end > MAXHUNKSIZE)
945             fatal4("hunk too large (%ld lines) at line %ld: %s",
946                   p_end, p_input_line, buf);
947         while (p_end >= hunkmax)
948             grow_hunkmax();
949         p_newfirst = min;
950         p_repl_lines = max - min + 1;
951         Sprintf(buf, "*** %ld,%ld\n", p_first, p_first + p_ptrn_lines - 1);
952         p_line[0] = savestr(buf);
953         if (out_of_mem) {
954             p_end = -1;
955             return FALSE;
956         }
957         p_char[0] = '*';
958         for (i=1; i<=p_ptrn_lines; i++) {
959             ret = pgets(buf, sizeof buf, pfp);
960             p_input_line++;
961             if (ret == Nullch)
962                 fatal2("unexpected end of file in patch at line %ld\n",
963                   p_input_line);
964             if (*buf != '<')
965                 fatal2("< expected at line %ld of patch\n", p_input_line);
966             p_line[i] = savestr(buf+2);
967             if (out_of_mem) {
968                 p_end = i-1;
969                 return FALSE;
970             }
971             p_len[i] = strlen(p_line[i]);
972             p_char[i] = '-';
973         }
974         if (hunk_type == 'c') {
975             ret = pgets(buf, sizeof buf, pfp);
976             p_input_line++;
977             if (ret == Nullch)
978                 fatal2("unexpected end of file in patch at line %ld\n",
979                     p_input_line);
980             if (*buf != '-')
981                 fatal2("--- expected at line %ld of patch\n", p_input_line);
982         }
983         Sprintf(buf, "--- %ld,%ld\n", min, max);
984         p_line[i] = savestr(buf);
985         if (out_of_mem) {
986             p_end = i-1;
987             return FALSE;
988         }
989         p_char[i] = '=';
990         for (i++; i<=p_end; i++) {
991             ret = pgets(buf, sizeof buf, pfp);
992             p_input_line++;
993             if (ret == Nullch)
994                 fatal2("unexpected end of file in patch at line %ld\n",
995                     p_input_line);
996             if (*buf != '>')
997                 fatal2("> expected at line %ld of patch\n", p_input_line);
998             p_line[i] = savestr(buf+2);
999             if (out_of_mem) {
1000                 p_end = i-1;
1001                 return FALSE;
1002             }
1003             p_len[i] = strlen(p_line[i]);
1004             p_char[i] = '+';
1005         }
1006     }
1007     if (reverse)                        /* backwards patch? */
1008         if (!pch_swap())
1009             say1("Not enough memory to swap next hunk!\n");
1010 #ifdef DEBUGGING
1011     if (debug & 2) {
1012         int i;
1013         char special;
1014
1015         for (i=0; i <= p_end; i++) {
1016             if (i == p_ptrn_lines)
1017                 special = '^';
1018             else
1019                 special = ' ';
1020             fprintf(stderr, "%3d %c %c %s", i, p_char[i], special, p_line[i]);
1021             Fflush(stderr);
1022         }
1023     }
1024 #endif
1025     if (p_end+1 < hunkmax)      /* paranoia reigns supreme... */
1026         p_char[p_end+1] = '^';  /* add a stopper for apply_hunk */
1027     return TRUE;
1028 }
1029
1030 /* Input a line from the patch file, worrying about indentation. */
1031
1032 char *
1033 pgets(bf,sz,fp)
1034 char *bf;
1035 int sz;
1036 FILE *fp;
1037 {
1038     char *ret = fgets(bf, sz, fp);
1039     Reg1 char *s;
1040     Reg2 int indent = 0;
1041
1042     if (p_indent && ret != Nullch) {
1043         for (s=buf;
1044           indent < p_indent && (*s == ' ' || *s == '\t' || *s == 'X'); s++) {
1045             if (*s == '\t')
1046                 indent += 8 - (indent % 7);
1047             else
1048                 indent++;
1049         }
1050         if (buf != s)
1051             Strcpy(buf, s);
1052     }
1053     return ret;
1054 }
1055
1056 /* Reverse the old and new portions of the current hunk. */
1057
1058 bool
1059 pch_swap()
1060 {
1061     char **tp_line;             /* the text of the hunk */
1062     short *tp_len;              /* length of each line */
1063     char *tp_char;              /* +, -, and ! */
1064     Reg1 LINENUM i;
1065     Reg2 LINENUM n;
1066     bool blankline = FALSE;
1067     Reg3 char *s;
1068
1069     i = p_first;
1070     p_first = p_newfirst;
1071     p_newfirst = i;
1072     
1073     /* make a scratch copy */
1074
1075     tp_line = p_line;
1076     tp_len = p_len;
1077     tp_char = p_char;
1078     p_line = Null(char**);      /* force set_hunkmax to allocate again */
1079     p_len = Null(short*);
1080     p_char = Nullch;
1081     set_hunkmax();
1082     if (p_line == Null(char**) || p_len == Null(short*) || p_char == Nullch) {
1083 #ifndef lint
1084         if (p_line == Null(char**))
1085             free((char*)p_line);
1086         p_line = tp_line;
1087         if (p_len == Null(short*))
1088             free((char*)p_len);
1089         p_len = tp_len;
1090 #endif
1091         if (p_char == Nullch)
1092             free((char*)p_char);
1093         p_char = tp_char;
1094         return FALSE;           /* not enough memory to swap hunk! */
1095     }
1096
1097     /* now turn the new into the old */
1098
1099     i = p_ptrn_lines + 1;
1100     if (tp_char[i] == '\n') {           /* account for possible blank line */
1101         blankline = TRUE;
1102         i++;
1103     }
1104     if (p_efake >= 0) {                 /* fix non-freeable ptr range */
1105         if (p_efake <= i)
1106             n = p_end - i + 1;
1107         else
1108             n = -i;
1109         p_efake += n;
1110         p_bfake += n;
1111     }
1112     for (n=0; i <= p_end; i++,n++) {
1113         p_line[n] = tp_line[i];
1114         p_char[n] = tp_char[i];
1115         if (p_char[n] == '+')
1116             p_char[n] = '-';
1117         p_len[n] = tp_len[i];
1118     }
1119     if (blankline) {
1120         i = p_ptrn_lines + 1;
1121         p_line[n] = tp_line[i];
1122         p_char[n] = tp_char[i];
1123         p_len[n] = tp_len[i];
1124         n++;
1125     }
1126     assert(p_char[0] == '=');
1127     p_char[0] = '*';
1128     for (s=p_line[0]; *s; s++)
1129         if (*s == '-')
1130             *s = '*';
1131
1132     /* now turn the old into the new */
1133
1134     assert(tp_char[0] == '*');
1135     tp_char[0] = '=';
1136     for (s=tp_line[0]; *s; s++)
1137         if (*s == '*')
1138             *s = '-';
1139     for (i=0; n <= p_end; i++,n++) {
1140         p_line[n] = tp_line[i];
1141         p_char[n] = tp_char[i];
1142         if (p_char[n] == '-')
1143             p_char[n] = '+';
1144         p_len[n] = tp_len[i];
1145     }
1146     assert(i == p_ptrn_lines + 1);
1147     i = p_ptrn_lines;
1148     p_ptrn_lines = p_repl_lines;
1149     p_repl_lines = i;
1150 #ifndef lint
1151     if (tp_line == Null(char**))
1152         free((char*)tp_line);
1153     if (tp_len == Null(short*))
1154         free((char*)tp_len);
1155 #endif
1156     if (tp_char == Nullch)
1157         free((char*)tp_char);
1158     return TRUE;
1159 }
1160
1161 /* Return the specified line position in the old file of the old context. */
1162
1163 LINENUM
1164 pch_first()
1165 {
1166     return p_first;
1167 }
1168
1169 /* Return the number of lines of old context. */
1170
1171 LINENUM
1172 pch_ptrn_lines()
1173 {
1174     return p_ptrn_lines;
1175 }
1176
1177 /* Return the probable line position in the new file of the first line. */
1178
1179 LINENUM
1180 pch_newfirst()
1181 {
1182     return p_newfirst;
1183 }
1184
1185 /* Return the number of lines in the replacement text including context. */
1186
1187 LINENUM
1188 pch_repl_lines()
1189 {
1190     return p_repl_lines;
1191 }
1192
1193 /* Return the number of lines in the whole hunk. */
1194
1195 LINENUM
1196 pch_end()
1197 {
1198     return p_end;
1199 }
1200
1201 /* Return the number of context lines before the first changed line. */
1202
1203 LINENUM
1204 pch_context()
1205 {
1206     return p_context;
1207 }
1208
1209 /* Return the length of a particular patch line. */
1210
1211 short
1212 pch_line_len(line)
1213 LINENUM line;
1214 {
1215     return p_len[line];
1216 }
1217
1218 /* Return the control character (+, -, *, !, etc) for a patch line. */
1219
1220 char
1221 pch_char(line)
1222 LINENUM line;
1223 {
1224     return p_char[line];
1225 }
1226
1227 /* Return a pointer to a particular patch line. */
1228
1229 char *
1230 pfetch(line)
1231 LINENUM line;
1232 {
1233     return p_line[line];
1234 }
1235
1236 /* Return where in the patch file this hunk began, for error messages. */
1237
1238 LINENUM
1239 pch_hunk_beg()
1240 {
1241     return p_hunk_beg;
1242 }
1243
1244 /* Apply an ed script by feeding ed itself. */
1245
1246 void
1247 do_ed_script()
1248 {
1249     Reg1 char *t;
1250     Reg2 long beginning_of_this_line;
1251     Reg3 bool this_line_is_command = FALSE;
1252     Reg4 FILE *pipefp;
1253
1254     if (!skip_rest_of_patch) {
1255         Unlink(TMPOUTNAME);
1256         copy_file(filearg[0], TMPOUTNAME);
1257         if (verbose)
1258             Sprintf(buf, "/bin/ed %s", TMPOUTNAME);
1259         else
1260             Sprintf(buf, "/bin/ed - %s", TMPOUTNAME);
1261         pipefp = popen(buf, "w");
1262     }
1263     for (;;) {
1264         beginning_of_this_line = ftell(pfp);
1265         if (pgets(buf, sizeof buf, pfp) == Nullch) {
1266             next_intuit_at(beginning_of_this_line,p_input_line);
1267             break;
1268         }
1269         p_input_line++;
1270         for (t=buf; isdigit(*t) || *t == ','; t++) ;
1271         this_line_is_command = (isdigit(*buf) &&
1272           (*t == 'd' || *t == 'c' || *t == 'a') );
1273         if (this_line_is_command) {
1274             if (!skip_rest_of_patch)
1275                 fputs(buf, pipefp);
1276             if (*t != 'd') {
1277                 while (pgets(buf, sizeof buf, pfp) != Nullch) {
1278                     p_input_line++;
1279                     if (!skip_rest_of_patch)
1280                         fputs(buf, pipefp);
1281                     if (strEQ(buf, ".\n"))
1282                         break;
1283                 }
1284             }
1285         }
1286         else {
1287             next_intuit_at(beginning_of_this_line,p_input_line);
1288             break;
1289         }
1290     }
1291     if (skip_rest_of_patch)
1292         return;
1293     fprintf(pipefp, "w\n");
1294     fprintf(pipefp, "q\n");
1295     Fflush(pipefp);
1296     Pclose(pipefp);
1297     ignore_signals();
1298     if (move_file(TMPOUTNAME, outname) < 0) {
1299         toutkeep = TRUE;
1300         chmod(TMPOUTNAME, filemode);
1301     }
1302     else
1303         chmod(outname, filemode);
1304     set_signals(1);
1305 }