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