Return to patch.c CVS log

Up to [Research Unix] / researchv10no / cmd

Annotation of researchv10no/cmd/patch.c, revision 1.1

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.