/* $OpenBSD: more.c,v 1.42 2024/10/16 18:47:47 miod Exp $ */ /* * Copyright (c) 2003 Todd C. Miller * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Sponsored in part by the Defense Advanced Research Projects * Agency (DARPA) and Air Force Research Laboratory, Air Force * Materiel Command, USAF, under agreement number F39502-99-1-0512. */ /*- * Copyright (c) 1980 The Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * more.c - General purpose tty output filter and file perusal program * * by Eric Shienbrood, UC Berkeley * * modified by Geoff Peck, UCB to add underlining, single spacing * modified by John Foderaro, UCB to add -c and MORE environment variable */ /* * TODO (millert) * o POSIX compliance */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define Fopen(s, m) (Currline = 0, file_pos = 0, fopen(s,m)) #define Ftell(f) (file_pos) #define Fseek(f, off) (file_pos = off, fseeko(f, off, SEEK_SET)) #define Getc(f) (++file_pos, getc(f)) #define Ungetc(c, f) (--file_pos, ungetc(c, f)) #define cleareol() (tputs(eraseln, 1, putch)) #define clreos() (tputs(EodClr, 1, putch)) #define home() (tputs(Home, 1, putch)) #define TBUFSIZ 1024 #define LINSIZ 256 #define ctrl(letter) (letter & 077) #define RUBOUT '\177' #define ESC '\033' #define QUIT '\034' #define DUM_PROMPT "[Press space to continue, 'q' to quit.]" #define DUM_ERROR "[Press 'h' for instructions.]" #define QUIT_IT "[Use q or Q to quit]" #include "morehelp.h" struct termios otty, ntty; off_t file_pos, file_size; int fnum, no_intty, no_tty, slow_tty; int dum_opt, dlines; int nscroll = 11; /* Number of lines scrolled by 'd' */ int fold_opt = 1; /* Fold long lines */ int stop_opt = 1; /* Stop after form feeds */ int ssp_opt = 0; /* Suppress white space */ int ul_opt = 1; /* Underline as best we can */ int promptlen; off_t Currline; /* Line we are currently at */ int startup = 1; int firstf = 1; int notell = 1; int docrterase = 0; int docrtkill = 0; int bad_so; /* True if overwriting does not turn off standout */ int inwait, Pause, errors; int within; /* true if we are within a file, false if we are between files */ int hard, dumb, noscroll, hardtabs, clreol, eatnl; int catch_susp; /* We should catch the SIGTSTP signal */ char **fnames; /* The list of file names */ int nfiles; /* Number of files left to process */ char *shell; /* The name of the shell to use */ int shellp; /* A previous shell command exists */ char Lineb[LINSIZ]; /* Line buffer */ char *Line = Lineb; /* Line pointer */ int Lpp = 24; /* lines per page */ char *Clear; /* clear screen */ char *eraseln; /* erase line */ char *Senter, *Sexit;/* enter and exit standout mode */ char *ULenter, *ULexit; /* enter and exit underline mode */ char *chUL; /* underline character */ char *chBS; /* backspace character */ char *Home; /* go to home */ char *cursorm; /* cursor movement */ char cursorhome[40]; /* contains cursor movement to home */ char *EodClr; /* clear rest of screen */ int Mcol = 80; /* number of columns */ int Wrap = 1; /* set if automargins */ int soglitch; /* terminal has standout mode glitch */ int ulglitch; /* terminal has underline mode glitch */ int pstate = 0; /* current UL state */ int altscr = 0; /* terminal supports an alternate screen */ size_t linsize = LINSIZ; volatile sig_atomic_t signo[_NSIG]; /* signals received */ struct { off_t chrctr, line; } context, screen_start; extern char PC; /* pad character (termcap) */ extern char *__progname; /* program name (crt0) */ int colon(char *, int, int); int command(char *, FILE *); int expand(char *, size_t, char *); int get_line(FILE *, int *); int magic(FILE *, char *); int number(char *); int readch(void); int search(char *, FILE *, int); int ttyin(char *, int, char); void argscan(char *); void copy_file(FILE *); void doclear(void); void end_it(void); void erasep(int); void error(char *); void execute(char *filename, char *cmd, char *, char *, char *); void initterm(void); void kill_line(void); void onsignal(int); void prbuf(char *, int); void putch(int); void rdline(FILE *); void reset_tty(void); void screen(FILE *, int); void set_tty(void); void show(int); void skipf(int); void skiplns(int, FILE *); char *resize_line(char *); FILE *checkf(char *, int *); __dead void usage(void); struct sigaction sa; int main(int argc, char **argv) { FILE * volatile f; char *s; volatile int left; volatile off_t initline; volatile int prnames = 0; volatile int initopt = 0; volatile int srchopt = 0; int clearit = 0; int ch; char initbuf[80]; if (pledge("stdio rpath tty", NULL) == -1) { perror("pledge"); exit(1); } setlocale(LC_ALL, ""); /* all signals just use a stub handler and interrupt syscalls */ sigemptyset(&sa.sa_mask); sa.sa_flags = 0; sa.sa_handler = onsignal; nfiles = argc; fnames = argv; initterm(); nscroll = Lpp/2 - 1; if (nscroll <= 0) nscroll = 1; if ((s = getenv("MORE")) != NULL && *s != '\0') argscan(s); while (--nfiles > 0) { if ((ch = (*++fnames)[0]) == '-') argscan(*fnames + 1); else if (ch == '+') { s = *fnames; if (*++s == '/') { srchopt++; (void)strlcpy(initbuf, ++s, sizeof(initbuf)); } else { initopt++; for (initline = 0; *s != '\0'; s++) { if (isdigit((unsigned char)*s)) initline = initline * 10 + *s - '0'; } --initline; } } else break; } /* * Allow clreol only if Home and eraseln and EodClr strings are * defined, and in that case, make sure we are in noscroll mode. */ if (clreol) { if (Home == NULL || *Home == '\0' || eraseln == NULL || *eraseln == '\0' || EodClr == NULL || *EodClr == '\0') clreol = 0; else noscroll = 1; } if (dlines == 0) dlines = Lpp - 1; left = dlines; if (nfiles > 1) prnames++; if (!no_intty && nfiles == 0) usage(); else f = stdin; if (!no_tty) { struct sigaction osa; (void)sigaction(SIGQUIT, &sa, NULL); (void)sigaction(SIGINT, &sa, NULL); (void)sigaction(SIGWINCH, &sa, NULL); if (sigaction(SIGTSTP, &osa, NULL) == 0 && osa.sa_handler == SIG_DFL) { (void)sigaction(SIGTSTP, &sa, NULL); (void)sigaction(SIGTTIN, &sa, NULL); (void)sigaction(SIGTTOU, &sa, NULL); catch_susp++; } set_tty(); } if (no_intty) { if (no_tty) copy_file(stdin); else { if ((ch = Getc(f)) == '\f') doclear(); else { Ungetc(ch, f); if (noscroll && ch != EOF) { if (clreol) home(); else doclear(); } } if (srchopt) { if (search(initbuf, stdin, 1) == 0 && noscroll) left--; } else if (initopt) skiplns(initline, stdin); screen(stdin, left); } no_intty = 0; dup2(STDERR_FILENO, STDIN_FILENO); /* stderr is a tty */ prnames++; firstf = 0; } while (fnum < nfiles) { if ((f = checkf(fnames[fnum], &clearit)) != NULL) { context.line = context.chrctr = 0; Currline = 0; restart: if (firstf) { firstf = 0; if (srchopt) { if (search(initbuf, f, 1) < 0) goto restart; if (noscroll) left--; } else if (initopt) skiplns(initline, f); } else if (fnum < nfiles && !no_tty) left = command(fnames[fnum], f); if (left != 0) { if ((noscroll || clearit) && (file_size != LONG_MAX)) { if (clreol) home(); else doclear(); } if (prnames) { if (bad_so) erasep(0); if (clreol) cleareol(); fputs("::::::::::::::", stdout); if (promptlen > 14) erasep(14); putchar('\n'); if (clreol) cleareol(); printf("%s\n", fnames[fnum]); if (clreol) cleareol(); fputs("::::::::::::::\n", stdout); if (left > Lpp - 4) left = Lpp - 4; } if (no_tty) copy_file(f); else { within++; screen(f, left); within = 0; } } fflush(stdout); fclose(f); screen_start.line = screen_start.chrctr = 0L; context.line = context.chrctr = 0L; } fnum++; firstf = 0; } reset_tty(); exit(0); } void argscan(char *s) { int seen_num = 0; while (*s != '\0') { switch (*s) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (!seen_num) { dlines = 0; seen_num = 1; } dlines = (dlines * 10) + (*s - '0'); break; case 'd': dum_opt = 1; break; case 'l': stop_opt = 0; break; case 'f': fold_opt = 0; break; case 'p': noscroll++; break; case 'c': clreol++; break; case 's': ssp_opt = 1; break; case 'u': ul_opt = 0; break; case 'X': case 'E': case '-': case ' ': case '\t': break; default: fprintf(stderr, "%s: unknown option \"-%c\"\n", __progname, *s); usage(); } s++; } } /* * Check whether the file named by fs is an ASCII file which the user may * access. If it is, return the opened file. Otherwise return NULL. */ FILE * checkf(char *fs, int *clearfirst) { struct stat stbuf; FILE *f; int ch; if (stat(fs, &stbuf) == -1) { (void)fflush(stdout); if (clreol) cleareol(); perror(fs); return (NULL); } if ((stbuf.st_mode & S_IFMT) == S_IFDIR) { printf("\n*** %s: directory ***\n\n", fs); return (NULL); } if ((f = Fopen(fs, "r")) == NULL) { (void)fflush(stdout); perror(fs); return (NULL); } if (magic(f, fs)) return (NULL); ch = Getc(f); *clearfirst = (ch == '\f'); Ungetc(ch, f); if ((file_size = stbuf.st_size) == 0) file_size = LONG_MAX; return (f); } /* * magic -- * Check for file magic numbers. This code would best be shared with * the file(1) program or, perhaps, more should not try and be so smart? */ int magic(FILE *f, char *fs) { char twobytes[2]; /* don't try to look ahead if the input is unseekable */ if (fseeko(f, (off_t)0, SEEK_SET)) return (0); if (fread(twobytes, 2, 1, f) == 1) { switch(twobytes[0] + (twobytes[1]<<8)) { case OMAGIC: case NMAGIC: case ZMAGIC: case 0405: case 0411: case 0x457f: case 0177545: printf("\n******** %s: Not a text file ********\n\n", fs); (void)fclose(f); return (1); } } (void)fseeko(f, (off_t)0, SEEK_SET); /* rewind() not necessary */ return (0); } /* * A real function (not a macro), for the tputs() routine in termlib */ void putch(int ch) { putchar(ch); } #define STOP (-10) /* * Print out the contents of the file f, one screenful at a time. */ void screen(FILE *f, int num_lines) { int ch; int nchars; int length; /* length of current line */ static int prev_len = 1; /* length of previous line */ for (;;) { while (num_lines > 0 && !Pause) { if ((nchars = get_line(f, &length)) == EOF) { if (clreol) clreos(); return; } if (ssp_opt && length == 0 && prev_len == 0) continue; prev_len = length; if (bad_so || (Senter && *Senter == ' ' && promptlen > 0)) erasep(0); /* * Must clear before drawing line since tabs on some * terminals do not erase what they tab over. */ if (clreol) cleareol(); prbuf(Line, length); if (nchars < promptlen) { /* erasep() sets promptlen to 0 */ erasep(nchars); } else promptlen = 0; #if 0 /* XXX - is this needed? */ if (clreol) { /* must clear again in case we wrapped * */ cleareol(); } #endif if (nchars < Mcol || !fold_opt) { /* will turn off UL if necessary */ prbuf("\n", 1); } if (nchars == STOP) break; num_lines--; } if (pstate) { tputs(ULexit, 1, putch); pstate = 0; } fflush(stdout); if ((ch = Getc(f)) == EOF) { if (clreol) clreos(); return; } if (Pause && clreol) clreos(); Ungetc(ch, f); Pause = 0; startup = 0; if ((num_lines = command(NULL, f)) == 0) return; if (hard && promptlen > 0) erasep(0); if (noscroll && num_lines >= dlines) { if (clreol) home(); else doclear(); } /* * XXX - should store the *first* line on the screen, * not the last (but we don't know the file position). * Fixing this requires keeping an arry of dline off_ts * and updating each one when a new line is started. */ screen_start.line = Currline; screen_start.chrctr = Ftell(f); } } /* * Clean up terminal state and exit. Also come here if interrupt signal received */ void __dead end_it(void) { reset_tty(); if (clreol) { putchar('\r'); clreos(); fflush(stdout); } else if (promptlen > 0) { kill_line(); fflush(stdout); } else write(STDERR_FILENO, "\n", 1); _exit(0); } void copy_file(FILE *f) { int ch; while ((ch = getc(f)) != EOF) putchar(ch); } static char bell = ctrl('G'); void prompt(char *filename) { if (clreol) cleareol(); else if (promptlen > 0) kill_line(); if (!hard) { promptlen = 8; if (Senter && Sexit) { tputs(Senter, 1, putch); promptlen += (2 * soglitch); } if (clreol) cleareol(); fputs("--More--", stdout); if (filename != NULL) promptlen += printf("(Next file: %s)", filename); else if (!no_intty) promptlen += printf("(%d%%)", (int)((file_pos * 100) / file_size)); if (dum_opt) { fputs(DUM_PROMPT, stdout); promptlen += sizeof(DUM_PROMPT) - 1; } if (Senter && Sexit) tputs(Sexit, 1, putch); if (clreol) clreos(); fflush(stdout); } else write(STDERR_FILENO, &bell, 1); inwait++; } /* * Get a logical line. */ int get_line(FILE *f, int *length) { int ch, lastch; char *p, *ep; int column; static int colflg; p = Line; ep = Line + linsize - 1; column = 0; ch = Getc(f); if (colflg && ch == '\n') { Currline++; ch = Getc(f); } for (;;) { if (p >= ep) { p = resize_line(p); ep = Line + linsize - 1; } if (ch == EOF) { if (p > Line) { *p = '\0'; *length = p - Line; return (column); } *length = p - Line; return (EOF); } if (ch == '\n') { Currline++; break; } *p++ = (char)ch; if (ch == '\t') { if (!hardtabs || (column < promptlen && !hard)) { if (hardtabs && eraseln && !dumb) { column = 1 + (column | 7); tputs(eraseln, 1, putch); promptlen = 0; } else { for (--p;;) { if (p >= ep) { p = resize_line(p); ep = Line + linsize - 1; } *p++ = ' '; if ((++column & 7) == 0) break; } if (column >= promptlen) promptlen = 0; } } else column = 1 + (column | 7); } else if (ch == '\b' && column > 0) column--; else if (ch == '\f' && stop_opt) { p[-1] = '^'; *p++ = 'L'; column += 2; Pause++; } else if (ch == EOF) { *length = p - Line; return (column); } else if (ch >= ' ' && ch != RUBOUT) column++; if (column >= Mcol && fold_opt) break; lastch = ch; ch = Getc(f); if (lastch == '\r') { /* * Reset column to 0 for carriage return unless * immediately followed by a newline. */ if (ch != '\n') column = 0; else p--; } } /* XXX - potential oflow */ if (column >= Mcol && Mcol > 0 && !Wrap) *p++ = '\n'; colflg = (column == Mcol && fold_opt); if (colflg && eatnl && Wrap) *p++ = '\n'; /* simulate normal wrap */ *length = p - Line; *p = '\0'; return (column); } /* * Erase the rest of the prompt, assuming we are starting at column col. */ void erasep(int col) { if (promptlen == 0) return; if (hard) putchar('\n'); else { if (col == 0) putchar('\r'); if (!dumb && eraseln) tputs(eraseln, 1, putch); else { for (col = promptlen - col; col > 0; col--) putchar(' '); } } promptlen = 0; } /* * Erase the current line entirely */ void kill_line(void) { erasep(0); if (!eraseln || dumb) putchar('\r'); } /* * Print a buffer of n characters. */ void prbuf(char *s, int n) { char c; /* next output character */ int state; /* next output char's UL state */ #define wouldul(s,n) ((n) >= 2 && (((s)[0] == '_' && (s)[1] == '\b') || ((s)[1] == '\b' && (s)[2] == '_'))) while (--n >= 0) { if (!ul_opt) putchar(*s++); else { if (*s == ' ' && pstate == 0 && ulglitch && wouldul(s + 1, n - 1)) { s++; continue; } if ((state = wouldul(s, n))) { c = (*s == '_')? s[2] : *s ; n -= 2; s += 3; } else c = *s++; if (state != pstate) { if (c == ' ' && state == 0 && ulglitch && wouldul(s, n - 1)) state = 1; else tputs(state ? ULenter : ULexit, 1, putch); } if (c != ' ' || pstate == 0 || state != 0 || ulglitch == 0) putchar(c); if (state && *chUL) { fputs(chBS, stdout); tputs(chUL, 1, putch); } pstate = state; } } } /* * Clear the screen */ void doclear(void) { if (Clear && !hard) { tputs(Clear, 1, putch); /* * Put out carriage return so that system doesn't * get confused by escape sequences when expanding tabs. */ putchar('\r'); promptlen = 0; } } static int lastcmd, lastarg, lastp; static int lastcolon; char shell_line[BUFSIZ]; /* * Read a command and do it. A command consists of an optional integer * argument followed by the command character. Return the number of lines * to display in the next screenful. If there is nothing more to display * in the current file, zero is returned. */ int command(char *filename, FILE *f) { int nlines; int retval; int ch; char colonch; int done; char comchar, cmdbuf[80]; #define ret(val) retval=val;done++;break retval = done = 0; if (!errors) prompt(filename); else errors = 0; for (;;) { nlines = number(&comchar); lastp = colonch = 0; if (comchar == '.') { /* Repeat last command */ lastp++; comchar = lastcmd; nlines = lastarg; if (lastcmd == ':') colonch = lastcolon; } lastcmd = comchar; lastarg = nlines; if (comchar == otty.c_cc[VERASE]) { kill_line(); prompt(filename); continue; } switch (comchar) { case ':': retval = colon(filename, colonch, nlines); if (retval >= 0) done++; break; case 'b': case ctrl('B'): { int initline; if (no_intty) { write(STDERR_FILENO, &bell, 1); return (-1); } if (nlines == 0) nlines++; putchar('\r'); erasep(0); putchar('\n'); if (clreol) cleareol(); printf("...back %d page", nlines); if (nlines > 1) fputs("s\n", stdout); else putchar('\n'); if (clreol) cleareol(); putchar('\n'); initline = Currline - (off_t)dlines * (nlines + 1); if (!noscroll) --initline; if (initline < 0) initline = 0; Fseek(f, (off_t)0); Currline = 0; /* skiplns() will make Currline correct */ skiplns(initline, f); ret(dlines); } case ' ': case 'z': if (nlines == 0) nlines = dlines; else if (comchar == 'z') dlines = nlines; ret(nlines); case 'd': case ctrl('D'): if (nlines != 0) nscroll = nlines; ret(nscroll); case 'q': case 'Q': end_it(); case 's': case 'f': if (nlines == 0) nlines++; if (comchar == 'f') nlines *= dlines; putchar('\r'); erasep(0); putchar('\n'); if (clreol) cleareol(); printf("...skipping %d line", nlines); if (nlines > 1) fputs("s\n", stdout); else putchar('\n'); if (clreol) cleareol(); putchar('\n'); while (nlines > 0) { while ((ch = Getc(f)) != '\n') { if (ch == EOF) { retval = 0; done++; goto endsw; } } Currline++; nlines--; } ret(dlines); case '\n': if (nlines != 0) dlines = nlines; else nlines = 1; ret(nlines); case '\f': if (!no_intty) { doclear(); Fseek(f, screen_start.chrctr); Currline = screen_start.line; ret(dlines); } else { write(STDERR_FILENO, &bell, 1); break; } case '\'': if (!no_intty) { kill_line(); fputs("\n***Back***\n\n", stdout); Fseek(f, context.chrctr); Currline = context.line; ret(dlines); } else { write(STDERR_FILENO, &bell, 1); break; } case '=': kill_line(); promptlen = printf("%lld", (long long)Currline); fflush(stdout); break; case 'n': lastp++; case '/': if (nlines == 0) nlines++; kill_line(); putchar('/'); promptlen = 1; fflush(stdout); if (lastp) { /* Use previous r.e. */ write(STDERR_FILENO, "\r", 1); if (search(NULL, f, nlines) < 0) break; } else { if (ttyin(cmdbuf, sizeof(cmdbuf) - 2, '/') < 0) { kill_line(); prompt(filename); continue; } write(STDERR_FILENO, "\r", 1); if (search(cmdbuf, f, nlines) < 0) break; } ret(dlines-1); case '?': case 'h': if (noscroll) doclear(); fputs(more_help, stdout); prompt(filename); break; default: if (dum_opt) { kill_line(); if (Senter && Sexit) { tputs(Senter, 1, putch); fputs(DUM_ERROR, stdout); promptlen = sizeof(DUM_ERROR) - 1 + (2 * soglitch); tputs(Sexit, 1, putch); } else { fputs(DUM_ERROR, stdout); promptlen = sizeof(DUM_ERROR) - 1; } fflush(stdout); } else write(STDERR_FILENO, &bell, 1); break; } if (done) break; } putchar('\r'); endsw: inwait = 0; notell++; return (retval); } /* * Execute a colon-prefixed command. * Returns <0 if not a command that should cause * more of the file to be printed. */ int colon(char *filename, int cmd, int nlines) { int ch; if (cmd == 0) ch = readch(); else ch = cmd; lastcolon = ch; switch (ch) { case 'f': kill_line(); if (!no_intty) promptlen = printf("\"%s\" line %lld", fnames[fnum], (long long)Currline); else promptlen = printf("[Not a file] line %lld", (long long)Currline); fflush(stdout); return (-1); case 'n': if (nlines == 0) { if (fnum >= nfiles - 1) end_it(); nlines++; } putchar('\r'); erasep(0); skipf(nlines); return (0); case 'p': if (no_intty) { write(STDERR_FILENO, &bell, 1); return (-1); } putchar('\r'); erasep(0); if (nlines == 0) nlines++; skipf (-nlines); return (0); case 'q': case 'Q': end_it(); /*FALLTHROUGH*/ default: write(STDERR_FILENO, &bell, 1); return (-1); } } /* * Read a decimal number from the terminal. Set cmd to the non-digit which * terminates the number. */ int number(char *cmd) { int ch, i; ch = otty.c_cc[VKILL]; i = 0; for (;;) { ch = readch(); if (isdigit(ch)) i = i*10 + ch - '0'; else if (ch == otty.c_cc[VKILL]) i = 0; else { *cmd = ch; break; } } return (i); } /* * Search for nth occurrence of regular expression contained in buf in the file */ int search(char *buf, FILE *file, int n) { off_t startline = Ftell(file); off_t line1 = startline; off_t line2 = startline; off_t line3 = startline; off_t saveln; int lncount, rv; char ebuf[BUFSIZ]; static regex_t reg; static int initialized; context.line = saveln = Currline; context.chrctr = startline; lncount = 0; if (buf != NULL && *buf != '\0') { if ((rv = regcomp(®, buf, REG_NOSUB)) != 0) { initialized = 0; regerror(rv, ®, ebuf, sizeof(ebuf)); regfree(®); error(ebuf); return (-1); } initialized = 1; } else if (!initialized) { error("No previous regular expression"); return (-1); } while (!feof(file)) { line3 = line2; line2 = line1; line1 = Ftell(file); rdline(file); lncount++; if ((rv = regexec(®, Line, 0, NULL, 0)) == 0) { if (--n == 0) { if (lncount > 3 || (lncount > 1 && no_intty)) { putchar('\n'); if (clreol) cleareol(); fputs("...skipping\n", stdout); } if (!no_intty) { Currline -= (lncount >= 3 ? 3 : lncount); Fseek(file, line3); if (noscroll) { if (clreol) { home(); cleareol(); } else doclear(); } } else { kill_line(); if (noscroll) { if (clreol) { home(); cleareol(); } else doclear(); } fputs(Line, stdout); putchar('\n'); } break; } } else if (rv != REG_NOMATCH) { regerror(rv, ®, ebuf, sizeof(ebuf)); error(ebuf); return (-1); } } if (feof(file)) { if (!no_intty) { Currline = saveln; Fseek(file, startline); } else { fputs("\nPattern not found\n", stdout); end_it(); } error("Pattern not found"); return (-1); } return (0); } /* * Skip n lines in the file f */ void skiplns(int n, FILE *f) { int ch; while (n > 0) { while ((ch = Getc(f)) != '\n') { if (ch == EOF) return; } n--; Currline++; } } /* * Skip nskip files in the file list (from the command line). * Nskip may be negative. */ void skipf(int nskip) { if (nskip == 0) return; if (nskip > 0) { if (fnum + nskip > nfiles - 1) nskip = nfiles - fnum - 1; } else if (within) ++fnum; fnum += nskip; if (fnum < 0) fnum = 0; fputs("\n...Skipping \n", stdout); /* XXX huh? */ if (clreol) cleareol(); printf("...Skipping %sto file %s\n", nskip > 0 ? "" : "back ", fnames[fnum]); if (clreol) cleareol(); putchar('\n'); --fnum; } /* * Terminal I/O */ void initterm(void) { char buf[TBUFSIZ]; static char clearbuf[TBUFSIZ]; char *clearptr, *padstr; char *term; int tgrp; struct winsize win; retry: if (!(no_tty = tcgetattr(STDOUT_FILENO, &otty))) { docrterase = (otty.c_cc[VERASE] != _POSIX_VDISABLE); docrtkill = (otty.c_cc[VKILL] != _POSIX_VDISABLE); /* * Wait until we're in the foreground before we save the * the terminal modes. */ if ((tgrp = tcgetpgrp(STDOUT_FILENO)) == -1) { perror("tcgetpgrp"); exit(1); } if (tgrp != getpgrp()) { kill(0, SIGTTOU); goto retry; } if ((term = getenv("TERM")) == 0 || tgetent(buf, term) <= 0) { dumb++; ul_opt = 0; } else { if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) == -1) { Lpp = tgetnum("li"); Mcol = tgetnum("co"); } else { if ((Lpp = win.ws_row) == 0) Lpp = tgetnum("li"); if ((Mcol = win.ws_col) == 0) Mcol = tgetnum("co"); } if (Lpp <= 0 || tgetflag("hc")) { hard++; /* Hard copy terminal */ Lpp = 24; } if (tgetflag("xn")) { /* Eat newline at last column + 1 */ eatnl++; } if (Mcol <= 0) Mcol = 80; if (strcmp(__progname, "page") == 0 || (!hard && tgetflag("ns"))) noscroll++; Wrap = tgetflag("am"); bad_so = tgetflag ("xs"); clearptr = clearbuf; eraseln = tgetstr("ce", &clearptr); Clear = tgetstr("cl", &clearptr); Senter = tgetstr("so", &clearptr); Sexit = tgetstr("se", &clearptr); if ((soglitch = tgetnum("sg")) < 0) soglitch = 0; /* * Setup for underlining. Some terminals don't need it, * others have start/stop sequences, still others have * an underline char sequence which is assumed to move * the cursor forward one character. If underline seq * isn't available, settle for standout sequence. */ if (tgetflag("ul") || tgetflag("os")) ul_opt = 0; if ((chUL = tgetstr("uc", &clearptr)) == NULL) chUL = ""; if (((ULenter = tgetstr("us", &clearptr)) == NULL || (ULexit = tgetstr("ue", &clearptr)) == NULL) && !*chUL) { if ((ULenter = Senter) == NULL || (ULexit = Sexit) == NULL) { ULenter = ""; ULexit = ""; } else ulglitch = soglitch; } else { if ((ulglitch = tgetnum("ug")) < 0) ulglitch = 0; } if ((padstr = tgetstr("pc", &clearptr))) PC = *padstr; Home = tgetstr("ho", &clearptr); if (Home == 0 || *Home == '\0') { cursorm = tgetstr("cm", &clearptr); if (cursorm != NULL) { strlcpy(cursorhome, tgoto(cursorm, 0, 0), sizeof(cursorhome)); Home = cursorhome; } } EodClr = tgetstr("cd", &clearptr); if ((chBS = tgetstr("bc", &clearptr)) == NULL) chBS = "\b"; if (tgetstr("te", &clearptr) != NULL && tgetstr("ti", &clearptr) != NULL) altscr = 1; } if ((shell = getenv("SHELL")) == NULL) shell = _PATH_BSHELL; } no_intty = !isatty(STDIN_FILENO); tcgetattr(STDERR_FILENO, &otty); slow_tty = cfgetospeed(&otty) < B1200; hardtabs = !(otty.c_oflag & OXTABS); ntty = otty; if (!no_tty) { ntty.c_lflag &= ~(ICANON|ECHO); ntty.c_cc[VMIN] = 1; /* read at least 1 char */ ntty.c_cc[VTIME] = 0; /* no timeout */ } } int handle_signal(void) { int sig, ch = -1; for (sig = 0; sig < _NSIG; sig++) { if (signo[sig] == 0) continue; signo[sig] = 0; switch (sig) { case SIGQUIT: if (!inwait) { putchar('\n'); if (startup) Pause++; } else if (!dum_opt && notell) { write(STDERR_FILENO, QUIT_IT, sizeof(QUIT_IT) - 1); promptlen += sizeof(QUIT_IT) - 1; notell = 0; } break; case SIGTSTP: case SIGTTIN: case SIGTTOU: /* XXX - should use saved values instead of SIG_DFL */ sa.sa_handler = SIG_DFL; sa.sa_flags = SA_RESTART; (void)sigaction(SIGTSTP, &sa, NULL); (void)sigaction(SIGTTIN, &sa, NULL); (void)sigaction(SIGTTOU, &sa, NULL); reset_tty(); kill(getpid(), sig); sa.sa_handler = onsignal; sa.sa_flags = 0; (void)sigaction(SIGTSTP, &sa, NULL); (void)sigaction(SIGTTIN, &sa, NULL); (void)sigaction(SIGTTOU, &sa, NULL); set_tty(); if (!no_intty) ch = '\f'; /* force redraw */ break; case SIGINT: end_it(); break; case SIGWINCH: { struct winsize win; if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) != 0) break; if (win.ws_row != 0) { Lpp = win.ws_row; nscroll = Lpp/2 - 1; if (nscroll <= 0) nscroll = 1; dlines = Lpp - 1; } if (win.ws_col != 0) Mcol = win.ws_col; if (!no_intty) ch = '\f'; /* force redraw */ break; } default: /* NOTREACHED */ break; } } return (ch); } int readch(void) { unsigned char ch; int r; /* We know stderr is hooked up to /dev/tty so this is safe. */ again: switch (read(STDERR_FILENO, &ch, 1)) { case 1: return (ch); case -1: if (errno != EINTR) end_it(); r = handle_signal(); if (r == -1) goto again; return (r); /* redraw, continue, etc */ default: case 0: end_it(); } } static char BS1 = '\b'; static char BSB[] = "\b \b"; static char CARAT = '^'; #define ERASEONECHAR do { \ if (docrterase) \ write(STDERR_FILENO, BSB, sizeof(BSB) - 1); \ else \ write(STDERR_FILENO, &BS1, 1); \ } while (0) int ttyin(char *buf, int nmax, char pchar) { char cbuf, ch, *sptr; int maxlen, slash; sptr = buf; slash = maxlen = 0; while (sptr - buf < nmax) { if (promptlen > maxlen) maxlen = promptlen; ch = readch(); if (ch == '\\') slash++; else if ((ch == otty.c_cc[VERASE]) && !slash) { if (sptr > buf) { --promptlen; ERASEONECHAR; --sptr; if ((*sptr < ' ' && *sptr != '\n') || *sptr == RUBOUT) { --promptlen; ERASEONECHAR; } continue; } else { if (!eraseln) promptlen = maxlen; return (-1); } } else if ((ch == otty.c_cc[VKILL]) && !slash) { if (hard) { show(ch); putchar('\n'); putchar(pchar); } else { putchar('\r'); putchar(pchar); if (eraseln) erasep(1); else if (docrtkill) { while (promptlen-- > 1) write(STDERR_FILENO, BSB, sizeof(BSB) - 1); } promptlen = 1; } sptr = buf; fflush(stdout); continue; } if (slash && (ch == otty.c_cc[VKILL] || ch == otty.c_cc[VERASE])) { ERASEONECHAR; --sptr; } if (ch != '\\') slash = 0; *sptr++ = ch; if ((ch < ' ' && ch != '\n' && ch != ESC) || ch == RUBOUT) { ch += ch == RUBOUT ? -0100 : 0100; write(STDERR_FILENO, &CARAT, 1); promptlen++; } cbuf = ch; if (ch != '\n' && ch != ESC) { write(STDERR_FILENO, &cbuf, 1); promptlen++; } else break; } *--sptr = '\0'; if (!eraseln) promptlen = maxlen; if (sptr - buf >= nmax - 1) error("Line too long"); return (0); } int expand(char *outbuf, size_t olen, char *inbuf) { size_t len; char *instr; char *outstr; char c; char temp[200]; int changed = 0; instr = inbuf; outstr = temp; while ((c = *instr++) != '\0') { switch (c) { case '%': if (!no_intty) { len = strlcpy(outstr, fnames[fnum], temp + sizeof(temp) - outstr); if (len >= temp + sizeof(temp) - outstr) len = temp + sizeof(temp) - outstr - 1; outstr += len; changed++; } else *outstr++ = c; break; case '!': if (!shellp) error("No previous command to substitute for"); len = strlcpy(outstr, shell_line, temp + sizeof(temp) - outstr); if (len >= temp + sizeof(temp) - outstr) len = temp + sizeof(temp) - outstr - 1; outstr += len; changed++; break; case '\\': if (*instr == '%' || *instr == '!') { *outstr++ = *instr++; break; } default: *outstr++ = c; break; } } *outstr++ = '\0'; strlcpy(outbuf, temp, olen); return (changed); } void show(int ch) { char cbuf; if ((ch < ' ' && ch != '\n' && ch != ESC) || ch == RUBOUT) { ch += ch == RUBOUT ? -0100 : 0100; write(STDERR_FILENO, &CARAT, 1); promptlen++; } cbuf = ch; write(STDERR_FILENO, &cbuf, 1); promptlen++; } void error(char *mess) { if (clreol) cleareol(); else kill_line(); promptlen += strlen (mess); if (Senter && Sexit) { tputs(Senter, 1, putch); fputs(mess, stdout); tputs(Sexit, 1, putch); } else fputs(mess, stdout); fflush(stdout); errors++; } void set_tty(void) { tcsetattr(STDERR_FILENO, TCSANOW, &ntty); } void reset_tty(void) { if (no_tty) return; if (pstate) { tputs(ULexit, 1, putch); fflush(stdout); pstate = 0; } tcsetattr(STDERR_FILENO, TCSANOW, &otty); } void rdline(FILE *f) { int ch; char *p, *ep; p = Line; ep = Line + linsize - 1; while ((ch = Getc(f)) != '\n' && ch != EOF) { if (p >= ep) { p = resize_line(p); ep = Line + linsize - 1; } *p++ = (char)ch; } if (ch == '\n') Currline++; *p = '\0'; } char * resize_line(char *pos) { char *np; linsize *= 2; if (Line != Lineb) np = realloc(Line, linsize); else if ((np = malloc(linsize)) != NULL) memcpy(np, Lineb, sizeof(Lineb)); if (np == NULL) { kill_line(); fputs("out of memory!\n", stdout); reset_tty(); exit(1); } pos = np + (pos - Line); Line = np; return (pos); } /* * Come here when we get a signal we can handle. */ void onsignal(int sig) { signo[sig] = 1; } __dead void usage(void) { fprintf(stderr, "usage: %s [-dfln] [+linenum | +/pattern] name1 name2 ...\n", __progname); exit(1); }