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