Return to more.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / more

Annotation of 43BSDReno/usr.bin/more/more.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1980 Regents of the University of California.
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * Redistribution and use in source and binary forms are permitted
        !             6:  * provided that the above copyright notice and this paragraph are
        !             7:  * duplicated in all such forms and that any documentation,
        !             8:  * advertising materials, and other materials related to such
        !             9:  * distribution and use acknowledge that the software was developed
        !            10:  * by the University of California, Berkeley.  The name of the
        !            11:  * University may not be used to endorse or promote products derived
        !            12:  * from this software without specific prior written permission.
        !            13:  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
        !            14:  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
        !            15:  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
        !            16:  */
        !            17: 
        !            18: #ifndef lint
        !            19: char copyright[] =
        !            20: "@(#) Copyright (c) 1980 Regents of the University of California.\n\
        !            21:  All rights reserved.\n";
        !            22: #endif /* not lint */
        !            23: 
        !            24: #ifndef lint
        !            25: static char sccsid[] = "@(#)more.c     5.22 (Berkeley) 7/30/89";
        !            26: #endif /* not lint */
        !            27: 
        !            28: /*
        !            29: ** more.c - General purpose tty output filter and file perusal program
        !            30: **
        !            31: **     by Eric Shienbrood, UC Berkeley
        !            32: **
        !            33: **     modified by Geoff Peck, UCB to add underlining, single spacing
        !            34: **     modified by John Foderaro, UCB to add -c and MORE environment variable
        !            35: */
        !            36: 
        !            37: #include <stdio.h>
        !            38: #include <sys/param.h>
        !            39: #include <ctype.h>
        !            40: #include <signal.h>
        !            41: #include <errno.h>
        !            42: #include <sgtty.h>
        !            43: #include <setjmp.h>
        !            44: #include <sys/stat.h>
        !            45: #include <sys/file.h>
        !            46: #include <a.out.h>
        !            47: #include <varargs.h>
        !            48: #include "pathnames.h"
        !            49: 
        !            50: #define Fopen(s,m)     (Currline = 0,file_pos=0,fopen(s,m))
        !            51: #define Ftell(f)       file_pos
        !            52: #define Fseek(f,off)   (file_pos=off,fseek(f,off,0))
        !            53: #define Getc(f)                (++file_pos, getc(f))
        !            54: #define Ungetc(c,f)    (--file_pos, ungetc(c,f))
        !            55: 
        !            56: #define MBIT   CBREAK
        !            57: #define stty(fd,argp)  ioctl(fd,TIOCSETN,argp)
        !            58: 
        !            59: #define TBUFSIZ        1024
        !            60: #define LINSIZ 256
        !            61: #define ctrl(letter)   (letter & 077)
        !            62: #define RUBOUT '\177'
        !            63: #define ESC    '\033'
        !            64: #define QUIT   '\034'
        !            65: 
        !            66: struct sgttyb  otty, savetty;
        !            67: long           file_pos, file_size;
        !            68: int            fnum, no_intty, no_tty, slow_tty;
        !            69: int            dum_opt, dlines, onquit(), end_it(), chgwinsz();
        !            70: int            onsusp();
        !            71: int            nscroll = 11;   /* Number of lines scrolled by 'd' */
        !            72: int            fold_opt = 1;   /* Fold long lines */
        !            73: int            stop_opt = 1;   /* Stop after form feeds */
        !            74: int            ssp_opt = 0;    /* Suppress white space */
        !            75: int            ul_opt = 1;     /* Underline as best we can */
        !            76: int            promptlen;
        !            77: int            Currline;       /* Line we are currently at */
        !            78: int            startup = 1;
        !            79: int            firstf = 1;
        !            80: int            notell = 1;
        !            81: int            docrterase = 0;
        !            82: int            docrtkill = 0;
        !            83: int            bad_so; /* True if overwriting does not turn off standout */
        !            84: int            inwait, Pause, errors;
        !            85: int            within; /* true if we are within a file,
        !            86:                        false if we are between files */
        !            87: int            hard, dumb, noscroll, hardtabs, clreol, eatnl;
        !            88: int            catch_susp;     /* We should catch the SIGTSTP signal */
        !            89: char           **fnames;       /* The list of file names */
        !            90: int            nfiles;         /* Number of files left to process */
        !            91: char           *shell;         /* The name of the shell to use */
        !            92: int            shellp;         /* A previous shell command exists */
        !            93: char           ch;
        !            94: jmp_buf                restore;
        !            95: char           Line[LINSIZ];   /* Line buffer */
        !            96: int            Lpp = 24;       /* lines per page */
        !            97: char           *Clear;         /* clear screen */
        !            98: char           *eraseln;       /* erase line */
        !            99: char           *Senter, *Sexit;/* enter and exit standout mode */
        !           100: char           *ULenter, *ULexit;      /* enter and exit underline mode */
        !           101: char           *chUL;          /* underline character */
        !           102: char           *chBS;          /* backspace character */
        !           103: char           *Home;          /* go to home */
        !           104: char           *cursorm;       /* cursor movement */
        !           105: char           cursorhome[40]; /* contains cursor movement to home */
        !           106: char           *EodClr;        /* clear rest of screen */
        !           107: char           *tgetstr();
        !           108: int            Mcol = 80;      /* number of columns */
        !           109: int            Wrap = 1;       /* set if automargins */
        !           110: int            soglitch;       /* terminal has standout mode glitch */
        !           111: int            ulglitch;       /* terminal has underline mode glitch */
        !           112: int            pstate = 0;     /* current UL state */
        !           113: long           fseek();
        !           114: char           *getenv();
        !           115: struct {
        !           116:     long chrctr, line;
        !           117: } context, screen_start;
        !           118: extern char    PC;             /* pad character */
        !           119: extern short   ospeed;
        !           120: 
        !           121: 
        !           122: main(argc, argv)
        !           123: int argc;
        !           124: char *argv[];
        !           125: {
        !           126:     register FILE      *f;
        !           127:     register char      *s;
        !           128:     register char      *p;
        !           129:     register char      ch;
        !           130:     register int       left;
        !           131:     int                        prnames = 0;
        !           132:     int                        initopt = 0;
        !           133:     int                        srchopt = 0;
        !           134:     int                        clearit = 0;
        !           135:     int                        initline;
        !           136:     char               initbuf[80];
        !           137:     FILE               *checkf();
        !           138: 
        !           139:     nfiles = argc;
        !           140:     fnames = argv;
        !           141:     initterm ();
        !           142:     nscroll = Lpp/2 - 1;
        !           143:     if (nscroll <= 0)
        !           144:        nscroll = 1;
        !           145:     if(s = getenv("MORE")) argscan(s);
        !           146:     while (--nfiles > 0) {
        !           147:        if ((ch = (*++fnames)[0]) == '-') {
        !           148:            argscan(*fnames+1);
        !           149:        }
        !           150:        else if (ch == '+') {
        !           151:            s = *fnames;
        !           152:            if (*++s == '/') {
        !           153:                srchopt++;
        !           154:                for (++s, p = initbuf; p < initbuf + 79 && *s != '\0';)
        !           155:                    *p++ = *s++;
        !           156:                *p = '\0';
        !           157:            }
        !           158:            else {
        !           159:                initopt++;
        !           160:                for (initline = 0; *s != '\0'; s++)
        !           161:                    if (isdigit (*s))
        !           162:                        initline = initline*10 + *s -'0';
        !           163:                --initline;
        !           164:            }
        !           165:        }
        !           166:        else break;
        !           167:     }
        !           168:     /* allow clreol only if Home and eraseln and EodClr strings are
        !           169:      *  defined, and in that case, make sure we are in noscroll mode
        !           170:      */
        !           171:     if(clreol)
        !           172:     {
        !           173:         if((Home == NULL) || (*Home == '\0') ||
        !           174:           (eraseln == NULL) || (*eraseln == '\0') ||
        !           175:            (EodClr == NULL) || (*EodClr == '\0') )
        !           176:              clreol = 0;
        !           177:        else noscroll = 1;
        !           178:     }
        !           179:     if (dlines == 0)
        !           180:        dlines = Lpp - (noscroll ? 1 : 2);
        !           181:     left = dlines;
        !           182:     if (nfiles > 1)
        !           183:        prnames++;
        !           184:     if (!no_intty && nfiles == 0) {
        !           185:        char *rindex();
        !           186: 
        !           187:        p = rindex(argv[0], '/');
        !           188:        fputs("usage: ",stderr);
        !           189:        fputs(p ? p + 1 : argv[0],stderr);
        !           190:        fputs(" [-dfln] [+linenum | +/pattern] name1 name2 ...\n",stderr);
        !           191:        exit(1);
        !           192:     }
        !           193:     else
        !           194:        f = stdin;
        !           195:     if (!no_tty) {
        !           196:        signal(SIGQUIT, onquit);
        !           197:        signal(SIGINT, end_it);
        !           198:        signal(SIGWINCH, chgwinsz);
        !           199:        if (signal (SIGTSTP, SIG_IGN) == SIG_DFL) {
        !           200:            signal(SIGTSTP, onsusp);
        !           201:            catch_susp++;
        !           202:        }
        !           203:        stty (fileno(stderr), &otty);
        !           204:     }
        !           205:     if (no_intty) {
        !           206:        if (no_tty)
        !           207:            copy_file (stdin);
        !           208:        else {
        !           209:            if ((ch = Getc (f)) == '\f')
        !           210:                doclear();
        !           211:            else {
        !           212:                Ungetc (ch, f);
        !           213:                if (noscroll && (ch != EOF)) {
        !           214:                    if (clreol)
        !           215:                        home ();
        !           216:                    else
        !           217:                        doclear ();
        !           218:                }
        !           219:            }
        !           220:            if (srchopt)
        !           221:            {
        !           222:                search (initbuf, stdin, 1);
        !           223:                if (noscroll)
        !           224:                    left--;
        !           225:            }
        !           226:            else if (initopt)
        !           227:                skiplns (initline, stdin);
        !           228:            screen (stdin, left);
        !           229:        }
        !           230:        no_intty = 0;
        !           231:        prnames++;
        !           232:        firstf = 0;
        !           233:     }
        !           234: 
        !           235:     while (fnum < nfiles) {
        !           236:        if ((f = checkf (fnames[fnum], &clearit)) != NULL) {
        !           237:            context.line = context.chrctr = 0;
        !           238:            Currline = 0;
        !           239:            if (firstf) setjmp (restore);
        !           240:            if (firstf) {
        !           241:                firstf = 0;
        !           242:                if (srchopt)
        !           243:                {
        !           244:                    search (initbuf, f, 1);
        !           245:                    if (noscroll)
        !           246:                        left--;
        !           247:                }
        !           248:                else if (initopt)
        !           249:                    skiplns (initline, f);
        !           250:            }
        !           251:            else if (fnum < nfiles && !no_tty) {
        !           252:                setjmp (restore);
        !           253:                left = command (fnames[fnum], f);
        !           254:            }
        !           255:            if (left != 0) {
        !           256:                if ((noscroll || clearit) && (file_size != LONG_MAX))
        !           257:                    if (clreol)
        !           258:                        home ();
        !           259:                    else
        !           260:                        doclear ();
        !           261:                if (prnames) {
        !           262:                    if (bad_so)
        !           263:                        erase (0);
        !           264:                    if (clreol)
        !           265:                        cleareol ();
        !           266:                    pr("::::::::::::::");
        !           267:                    if (promptlen > 14)
        !           268:                        erase (14);
        !           269:                    printf ("\n");
        !           270:                    if(clreol) cleareol();
        !           271:                    printf("%s\n", fnames[fnum]);
        !           272:                    if(clreol) cleareol();
        !           273:                    printf("::::::::::::::\n");
        !           274:                    if (left > Lpp - 4)
        !           275:                        left = Lpp - 4;
        !           276:                }
        !           277:                if (no_tty)
        !           278:                    copy_file (f);
        !           279:                else {
        !           280:                    within++;
        !           281:                    screen(f, left);
        !           282:                    within = 0;
        !           283:                }
        !           284:            }
        !           285:            setjmp (restore);
        !           286:            fflush(stdout);
        !           287:            fclose(f);
        !           288:            screen_start.line = screen_start.chrctr = 0L;
        !           289:            context.line = context.chrctr = 0L;
        !           290:        }
        !           291:        fnum++;
        !           292:        firstf = 0;
        !           293:     }
        !           294:     reset_tty ();
        !           295:     exit(0);
        !           296: }
        !           297: 
        !           298: argscan(s)
        !           299: char *s;
        !           300: {
        !           301:        int seen_num = 0;
        !           302: 
        !           303:        while (*s != '\0') {
        !           304:                switch (*s) {
        !           305:                  case '0': case '1': case '2':
        !           306:                  case '3': case '4': case '5':
        !           307:                  case '6': case '7': case '8':
        !           308:                  case '9':
        !           309:                        if (!seen_num) {
        !           310:                                dlines = 0;
        !           311:                                seen_num = 1;
        !           312:                        }
        !           313:                        dlines = dlines*10 + *s - '0';
        !           314:                        break;
        !           315:                  case 'd':
        !           316:                        dum_opt = 1;
        !           317:                        break;
        !           318:                  case 'l':
        !           319:                        stop_opt = 0;
        !           320:                        break;
        !           321:                  case 'f':
        !           322:                        fold_opt = 0;
        !           323:                        break;
        !           324:                  case 'p':
        !           325:                        noscroll++;
        !           326:                        break;
        !           327:                  case 'c':
        !           328:                        clreol++;
        !           329:                        break;
        !           330:                  case 's':
        !           331:                        ssp_opt = 1;
        !           332:                        break;
        !           333:                  case 'u':
        !           334:                        ul_opt = 0;
        !           335:                        break;
        !           336:                }
        !           337:                s++;
        !           338:        }
        !           339: }
        !           340: 
        !           341: 
        !           342: /*
        !           343: ** Check whether the file named by fs is an ASCII file which the user may
        !           344: ** access.  If it is, return the opened file. Otherwise return NULL.
        !           345: */
        !           346: 
        !           347: FILE *
        !           348: checkf (fs, clearfirst)
        !           349:        register char *fs;
        !           350:        int *clearfirst;
        !           351: {
        !           352:        struct stat stbuf;
        !           353:        register FILE *f;
        !           354:        char c;
        !           355: 
        !           356:        if (stat (fs, &stbuf) == -1) {
        !           357:                (void)fflush(stdout);
        !           358:                if (clreol)
        !           359:                        cleareol ();
        !           360:                perror(fs);
        !           361:                return((FILE *)NULL);
        !           362:        }
        !           363:        if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {
        !           364:                printf("\n*** %s: directory ***\n\n", fs);
        !           365:                return((FILE *)NULL);
        !           366:        }
        !           367:        if ((f = Fopen(fs, "r")) == NULL) {
        !           368:                (void)fflush(stdout);
        !           369:                perror(fs);
        !           370:                return((FILE *)NULL);
        !           371:        }
        !           372:        if (magic(f, fs))
        !           373:                return((FILE *)NULL);
        !           374:        c = Getc(f);
        !           375:        *clearfirst = c == '\f';
        !           376:        Ungetc (c, f);
        !           377:        if ((file_size = stbuf.st_size) == 0)
        !           378:                file_size = LONG_MAX;
        !           379:        return(f);
        !           380: }
        !           381: 
        !           382: /*
        !           383:  * magic --
        !           384:  *     check for file magic numbers.  This code would best be shared with
        !           385:  *     the file(1) program or, perhaps, more should not try and be so smart?
        !           386:  */
        !           387: static
        !           388: magic(f, fs)
        !           389:        FILE *f;
        !           390:        char *fs;
        !           391: {
        !           392:        struct exec ex;
        !           393: 
        !           394:        if (fread(&ex, sizeof(ex), 1, f) == 1)
        !           395:                switch(ex.a_magic) {
        !           396:                case OMAGIC:
        !           397:                case NMAGIC:
        !           398:                case ZMAGIC:
        !           399:                case 0405:
        !           400:                case 0411:
        !           401:                case 0177545:
        !           402:                        printf("\n******** %s: Not a text file ********\n\n", fs);
        !           403:                        (void)fclose(f);
        !           404:                        return(1);
        !           405:                }
        !           406:        (void)fseek(f, 0L, L_SET);              /* rewind() not necessary */
        !           407:        return(0);
        !           408: }
        !           409: 
        !           410: /*
        !           411: ** A real function, for the tputs routine in termlib
        !           412: */
        !           413: 
        !           414: putch (ch)
        !           415: char ch;
        !           416: {
        !           417:     putchar (ch);
        !           418: }
        !           419: 
        !           420: /*
        !           421: ** Print out the contents of the file f, one screenful at a time.
        !           422: */
        !           423: 
        !           424: #define STOP -10
        !           425: 
        !           426: screen (f, num_lines)
        !           427: register FILE *f;
        !           428: register int num_lines;
        !           429: {
        !           430:     register int c;
        !           431:     register int nchars;
        !           432:     int length;                        /* length of current line */
        !           433:     static int prev_len = 1;   /* length of previous line */
        !           434: 
        !           435:     for (;;) {
        !           436:        while (num_lines > 0 && !Pause) {
        !           437:            if ((nchars = getline (f, &length)) == EOF)
        !           438:            {
        !           439:                if (clreol)
        !           440:                    clreos();
        !           441:                return;
        !           442:            }
        !           443:            if (ssp_opt && length == 0 && prev_len == 0)
        !           444:                continue;
        !           445:            prev_len = length;
        !           446:            if (bad_so || (Senter && *Senter == ' ') && promptlen > 0)
        !           447:                erase (0);
        !           448:            /* must clear before drawing line since tabs on some terminals
        !           449:             * do not erase what they tab over.
        !           450:             */
        !           451:            if (clreol)
        !           452:                cleareol ();
        !           453:            prbuf (Line, length);
        !           454:            if (nchars < promptlen)
        !           455:                erase (nchars); /* erase () sets promptlen to 0 */
        !           456:            else promptlen = 0;
        !           457:            /* is this needed?
        !           458:             * if (clreol)
        !           459:             *  cleareol();     /* must clear again in case we wrapped *
        !           460:             */
        !           461:            if (nchars < Mcol || !fold_opt)
        !           462:                prbuf("\n", 1); /* will turn off UL if necessary */
        !           463:            if (nchars == STOP)
        !           464:                break;
        !           465:            num_lines--;
        !           466:        }
        !           467:        if (pstate) {
        !           468:                tputs(ULexit, 1, putch);
        !           469:                pstate = 0;
        !           470:        }
        !           471:        fflush(stdout);
        !           472:        if ((c = Getc(f)) == EOF)
        !           473:        {
        !           474:            if (clreol)
        !           475:                clreos ();
        !           476:            return;
        !           477:        }
        !           478: 
        !           479:        if (Pause && clreol)
        !           480:            clreos ();
        !           481:        Ungetc (c, f);
        !           482:        setjmp (restore);
        !           483:        Pause = 0; startup = 0;
        !           484:        if ((num_lines = command (NULL, f)) == 0)
        !           485:            return;
        !           486:        if (hard && promptlen > 0)
        !           487:                erase (0);
        !           488:        if (noscroll && num_lines >= dlines)
        !           489:        {
        !           490:            if (clreol)
        !           491:                home();
        !           492:            else
        !           493:                doclear ();
        !           494:        }
        !           495:        screen_start.line = Currline;
        !           496:        screen_start.chrctr = Ftell (f);
        !           497:     }
        !           498: }
        !           499: 
        !           500: /*
        !           501: ** Come here if a quit signal is received
        !           502: */
        !           503: 
        !           504: onquit()
        !           505: {
        !           506:     signal(SIGQUIT, SIG_IGN);
        !           507:     if (!inwait) {
        !           508:        putchar ('\n');
        !           509:        if (!startup) {
        !           510:            signal(SIGQUIT, onquit);
        !           511:            longjmp (restore, 1);
        !           512:        }
        !           513:        else
        !           514:            Pause++;
        !           515:     }
        !           516:     else if (!dum_opt && notell) {
        !           517:        write (2, "[Use q or Q to quit]", 20);
        !           518:        promptlen += 20;
        !           519:        notell = 0;
        !           520:     }
        !           521:     signal(SIGQUIT, onquit);
        !           522: }
        !           523: 
        !           524: /*
        !           525: ** Come here if a signal for a window size change is received
        !           526: */
        !           527: 
        !           528: chgwinsz()
        !           529: {
        !           530:     struct winsize win;
        !           531: 
        !           532:     (void) signal(SIGWINCH, SIG_IGN);
        !           533:     if (ioctl(fileno(stdout), TIOCGWINSZ, &win) != -1) {
        !           534:        if (win.ws_row != 0) {
        !           535:            Lpp = win.ws_row;
        !           536:            nscroll = Lpp/2 - 1;
        !           537:            if (nscroll <= 0)
        !           538:                nscroll = 1;
        !           539:            dlines = Lpp - (noscroll ? 1 : 2);
        !           540:        }
        !           541:        if (win.ws_col != 0)
        !           542:            Mcol = win.ws_col;
        !           543:     }
        !           544:     (void) signal(SIGWINCH, chgwinsz);
        !           545: }
        !           546: 
        !           547: /*
        !           548: ** Clean up terminal state and exit. Also come here if interrupt signal received
        !           549: */
        !           550: 
        !           551: end_it ()
        !           552: {
        !           553: 
        !           554:     reset_tty ();
        !           555:     if (clreol) {
        !           556:        putchar ('\r');
        !           557:        clreos ();
        !           558:        fflush (stdout);
        !           559:     }
        !           560:     else if (!clreol && (promptlen > 0)) {
        !           561:        kill_line ();
        !           562:        fflush (stdout);
        !           563:     }
        !           564:     else
        !           565:        write (2, "\n", 1);
        !           566:     _exit(0);
        !           567: }
        !           568: 
        !           569: copy_file(f)
        !           570: register FILE *f;
        !           571: {
        !           572:     register int c;
        !           573: 
        !           574:     while ((c = getc(f)) != EOF)
        !           575:        putchar(c);
        !           576: }
        !           577: 
        !           578: /* Simplified printf function */
        !           579: 
        !           580: printf (fmt, va_alist)
        !           581: register char *fmt;
        !           582: va_dcl
        !           583: {
        !           584:        va_list ap;
        !           585:        register char ch;
        !           586:        register int ccount;
        !           587: 
        !           588:        ccount = 0;
        !           589:        va_start(ap);
        !           590:        while (*fmt) {
        !           591:                while ((ch = *fmt++) != '%') {
        !           592:                        if (ch == '\0')
        !           593:                                return (ccount);
        !           594:                        ccount++;
        !           595:                        putchar (ch);
        !           596:                }
        !           597:                switch (*fmt++) {
        !           598:                case 'd':
        !           599:                        ccount += printd (va_arg(ap, int));
        !           600:                        break;
        !           601:                case 's':
        !           602:                        ccount += pr (va_arg(ap, char *));
        !           603:                        break;
        !           604:                case '%':
        !           605:                        ccount++;
        !           606:                        putchar ('%');
        !           607:                        break;
        !           608:                case '0':
        !           609:                        return (ccount);
        !           610:                default:
        !           611:                        break;
        !           612:                }
        !           613:        }
        !           614:        va_end(ap);
        !           615:        return (ccount);
        !           616: 
        !           617: }
        !           618: 
        !           619: /*
        !           620: ** Print an integer as a string of decimal digits,
        !           621: ** returning the length of the print representation.
        !           622: */
        !           623: 
        !           624: printd (n)
        !           625: int n;
        !           626: {
        !           627:     int a, nchars;
        !           628: 
        !           629:     if (a = n/10)
        !           630:        nchars = 1 + printd(a);
        !           631:     else
        !           632:        nchars = 1;
        !           633:     putchar (n % 10 + '0');
        !           634:     return (nchars);
        !           635: }
        !           636: 
        !           637: /* Put the print representation of an integer into a string */
        !           638: static char *sptr;
        !           639: 
        !           640: scanstr (n, str)
        !           641: int n;
        !           642: char *str;
        !           643: {
        !           644:     sptr = str;
        !           645:     Sprintf (n);
        !           646:     *sptr = '\0';
        !           647: }
        !           648: 
        !           649: Sprintf (n)
        !           650: {
        !           651:     int a;
        !           652: 
        !           653:     if (a = n/10)
        !           654:        Sprintf (a);
        !           655:     *sptr++ = n % 10 + '0';
        !           656: }
        !           657: 
        !           658: static char bell = ctrl('G');
        !           659: 
        !           660: strlen (s)
        !           661: char *s;
        !           662: {
        !           663:     register char *p;
        !           664: 
        !           665:     p = s;
        !           666:     while (*p++)
        !           667:        ;
        !           668:     return (p - s - 1);
        !           669: }
        !           670: 
        !           671: /* See whether the last component of the path name "path" is equal to the
        !           672: ** string "string"
        !           673: */
        !           674: 
        !           675: tailequ (path, string)
        !           676: char *path;
        !           677: register char *string;
        !           678: {
        !           679:        register char *tail;
        !           680: 
        !           681:        tail = path + strlen(path);
        !           682:        while (tail >= path)
        !           683:                if (*(--tail) == '/')
        !           684:                        break;
        !           685:        ++tail;
        !           686:        while (*tail++ == *string++)
        !           687:                if (*tail == '\0')
        !           688:                        return(1);
        !           689:        return(0);
        !           690: }
        !           691: 
        !           692: prompt (filename)
        !           693: char *filename;
        !           694: {
        !           695:     if (clreol)
        !           696:        cleareol ();
        !           697:     else if (promptlen > 0)
        !           698:        kill_line ();
        !           699:     if (!hard) {
        !           700:        promptlen = 8;
        !           701:        if (Senter && Sexit) {
        !           702:            tputs (Senter, 1, putch);
        !           703:            promptlen += (2 * soglitch);
        !           704:        }
        !           705:        if (clreol)
        !           706:            cleareol ();
        !           707:        pr("--More--");
        !           708:        if (filename != NULL) {
        !           709:            promptlen += printf ("(Next file: %s)", filename);
        !           710:        }
        !           711:        else if (!no_intty) {
        !           712:            promptlen += printf ("(%d%%)", (int)((file_pos * 100) / file_size));
        !           713:        }
        !           714:        if (dum_opt) {
        !           715:            promptlen += pr("[Press space to continue, 'q' to quit.]");
        !           716:        }
        !           717:        if (Senter && Sexit)
        !           718:            tputs (Sexit, 1, putch);
        !           719:        if (clreol)
        !           720:            clreos ();
        !           721:        fflush(stdout);
        !           722:     }
        !           723:     else
        !           724:        write (2, &bell, 1);
        !           725:     inwait++;
        !           726: }
        !           727: 
        !           728: /*
        !           729: ** Get a logical line
        !           730: */
        !           731: 
        !           732: getline(f, length)
        !           733: register FILE *f;
        !           734: int *length;
        !           735: {
        !           736:     register int       c;
        !           737:     register char      *p;
        !           738:     register int       column;
        !           739:     static int         colflg;
        !           740: 
        !           741:     p = Line;
        !           742:     column = 0;
        !           743:     c = Getc (f);
        !           744:     if (colflg && c == '\n') {
        !           745:        Currline++;
        !           746:        c = Getc (f);
        !           747:     }
        !           748:     while (p < &Line[LINSIZ - 1]) {
        !           749:        if (c == EOF) {
        !           750:            if (p > Line) {
        !           751:                *p = '\0';
        !           752:                *length = p - Line;
        !           753:                return (column);
        !           754:            }
        !           755:            *length = p - Line;
        !           756:            return (EOF);
        !           757:        }
        !           758:        if (c == '\n') {
        !           759:            Currline++;
        !           760:            break;
        !           761:        }
        !           762:        *p++ = c;
        !           763:        if (c == '\t')
        !           764:            if (!hardtabs || column < promptlen && !hard) {
        !           765:                if (hardtabs && eraseln && !dumb) {
        !           766:                    column = 1 + (column | 7);
        !           767:                    tputs (eraseln, 1, putch);
        !           768:                    promptlen = 0;
        !           769:                }
        !           770:                else {
        !           771:                    for (--p; p < &Line[LINSIZ - 1];) {
        !           772:                        *p++ = ' ';
        !           773:                        if ((++column & 7) == 0)
        !           774:                            break;
        !           775:                    }
        !           776:                    if (column >= promptlen) promptlen = 0;
        !           777:                }
        !           778:            }
        !           779:            else
        !           780:                column = 1 + (column | 7);
        !           781:        else if (c == '\b' && column > 0)
        !           782:            column--;
        !           783:        else if (c == '\r')
        !           784:            column = 0;
        !           785:        else if (c == '\f' && stop_opt) {
        !           786:                p[-1] = '^';
        !           787:                *p++ = 'L';
        !           788:                column += 2;
        !           789:                Pause++;
        !           790:        }
        !           791:        else if (c == EOF) {
        !           792:            *length = p - Line;
        !           793:            return (column);
        !           794:        }
        !           795:        else if (c >= ' ' && c != RUBOUT)
        !           796:            column++;
        !           797:        if (column >= Mcol && fold_opt) break;
        !           798:        c = Getc (f);
        !           799:     }
        !           800:     if (column >= Mcol && Mcol > 0) {
        !           801:        if (!Wrap) {
        !           802:            *p++ = '\n';
        !           803:        }
        !           804:     }
        !           805:     colflg = column == Mcol && fold_opt;
        !           806:     if (colflg && eatnl && Wrap) {
        !           807:        *p++ = '\n'; /* simulate normal wrap */
        !           808:     }
        !           809:     *length = p - Line;
        !           810:     *p = 0;
        !           811:     return (column);
        !           812: }
        !           813: 
        !           814: /*
        !           815: ** Erase the rest of the prompt, assuming we are starting at column col.
        !           816: */
        !           817: 
        !           818: erase (col)
        !           819: register int col;
        !           820: {
        !           821: 
        !           822:     if (promptlen == 0)
        !           823:        return;
        !           824:     if (hard) {
        !           825:        putchar ('\n');
        !           826:     }
        !           827:     else {
        !           828:        if (col == 0)
        !           829:            putchar ('\r');
        !           830:        if (!dumb && eraseln)
        !           831:            tputs (eraseln, 1, putch);
        !           832:        else
        !           833:            for (col = promptlen - col; col > 0; col--)
        !           834:                putchar (' ');
        !           835:     }
        !           836:     promptlen = 0;
        !           837: }
        !           838: 
        !           839: /*
        !           840: ** Erase the current line entirely
        !           841: */
        !           842: 
        !           843: kill_line ()
        !           844: {
        !           845:     erase (0);
        !           846:     if (!eraseln || dumb) putchar ('\r');
        !           847: }
        !           848: 
        !           849: /*
        !           850:  * force clear to end of line
        !           851:  */
        !           852: cleareol()
        !           853: {
        !           854:     tputs(eraseln, 1, putch);
        !           855: }
        !           856: 
        !           857: clreos()
        !           858: {
        !           859:     tputs(EodClr, 1, putch);
        !           860: }
        !           861: 
        !           862: /*
        !           863: **  Print string and return number of characters
        !           864: */
        !           865: 
        !           866: pr(s1)
        !           867: char   *s1;
        !           868: {
        !           869:     register char      *s;
        !           870:     register char      c;
        !           871: 
        !           872:     for (s = s1; c = *s++; )
        !           873:        putchar(c);
        !           874:     return (s - s1 - 1);
        !           875: }
        !           876: 
        !           877: 
        !           878: /* Print a buffer of n characters */
        !           879: 
        !           880: prbuf (s, n)
        !           881: register char *s;
        !           882: register int n;
        !           883: {
        !           884:     register char c;                   /* next output character */
        !           885:     register int state;                        /* next output char's UL state */
        !           886: #define wouldul(s,n)   ((n) >= 2 && (((s)[0] == '_' && (s)[1] == '\b') || ((s)[1] == '\b' && (s)[2] == '_')))
        !           887: 
        !           888:     while (--n >= 0)
        !           889:        if (!ul_opt)
        !           890:            putchar (*s++);
        !           891:        else {
        !           892:            if (*s == ' ' && pstate == 0 && ulglitch && wouldul(s+1, n-1)) {
        !           893:                s++;
        !           894:                continue;
        !           895:            }
        !           896:            if (state = wouldul(s, n)) {
        !           897:                c = (*s == '_')? s[2] : *s ;
        !           898:                n -= 2;
        !           899:                s += 3;
        !           900:            } else
        !           901:                c = *s++;
        !           902:            if (state != pstate) {
        !           903:                if (c == ' ' && state == 0 && ulglitch && wouldul(s, n-1))
        !           904:                    state = 1;
        !           905:                else
        !           906:                    tputs(state ? ULenter : ULexit, 1, putch);
        !           907:            }
        !           908:            if (c != ' ' || pstate == 0 || state != 0 || ulglitch == 0)
        !           909:                putchar(c);
        !           910:            if (state && *chUL) {
        !           911:                pr(chBS);
        !           912:                tputs(chUL, 1, putch);
        !           913:            }
        !           914:            pstate = state;
        !           915:        }
        !           916: }
        !           917: 
        !           918: /*
        !           919: **  Clear the screen
        !           920: */
        !           921: 
        !           922: doclear()
        !           923: {
        !           924:     if (Clear && !hard) {
        !           925:        tputs(Clear, 1, putch);
        !           926: 
        !           927:        /* Put out carriage return so that system doesn't
        !           928:        ** get confused by escape sequences when expanding tabs
        !           929:        */
        !           930:        putchar ('\r');
        !           931:        promptlen = 0;
        !           932:     }
        !           933: }
        !           934: 
        !           935: /*
        !           936:  * Go to home position
        !           937:  */
        !           938: home()
        !           939: {
        !           940:     tputs(Home,1,putch);
        !           941: }
        !           942: 
        !           943: static int lastcmd, lastarg, lastp;
        !           944: static int lastcolon;
        !           945: char shell_line[132];
        !           946: 
        !           947: /*
        !           948: ** Read a command and do it. A command consists of an optional integer
        !           949: ** argument followed by the command character.  Return the number of lines
        !           950: ** to display in the next screenful.  If there is nothing more to display
        !           951: ** in the current file, zero is returned.
        !           952: */
        !           953: 
        !           954: command (filename, f)
        !           955: char *filename;
        !           956: register FILE *f;
        !           957: {
        !           958:     register int nlines;
        !           959:     register int retval;
        !           960:     register char c;
        !           961:     char colonch;
        !           962:     FILE *helpf;
        !           963:     int done;
        !           964:     char comchar, cmdbuf[80], *p;
        !           965: 
        !           966: #define ret(val) retval=val;done++;break
        !           967: 
        !           968:     done = 0;
        !           969:     if (!errors)
        !           970:        prompt (filename);
        !           971:     else
        !           972:        errors = 0;
        !           973:     if (MBIT == RAW && slow_tty) {
        !           974:        otty.sg_flags |= MBIT;
        !           975:        stty(fileno(stderr), &otty);
        !           976:     }
        !           977:     for (;;) {
        !           978:        nlines = number (&comchar);
        !           979:        lastp = colonch = 0;
        !           980:        if (comchar == '.') {   /* Repeat last command */
        !           981:                lastp++;
        !           982:                comchar = lastcmd;
        !           983:                nlines = lastarg;
        !           984:                if (lastcmd == ':')
        !           985:                        colonch = lastcolon;
        !           986:        }
        !           987:        lastcmd = comchar;
        !           988:        lastarg = nlines;
        !           989:        if (comchar == otty.sg_erase) {
        !           990:            kill_line ();
        !           991:            prompt (filename);
        !           992:            continue;
        !           993:        }
        !           994:        switch (comchar) {
        !           995:        case ':':
        !           996:            retval = colon (filename, colonch, nlines);
        !           997:            if (retval >= 0)
        !           998:                done++;
        !           999:            break;
        !          1000:        case 'b':
        !          1001:        case ctrl('B'):
        !          1002:            {
        !          1003:                register int initline;
        !          1004: 
        !          1005:                if (no_intty) {
        !          1006:                    write(2, &bell, 1);
        !          1007:                    return (-1);
        !          1008:                }
        !          1009: 
        !          1010:                if (nlines == 0) nlines++;
        !          1011: 
        !          1012:                putchar ('\r');
        !          1013:                erase (0);
        !          1014:                printf ("\n");
        !          1015:                if (clreol)
        !          1016:                        cleareol ();
        !          1017:                printf ("...back %d page", nlines);
        !          1018:                if (nlines > 1)
        !          1019:                        pr ("s\n");
        !          1020:                else
        !          1021:                        pr ("\n");
        !          1022: 
        !          1023:                if (clreol)
        !          1024:                        cleareol ();
        !          1025:                pr ("\n");
        !          1026: 
        !          1027:                initline = Currline - dlines * (nlines + 1);
        !          1028:                if (! noscroll)
        !          1029:                    --initline;
        !          1030:                if (initline < 0) initline = 0;
        !          1031:                Fseek(f, 0L);
        !          1032:                Currline = 0;   /* skiplns() will make Currline correct */
        !          1033:                skiplns(initline, f);
        !          1034:                if (! noscroll) {
        !          1035:                    ret(dlines + 1);
        !          1036:                }
        !          1037:                else {
        !          1038:                    ret(dlines);
        !          1039:                }
        !          1040:            }
        !          1041:        case ' ':
        !          1042:        case 'z':
        !          1043:            if (nlines == 0) nlines = dlines;
        !          1044:            else if (comchar == 'z') dlines = nlines;
        !          1045:            ret (nlines);
        !          1046:        case 'd':
        !          1047:        case ctrl('D'):
        !          1048:            if (nlines != 0) nscroll = nlines;
        !          1049:            ret (nscroll);
        !          1050:        case 'q':
        !          1051:        case 'Q':
        !          1052:            end_it ();
        !          1053:        case 's':
        !          1054:        case 'f':
        !          1055:            if (nlines == 0) nlines++;
        !          1056:            if (comchar == 'f')
        !          1057:                nlines *= dlines;
        !          1058:            putchar ('\r');
        !          1059:            erase (0);
        !          1060:            printf ("\n");
        !          1061:            if (clreol)
        !          1062:                cleareol ();
        !          1063:            printf ("...skipping %d line", nlines);
        !          1064:            if (nlines > 1)
        !          1065:                pr ("s\n");
        !          1066:            else
        !          1067:                pr ("\n");
        !          1068: 
        !          1069:            if (clreol)
        !          1070:                cleareol ();
        !          1071:            pr ("\n");
        !          1072: 
        !          1073:            while (nlines > 0) {
        !          1074:                while ((c = Getc (f)) != '\n')
        !          1075:                    if (c == EOF) {
        !          1076:                        retval = 0;
        !          1077:                        done++;
        !          1078:                        goto endsw;
        !          1079:                    }
        !          1080:                    Currline++;
        !          1081:                    nlines--;
        !          1082:            }
        !          1083:            ret (dlines);
        !          1084:        case '\n':
        !          1085:            if (nlines != 0)
        !          1086:                dlines = nlines;
        !          1087:            else
        !          1088:                nlines = 1;
        !          1089:            ret (nlines);
        !          1090:        case '\f':
        !          1091:            if (!no_intty) {
        !          1092:                doclear ();
        !          1093:                Fseek (f, screen_start.chrctr);
        !          1094:                Currline = screen_start.line;
        !          1095:                ret (dlines);
        !          1096:            }
        !          1097:            else {
        !          1098:                write (2, &bell, 1);
        !          1099:                break;
        !          1100:            }
        !          1101:        case '\'':
        !          1102:            if (!no_intty) {
        !          1103:                kill_line ();
        !          1104:                pr ("\n***Back***\n\n");
        !          1105:                Fseek (f, context.chrctr);
        !          1106:                Currline = context.line;
        !          1107:                ret (dlines);
        !          1108:            }
        !          1109:            else {
        !          1110:                write (2, &bell, 1);
        !          1111:                break;
        !          1112:            }
        !          1113:        case '=':
        !          1114:            kill_line ();
        !          1115:            promptlen = printd (Currline);
        !          1116:            fflush (stdout);
        !          1117:            break;
        !          1118:        case 'n':
        !          1119:            lastp++;
        !          1120:        case '/':
        !          1121:            if (nlines == 0) nlines++;
        !          1122:            kill_line ();
        !          1123:            pr ("/");
        !          1124:            promptlen = 1;
        !          1125:            fflush (stdout);
        !          1126:            if (lastp) {
        !          1127:                write (2,"\r", 1);
        !          1128:                search (NULL, f, nlines);       /* Use previous r.e. */
        !          1129:            }
        !          1130:            else {
        !          1131:                ttyin (cmdbuf, 78, '/');
        !          1132:                write (2, "\r", 1);
        !          1133:                search (cmdbuf, f, nlines);
        !          1134:            }
        !          1135:            ret (dlines-1);
        !          1136:        case '!':
        !          1137:            do_shell (filename);
        !          1138:            break;
        !          1139:        case '?':
        !          1140:        case 'h':
        !          1141:            if ((helpf = fopen (HELPFILE, "r")) == NULL)
        !          1142:                error ("Can't open help file");
        !          1143:            if (noscroll) doclear ();
        !          1144:            copy_file (helpf);
        !          1145:            fclose (helpf);
        !          1146:            prompt (filename);
        !          1147:            break;
        !          1148:        case 'v':       /* This case should go right before default */
        !          1149:            if (!no_intty) {
        !          1150:                kill_line ();
        !          1151:                cmdbuf[0] = '+';
        !          1152:                scanstr (Currline - dlines < 0 ? 0
        !          1153:                                : Currline - (dlines + 1) / 2, &cmdbuf[1]);
        !          1154:                pr ("vi "); pr (cmdbuf); putchar (' '); pr (fnames[fnum]);
        !          1155:                execute (filename, _PATH_VI, "vi", cmdbuf, fnames[fnum], 0);
        !          1156:                break;
        !          1157:            }
        !          1158:        default:
        !          1159:            if (dum_opt) {
        !          1160:                kill_line ();
        !          1161:                if (Senter && Sexit) {
        !          1162:                    tputs (Senter, 1, putch);
        !          1163:                    promptlen = pr ("[Press 'h' for instructions.]") + (2 * soglitch);
        !          1164:                    tputs (Sexit, 1, putch);
        !          1165:                }
        !          1166:                else
        !          1167:                    promptlen = pr ("[Press 'h' for instructions.]");
        !          1168:                fflush (stdout);
        !          1169:            }
        !          1170:            else
        !          1171:                write (2, &bell, 1);
        !          1172:            break;
        !          1173:        }
        !          1174:        if (done) break;
        !          1175:     }
        !          1176:     putchar ('\r');
        !          1177: endsw:
        !          1178:     inwait = 0;
        !          1179:     notell++;
        !          1180:     if (MBIT == RAW && slow_tty) {
        !          1181:        otty.sg_flags &= ~MBIT;
        !          1182:        stty(fileno(stderr), &otty);
        !          1183:     }
        !          1184:     return (retval);
        !          1185: }
        !          1186: 
        !          1187: char ch;
        !          1188: 
        !          1189: /*
        !          1190:  * Execute a colon-prefixed command.
        !          1191:  * Returns <0 if not a command that should cause
        !          1192:  * more of the file to be printed.
        !          1193:  */
        !          1194: 
        !          1195: colon (filename, cmd, nlines)
        !          1196: char *filename;
        !          1197: int cmd;
        !          1198: int nlines;
        !          1199: {
        !          1200:        if (cmd == 0)
        !          1201:                ch = readch ();
        !          1202:        else
        !          1203:                ch = cmd;
        !          1204:        lastcolon = ch;
        !          1205:        switch (ch) {
        !          1206:        case 'f':
        !          1207:                kill_line ();
        !          1208:                if (!no_intty)
        !          1209:                        promptlen = printf ("\"%s\" line %d", fnames[fnum], Currline);
        !          1210:                else
        !          1211:                        promptlen = printf ("[Not a file] line %d", Currline);
        !          1212:                fflush (stdout);
        !          1213:                return (-1);
        !          1214:        case 'n':
        !          1215:                if (nlines == 0) {
        !          1216:                        if (fnum >= nfiles - 1)
        !          1217:                                end_it ();
        !          1218:                        nlines++;
        !          1219:                }
        !          1220:                putchar ('\r');
        !          1221:                erase (0);
        !          1222:                skipf (nlines);
        !          1223:                return (0);
        !          1224:        case 'p':
        !          1225:                if (no_intty) {
        !          1226:                        write (2, &bell, 1);
        !          1227:                        return (-1);
        !          1228:                }
        !          1229:                putchar ('\r');
        !          1230:                erase (0);
        !          1231:                if (nlines == 0)
        !          1232:                        nlines++;
        !          1233:                skipf (-nlines);
        !          1234:                return (0);
        !          1235:        case '!':
        !          1236:                do_shell (filename);
        !          1237:                return (-1);
        !          1238:        case 'q':
        !          1239:        case 'Q':
        !          1240:                end_it ();
        !          1241:        default:
        !          1242:                write (2, &bell, 1);
        !          1243:                return (-1);
        !          1244:        }
        !          1245: }
        !          1246: 
        !          1247: /*
        !          1248: ** Read a decimal number from the terminal. Set cmd to the non-digit which
        !          1249: ** terminates the number.
        !          1250: */
        !          1251: 
        !          1252: number(cmd)
        !          1253: char *cmd;
        !          1254: {
        !          1255:        register int i;
        !          1256: 
        !          1257:        i = 0; ch = otty.sg_kill;
        !          1258:        for (;;) {
        !          1259:                ch = readch ();
        !          1260:                if (ch >= '0' && ch <= '9')
        !          1261:                        i = i*10 + ch - '0';
        !          1262:                else if (ch == otty.sg_kill)
        !          1263:                        i = 0;
        !          1264:                else {
        !          1265:                        *cmd = ch;
        !          1266:                        break;
        !          1267:                }
        !          1268:        }
        !          1269:        return (i);
        !          1270: }
        !          1271: 
        !          1272: do_shell (filename)
        !          1273: char *filename;
        !          1274: {
        !          1275:        char cmdbuf[80];
        !          1276: 
        !          1277:        kill_line ();
        !          1278:        pr ("!");
        !          1279:        fflush (stdout);
        !          1280:        promptlen = 1;
        !          1281:        if (lastp)
        !          1282:                pr (shell_line);
        !          1283:        else {
        !          1284:                ttyin (cmdbuf, 78, '!');
        !          1285:                if (expand (shell_line, cmdbuf)) {
        !          1286:                        kill_line ();
        !          1287:                        promptlen = printf ("!%s", shell_line);
        !          1288:                }
        !          1289:        }
        !          1290:        fflush (stdout);
        !          1291:        write (2, "\n", 1);
        !          1292:        promptlen = 0;
        !          1293:        shellp = 1;
        !          1294:        execute (filename, shell, shell, "-c", shell_line, 0);
        !          1295: }
        !          1296: 
        !          1297: /*
        !          1298: ** Search for nth ocurrence of regular expression contained in buf in the file
        !          1299: */
        !          1300: 
        !          1301: search (buf, file, n)
        !          1302: char buf[];
        !          1303: FILE *file;
        !          1304: register int n;
        !          1305: {
        !          1306:     long startline = Ftell (file);
        !          1307:     register long line1 = startline;
        !          1308:     register long line2 = startline;
        !          1309:     register long line3 = startline;
        !          1310:     register int lncount;
        !          1311:     int saveln, rv, re_exec();
        !          1312:     char *s, *re_comp();
        !          1313: 
        !          1314:     context.line = saveln = Currline;
        !          1315:     context.chrctr = startline;
        !          1316:     lncount = 0;
        !          1317:     if ((s = re_comp (buf)) != 0)
        !          1318:        error (s);
        !          1319:     while (!feof (file)) {
        !          1320:        line3 = line2;
        !          1321:        line2 = line1;
        !          1322:        line1 = Ftell (file);
        !          1323:        rdline (file);
        !          1324:        lncount++;
        !          1325:        if ((rv = re_exec (Line)) == 1)
        !          1326:                if (--n == 0) {
        !          1327:                    if (lncount > 3 || (lncount > 1 && no_intty))
        !          1328:                    {
        !          1329:                        pr ("\n");
        !          1330:                        if (clreol)
        !          1331:                            cleareol ();
        !          1332:                        pr("...skipping\n");
        !          1333:                    }
        !          1334:                    if (!no_intty) {
        !          1335:                        Currline -= (lncount >= 3 ? 3 : lncount);
        !          1336:                        Fseek (file, line3);
        !          1337:                        if (noscroll)
        !          1338:                            if (clreol) {
        !          1339:                                home ();
        !          1340:                                cleareol ();
        !          1341:                            }
        !          1342:                            else
        !          1343:                                doclear ();
        !          1344:                    }
        !          1345:                    else {
        !          1346:                        kill_line ();
        !          1347:                        if (noscroll)
        !          1348:                            if (clreol) {
        !          1349:                                home ();
        !          1350:                                cleareol ();
        !          1351:                            }
        !          1352:                            else
        !          1353:                                doclear ();
        !          1354:                        pr (Line);
        !          1355:                        putchar ('\n');
        !          1356:                    }
        !          1357:                    break;
        !          1358:                }
        !          1359:        else if (rv == -1)
        !          1360:            error ("Regular expression botch");
        !          1361:     }
        !          1362:     if (feof (file)) {
        !          1363:        if (!no_intty) {
        !          1364:            file->_flag &= ~_IOEOF; /* why doesn't fseek do this ??!!??! */
        !          1365:            Currline = saveln;
        !          1366:            Fseek (file, startline);
        !          1367:        }
        !          1368:        else {
        !          1369:            pr ("\nPattern not found\n");
        !          1370:            end_it ();
        !          1371:        }
        !          1372:        error ("Pattern not found");
        !          1373:     }
        !          1374: }
        !          1375: 
        !          1376: /*VARARGS2*/
        !          1377: execute (filename, cmd, va_alist)
        !          1378: char *filename;
        !          1379: char *cmd;
        !          1380: va_dcl
        !          1381: {
        !          1382:        int id;
        !          1383:        int n;
        !          1384:        va_list argp;
        !          1385: 
        !          1386:        fflush (stdout);
        !          1387:        reset_tty ();
        !          1388:        for (n = 10; (id = fork ()) < 0 && n > 0; n--)
        !          1389:            sleep (5);
        !          1390:        if (id == 0) {
        !          1391:            if (!isatty(0)) {
        !          1392:                close(0);
        !          1393:                open("/dev/tty", 0);
        !          1394:            }
        !          1395:            va_start(argp);
        !          1396:            execv (cmd, argp);
        !          1397:            write (2, "exec failed\n", 12);
        !          1398:            exit (1);
        !          1399:            va_end(argp);       /* balance {}'s for some UNIX's */
        !          1400:        }
        !          1401:        if (id > 0) {
        !          1402:            signal (SIGINT, SIG_IGN);
        !          1403:            signal (SIGQUIT, SIG_IGN);
        !          1404:            if (catch_susp)
        !          1405:                signal(SIGTSTP, SIG_DFL);
        !          1406:            while (wait(0) > 0);
        !          1407:            signal (SIGINT, end_it);
        !          1408:            signal (SIGQUIT, onquit);
        !          1409:            if (catch_susp)
        !          1410:                signal(SIGTSTP, onsusp);
        !          1411:        } else
        !          1412:            write(2, "can't fork\n", 11);
        !          1413:        set_tty ();
        !          1414:        pr ("------------------------\n");
        !          1415:        prompt (filename);
        !          1416: }
        !          1417: /*
        !          1418: ** Skip n lines in the file f
        !          1419: */
        !          1420: 
        !          1421: skiplns (n, f)
        !          1422: register int n;
        !          1423: register FILE *f;
        !          1424: {
        !          1425:     register char c;
        !          1426: 
        !          1427:     while (n > 0) {
        !          1428:        while ((c = Getc (f)) != '\n')
        !          1429:            if (c == EOF)
        !          1430:                return;
        !          1431:            n--;
        !          1432:            Currline++;
        !          1433:     }
        !          1434: }
        !          1435: 
        !          1436: /*
        !          1437: ** Skip nskip files in the file list (from the command line). Nskip may be
        !          1438: ** negative.
        !          1439: */
        !          1440: 
        !          1441: skipf (nskip)
        !          1442: register int nskip;
        !          1443: {
        !          1444:     if (nskip == 0) return;
        !          1445:     if (nskip > 0) {
        !          1446:        if (fnum + nskip > nfiles - 1)
        !          1447:            nskip = nfiles - fnum - 1;
        !          1448:     }
        !          1449:     else if (within)
        !          1450:        ++fnum;
        !          1451:     fnum += nskip;
        !          1452:     if (fnum < 0)
        !          1453:        fnum = 0;
        !          1454:     pr ("\n...Skipping ");
        !          1455:     pr ("\n");
        !          1456:     if (clreol)
        !          1457:        cleareol ();
        !          1458:     pr ("...Skipping ");
        !          1459:     pr (nskip > 0 ? "to file " : "back to file ");
        !          1460:     pr (fnames[fnum]);
        !          1461:     pr ("\n");
        !          1462:     if (clreol)
        !          1463:        cleareol ();
        !          1464:     pr ("\n");
        !          1465:     --fnum;
        !          1466: }
        !          1467: 
        !          1468: /*----------------------------- Terminal I/O -------------------------------*/
        !          1469: 
        !          1470: initterm ()
        !          1471: {
        !          1472:     char       buf[TBUFSIZ];
        !          1473:     static char        clearbuf[TBUFSIZ];
        !          1474:     char       *clearptr, *padstr;
        !          1475:     int                ldisc;
        !          1476:     int                lmode;
        !          1477:     char       *term;
        !          1478:     int                tgrp;
        !          1479:     struct winsize win;
        !          1480: 
        !          1481: retry:
        !          1482:     if (!(no_tty = gtty(fileno(stdout), &otty))) {
        !          1483:        if (ioctl(fileno(stdout), TIOCLGET, &lmode) < 0) {
        !          1484:            perror("TIOCLGET");
        !          1485:            exit(1);
        !          1486:        }
        !          1487:        docrterase = ((lmode & LCRTERA) != 0);
        !          1488:        docrtkill = ((lmode & LCRTKIL) != 0);
        !          1489:        /*
        !          1490:         * Wait until we're in the foreground before we save the
        !          1491:         * the terminal modes.
        !          1492:         */
        !          1493:        if (ioctl(fileno(stdout), TIOCGPGRP, &tgrp) < 0) {
        !          1494:            perror("TIOCGPGRP");
        !          1495:            exit(1);
        !          1496:        }
        !          1497:        if (tgrp != getpgrp(0)) {
        !          1498:            kill(0, SIGTTOU);
        !          1499:            goto retry;
        !          1500:        }
        !          1501:        if ((term = getenv("TERM")) == 0 || tgetent(buf, term) <= 0) {
        !          1502:            dumb++; ul_opt = 0;
        !          1503:        }
        !          1504:        else {
        !          1505:            if (ioctl(fileno(stdout), TIOCGWINSZ, &win) < 0) {
        !          1506:                Lpp = tgetnum("li");
        !          1507:                Mcol = tgetnum("co");
        !          1508:            } else {
        !          1509:                if ((Lpp = win.ws_row) == 0)
        !          1510:                    Lpp = tgetnum("li");
        !          1511:                if ((Mcol = win.ws_col) == 0)
        !          1512:                    Mcol = tgetnum("co");
        !          1513:            }
        !          1514:            if ((Lpp <= 0) || tgetflag("hc")) {
        !          1515:                hard++; /* Hard copy terminal */
        !          1516:                Lpp = 24;
        !          1517:            }
        !          1518:            if (tgetflag("xn"))
        !          1519:                eatnl++; /* Eat newline at last column + 1; dec, concept */
        !          1520:            if (Mcol <= 0)
        !          1521:                Mcol = 80;
        !          1522: 
        !          1523:            if (tailequ (fnames[0], "page") || !hard && tgetflag("ns"))
        !          1524:                noscroll++;
        !          1525:            Wrap = tgetflag("am");
        !          1526:            bad_so = tgetflag ("xs");
        !          1527:            clearptr = clearbuf;
        !          1528:            eraseln = tgetstr("ce",&clearptr);
        !          1529:            Clear = tgetstr("cl", &clearptr);
        !          1530:            Senter = tgetstr("so", &clearptr);
        !          1531:            Sexit = tgetstr("se", &clearptr);
        !          1532:            if ((soglitch = tgetnum("sg")) < 0)
        !          1533:                soglitch = 0;
        !          1534: 
        !          1535:            /*
        !          1536:             *  Set up for underlining:  some terminals don't need it;
        !          1537:             *  others have start/stop sequences, still others have an
        !          1538:             *  underline char sequence which is assumed to move the
        !          1539:             *  cursor forward one character.  If underline sequence
        !          1540:             *  isn't available, settle for standout sequence.
        !          1541:             */
        !          1542: 
        !          1543:            if (tgetflag("ul") || tgetflag("os"))
        !          1544:                ul_opt = 0;
        !          1545:            if ((chUL = tgetstr("uc", &clearptr)) == NULL )
        !          1546:                chUL = "";
        !          1547:            if (((ULenter = tgetstr("us", &clearptr)) == NULL ||
        !          1548:                 (ULexit = tgetstr("ue", &clearptr)) == NULL) && !*chUL) {
        !          1549:                if ((ULenter = Senter) == NULL || (ULexit = Sexit) == NULL) {
        !          1550:                        ULenter = "";
        !          1551:                        ULexit = "";
        !          1552:                } else
        !          1553:                        ulglitch = soglitch;
        !          1554:            } else {
        !          1555:                if ((ulglitch = tgetnum("ug")) < 0)
        !          1556:                    ulglitch = 0;
        !          1557:            }
        !          1558: 
        !          1559:            if (padstr = tgetstr("pc", &clearptr))
        !          1560:                PC = *padstr;
        !          1561:            Home = tgetstr("ho",&clearptr);
        !          1562:            if (Home == 0 || *Home == '\0')
        !          1563:            {
        !          1564:                if ((cursorm = tgetstr("cm", &clearptr)) != NULL) {
        !          1565:                    strcpy(cursorhome, tgoto(cursorm, 0, 0));
        !          1566:                    Home = cursorhome;
        !          1567:               }
        !          1568:            }
        !          1569:            EodClr = tgetstr("cd", &clearptr);
        !          1570:            if ((chBS = tgetstr("bc", &clearptr)) == NULL)
        !          1571:                chBS = "\b";
        !          1572: 
        !          1573:        }
        !          1574:        if ((shell = getenv("SHELL")) == NULL)
        !          1575:            shell = "/bin/sh";
        !          1576:     }
        !          1577:     no_intty = gtty(fileno(stdin), &otty);
        !          1578:     gtty(fileno(stderr), &otty);
        !          1579:     savetty = otty;
        !          1580:     ospeed = otty.sg_ospeed;
        !          1581:     slow_tty = ospeed < B1200;
        !          1582:     hardtabs = (otty.sg_flags & TBDELAY) != XTABS;
        !          1583:     if (!no_tty) {
        !          1584:        otty.sg_flags &= ~ECHO;
        !          1585:        if (MBIT == CBREAK || !slow_tty)
        !          1586:            otty.sg_flags |= MBIT;
        !          1587:     }
        !          1588: }
        !          1589: 
        !          1590: readch ()
        !          1591: {
        !          1592:        char ch;
        !          1593:        extern int errno;
        !          1594: 
        !          1595:        errno = 0;
        !          1596:        if (read (2, &ch, 1) <= 0)
        !          1597:                if (errno != EINTR)
        !          1598:                        end_it();
        !          1599:                else
        !          1600:                        ch = otty.sg_kill;
        !          1601:        return (ch);
        !          1602: }
        !          1603: 
        !          1604: static char BS = '\b';
        !          1605: static char *BSB = "\b \b";
        !          1606: static char CARAT = '^';
        !          1607: #define ERASEONECHAR \
        !          1608:     if (docrterase) \
        !          1609:        write (2, BSB, sizeof(BSB)); \
        !          1610:     else \
        !          1611:        write (2, &BS, sizeof(BS));
        !          1612: 
        !          1613: ttyin (buf, nmax, pchar)
        !          1614: char buf[];
        !          1615: register int nmax;
        !          1616: char pchar;
        !          1617: {
        !          1618:     register char *sptr;
        !          1619:     register char ch;
        !          1620:     register int slash = 0;
        !          1621:     int        maxlen;
        !          1622:     char cbuf;
        !          1623: 
        !          1624:     sptr = buf;
        !          1625:     maxlen = 0;
        !          1626:     while (sptr - buf < nmax) {
        !          1627:        if (promptlen > maxlen) maxlen = promptlen;
        !          1628:        ch = readch ();
        !          1629:        if (ch == '\\') {
        !          1630:            slash++;
        !          1631:        }
        !          1632:        else if ((ch == otty.sg_erase) && !slash) {
        !          1633:            if (sptr > buf) {
        !          1634:                --promptlen;
        !          1635:                ERASEONECHAR
        !          1636:                --sptr;
        !          1637:                if ((*sptr < ' ' && *sptr != '\n') || *sptr == RUBOUT) {
        !          1638:                    --promptlen;
        !          1639:                    ERASEONECHAR
        !          1640:                }
        !          1641:                continue;
        !          1642:            }
        !          1643:            else {
        !          1644:                if (!eraseln) promptlen = maxlen;
        !          1645:                longjmp (restore, 1);
        !          1646:            }
        !          1647:        }
        !          1648:        else if ((ch == otty.sg_kill) && !slash) {
        !          1649:            if (hard) {
        !          1650:                show (ch);
        !          1651:                putchar ('\n');
        !          1652:                putchar (pchar);
        !          1653:            }
        !          1654:            else {
        !          1655:                putchar ('\r');
        !          1656:                putchar (pchar);
        !          1657:                if (eraseln)
        !          1658:                    erase (1);
        !          1659:                else if (docrtkill)
        !          1660:                    while (promptlen-- > 1)
        !          1661:                        write (2, BSB, sizeof(BSB));
        !          1662:                promptlen = 1;
        !          1663:            }
        !          1664:            sptr = buf;
        !          1665:            fflush (stdout);
        !          1666:            continue;
        !          1667:        }
        !          1668:        if (slash && (ch == otty.sg_kill || ch == otty.sg_erase)) {
        !          1669:            ERASEONECHAR
        !          1670:            --sptr;
        !          1671:        }
        !          1672:        if (ch != '\\')
        !          1673:            slash = 0;
        !          1674:        *sptr++ = ch;
        !          1675:        if ((ch < ' ' && ch != '\n' && ch != ESC) || ch == RUBOUT) {
        !          1676:            ch += ch == RUBOUT ? -0100 : 0100;
        !          1677:            write (2, &CARAT, 1);
        !          1678:            promptlen++;
        !          1679:        }
        !          1680:        cbuf = ch;
        !          1681:        if (ch != '\n' && ch != ESC) {
        !          1682:            write (2, &cbuf, 1);
        !          1683:            promptlen++;
        !          1684:        }
        !          1685:        else
        !          1686:            break;
        !          1687:     }
        !          1688:     *--sptr = '\0';
        !          1689:     if (!eraseln) promptlen = maxlen;
        !          1690:     if (sptr - buf >= nmax - 1)
        !          1691:        error ("Line too long");
        !          1692: }
        !          1693: 
        !          1694: expand (outbuf, inbuf)
        !          1695: char *outbuf;
        !          1696: char *inbuf;
        !          1697: {
        !          1698:     register char *instr;
        !          1699:     register char *outstr;
        !          1700:     register char ch;
        !          1701:     char temp[200];
        !          1702:     int changed = 0;
        !          1703: 
        !          1704:     instr = inbuf;
        !          1705:     outstr = temp;
        !          1706:     while ((ch = *instr++) != '\0')
        !          1707:        switch (ch) {
        !          1708:        case '%':
        !          1709:            if (!no_intty) {
        !          1710:                strcpy (outstr, fnames[fnum]);
        !          1711:                outstr += strlen (fnames[fnum]);
        !          1712:                changed++;
        !          1713:            }
        !          1714:            else
        !          1715:                *outstr++ = ch;
        !          1716:            break;
        !          1717:        case '!':
        !          1718:            if (!shellp)
        !          1719:                error ("No previous command to substitute for");
        !          1720:            strcpy (outstr, shell_line);
        !          1721:            outstr += strlen (shell_line);
        !          1722:            changed++;
        !          1723:            break;
        !          1724:        case '\\':
        !          1725:            if (*instr == '%' || *instr == '!') {
        !          1726:                *outstr++ = *instr++;
        !          1727:                break;
        !          1728:            }
        !          1729:        default:
        !          1730:            *outstr++ = ch;
        !          1731:        }
        !          1732:     *outstr++ = '\0';
        !          1733:     strcpy (outbuf, temp);
        !          1734:     return (changed);
        !          1735: }
        !          1736: 
        !          1737: show (ch)
        !          1738: register char ch;
        !          1739: {
        !          1740:     char cbuf;
        !          1741: 
        !          1742:     if ((ch < ' ' && ch != '\n' && ch != ESC) || ch == RUBOUT) {
        !          1743:        ch += ch == RUBOUT ? -0100 : 0100;
        !          1744:        write (2, &CARAT, 1);
        !          1745:        promptlen++;
        !          1746:     }
        !          1747:     cbuf = ch;
        !          1748:     write (2, &cbuf, 1);
        !          1749:     promptlen++;
        !          1750: }
        !          1751: 
        !          1752: error (mess)
        !          1753: char *mess;
        !          1754: {
        !          1755:     if (clreol)
        !          1756:        cleareol ();
        !          1757:     else
        !          1758:        kill_line ();
        !          1759:     promptlen += strlen (mess);
        !          1760:     if (Senter && Sexit) {
        !          1761:        tputs (Senter, 1, putch);
        !          1762:        pr(mess);
        !          1763:        tputs (Sexit, 1, putch);
        !          1764:     }
        !          1765:     else
        !          1766:        pr (mess);
        !          1767:     fflush(stdout);
        !          1768:     errors++;
        !          1769:     longjmp (restore, 1);
        !          1770: }
        !          1771: 
        !          1772: 
        !          1773: set_tty ()
        !          1774: {
        !          1775:        otty.sg_flags |= MBIT;
        !          1776:        otty.sg_flags &= ~ECHO;
        !          1777:        stty(fileno(stderr), &otty);
        !          1778: }
        !          1779: 
        !          1780: reset_tty ()
        !          1781: {
        !          1782:     if (no_tty)
        !          1783:        return;
        !          1784:     if (pstate) {
        !          1785:        tputs(ULexit, 1, putch);
        !          1786:        fflush(stdout);
        !          1787:        pstate = 0;
        !          1788:     }
        !          1789:     otty.sg_flags |= ECHO;
        !          1790:     otty.sg_flags &= ~MBIT;
        !          1791:     stty(fileno(stderr), &savetty);
        !          1792: }
        !          1793: 
        !          1794: rdline (f)
        !          1795: register FILE *f;
        !          1796: {
        !          1797:     register char c;
        !          1798:     register char *p;
        !          1799: 
        !          1800:     p = Line;
        !          1801:     while ((c = Getc (f)) != '\n' && c != EOF && p - Line < LINSIZ - 1)
        !          1802:        *p++ = c;
        !          1803:     if (c == '\n')
        !          1804:        Currline++;
        !          1805:     *p = '\0';
        !          1806: }
        !          1807: 
        !          1808: /* Come here when we get a suspend signal from the terminal */
        !          1809: 
        !          1810: onsusp ()
        !          1811: {
        !          1812:     /* ignore SIGTTOU so we don't get stopped if csh grabs the tty */
        !          1813:     signal(SIGTTOU, SIG_IGN);
        !          1814:     reset_tty ();
        !          1815:     fflush (stdout);
        !          1816:     signal(SIGTTOU, SIG_DFL);
        !          1817:     /* Send the TSTP signal to suspend our process group */
        !          1818:     signal(SIGTSTP, SIG_DFL);
        !          1819:     sigsetmask(0);
        !          1820:     kill (0, SIGTSTP);
        !          1821:     /* Pause for station break */
        !          1822: 
        !          1823:     /* We're back */
        !          1824:     signal (SIGTSTP, onsusp);
        !          1825:     set_tty ();
        !          1826:     if (inwait)
        !          1827:            longjmp (restore);
        !          1828: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.