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