Return to more.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ucb / more

Annotation of 43BSD/ucb/more/more.c, revision 1.1

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

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