![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to patch.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / mh / miscellany / patch|
Return to patch.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / mh / miscellany / patch |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)patch.c 5.3 (Berkeley) 8/16/85";
3: #endif not lint
4:
5: /* patch - a program to apply diffs to original files
6: *
7: * $Header: patch.c,v 1.3 85/03/26 15:07:43 lwall Exp $
8: *
9: * Copyright 1984, Larry Wall
10: *
11: * This program may be copied as long as you don't try to make any
12: * money off of it, or pretend that you wrote it.
13: *
14: * $Log: patch.c,v $
15: * 85/08/15 van%ucbmonet@berkeley
16: * Changes for 4.3bsd diff -c.
17: *
18: * Revision 1.3 85/03/26 15:07:43 lwall
19: * Frozen.
20: *
21: * Revision 1.2.1.9 85/03/12 17:03:35 lwall
22: * Changed pfp->_file to fileno(pfp).
23: *
24: * Revision 1.2.1.8 85/03/12 16:30:43 lwall
25: * Check i_ptr and i_womp to make sure they aren't null before freeing.
26: * Also allow ed output to be suppressed.
27: *
28: * Revision 1.2.1.7 85/03/12 15:56:13 lwall
29: * Added -p option from jromine@uci-750a.
30: *
31: * Revision 1.2.1.6 85/03/12 12:12:51 lwall
32: * Now checks for normalness of file to patch.
33: *
34: * Revision 1.2.1.5 85/03/12 11:52:12 lwall
35: * Added -D (#ifdef) option from joe@fluke.
36: *
37: * Revision 1.2.1.4 84/12/06 11:14:15 lwall
38: * Made smarter about SCCS subdirectories.
39: *
40: * Revision 1.2.1.3 84/12/05 11:18:43 lwall
41: * Added -l switch to do loose string comparison.
42: *
43: * Revision 1.2.1.2 84/12/04 09:47:13 lwall
44: * Failed hunk count not reset on multiple patch file.
45: *
46: * Revision 1.2.1.1 84/12/04 09:42:37 lwall
47: * Branch for sdcrdcf changes.
48: *
49: * Revision 1.2 84/11/29 13:29:51 lwall
50: * Linted. Identifiers uniqified. Fixed i_ptr malloc() bug. Fixed
51: * multiple calls to mktemp(). Will now work on machines that can only
52: * read 32767 chars. Added -R option for diffs with new and old swapped.
53: * Various cosmetic changes.
54: *
55: * Revision 1.1 84/11/09 17:03:58 lwall
56: * Initial revision
57: *
58: */
59:
60: #define DEBUGGING
61:
62: /* shut lint up about the following when return value ignored */
63:
64: #define Signal (void)signal
65: #define Unlink (void)unlink
66: #define Lseek (void)lseek
67: #define Fseek (void)fseek
68: #define Fstat (void)fstat
69: #define Pclose (void)pclose
70: #define Close (void)close
71: #define Fclose (void)fclose
72: #define Fflush (void)fflush
73: #define Sprintf (void)sprintf
74: #define Mktemp (void)mktemp
75: #define Strcpy (void)strcpy
76: #define Strcat (void)strcat
77:
78: #include <stdio.h>
79: #include <assert.h>
80: #include <sys/types.h>
81: #include <sys/stat.h>
82: #include <ctype.h>
83: #include <signal.h>
84:
85: /* constants */
86:
87: #define TRUE (1)
88: #define FALSE (0)
89:
90: #define MAXHUNKSIZE 500
91: #define MAXLINELEN 1024
92: #define BUFFERSIZE 1024
93: #define ORIGEXT ".orig"
94: #define SCCSPREFIX "s."
95: #define GET "get -e %s"
96: #define RCSSUFFIX ",v"
97: #define CHECKOUT "co -l %s"
98:
99: /* handy definitions */
100:
101: #define Null(t) ((t)0)
102: #define Nullch Null(char *)
103: #define Nullfp Null(FILE *)
104:
105: #define Ctl(ch) (ch & 037)
106:
107: #define strNE(s1,s2) (strcmp(s1,s2))
108: #define strEQ(s1,s2) (!strcmp(s1,s2))
109: #define strnNE(s1,s2,l) (strncmp(s1,s2,l))
110: #define strnEQ(s1,s2,l) (!strncmp(s1,s2,l))
111:
112: /* typedefs */
113:
114: typedef char bool;
115: typedef long LINENUM; /* must be signed */
116: typedef unsigned MEM; /* what to feed malloc */
117:
118: /* globals */
119:
120: int Argc; /* guess */
121: char **Argv;
122:
123: struct stat filestat; /* file statistics area */
124:
125: char serrbuf[BUFSIZ]; /* buffer for stderr */
126: char buf[MAXLINELEN]; /* general purpose buffer */
127: FILE *pfp = Nullfp; /* patch file pointer */
128: FILE *ofp = Nullfp; /* output file pointer */
129: FILE *rejfp = Nullfp; /* reject file pointer */
130:
131: LINENUM input_lines = 0; /* how long is input file in lines */
132: LINENUM last_frozen_line = 0; /* how many input lines have been */
133: /* irretractibly output */
134:
135: #define MAXFILEC 2
136: int filec = 0; /* how many file arguments? */
137: char *filearg[MAXFILEC];
138:
139: char *outname = Nullch;
140: char rejname[128];
141:
142: char *origext = Nullch;
143:
144: char TMPOUTNAME[] = "/tmp/patchoXXXXXX";
145: char TMPINNAME[] = "/tmp/patchiXXXXXX"; /* you might want /usr/tmp here */
146: char TMPREJNAME[] = "/tmp/patchrXXXXXX";
147: char TMPPATNAME[] = "/tmp/patchpXXXXXX";
148:
149: LINENUM last_offset = 0;
150: #ifdef DEBUGGING
151: int debug = 0;
152: #endif
153: bool verbose = TRUE;
154: bool reverse = FALSE;
155: bool usepath = FALSE;
156: bool canonicalize = FALSE;
157:
158: #define CONTEXT_DIFF 1
159: #define NORMAL_DIFF 2
160: #define ED_DIFF 3
161: #define NEW_CONTEXT_DIFF 4
162: int diff_type = 0;
163:
164: int do_defines = 0; /* patch using ifdef, ifndef, etc. */
165: char if_defined[128]; /* #ifdef xyzzy */
166: char not_defined[128]; /* #ifndef xyzzy */
167: char else_defined[] = "#else\n"; /* #else */
168: char end_defined[128]; /* #endif xyzzy */
169:
170: char *revision = Nullch; /* prerequisite revision, if any */
171:
172: /* procedures */
173:
174: LINENUM locate_hunk();
175: bool patch_match();
176: bool similar();
177: char *malloc();
178: char *savestr();
179: char *strcpy();
180: char *strcat();
181: char *sprintf(); /* usually */
182: int my_exit();
183: bool rev_in_string();
184: char *fetchname();
185: long atol();
186: long lseek();
187: char *mktemp();
188:
189: /* patch type */
190:
191: bool there_is_another_patch();
192: bool another_hunk();
193: char *pfetch();
194: int pch_line_len();
195: LINENUM pch_first();
196: LINENUM pch_ptrn_lines();
197: LINENUM pch_newfirst();
198: LINENUM pch_repl_lines();
199: LINENUM pch_end();
200: LINENUM pch_context();
201: LINENUM pch_hunk_beg();
202: char pch_char();
203: char *pfetch();
204: char *pgets();
205:
206: /* input file type */
207:
208: char *ifetch();
209:
210: /* apply a context patch to a named file */
211:
212: main(argc,argv)
213: int argc;
214: char **argv;
215: {
216: LINENUM where;
217: int hunk = 0;
218: int failed = 0;
219: int i;
220:
221: setbuf(stderr,serrbuf);
222: for (i = 0; i<MAXFILEC; i++)
223: filearg[i] = Nullch;
224: Mktemp(TMPOUTNAME);
225: Mktemp(TMPINNAME);
226: Mktemp(TMPREJNAME);
227: Mktemp(TMPPATNAME);
228:
229: /* parse switches */
230: Argc = argc;
231: Argv = argv;
232: get_some_switches();
233:
234: /* make sure we clean up /tmp in case of disaster */
235: set_signals();
236:
237: for (
238: open_patch_file(filearg[1]);
239: there_is_another_patch();
240: reinitialize_almost_everything()
241: ) { /* for each patch in patch file */
242:
243: if (outname == Nullch)
244: outname = savestr(filearg[0]);
245:
246: /* initialize the patched file */
247: init_output(TMPOUTNAME);
248:
249: /* for ed script just up and do it and exit */
250: if (diff_type == ED_DIFF) {
251: do_ed_script();
252: continue;
253: }
254:
255: /* initialize reject file */
256: init_reject(TMPREJNAME);
257:
258: /* find out where all the lines are */
259: scan_input(filearg[0]);
260:
261: /* from here on, open no standard i/o files, because malloc */
262: /* might misfire */
263:
264: /* apply each hunk of patch */
265: hunk = 0;
266: failed = 0;
267: while (another_hunk()) {
268: hunk++;
269: where = locate_hunk();
270: if (hunk == 1 && where == Null(LINENUM)) {
271: /* dwim for reversed patch? */
272: pch_swap();
273: reverse = !reverse;
274: where = locate_hunk(); /* try again */
275: if (where == Null(LINENUM)) {
276: pch_swap(); /* no, put it back to normal */
277: reverse = !reverse;
278: }
279: else {
280: say("%seversed (or previously applied) patch detected! %s -R.\n",
281: reverse ? "R" : "Unr",
282: reverse ? "Assuming" : "Ignoring");
283: }
284: }
285: if (where == Null(LINENUM)) {
286: abort_hunk();
287: failed++;
288: if (verbose)
289: say("Hunk #%d failed.\n",hunk);
290: }
291: else {
292: apply_hunk(where);
293: if (verbose)
294: if (last_offset)
295: say("Hunk #%d succeeded (offset %d line%s).\n",
296: hunk,last_offset,last_offset==1?"":"s");
297: else
298: say("Hunk #%d succeeded.\n", hunk);
299: }
300: }
301:
302: assert(hunk);
303:
304: /* finish spewing out the new file */
305: spew_output();
306:
307: /* and put the output where desired */
308: ignore_signals();
309: move_file(TMPOUTNAME,outname);
310: Fclose(rejfp);
311: rejfp = Nullfp;
312: if (failed) {
313: if (!*rejname) {
314: Strcpy(rejname, outname);
315: Strcat(rejname, ".rej");
316: }
317: say("%d out of %d hunks failed--saving rejects to %s\n",
318: failed, hunk, rejname);
319: move_file(TMPREJNAME,rejname);
320: }
321: set_signals();
322: }
323: my_exit(0);
324: }
325:
326: reinitialize_almost_everything()
327: {
328: re_patch();
329: re_input();
330:
331: input_lines = 0;
332: last_frozen_line = 0;
333:
334: filec = 0;
335: if (filearg[0] != Nullch) {
336: free(filearg[0]);
337: filearg[0] = Nullch;
338: }
339:
340: if (outname != Nullch) {
341: free(outname);
342: outname = Nullch;
343: }
344:
345: last_offset = 0;
346:
347: diff_type = 0;
348:
349: if (revision != Nullch) {
350: free(revision);
351: revision = Nullch;
352: }
353:
354: reverse = FALSE;
355:
356: get_some_switches();
357:
358: if (filec >= 2)
359: fatal("You may not change to a different patch file.\n");
360: }
361:
362: get_some_switches()
363: {
364: register char *s;
365:
366: rejname[0] = '\0';
367: if (!Argc)
368: return;
369: for (Argc--,Argv++; Argc; Argc--,Argv++) {
370: s = Argv[0];
371: if (strEQ(s,"+")) {
372: return; /* + will be skipped by for loop */
373: }
374: if (*s != '-' || !s[1]) {
375: if (filec == MAXFILEC)
376: fatal("Too many file arguments.\n");
377: filearg[filec++] = savestr(s);
378: }
379: else {
380: switch (*++s) {
381: case 'b':
382: origext = savestr(Argv[1]);
383: Argc--,Argv++;
384: break;
385: case 'c':
386: diff_type = CONTEXT_DIFF;
387: break;
388: case 'd':
389: if (chdir(Argv[1]) < 0)
390: fatal("Can't cd to %s.\n",Argv[1]);
391: Argc--,Argv++;
392: break;
393: case 'D':
394: do_defines++;
395: Sprintf(if_defined, "#ifdef %s\n", Argv[1]);
396: Sprintf(not_defined, "#ifndef %s\n", Argv[1]);
397: Sprintf(end_defined, "#endif %s\n", Argv[1]);
398: Argc--,Argv++;
399: break;
400: case 'e':
401: diff_type = ED_DIFF;
402: break;
403: case 'l':
404: canonicalize = TRUE;
405: break;
406: case 'n':
407: diff_type = NORMAL_DIFF;
408: break;
409: case 'o':
410: outname = savestr(Argv[1]);
411: Argc--,Argv++;
412: break;
413: case 'p':
414: usepath = TRUE; /* do not strip path names */
415: break;
416: case 'r':
417: Strcpy(rejname,Argv[1]);
418: Argc--,Argv++;
419: break;
420: case 'R':
421: reverse = TRUE;
422: break;
423: case 's':
424: verbose = FALSE;
425: break;
426: #ifdef DEBUGGING
427: case 'x':
428: debug = atoi(s+1);
429: break;
430: #endif
431: default:
432: fatal("Unrecognized switch: %s\n",Argv[0]);
433: }
434: }
435: }
436: }
437:
438: LINENUM
439: locate_hunk()
440: {
441: register LINENUM first_guess = pch_first() + last_offset;
442: register LINENUM offset;
443: LINENUM pat_lines = pch_ptrn_lines();
444: register LINENUM max_pos_offset = input_lines - first_guess
445: - pat_lines + 1;
446: register LINENUM max_neg_offset = first_guess - last_frozen_line - 1
447: - pch_context();
448:
449: if (!pat_lines) /* null range matches always */
450: return first_guess;
451: if (max_neg_offset >= first_guess) /* do not try lines < 0 */
452: max_neg_offset = first_guess - 1;
453: if (first_guess <= input_lines && patch_match(first_guess,(LINENUM)0))
454: return first_guess;
455: for (offset = 1; ; offset++) {
456: bool check_after = (offset <= max_pos_offset);
457: bool check_before = (offset <= max_pos_offset);
458:
459: if (check_after && patch_match(first_guess,offset)) {
460: #ifdef DEBUGGING
461: if (debug & 1)
462: printf("Offset changing from %d to %d\n",last_offset,offset);
463: #endif
464: last_offset = offset;
465: return first_guess+offset;
466: }
467: else if (check_before && patch_match(first_guess,-offset)) {
468: #ifdef DEBUGGING
469: if (debug & 1)
470: printf("Offset changing from %d to %d\n",last_offset,-offset);
471: #endif
472: last_offset = -offset;
473: return first_guess-offset;
474: }
475: else if (!check_before && !check_after)
476: return Null(LINENUM);
477: }
478: }
479:
480: /* we did not find the pattern, dump out the hunk so they can handle it */
481:
482: abort_hunk()
483: {
484: register LINENUM i;
485: register LINENUM pat_end = pch_end();
486: /* add in last_offset to guess the same as the previous successful hunk */
487: int oldfirst = pch_first() + last_offset;
488: int newfirst = pch_newfirst() + last_offset;
489: int oldlast = oldfirst + pch_ptrn_lines() - 1;
490: int newlast = newfirst + pch_repl_lines() - 1;
491:
492: fprintf(rejfp,"***************\n");
493: for (i=0; i<=pat_end; i++) {
494: switch (pch_char(i)) {
495: case '*':
496: fprintf(rejfp,"*** %d,%d\n", oldfirst, oldlast);
497: break;
498: case '=':
499: fprintf(rejfp,"--- %d,%d -----\n", newfirst, newlast);
500: break;
501: case '\n':
502: fprintf(rejfp,"%s", pfetch(i));
503: break;
504: case ' ': case '-': case '+': case '!':
505: fprintf(rejfp,"%c %s", pch_char(i), pfetch(i));
506: break;
507: default:
508: say("Fatal internal error in abort_hunk().\n");
509: abort();
510: }
511: }
512: }
513:
514: /* we found where to apply it (we hope), so do it */
515:
516: apply_hunk(where)
517: LINENUM where;
518: {
519: register LINENUM old = 1;
520: register LINENUM lastline = pch_ptrn_lines();
521: register LINENUM new = lastline+1;
522: register int def_state = 0; /* -1 = ifndef, 1 = ifdef */
523:
524: where--;
525: while (pch_char(new) == '=' || pch_char(new) == '\n')
526: new++;
527:
528: while (old <= lastline) {
529: if (pch_char(old) == '-') {
530: copy_till(where + old - 1);
531: if (do_defines) {
532: if (def_state == 0) {
533: fputs(not_defined, ofp);
534: def_state = -1;
535: } else
536: if (def_state == 1) {
537: fputs(else_defined, ofp);
538: def_state = 2;
539: }
540: fputs(pfetch(old), ofp);
541: }
542: last_frozen_line++;
543: old++;
544: }
545: else if (pch_char(new) == '+') {
546: copy_till(where + old - 1);
547: if (do_defines) {
548: if (def_state == -1) {
549: fputs(else_defined, ofp);
550: def_state = 2;
551: } else
552: if (def_state == 0) {
553: fputs(if_defined, ofp);
554: def_state = 1;
555: }
556: }
557: fputs(pfetch(new),ofp);
558: new++;
559: }
560: else {
561: if (pch_char(new) != pch_char(old)) {
562: say("Out-of-sync patch, lines %d,%d\n",
563: pch_hunk_beg() + old - 1,
564: pch_hunk_beg() + new - 1);
565: #ifdef DEBUGGING
566: printf("oldchar = '%c', newchar = '%c'\n",
567: pch_char(old), pch_char(new));
568: #endif
569: my_exit(1);
570: }
571: if (pch_char(new) == '!') {
572: copy_till(where + old - 1);
573: if (do_defines) {
574: fputs(not_defined,ofp);
575: def_state = -1;
576: }
577: while (pch_char(old) == '!') {
578: if (do_defines) {
579: fputs(pfetch(old),ofp);
580: }
581: last_frozen_line++;
582: old++;
583: }
584: if (do_defines) {
585: fputs(else_defined, ofp);
586: def_state = 2;
587: }
588: while (pch_char(new) == '!') {
589: fputs(pfetch(new),ofp);
590: new++;
591: }
592: if (do_defines) {
593: fputs(end_defined, ofp);
594: def_state = 0;
595: }
596: }
597: else {
598: assert(pch_char(new) == ' ');
599: old++;
600: new++;
601: }
602: }
603: }
604: if (new <= pch_end() && pch_char(new) == '+') {
605: copy_till(where + old - 1);
606: if (do_defines) {
607: if (def_state == 0) {
608: fputs(if_defined, ofp);
609: def_state = 1;
610: } else
611: if (def_state == -1) {
612: fputs(else_defined, ofp);
613: def_state = 2;
614: }
615: }
616: while (new <= pch_end() && pch_char(new) == '+') {
617: fputs(pfetch(new),ofp);
618: new++;
619: }
620: }
621: if (do_defines && def_state) {
622: fputs(end_defined, ofp);
623: }
624: }
625:
626: do_ed_script()
627: {
628: FILE *pipefp, *popen();
629: bool this_line_is_command = FALSE;
630: register char *t;
631: long beginning_of_this_line;
632:
633: Unlink(TMPOUTNAME);
634: copy_file(filearg[0],TMPOUTNAME);
635: if (verbose)
636: Sprintf(buf,"/bin/ed %s",TMPOUTNAME);
637: else
638: Sprintf(buf,"/bin/ed - %s",TMPOUTNAME);
639: pipefp = popen(buf,"w");
640: for (;;) {
641: beginning_of_this_line = ftell(pfp);
642: if (pgets(buf,sizeof buf,pfp) == Nullch) {
643: next_intuit_at(beginning_of_this_line);
644: break;
645: }
646: for (t=buf; isdigit(*t) || *t == ','; t++) ;
647: this_line_is_command = (isdigit(*buf) &&
648: (*t == 'd' || *t == 'c' || *t == 'a') );
649: if (this_line_is_command) {
650: fputs(buf,pipefp);
651: if (*t != 'd') {
652: while (pgets(buf,sizeof buf,pfp) != Nullch) {
653: fputs(buf,pipefp);
654: if (strEQ(buf,".\n"))
655: break;
656: }
657: }
658: }
659: else {
660: next_intuit_at(beginning_of_this_line);
661: break;
662: }
663: }
664: fprintf(pipefp,"w\n");
665: fprintf(pipefp,"q\n");
666: Fflush(pipefp);
667: Pclose(pipefp);
668: ignore_signals();
669: move_file(TMPOUTNAME,outname);
670: set_signals();
671: }
672:
673: init_output(name)
674: char *name;
675: {
676: ofp = fopen(name,"w");
677: if (ofp == Nullfp)
678: fatal("patch: can't create %s.\n",name);
679: }
680:
681: init_reject(name)
682: char *name;
683: {
684: rejfp = fopen(name,"w");
685: if (rejfp == Nullfp)
686: fatal("patch: can't create %s.\n",name);
687: }
688:
689: move_file(from,to)
690: char *from, *to;
691: {
692: char bakname[512];
693: register char *s;
694: int fromfd;
695: register int i;
696:
697: /* to stdout? */
698:
699: if (strEQ(to,"-")) {
700: #ifdef DEBUGGING
701: if (debug & 4)
702: say("Moving %s to stdout.\n",from);
703: #endif
704: fromfd = open(from,0);
705: if (fromfd < 0)
706: fatal("patch: internal error, can't reopen %s\n",from);
707: while ((i=read(fromfd,buf,sizeof buf)) > 0)
708: if (write(1,buf,i) != 1)
709: fatal("patch: write failed\n");
710: Close(fromfd);
711: return;
712: }
713:
714: Strcpy(bakname,to);
715: Strcat(bakname,origext?origext:ORIGEXT);
716: if (stat(to,&filestat) >= 0) { /* output file exists */
717: dev_t to_device = filestat.st_dev;
718: ino_t to_inode = filestat.st_ino;
719: char *simplename = bakname;
720:
721: for (s=bakname; *s; s++) {
722: if (*s == '/')
723: simplename = s+1;
724: }
725: /* find a backup name that is not the same file */
726: while (stat(bakname,&filestat) >= 0 &&
727: to_device == filestat.st_dev && to_inode == filestat.st_ino) {
728: for (s=simplename; *s && !islower(*s); s++) ;
729: if (*s)
730: *s = toupper(*s);
731: else
732: Strcpy(simplename, simplename+1);
733: }
734: while (unlink(bakname) >= 0) ; /* while() is for benefit of Eunice */
735: #ifdef DEBUGGING
736: if (debug & 4)
737: say("Moving %s to %s.\n",to,bakname);
738: #endif
739: if (link(to,bakname) < 0) {
740: say("patch: can't backup %s, output is in %s\n",
741: to,from);
742: return;
743: }
744: while (unlink(to) >= 0) ;
745: }
746: #ifdef DEBUGGING
747: if (debug & 4)
748: say("Moving %s to %s.\n",from,to);
749: #endif
750: if (link(from,to) < 0) { /* different file system? */
751: int tofd;
752:
753: tofd = creat(to,0666);
754: if (tofd < 0) {
755: say("patch: can't create %s, output is in %s.\n",
756: to, from);
757: return;
758: }
759: fromfd = open(from,0);
760: if (fromfd < 0)
761: fatal("patch: internal error, can't reopen %s\n",from);
762: while ((i=read(fromfd,buf,sizeof buf)) > 0)
763: if (write(tofd,buf,i) != i)
764: fatal("patch: write failed\n");
765: Close(fromfd);
766: Close(tofd);
767: }
768: Unlink(from);
769: }
770:
771: copy_file(from,to)
772: char *from, *to;
773: {
774: int tofd;
775: int fromfd;
776: register int i;
777:
778: tofd = creat(to,0666);
779: if (tofd < 0)
780: fatal("patch: can't create %s.\n", to);
781: fromfd = open(from,0);
782: if (fromfd < 0)
783: fatal("patch: internal error, can't reopen %s\n",from);
784: while ((i=read(fromfd,buf,sizeof buf)) > 0)
785: if (write(tofd,buf,i) != i)
786: fatal("patch: write (%s) failed\n", to);
787: Close(fromfd);
788: Close(tofd);
789: }
790:
791: copy_till(lastline)
792: register LINENUM lastline;
793: {
794: if (last_frozen_line > lastline)
795: say("patch: misordered hunks! output will be garbled.\n");
796: while (last_frozen_line < lastline) {
797: dump_line(++last_frozen_line);
798: }
799: }
800:
801: spew_output()
802: {
803: copy_till(input_lines); /* dump remainder of file */
804: Fclose(ofp);
805: ofp = Nullfp;
806: }
807:
808: dump_line(line)
809: LINENUM line;
810: {
811: register char *s;
812:
813: for (s=ifetch(line,0); putc(*s,ofp) != '\n'; s++) ;
814: }
815:
816: /* does the patch pattern match at line base+offset? */
817:
818: bool
819: patch_match(base,offset)
820: LINENUM base;
821: LINENUM offset;
822: {
823: register LINENUM pline;
824: register LINENUM iline;
825: register LINENUM pat_lines = pch_ptrn_lines();
826:
827: for (pline = 1, iline=base+offset; pline <= pat_lines; pline++,iline++) {
828: if (canonicalize) {
829: if (!similar(ifetch(iline,(offset >= 0)),
830: pfetch(pline),
831: pch_line_len(pline) ))
832: return FALSE;
833: }
834: else if (strnNE(ifetch(iline,(offset >= 0)),
835: pfetch(pline),
836: pch_line_len(pline) ))
837: return FALSE;
838: }
839: return TRUE;
840: }
841:
842: /* match two lines with canonicalized white space */
843:
844: bool
845: similar(a,b,len)
846: register char *a, *b;
847: register int len;
848: {
849: while (len) {
850: if (isspace(*b)) { /* whitespace (or \n) to match? */
851: if (!isspace(*a)) /* no corresponding whitespace? */
852: return FALSE;
853: while (len && isspace(*b) && *b != '\n')
854: b++,len--; /* skip pattern whitespace */
855: while (isspace(*a) && *a != '\n')
856: a++; /* skip target whitespace */
857: if (*a == '\n' || *b == '\n')
858: return (*a == *b); /* should end in sync */
859: }
860: else if (*a++ != *b++) /* match non-whitespace chars */
861: return FALSE;
862: else
863: len--; /* probably not necessary */
864: }
865: return TRUE; /* actually, this is not reached */
866: /* since there is always a \n */
867: }
868:
869: /* input file with indexable lines abstract type */
870:
871: bool using_plan_a = TRUE;
872: static long i_size; /* size of the input file */
873: static char *i_womp; /* plan a buffer for entire file */
874: static char **i_ptr; /* pointers to lines in i_womp */
875:
876: static int tifd = -1; /* plan b virtual string array */
877: static char *tibuf[2]; /* plan b buffers */
878: static LINENUM tiline[2] = {-1,-1}; /* 1st line in each buffer */
879: static LINENUM lines_per_buf; /* how many lines per buffer */
880: static int tireclen; /* length of records in tmp file */
881:
882: re_input()
883: {
884: if (using_plan_a) {
885: i_size = 0;
886: /*NOSTRICT*/
887: if (i_ptr != Null(char**))
888: free((char *)i_ptr);
889: if (i_womp != Nullch)
890: free(i_womp);
891: i_womp = Nullch;
892: i_ptr = Null(char **);
893: }
894: else {
895: using_plan_a = TRUE; /* maybe the next one is smaller */
896: Close(tifd);
897: tifd = -1;
898: free(tibuf[0]);
899: free(tibuf[1]);
900: tibuf[0] = tibuf[1] = Nullch;
901: tiline[0] = tiline[1] = -1;
902: tireclen = 0;
903: }
904: }
905:
906: scan_input(filename)
907: char *filename;
908: {
909: bool plan_a();
910:
911: if (!plan_a(filename))
912: plan_b(filename);
913: }
914:
915: /* try keeping everything in memory */
916:
917: bool
918: plan_a(filename)
919: char *filename;
920: {
921: int ifd;
922: register char *s;
923: register LINENUM iline;
924:
925: if (stat(filename,&filestat) < 0) {
926: Sprintf(buf,"RCS/%s%s",filename,RCSSUFFIX);
927: if (stat(buf,&filestat) >= 0 || stat(buf+4,&filestat) >= 0) {
928: Sprintf(buf,CHECKOUT,filename);
929: if (verbose)
930: say("Can't find %s--attempting to check it out from RCS.\n",
931: filename);
932: if (system(buf) || stat(filename,&filestat))
933: fatal("Can't check out %s.\n",filename);
934: }
935: else {
936: Sprintf(buf,"SCCS/%s%s",SCCSPREFIX,filename);
937: if (stat(buf,&filestat) >= 0 || stat(buf+5,&filestat) >= 0) {
938: Sprintf(buf,GET,filename);
939: if (verbose)
940: say("Can't find %s--attempting to get it from SCCS.\n",
941: filename);
942: if (system(buf) || stat(filename,&filestat))
943: fatal("Can't get %s.\n",filename);
944: }
945: else
946: fatal("Can't find %s.\n",filename);
947: }
948: }
949: if ((filestat.st_mode & S_IFMT) & ~S_IFREG)
950: fatal("%s is not a normal file--can't patch.\n",filename);
951: i_size = filestat.st_size;
952: /*NOSTRICT*/
953: i_womp = malloc((MEM)(i_size+2));
954: if (i_womp == Nullch)
955: return FALSE;
956: if ((ifd = open(filename,0)) < 0)
957: fatal("Can't open file %s\n",filename);
958: /*NOSTRICT*/
959: if (read(ifd,i_womp,(int)i_size) != i_size) {
960: Close(ifd);
961: free(i_womp);
962: return FALSE;
963: }
964: Close(ifd);
965: if (i_womp[i_size-1] != '\n')
966: i_womp[i_size++] = '\n';
967: i_womp[i_size] = '\0';
968:
969: /* count the lines in the buffer so we know how many pointers we need */
970:
971: iline = 0;
972: for (s=i_womp; *s; s++) {
973: if (*s == '\n')
974: iline++;
975: }
976: /*NOSTRICT*/
977: i_ptr = (char **)malloc((MEM)((iline + 2) * sizeof(char *)));
978: if (i_ptr == Null(char **)) { /* shucks, it was a near thing */
979: free((char *)i_womp);
980: return FALSE;
981: }
982:
983: /* now scan the buffer and build pointer array */
984:
985: iline = 1;
986: i_ptr[iline] = i_womp;
987: for (s=i_womp; *s; s++) {
988: if (*s == '\n')
989: i_ptr[++iline] = s+1; /* these are NOT null terminated */
990: }
991: input_lines = iline - 1;
992:
993: /* now check for revision, if any */
994:
995: if (revision != Nullch) {
996: if (!rev_in_string(i_womp)) {
997: ask("This file doesn't appear to be the %s version--patch anyway? [n] ",
998: revision);
999: if (*buf != 'y')
1000: fatal("Aborted.\n");
1001: }
1002: else if (verbose)
1003: say("Good. This file appears to be the %s version.\n",
1004: revision);
1005: }
1006: return TRUE; /* plan a will work */
1007: }
1008:
1009: /* keep (virtually) nothing in memory */
1010:
1011: plan_b(filename)
1012: char *filename;
1013: {
1014: FILE *ifp;
1015: register int i = 0;
1016: register int maxlen = 1;
1017: bool found_revision = (revision == Nullch);
1018:
1019: using_plan_a = FALSE;
1020: if ((ifp = fopen(filename,"r")) == Nullfp)
1021: fatal("Can't open file %s\n",filename);
1022: if ((tifd = creat(TMPINNAME,0666)) < 0)
1023: fatal("Can't open file %s\n",TMPINNAME);
1024: while (fgets(buf,sizeof buf, ifp) != Nullch) {
1025: if (revision != Nullch && !found_revision && rev_in_string(buf))
1026: found_revision = TRUE;
1027: if ((i = strlen(buf)) > maxlen)
1028: maxlen = i; /* find longest line */
1029: }
1030: if (revision != Nullch) {
1031: if (!found_revision) {
1032: ask("This file doesn't appear to be the %s version--patch anyway? [n] ",
1033: revision);
1034: if (*buf != 'y')
1035: fatal("Aborted.\n");
1036: }
1037: else if (verbose)
1038: say("Good. This file appears to be the %s version.\n",
1039: revision);
1040: }
1041: Fseek(ifp,0L,0); /* rewind file */
1042: lines_per_buf = BUFFERSIZE / maxlen;
1043: tireclen = maxlen;
1044: tibuf[0] = malloc((MEM)(BUFFERSIZE + 1));
1045: tibuf[1] = malloc((MEM)(BUFFERSIZE + 1));
1046: if (tibuf[1] == Nullch)
1047: fatal("Can't seem to get enough memory.\n");
1048: for (i=1; ; i++) {
1049: if (! (i % lines_per_buf)) /* new block */
1050: if (write(tifd,tibuf[0],BUFFERSIZE) < BUFFERSIZE)
1051: fatal("patch: can't write temp file.\n");
1052: if (fgets(tibuf[0] + maxlen * (i%lines_per_buf), maxlen + 1, ifp)
1053: == Nullch) {
1054: input_lines = i - 1;
1055: if (i % lines_per_buf)
1056: if (write(tifd,tibuf[0],BUFFERSIZE) < BUFFERSIZE)
1057: fatal("patch: can't write temp file.\n");
1058: break;
1059: }
1060: }
1061: Fclose(ifp);
1062: Close(tifd);
1063: if ((tifd = open(TMPINNAME,0)) < 0) {
1064: fatal("Can't reopen file %s\n",TMPINNAME);
1065: }
1066: }
1067:
1068: /* fetch a line from the input file, \n terminated, not necessarily \0 */
1069: char *
1070: ifetch(line,whichbuf)
1071: register LINENUM line;
1072: int whichbuf; /* ignored when file in memory */
1073: {
1074: if (line < 1 || line > input_lines)
1075: return "";
1076: if (using_plan_a)
1077: return i_ptr[line];
1078: else {
1079: LINENUM offline = line % lines_per_buf;
1080: LINENUM baseline = line - offline;
1081:
1082: if (tiline[0] == baseline)
1083: whichbuf = 0;
1084: else if (tiline[1] == baseline)
1085: whichbuf = 1;
1086: else {
1087: tiline[whichbuf] = baseline;
1088: Lseek(tifd,(long)baseline / lines_per_buf * BUFFERSIZE,0);
1089: if (read(tifd,tibuf[whichbuf],BUFFERSIZE) < 0)
1090: fatal("Error reading tmp file %s.\n",TMPINNAME);
1091: }
1092: return tibuf[whichbuf] + (tireclen*offline);
1093: }
1094: }
1095:
1096: /* patch abstract type */
1097:
1098: static long p_filesize; /* size of the patch file */
1099: static LINENUM p_first; /* 1st line number */
1100: static LINENUM p_newfirst; /* 1st line number of replacement */
1101: static LINENUM p_ptrn_lines; /* # lines in pattern */
1102: static LINENUM p_repl_lines; /* # lines in replacement text */
1103: static LINENUM p_end = -1; /* last line in hunk */
1104: static LINENUM p_max; /* max allowed value of p_end */
1105: static LINENUM p_context = 3; /* # of context lines */
1106: static LINENUM p_input_line = 0; /* current line # from patch file */
1107: static char *p_line[MAXHUNKSIZE]; /* the text of the hunk */
1108: static char p_char[MAXHUNKSIZE]; /* +, -, and ! */
1109: static int p_len[MAXHUNKSIZE]; /* length of each line */
1110: static int p_indent; /* indent to patch */
1111: static long p_base; /* where to intuit this time */
1112: static long p_start; /* where intuit found a patch */
1113:
1114: re_patch()
1115: {
1116: p_first = (LINENUM)0;
1117: p_newfirst = (LINENUM)0;
1118: p_ptrn_lines = (LINENUM)0;
1119: p_repl_lines = (LINENUM)0;
1120: p_end = (LINENUM)-1;
1121: p_max = (LINENUM)0;
1122: p_indent = 0;
1123: }
1124:
1125: open_patch_file(filename)
1126: char *filename;
1127: {
1128: if (filename == Nullch || !*filename || strEQ(filename,"-")) {
1129: pfp = fopen(TMPPATNAME,"w");
1130: if (pfp == Nullfp)
1131: fatal("patch: can't create %s.\n",TMPPATNAME);
1132: while (fgets(buf,sizeof buf,stdin) != NULL)
1133: fputs(buf,pfp);
1134: Fclose(pfp);
1135: filename = TMPPATNAME;
1136: }
1137: pfp = fopen(filename,"r");
1138: if (pfp == Nullfp)
1139: fatal("patch file %s not found\n",filename);
1140: Fstat(fileno(pfp), &filestat);
1141: p_filesize = filestat.st_size;
1142: next_intuit_at(0L); /* start at the beginning */
1143: }
1144:
1145: bool
1146: there_is_another_patch()
1147: {
1148: bool no_input_file = (filearg[0] == Nullch);
1149:
1150: if (p_base != 0L && p_base >= p_filesize) {
1151: if (verbose)
1152: say("done\n");
1153: return FALSE;
1154: }
1155: if (verbose)
1156: say("Hmm...");
1157: diff_type = intuit_diff_type();
1158: if (!diff_type) {
1159: if (p_base != 0L) {
1160: if (verbose)
1161: say(" Ignoring the trailing garbage.\ndone\n");
1162: }
1163: else
1164: say(" I can't seem to find a patch in there anywhere.\n");
1165: return FALSE;
1166: }
1167: if (verbose)
1168: say(" %sooks like %s to me...\n",
1169: (p_base == 0L ? "L" : "The next patch l"),
1170: diff_type == CONTEXT_DIFF ? "a context diff" :
1171: diff_type == NEW_CONTEXT_DIFF ? "a new-style context diff" :
1172: diff_type == NORMAL_DIFF ? "a normal diff" :
1173: "an ed script" );
1174: if (p_indent && verbose)
1175: say("(Patch is indented %d space%s.)\n",p_indent,p_indent==1?"":"s");
1176: skip_to(p_start);
1177: if (no_input_file) {
1178: if (filearg[0] == Nullch) {
1179: ask("File to patch: ");
1180: filearg[0] = fetchname(buf);
1181: }
1182: else if (verbose) {
1183: say("Patching file %s...\n",filearg[0]);
1184: }
1185: }
1186: return TRUE;
1187: }
1188:
1189: intuit_diff_type()
1190: {
1191: long this_line = 0;
1192: long previous_line;
1193: long first_command_line = -1;
1194: bool last_line_was_command = FALSE;
1195: bool this_line_is_command = FALSE;
1196: bool last_line_was_stars = FALSE;
1197: bool this_line_is_stars = FALSE;
1198: register int indent;
1199: register char *s, *t;
1200: char *oldname = Nullch;
1201: char *newname = Nullch;
1202: bool no_filearg = (filearg[0] == Nullch);
1203:
1204: Fseek(pfp,p_base,0);
1205: for (;;) {
1206: previous_line = this_line;
1207: last_line_was_command = this_line_is_command;
1208: last_line_was_stars = this_line_is_stars;
1209: this_line = ftell(pfp);
1210: indent = 0;
1211: if (fgets(buf,sizeof buf,pfp) == Nullch) {
1212: if (first_command_line >= 0L) {
1213: /* nothing but deletes!? */
1214: p_start = first_command_line;
1215: return ED_DIFF;
1216: }
1217: else {
1218: p_start = this_line;
1219: return 0;
1220: }
1221: }
1222: for (s = buf; *s == ' ' || *s == '\t'; s++) {
1223: if (*s == '\t')
1224: indent += 8 - (indent % 8);
1225: else
1226: indent++;
1227: }
1228: for (t=s; isdigit(*t) || *t == ','; t++) ;
1229: this_line_is_command = (isdigit(*s) &&
1230: (*t == 'd' || *t == 'c' || *t == 'a') );
1231: if (first_command_line < 0L && this_line_is_command) {
1232: first_command_line = this_line;
1233: p_indent = indent; /* assume this for now */
1234: }
1235: if (strnEQ(s,"*** ",4))
1236: oldname = fetchname(s+4);
1237: else if (strnEQ(s,"--- ",4)) {
1238: newname = fetchname(s+4);
1239: if (no_filearg) {
1240: if (oldname && newname) {
1241: if (strlen(oldname) < strlen(newname))
1242: filearg[0] = oldname;
1243: else
1244: filearg[0] = newname;
1245: }
1246: else if (oldname)
1247: filearg[0] = oldname;
1248: else if (newname)
1249: filearg[0] = newname;
1250: }
1251: }
1252: else if (strnEQ(s,"Index:",6)) {
1253: if (no_filearg)
1254: filearg[0] = fetchname(s+6);
1255: /* this filearg might get limboed */
1256: }
1257: else if (strnEQ(s,"Prereq:",7)) {
1258: for (t=s+7; isspace(*t); t++) ;
1259: revision = savestr(t);
1260: for (t=revision; *t && !isspace(*t); t++) ;
1261: *t = '\0';
1262: if (!*revision) {
1263: free(revision);
1264: revision = Nullch;
1265: }
1266: }
1267: if ((!diff_type || diff_type == ED_DIFF) &&
1268: first_command_line >= 0L &&
1269: strEQ(s,".\n") ) {
1270: p_indent = indent;
1271: p_start = first_command_line;
1272: return ED_DIFF;
1273: }
1274: this_line_is_stars = strnEQ(s,"********",8);
1275: if ((!diff_type || diff_type == CONTEXT_DIFF) && last_line_was_stars &&
1276: strnEQ(s,"*** ",4)) {
1277: /* if this is a new context diff the character just before */
1278: /* the newline is a '*'. */
1279: while (*s != '\n')
1280: s++;
1281: p_indent = indent;
1282: p_start = previous_line;
1283: return (*(s-1) == '*' ? NEW_CONTEXT_DIFF : CONTEXT_DIFF);
1284: }
1285: if ((!diff_type || diff_type == NORMAL_DIFF) &&
1286: last_line_was_command &&
1287: (strnEQ(s,"< ",2) || strnEQ(s,"> ",2)) ) {
1288: p_start = previous_line;
1289: p_indent = indent;
1290: return NORMAL_DIFF;
1291: }
1292: }
1293: }
1294:
1295: char *
1296: fetchname(at)
1297: char *at;
1298: {
1299: char *s = savestr(at);
1300: char *name;
1301: register char *t;
1302: char tmpbuf[200];
1303:
1304: for (t=s; isspace(*t); t++) ;
1305: name = t;
1306: for (; *t && !isspace(*t); t++)
1307: if (!usepath)
1308: if (*t == '/')
1309: name = t+1;
1310: *t = '\0';
1311: name = savestr(name);
1312: Sprintf(tmpbuf,"RCS/%s",name);
1313: free(s);
1314: if (stat(name,&filestat) < 0) {
1315: Strcat(tmpbuf,RCSSUFFIX);
1316: if (stat(tmpbuf,&filestat) < 0 && stat(tmpbuf+4,&filestat) < 0) {
1317: Sprintf(tmpbuf,"SCCS/%s%s",SCCSPREFIX,name);
1318: if (stat(tmpbuf,&filestat) < 0 && stat(tmpbuf+5,&filestat) < 0) {
1319: free(name);
1320: name = Nullch;
1321: }
1322: }
1323: }
1324: return name;
1325: }
1326:
1327: next_intuit_at(file_pos)
1328: long file_pos;
1329: {
1330: p_base = file_pos;
1331: }
1332:
1333: skip_to(file_pos)
1334: long file_pos;
1335: {
1336: char *ret;
1337:
1338: assert(p_base <= file_pos);
1339: if (verbose && p_base < file_pos) {
1340: Fseek(pfp,p_base,0);
1341: say("The text leading up to this was:\n--------------------------\n");
1342: while (ftell(pfp) < file_pos) {
1343: ret = fgets(buf,sizeof buf,pfp);
1344: assert(ret != Nullch);
1345: say("|%s",buf);
1346: }
1347: say("--------------------------\n");
1348: }
1349: else
1350: Fseek(pfp,file_pos,0);
1351: }
1352:
1353: bool
1354: another_hunk()
1355: {
1356: register char *s;
1357: char *ret;
1358: register int context = 0;
1359:
1360: while (p_end >= 0) {
1361: free(p_line[p_end--]);
1362: }
1363: assert(p_end == -1);
1364:
1365: p_max = MAXHUNKSIZE; /* gets reduced when --- found */
1366: if (diff_type == CONTEXT_DIFF) {
1367: long line_beginning = ftell(pfp);
1368: LINENUM repl_beginning = 0;
1369:
1370: ret = pgets(buf,sizeof buf, pfp);
1371: if (ret == Nullch || strnNE(buf,"********",8)) {
1372: next_intuit_at(line_beginning);
1373: return FALSE;
1374: }
1375: p_context = 100;
1376: while (p_end < p_max) {
1377: ret = pgets(buf,sizeof buf, pfp);
1378: if (ret == Nullch) {
1379: if (p_max - p_end < 4)
1380: Strcpy(buf," \n"); /* assume blank lines got chopped */
1381: else
1382: fatal("Unexpected end of file in patch.\n");
1383: }
1384: p_input_line++;
1385: if (strnEQ(buf,"********",8))
1386: fatal("Unexpected end of hunk at line %d.\n",
1387: p_input_line);
1388: p_char[++p_end] = *buf;
1389: switch (*buf) {
1390: case '*':
1391: if (p_end != 0)
1392: fatal("Unexpected *** at line %d: %s", p_input_line, buf);
1393: context = 0;
1394: p_line[p_end] = savestr(buf);
1395: for (s=buf; *s && !isdigit(*s); s++) ;
1396: p_first = (LINENUM) atol(s);
1397: while (isdigit(*s)) s++;
1398: for (; *s && !isdigit(*s); s++) ;
1399: p_ptrn_lines = ((LINENUM)atol(s)) - p_first + 1;
1400: break;
1401: case '-':
1402: if (buf[1] == '-') {
1403: if (p_end != p_ptrn_lines + 1 &&
1404: p_end != p_ptrn_lines + 2)
1405: fatal("Unexpected --- at line %d: %s",
1406: p_input_line,buf);
1407: repl_beginning = p_end;
1408: context = 0;
1409: p_line[p_end] = savestr(buf);
1410: p_char[p_end] = '=';
1411: for (s=buf; *s && !isdigit(*s); s++) ;
1412: p_newfirst = (LINENUM) atol(s);
1413: while (isdigit(*s)) s++;
1414: for (; *s && !isdigit(*s); s++) ;
1415: p_max = ((LINENUM)atol(s)) - p_newfirst + 1 + p_end;
1416: break;
1417: }
1418: /* FALL THROUGH */
1419: case '+': case '!':
1420: if (context > 0) {
1421: if (context < p_context)
1422: p_context = context;
1423: context = -100;
1424: }
1425: p_line[p_end] = savestr(buf+2);
1426: break;
1427: case '\t': case '\n': /* assume the 2 spaces got eaten */
1428: p_line[p_end] = savestr(buf);
1429: if (p_end != p_ptrn_lines + 1) {
1430: context++;
1431: p_char[p_end] = ' ';
1432: }
1433: break;
1434: case ' ':
1435: context++;
1436: p_line[p_end] = savestr(buf+2);
1437: break;
1438: default:
1439: fatal("Malformed patch at line %d: %s",p_input_line,buf);
1440: }
1441: p_len[p_end] = 0;
1442: if (p_line[p_end] != 0)
1443: p_len[p_end] = strlen(p_line[p_end]);
1444: /* for strncmp() so we do not have */
1445: /* to assume null termination */
1446: }
1447: if (p_end >=0 && !p_ptrn_lines)
1448: fatal("No --- found in patch at line %d\n", pch_hunk_beg());
1449: p_repl_lines = p_end - repl_beginning;
1450: }
1451: else if (diff_type == NEW_CONTEXT_DIFF) {
1452: long line_beginning = ftell(pfp);
1453: LINENUM repl_beginning = 0;
1454: LINENUM fillcnt = 0;
1455: LINENUM fillsrc;
1456: LINENUM filldst;
1457:
1458: ret = pgets(buf,sizeof buf, pfp);
1459: if (ret == Nullch || strnNE(buf,"********",8)) {
1460: next_intuit_at(line_beginning);
1461: return FALSE;
1462: }
1463: p_context = 0;
1464: while (p_end < p_max) {
1465: line_beginning = ftell(pfp);
1466: ret = pgets(buf,sizeof buf, pfp);
1467: if (ret == Nullch) {
1468: if (p_max - p_end < 4)
1469: Strcpy(buf," \n"); /* assume blank lines got chopped */
1470: else
1471: fatal("Unexpected end of file in patch.\n");
1472: }
1473: p_input_line++;
1474: p_char[++p_end] = *buf;
1475: switch (*buf) {
1476: case '*':
1477: if (strnEQ(buf,"********",8)) {
1478: if (p_end != repl_beginning + 1)
1479: fatal("Unexpected end of hunk at line %d.\n",
1480: p_input_line);
1481: /* redundant 'new' context lines were omitted - set up */
1482: /* to fill them in from the the old file's context */
1483: fillsrc = 1;
1484: filldst = p_end;
1485: fillcnt = p_max - repl_beginning;
1486: p_end = p_max;
1487: Fseek(pfp, line_beginning, 0); /* backup the diff input */
1488: break;
1489: }
1490: if (p_end != 0)
1491: fatal("Unexpected *** at line %d: %s", p_input_line, buf);
1492: context = 0;
1493: p_line[p_end] = savestr(buf);
1494: for (s=buf; *s && !isdigit(*s); s++) ;
1495: p_first = (LINENUM) atol(s);
1496: while (isdigit(*s)) s++;
1497: for (; *s && !isdigit(*s); s++) ;
1498: p_ptrn_lines = ((LINENUM)atol(s)) - p_first + 1;
1499: break;
1500: case '-':
1501: if (buf[1] == '-') {
1502: if (p_end != p_ptrn_lines + 1) {
1503: if (p_end == 1) {
1504: /* `old' lines were omitted - set up to fill them */
1505: /* in from 'new' context lines. */
1506: p_end = p_ptrn_lines + 1;
1507: fillsrc = p_end + 1;
1508: filldst = 1;
1509: fillcnt = p_ptrn_lines;
1510: } else
1511: fatal("Unexpected --- at line %d: %s",
1512: p_input_line,buf);
1513: }
1514: repl_beginning = p_end;
1515: p_line[p_end] = savestr(buf);
1516: p_char[p_end] = '=';
1517: for (s=buf; *s && !isdigit(*s); s++) ;
1518: p_newfirst = (LINENUM) atol(s);
1519: while (isdigit(*s)) s++;
1520: for (; *s && !isdigit(*s); s++) ;
1521: p_max = ((LINENUM)atol(s)) - p_newfirst + 1 + p_end;
1522: break;
1523: }
1524: /* FALL THROUGH */
1525: case '+': case '!':
1526: if (context > 0 && p_context == 0) {
1527: p_context = context;
1528: }
1529: p_line[p_end] = savestr(buf+2);
1530: break;
1531: case '\t': case '\n': /* assume the 2 spaces got eaten */
1532: p_line[p_end] = savestr(buf);
1533: if (p_end != p_ptrn_lines + 1) {
1534: context++;
1535: p_char[p_end] = ' ';
1536: }
1537: break;
1538: case ' ':
1539: context++;
1540: p_line[p_end] = savestr(buf+2);
1541: break;
1542: default:
1543: fatal("Malformed patch at line %d: %s",p_input_line,buf);
1544: }
1545: p_len[p_end] = 0;
1546: if (p_line[p_end] != 0)
1547: p_len[p_end] = strlen(p_line[p_end]);
1548: /* for strncmp() so we do not have */
1549: /* to assume null termination */
1550: }
1551: if (p_end >=0 && !p_ptrn_lines)
1552: fatal("No --- found in patch at line %d\n", pch_hunk_beg());
1553:
1554: /* if there were omitted context lines, fill them in */
1555: if (fillcnt) {
1556: while (fillcnt-- > 0) {
1557: while (p_char[fillsrc] != ' ')
1558: fillsrc++;
1559: p_line[filldst] = p_line[fillsrc];
1560: p_char[filldst] = p_char[fillsrc];
1561: p_len[filldst] = p_len[fillsrc];
1562: fillsrc++; filldst++;
1563: }
1564: assert(fillsrc==p_end+1 || fillsrc==repl_beginning);
1565: assert(filldst==p_end+1 || filldst==repl_beginning);
1566: }
1567: p_repl_lines = p_end - repl_beginning;
1568: }
1569: else { /* normal diff--fake it up */
1570: char hunk_type;
1571: register int i;
1572: LINENUM min, max;
1573: long line_beginning = ftell(pfp);
1574:
1575: p_context = 0;
1576: ret = pgets(buf,sizeof buf, pfp);
1577: p_input_line++;
1578: if (ret == Nullch || !isdigit(*buf)) {
1579: next_intuit_at(line_beginning);
1580: return FALSE;
1581: }
1582: p_first = (LINENUM)atol(buf);
1583: for (s=buf; isdigit(*s); s++) ;
1584: if (*s == ',') {
1585: p_ptrn_lines = (LINENUM)atol(++s) - p_first + 1;
1586: while (isdigit(*s)) s++;
1587: }
1588: else
1589: p_ptrn_lines = (*s != 'a');
1590: hunk_type = *s;
1591: if (hunk_type == 'a')
1592: p_first++; /* do append rather than insert */
1593: min = (LINENUM)atol(++s);
1594: for (; isdigit(*s); s++) ;
1595: if (*s == ',')
1596: max = (LINENUM)atol(++s);
1597: else
1598: max = min;
1599: if (hunk_type == 'd')
1600: min++;
1601: p_end = p_ptrn_lines + 1 + max - min + 1;
1602: p_newfirst = min;
1603: p_repl_lines = max - min + 1;
1604: Sprintf(buf,"*** %d,%d\n", p_first, p_first + p_ptrn_lines - 1);
1605: p_line[0] = savestr(buf);
1606: p_char[0] = '*';
1607: for (i=1; i<=p_ptrn_lines; i++) {
1608: ret = pgets(buf,sizeof buf, pfp);
1609: p_input_line++;
1610: if (ret == Nullch)
1611: fatal("Unexpected end of file in patch at line %d.\n",
1612: p_input_line);
1613: if (*buf != '<')
1614: fatal("< expected at line %d of patch.\n", p_input_line);
1615: p_line[i] = savestr(buf+2);
1616: p_len[i] = 0;
1617: if (p_line[i] != 0)
1618: p_len[i] = strlen(p_line[i]);
1619: p_char[i] = '-';
1620: }
1621: if (hunk_type == 'c') {
1622: ret = pgets(buf,sizeof buf, pfp);
1623: p_input_line++;
1624: if (ret == Nullch)
1625: fatal("Unexpected end of file in patch at line %d.\n",
1626: p_input_line);
1627: if (*buf != '-')
1628: fatal("--- expected at line %d of patch.\n", p_input_line);
1629: }
1630: Sprintf(buf,"--- %d,%d\n",min,max);
1631: p_line[i] = savestr(buf);
1632: p_char[i] = '=';
1633: for (i++; i<=p_end; i++) {
1634: ret = pgets(buf,sizeof buf, pfp);
1635: p_input_line++;
1636: if (ret == Nullch)
1637: fatal("Unexpected end of file in patch at line %d.\n",
1638: p_input_line);
1639: if (*buf != '>')
1640: fatal("> expected at line %d of patch.\n", p_input_line);
1641: p_line[i] = savestr(buf+2);
1642: p_len[i] = 0;
1643: if (p_line[i] != 0)
1644: p_len[i] = strlen(p_line[i]);
1645: p_char[i] = '+';
1646: }
1647: }
1648: if (reverse) /* backwards patch? */
1649: pch_swap();
1650: #ifdef DEBUGGING
1651: if (debug & 2) {
1652: int i;
1653: char special;
1654:
1655: for (i=0; i <= p_end; i++) {
1656: if (i == p_ptrn_lines)
1657: special = '^';
1658: else
1659: special = ' ';
1660: printf("%3d %c %c %s",i,p_char[i],special,p_line[i]);
1661: }
1662: }
1663: #endif
1664: return TRUE;
1665: }
1666:
1667: char *
1668: pgets(bf,sz,fp)
1669: char *bf;
1670: int sz;
1671: FILE *fp;
1672: {
1673: char *ret = fgets(bf,sz,fp);
1674: register char *s;
1675: register int indent = 0;
1676:
1677: if (p_indent && ret != Nullch) {
1678: for (s=buf; indent < p_indent && (*s == ' ' || *s == '\t'); s++) {
1679: if (*s == '\t')
1680: indent += 8 - (indent % 7);
1681: else
1682: indent++;
1683: }
1684: if (buf != s)
1685: Strcpy(buf,s);
1686: }
1687: return ret;
1688: }
1689:
1690: pch_swap()
1691: {
1692: char *tp_line[MAXHUNKSIZE]; /* the text of the hunk */
1693: char tp_char[MAXHUNKSIZE]; /* +, -, and ! */
1694: int tp_len[MAXHUNKSIZE]; /* length of each line */
1695: register LINENUM i, n;
1696: bool blankline = FALSE;
1697: register char *s;
1698:
1699: i = p_first;
1700: p_first = p_newfirst;
1701: p_newfirst = i;
1702:
1703: /* make a scratch copy */
1704:
1705: for (i=0; i<=p_end; i++) {
1706: tp_line[i] = p_line[i];
1707: tp_char[i] = p_char[i];
1708: tp_len[i] = p_len[i];
1709: }
1710:
1711: /* now turn the new into the old */
1712:
1713: i = p_ptrn_lines + 1;
1714: if (tp_char[i] == '\n') { /* account for possible blank line */
1715: blankline = TRUE;
1716: i++;
1717: }
1718: for (n=0; i <= p_end; i++,n++) {
1719: p_line[n] = tp_line[i];
1720: p_char[n] = tp_char[i];
1721: if (p_char[n] == '+')
1722: p_char[n] = '-';
1723: p_len[n] = tp_len[i];
1724: }
1725: if (blankline) {
1726: i = p_ptrn_lines + 1;
1727: p_line[n] = tp_line[i];
1728: p_char[n] = tp_char[i];
1729: p_len[n] = tp_len[i];
1730: n++;
1731: }
1732: assert(p_char[0] == '=');
1733: p_char[0] = '*';
1734: for (s=p_line[0]; *s; s++)
1735: if (*s == '-')
1736: *s = '*';
1737:
1738: /* now turn the old into the new */
1739:
1740: assert(tp_char[0] == '*');
1741: tp_char[0] = '=';
1742: for (s=tp_line[0]; *s; s++)
1743: if (*s == '*')
1744: *s = '-';
1745: for (i=0; n <= p_end; i++,n++) {
1746: p_line[n] = tp_line[i];
1747: p_char[n] = tp_char[i];
1748: if (p_char[n] == '-')
1749: p_char[n] = '+';
1750: p_len[n] = tp_len[i];
1751: }
1752: assert(i == p_ptrn_lines + 1);
1753: i = p_ptrn_lines;
1754: p_ptrn_lines = p_repl_lines;
1755: p_repl_lines = i;
1756: }
1757:
1758: LINENUM
1759: pch_first()
1760: {
1761: return p_first;
1762: }
1763:
1764: LINENUM
1765: pch_ptrn_lines()
1766: {
1767: return p_ptrn_lines;
1768: }
1769:
1770: LINENUM
1771: pch_newfirst()
1772: {
1773: return p_newfirst;
1774: }
1775:
1776: LINENUM
1777: pch_repl_lines()
1778: {
1779: return p_repl_lines;
1780: }
1781:
1782: LINENUM
1783: pch_end()
1784: {
1785: return p_end;
1786: }
1787:
1788: LINENUM
1789: pch_context()
1790: {
1791: return p_context;
1792: }
1793:
1794: pch_line_len(line)
1795: LINENUM line;
1796: {
1797: return p_len[line];
1798: }
1799:
1800: char
1801: pch_char(line)
1802: LINENUM line;
1803: {
1804: return p_char[line];
1805: }
1806:
1807: char *
1808: pfetch(line)
1809: LINENUM line;
1810: {
1811: return p_line[line];
1812: }
1813:
1814: LINENUM
1815: pch_hunk_beg()
1816: {
1817: return p_input_line - p_end - 1;
1818: }
1819:
1820: char *
1821: savestr(s)
1822: register char *s;
1823: {
1824: register char *rv,
1825: *t;
1826:
1827: t = s;
1828: while (*t++);
1829: rv = malloc((MEM) (t - s));
1830: if (rv == NULL)
1831: fatal ("patch: out of memory (savestr)\n");
1832: t = rv;
1833: while (*t++ = *s++);
1834: return rv;
1835: }
1836:
1837: my_exit(status)
1838: int status;
1839: {
1840: Unlink(TMPINNAME);
1841: Unlink(TMPOUTNAME);
1842: Unlink(TMPREJNAME);
1843: Unlink(TMPPATNAME);
1844: exit(status);
1845: }
1846:
1847: #ifdef lint
1848:
1849: /*VARARGS ARGSUSED*/
1850: say(pat) char *pat; { ; }
1851: /*VARARGS ARGSUSED*/
1852: fatal(pat) char *pat; { ; }
1853: /*VARARGS ARGSUSED*/
1854: ask(pat) char *pat; { ; }
1855:
1856: #else lint
1857:
1858: say(pat,arg1,arg2,arg3)
1859: char *pat;
1860: int arg1,arg2,arg3;
1861: {
1862: fprintf(stderr,pat,arg1,arg2,arg3);
1863: Fflush(stderr);
1864: }
1865:
1866: fatal(pat,arg1,arg2,arg3)
1867: char *pat;
1868: int arg1,arg2,arg3;
1869: {
1870: say(pat,arg1,arg2,arg3);
1871: my_exit(1);
1872: }
1873:
1874: ask(pat,arg1,arg2,arg3)
1875: char *pat;
1876: int arg1,arg2,arg3;
1877: {
1878: int ttyfd = open("/dev/tty",2);
1879: int r;
1880:
1881: say(pat,arg1,arg2,arg3);
1882: if (ttyfd >= 0) {
1883: r = read(ttyfd, buf, sizeof buf);
1884: Close(ttyfd);
1885: }
1886: else
1887: r = read(2, buf, sizeof buf);
1888: if (r <= 0)
1889: buf[0] = 0;
1890: }
1891: #endif lint
1892:
1893: bool
1894: rev_in_string(string)
1895: char *string;
1896: {
1897: register char *s;
1898: register int patlen;
1899:
1900: if (revision == Nullch)
1901: return TRUE;
1902: patlen = strlen(revision);
1903: for (s = string; *s; s++) {
1904: if (isspace(*s) && strnEQ(s+1,revision,patlen) &&
1905: isspace(s[patlen+1] )) {
1906: return TRUE;
1907: }
1908: }
1909: return FALSE;
1910: }
1911:
1912: set_signals()
1913: {
1914: /*NOSTRICT*/
1915: if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
1916: Signal(SIGHUP, my_exit);
1917: /*NOSTRICT*/
1918: if (signal(SIGINT, SIG_IGN) != SIG_IGN)
1919: Signal(SIGINT, my_exit);
1920: }
1921:
1922: ignore_signals()
1923: {
1924: /*NOSTRICT*/
1925: Signal(SIGHUP, SIG_IGN);
1926: /*NOSTRICT*/
1927: Signal(SIGINT, SIG_IGN);
1928: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.