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