diff options
| -rw-r--r-- | distrib/special/more/Makefile | 9 | ||||
| -rw-r--r-- | distrib/special/more/more.1 | 356 | ||||
| -rw-r--r-- | distrib/special/more/more.c | 1837 | ||||
| -rw-r--r-- | distrib/special/more/more.help | 24 | ||||
| -rw-r--r-- | distrib/special/more/pathnames.h | 38 |
5 files changed, 2264 insertions, 0 deletions
diff --git a/distrib/special/more/Makefile b/distrib/special/more/Makefile new file mode 100644 index 00000000000..c0f8866a52b --- /dev/null +++ b/distrib/special/more/Makefile @@ -0,0 +1,9 @@ +# $OpenBSD: Makefile,v 1.1 2003/04/17 22:53:12 millert Exp $ + +PROG= more +MAN= +CFLAGS+=-D_USE_OLD_CURSES_ +DPADD= ${LIBOCURSES} ${LIBCOMPAT} +LDADD= -locurses -lcompat + +.include <bsd.prog.mk> diff --git a/distrib/special/more/more.1 b/distrib/special/more/more.1 new file mode 100644 index 00000000000..e2939fa80a5 --- /dev/null +++ b/distrib/special/more/more.1 @@ -0,0 +1,356 @@ +.\" 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. All advertising materials mentioning features or use of this software +.\" must display the following acknowledgement: +.\" This product includes software developed by the University of +.\" California, Berkeley and its contributors. +.\" 4. 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.1 6.6 (Berkeley) 4/18/91 +.\" +.TH MORE 1 "April 18, 1991" +.UC 4 +.SH NAME +more, page \- file perusal filter for crt viewing +.SH SYNOPSIS +.B more +[ +.B \-cdflsu +] +[ +.B \-\fIn\fP +] +[ +.B +\fIlinenumber\fP +] +[ +.B +/\fIpattern\fP +] [ name ... ] +.LP +.B page +.I "more options" +.SH DESCRIPTION +.I More +is a filter which allows examination of a continuous text +one screenful at a time on a soft-copy terminal. +It normally pauses after each screenful, printing --More-- +at the bottom of the screen. +If the user then types a carriage return, one more line is displayed. +If the user hits a space, +another screenful is displayed. Other possibilities are enumerated later. +.PP +The command line options are: +.TP +.I \-n +An integer which is the size (in lines) of the window which +.I more +will use instead of the default. +.TP +.B \-c +.I More +will draw each page by beginning at the top of the screen and erasing +each line just before it draws on it. +This avoids scrolling the screen, making it easier to read while +.I more +is writing. +This option will be ignored if the terminal does not have the ability +to clear to the end of a line. +.TP +.B \-d +.I More +will prompt the user with the message "Press +space to continue, \'q\' to quit." at the end of each screenful, +and will respond to subsequent illegal user input by +printing "Press \'h\' for instructions." instead of ringing the bell. +This is useful if +.I more +is being used as a filter in some setting, +such as a class, +where many users may be unsophisticated. +.TP +.B \-f +This causes +.I more +to count logical, rather than screen lines. +That is, long lines are not folded. +This option is recommended if +.I nroff +output is being piped through +.I ul, +since the latter may generate escape sequences. +These escape sequences contain characters which would ordinarily occupy +screen positions, but which do not print when they are sent to the +terminal as part of an escape sequence. +Thus +.I more +may think that lines are longer than they actually are, and fold +lines erroneously. +.TP +.B \-l +Do +not treat ^\&L (form feed) specially. +If this option is not given, +.I more +will pause after any line that contains a ^\&L, as if the end of a +screenful had been reached. +Also, if a file begins with a form feed, the screen will be cleared +before the file is printed. +.TP +.B \-s +Squeeze multiple blank lines from the output, producing only one blank +line. Especially helpful when viewing +.I nroff +output, this option maximizes the useful information present on the screen. +.TP +.B \-u +Normally, +.I more +will handle underlining such as produced by +.I nroff +in a manner appropriate to the particular terminal: if the terminal can +perform underlining or has a stand-out mode, +.I more +will output appropriate escape sequences to enable underlining or stand-out +mode for underlined information in the source file. The +.I \-u +option suppresses this processing. +.TP +.B +\fIlinenumber\fP +Start up at \fIlinenumber\fP. +.TP +.B +/\fIpattern\fP +Start up two lines before the line containing the +regular expression \fIpattern\fP. +.PP +If the program is invoked as +.I page, +then the screen is cleared before each screenful is printed (but only +if a full screenful is being printed), and +.I k +\- 1 rather +than +.I k +\- 2 lines are printed in each screenful, where +.I k +is the number of lines the terminal can display. +.PP +.I More +looks in the file +.I /etc/termcap +to determine terminal characteristics, +and to determine the default window size. +On a terminal capable of displaying 24 lines, +the default window size is 22 lines. +.PP +.I More +looks in the environment variable +.I MORE +to pre-set any flags desired. For example, if you prefer to view files using +the +.I \-c +mode of operation, the +.I csh +command +.I "setenv MORE -c" +or the +.I sh +command sequence +.I "MORE='-c' ; export MORE" +would cause all invocations of +.I more , +including invocations by programs such as +.I man +and +.I msgs , +to use this mode. +Normally, the user will place the command sequence which sets up the +.I MORE +environment variable in the +.I .cshrc +or +.I .profile +file. +.PP +If +.I more +is reading from a file, rather than a pipe, then a percentage is displayed +along with the --More-- prompt. +This gives the fraction of the file (in characters, not lines) that has been +read so far. +.PP +Other sequences which may be typed when +.I more +pauses, and their effects, are as follows (\fIi\fP is an optional integer +argument, defaulting to 1) : +.PP +.IP \fIi\|\fP<space> +display +.I i +more lines, (or another screenful if no argument is given) +.PP +.IP ^D +display 11 more lines (a ``scroll''). +If +.I i +is given, then the scroll size is set to \fIi\|\fP. +.PP +.IP d +same as ^D (control-D) +.PP +.IP \fIi\|\fPz +same as typing a space except that \fIi\|\fP, if present, becomes the new +window size. +.PP +.IP \fIi\|\fPs +skip \fIi\|\fP lines and print a screenful of lines +.PP +.IP \fIi\|\fPf +skip \fIi\fP screenfuls and print a screenful of lines +.PP +.IP \fIi\|\fPb +skip back \fIi\fP screenfuls and print a screenful of lines +.PP +.IP \fIi\|\fP^B +same as b +.PP +.IP "q or Q" +Exit from +.I more. +.PP +.IP = +Display the current line number. +.PP +.IP v +Start up the editor +.I vi +at the current line. +.PP +.IP h +Help command; give a description of all the +.I more +commands. +.PP +.IP \fIi\|\fP/expr +search for the \fIi\|\fP-th occurrence of the regular expression \fIexpr.\fP +If there are less than \fIi\fP occurrences of \fIexpr\|\fP, +and the input is a file (rather than a pipe), +then the position in the file remains unchanged. +Otherwise, a screenful is displayed, starting two lines before the place +where the expression was found. +The user's erase and kill characters may be used to edit the regular +expression. +Erasing back past the first column cancels the search command. +.PP +.IP \fIi\|\fPn +search for the \fIi\|\fP-th occurrence of the last regular expression entered. +.PP +.IP \' +(single quote) Go to the point from which the last search started. +If no search has been performed in the current file, this command +goes back to the beginning of the file. +.PP +.IP !command +invoke a shell with \fIcommand\|\fP. +The characters `%' and `!' in "command" are replaced with the +current file name and the previous shell command respectively. +If there is no current file name, `%' is not expanded. +The sequences "\\%" and "\\!" are replaced by "%" and "!" respectively. +.PP +.IP \fIi\|\fP:n +skip to the \fIi\|\fP-th next file given in the command line +(skips to last file if n doesn't make sense) +.PP +.IP \fIi\|\fP:p +skip to the \fIi\|\fP-th previous file given in the command line. +If this command is given in the middle of printing out a +file, then +.I more +goes back to the beginning of the file. If \fIi\fP doesn't make sense, +.I more +skips back to the first file. +If +.I more +is not reading from a file, the bell is rung and nothing else happens. +.PP +.IP :f +display the current file name and line number. +.PP +.IP ":q or :Q" +exit from +.I more +(same as q or Q). +.PP +.IP . +(dot) repeat the previous command. +.PP +The commands take effect immediately, i.e., it is not necessary to +type a carriage return. +Up to the time when the command character itself is given, +the user may hit the line kill character to cancel the numerical +argument being formed. +In addition, the user may hit the erase character to redisplay the +--More--(xx%) message. +.PP +At any time when output is being sent to the terminal, the user can +hit the quit key (normally control\-\\). +.I More +will stop sending output, and will display the usual --More-- +prompt. +The user may then enter one of the above commands in the normal manner. +Unfortunately, some output is lost when this is done, due to the +fact that any characters waiting in the terminal's output queue +are flushed when the quit signal occurs. +.PP +The terminal is set to +.I noecho +mode by this program so that the output can be continuous. +What you type will thus not show on your terminal, except for the / and ! +commands. +.PP +If the standard output is not a teletype, then +.I more +acts just like +.I cat, +except that a header is printed before each file (if there is +more than one). +.PP +.DT +A sample usage of +.I more +in previewing +.I nroff +output would be +.PP + nroff \-ms +2 doc.n | more -s +.SH FILES +.DT +/etc/termcap Terminal data base +.br +/usr/lib/more.help Help file +.SH "SEE ALSO" +csh(1), man(1), msgs(1), script(1), sh(1), environ(7) +.SH BUGS +Skipping backwards is too slow on large files. diff --git a/distrib/special/more/more.c b/distrib/special/more/more.c new file mode 100644 index 00000000000..ae69894203e --- /dev/null +++ b/distrib/special/more/more.c @@ -0,0 +1,1837 @@ +/*- + * 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. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. 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. + */ + +#ifndef lint +char copyright[] = +"@(#) Copyright (c) 1980 The Regents of the University of California.\n\ + All rights reserved.\n"; +#endif /* not lint */ + +#ifndef lint +static char sccsid[] = "@(#)more.c 5.28 (Berkeley) 3/1/93"; +#endif /* not lint */ + +/* +** 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 +*/ + +#include <sys/param.h> +#include <sys/stat.h> +#include <sys/file.h> +#include <signal.h> +#include <errno.h> +#include <sgtty.h> +#include <setjmp.h> +#include <a.out.h> +#include <varargs.h> +#include <stdio.h> +#include <string.h> +#include <ctype.h> +#include "pathnames.h" + +#define Fopen(s,m) (Currline = 0,file_pos=0,fopen(s,m)) +#define Ftell(f) file_pos +#define Fseek(f,off) (file_pos=off,fseek(f,off,0)) +#define Getc(f) (++file_pos, getc(f)) +#define Ungetc(c,f) (--file_pos, ungetc(c,f)) + +#define MBIT CBREAK +#define stty(fd,argp) ioctl(fd,TIOCSETN,argp) + +#define TBUFSIZ 1024 +#define LINSIZ 256 +#define ctrl(letter) (letter & 077) +#define RUBOUT '\177' +#define ESC '\033' +#define QUIT '\034' + +struct sgttyb otty, savetty; +long file_pos, file_size; +int fnum, no_intty, no_tty, slow_tty; +int dum_opt, dlines; +void chgwinsz(), end_it(), onquit(), onsusp(); +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; +int 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 ch; +jmp_buf restore; +char Line[LINSIZ]; /* Line buffer */ +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 */ +char *tgetstr(); +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 */ +char *getenv(); +struct { + long chrctr, line; +} context, screen_start; +extern char PC; /* pad character */ +extern short ospeed; + + +main(argc, argv) +int argc; +char *argv[]; +{ + register FILE *f; + register char *s; + register char *p; + register char ch; + register int left; + int prnames = 0; + int initopt = 0; + int srchopt = 0; + int clearit = 0; + int initline; + char initbuf[80]; + FILE *checkf(); + + nfiles = argc; + fnames = argv; + initterm (); + nscroll = Lpp/2 - 1; + if (nscroll <= 0) + nscroll = 1; + if(s = getenv("MORE")) argscan(s); + while (--nfiles > 0) { + if ((ch = (*++fnames)[0]) == '-') { + argscan(*fnames+1); + } + else if (ch == '+') { + s = *fnames; + if (*++s == '/') { + srchopt++; + for (++s, p = initbuf; p < initbuf + 79 && *s != '\0';) + *p++ = *s++; + *p = '\0'; + } + else { + initopt++; + for (initline = 0; *s != '\0'; s++) + if (isdigit (*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 - (noscroll ? 1 : 2); + left = dlines; + if (nfiles > 1) + prnames++; + if (!no_intty && nfiles == 0) { + char *rindex(); + + p = rindex(argv[0], '/'); + fputs("usage: ",stderr); + fputs(p ? p + 1 : argv[0],stderr); + fputs(" [-dfln] [+linenum | +/pattern] name1 name2 ...\n",stderr); + exit(1); + } + else + f = stdin; + if (!no_tty) { + signal(SIGQUIT, onquit); + signal(SIGINT, end_it); + signal(SIGWINCH, chgwinsz); + if (signal (SIGTSTP, SIG_IGN) == SIG_DFL) { + signal(SIGTSTP, onsusp); + catch_susp++; + } + stty (fileno(stderr), &otty); + } + 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) + { + search (initbuf, stdin, 1); + if (noscroll) + left--; + } + else if (initopt) + skiplns (initline, stdin); + screen (stdin, left); + } + no_intty = 0; + prnames++; + firstf = 0; + } + + while (fnum < nfiles) { + if ((f = checkf (fnames[fnum], &clearit)) != NULL) { + context.line = context.chrctr = 0; + Currline = 0; + if (firstf) setjmp (restore); + if (firstf) { + firstf = 0; + if (srchopt) + { + search (initbuf, f, 1); + if (noscroll) + left--; + } + else if (initopt) + skiplns (initline, f); + } + else if (fnum < nfiles && !no_tty) { + setjmp (restore); + 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) + erase (0); + if (clreol) + cleareol (); + pr("::::::::::::::"); + if (promptlen > 14) + erase (14); + prtf ("\n"); + if(clreol) cleareol(); + prtf("%s\n", fnames[fnum]); + if(clreol) cleareol(); + prtf("::::::::::::::\n"); + if (left > Lpp - 4) + left = Lpp - 4; + } + if (no_tty) + copy_file (f); + else { + within++; + screen(f, left); + within = 0; + } + } + setjmp (restore); + fflush(stdout); + fclose(f); + screen_start.line = screen_start.chrctr = 0L; + context.line = context.chrctr = 0L; + } + fnum++; + firstf = 0; + } + reset_tty (); + exit(0); +} + +argscan(s) +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; + } + 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 (fs, clearfirst) + register char *fs; + int *clearfirst; +{ + struct stat stbuf; + register FILE *f; + char c; + + if (stat (fs, &stbuf) == -1) { + (void)fflush(stdout); + if (clreol) + cleareol (); + perror(fs); + return((FILE *)NULL); + } + if ((stbuf.st_mode & S_IFMT) == S_IFDIR) { + prtf("\n*** %s: directory ***\n\n", fs); + return((FILE *)NULL); + } + if ((f = Fopen(fs, "r")) == NULL) { + (void)fflush(stdout); + perror(fs); + return((FILE *)NULL); + } + if (magic(f, fs)) + return((FILE *)NULL); + c = Getc(f); + *clearfirst = c == '\f'; + Ungetc (c, 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? + */ +magic(f, fs) + FILE *f; + char *fs; +{ + struct exec ex; + + if (fread(&ex, sizeof(ex), 1, f) == 1) + switch(ex.a_magic) { + case OMAGIC: + case NMAGIC: + case ZMAGIC: + case 0405: + case 0411: + case 0177545: + prtf("\n******** %s: Not a text file ********\n\n", fs); + (void)fclose(f); + return(1); + } + (void)fseek(f, 0L, L_SET); /* rewind() not necessary */ + return(0); +} + +/* +** A real function, for the tputs routine in termlib +*/ + +putch (ch) +char ch; +{ + putchar (ch); +} + +/* +** Print out the contents of the file f, one screenful at a time. +*/ + +#define STOP -10 + +screen (f, num_lines) +register FILE *f; +register int num_lines; +{ + register int c; + register 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 = getline (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) + erase (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) + erase (nchars); /* erase () sets promptlen to 0 */ + else promptlen = 0; + /* is this needed? + * if (clreol) + * cleareol(); /* must clear again in case we wrapped * + */ + if (nchars < Mcol || !fold_opt) + prbuf("\n", 1); /* will turn off UL if necessary */ + if (nchars == STOP) + break; + num_lines--; + } + if (pstate) { + tputs(ULexit, 1, putch); + pstate = 0; + } + fflush(stdout); + if ((c = Getc(f)) == EOF) + { + if (clreol) + clreos (); + return; + } + + if (Pause && clreol) + clreos (); + Ungetc (c, f); + setjmp (restore); + Pause = 0; startup = 0; + if ((num_lines = command (NULL, f)) == 0) + return; + if (hard && promptlen > 0) + erase (0); + if (noscroll && num_lines >= dlines) + { + if (clreol) + home(); + else + doclear (); + } + screen_start.line = Currline; + screen_start.chrctr = Ftell (f); + } +} + +/* +** Come here if a quit signal is received +*/ + +void +onquit() +{ + signal(SIGQUIT, SIG_IGN); + if (!inwait) { + putchar ('\n'); + if (!startup) { + signal(SIGQUIT, onquit); + longjmp (restore, 1); + } + else + Pause++; + } + else if (!dum_opt && notell) { + write (2, "[Use q or Q to quit]", 20); + promptlen += 20; + notell = 0; + } + signal(SIGQUIT, onquit); +} + +/* +** Come here if a signal for a window size change is received +*/ + +void +chgwinsz() +{ + struct winsize win; + + (void) signal(SIGWINCH, SIG_IGN); + if (ioctl(fileno(stdout), TIOCGWINSZ, &win) != -1) { + if (win.ws_row != 0) { + Lpp = win.ws_row; + nscroll = Lpp/2 - 1; + if (nscroll <= 0) + nscroll = 1; + dlines = Lpp - (noscroll ? 1 : 2); + } + if (win.ws_col != 0) + Mcol = win.ws_col; + } + (void) signal(SIGWINCH, chgwinsz); +} + +/* +** Clean up terminal state and exit. Also come here if interrupt signal received +*/ + +void +end_it () +{ + + reset_tty (); + if (clreol) { + putchar ('\r'); + clreos (); + fflush (stdout); + } + else if (!clreol && (promptlen > 0)) { + kill_line (); + fflush (stdout); + } + else + write (2, "\n", 1); + _exit(0); +} + +copy_file(f) +register FILE *f; +{ + register int c; + + while ((c = getc(f)) != EOF) + putchar(c); +} + +/* Simplified printf function */ + +prtf (fmt, va_alist) +register char *fmt; +va_dcl +{ + va_list ap; + register char ch; + register int ccount; + + ccount = 0; + va_start(ap); + while (*fmt) { + while ((ch = *fmt++) != '%') { + if (ch == '\0') + return (ccount); + ccount++; + putchar (ch); + } + switch (*fmt++) { + case 'd': + ccount += printd (va_arg(ap, int)); + break; + case 's': + ccount += pr (va_arg(ap, char *)); + break; + case '%': + ccount++; + putchar ('%'); + break; + case '0': + return (ccount); + default: + break; + } + } + va_end(ap); + return (ccount); + +} + +/* +** Print an integer as a string of decimal digits, +** returning the length of the print representation. +*/ + +printd (n) +int n; +{ + int a, nchars; + + if (a = n/10) + nchars = 1 + printd(a); + else + nchars = 1; + putchar (n % 10 + '0'); + return (nchars); +} + +/* Put the print representation of an integer into a string */ +static char *sptr; + +scanstr (n, str) +int n; +char *str; +{ + sptr = str; + Sprintf (n); + *sptr = '\0'; +} + +Sprintf (n) +{ + int a; + + if (a = n/10) + Sprintf (a); + *sptr++ = n % 10 + '0'; +} + +static char bell = ctrl('G'); + +/* See whether the last component of the path name "path" is equal to the +** string "string" +*/ + +tailequ (path, string) +char *path; +register char *string; +{ + register char *tail; + + tail = path + strlen(path); + while (tail >= path) + if (*(--tail) == '/') + break; + ++tail; + while (*tail++ == *string++) + if (*tail == '\0') + return(1); + return(0); +} + +prompt (filename) +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 (); + pr("--More--"); + if (filename != NULL) { + promptlen += prtf ("(Next file: %s)", filename); + } + else if (!no_intty) { + promptlen += prtf ("(%d%%)", (int)((file_pos * 100) / file_size)); + } + if (dum_opt) { + promptlen += pr("[Press space to continue, 'q' to quit.]"); + } + if (Senter && Sexit) + tputs (Sexit, 1, putch); + if (clreol) + clreos (); + fflush(stdout); + } + else + write (2, &bell, 1); + inwait++; +} + +/* +** Get a logical line +*/ + +getline(f, length) +register FILE *f; +int *length; +{ + register int c; + register char *p; + register int column; + static int colflg; + + p = Line; + column = 0; + c = Getc (f); + if (colflg && c == '\n') { + Currline++; + c = Getc (f); + } + while (p < &Line[LINSIZ - 1]) { + if (c == EOF) { + if (p > Line) { + *p = '\0'; + *length = p - Line; + return (column); + } + *length = p - Line; + return (EOF); + } + if (c == '\n') { + Currline++; + break; + } + *p++ = c; + if (c == '\t') + if (!hardtabs || column < promptlen && !hard) { + if (hardtabs && eraseln && !dumb) { + column = 1 + (column | 7); + tputs (eraseln, 1, putch); + promptlen = 0; + } + else { + for (--p; p < &Line[LINSIZ - 1];) { + *p++ = ' '; + if ((++column & 7) == 0) + break; + } + if (column >= promptlen) promptlen = 0; + } + } + else + column = 1 + (column | 7); + else if (c == '\b' && column > 0) + column--; + else if (c == '\r') + column = 0; + else if (c == '\f' && stop_opt) { + p[-1] = '^'; + *p++ = 'L'; + column += 2; + Pause++; + } + else if (c == EOF) { + *length = p - Line; + return (column); + } + else if (c >= ' ' && c != RUBOUT) + column++; + if (column >= Mcol && fold_opt) break; + c = Getc (f); + } + if (column >= Mcol && Mcol > 0) { + if (!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. +*/ + +erase (col) +register 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 +*/ + +kill_line () +{ + erase (0); + if (!eraseln || dumb) putchar ('\r'); +} + +/* + * force clear to end of line + */ +cleareol() +{ + tputs(eraseln, 1, putch); +} + +clreos() +{ + tputs(EodClr, 1, putch); +} + +/* +** Print string and return number of characters +*/ + +pr(s1) +char *s1; +{ + register char *s; + register char c; + + for (s = s1; c = *s++; ) + putchar(c); + return (s - s1 - 1); +} + + +/* Print a buffer of n characters */ + +prbuf (s, n) +register char *s; +register int n; +{ + register char c; /* next output character */ + register 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) { + pr(chBS); + tputs(chUL, 1, putch); + } + pstate = state; + } +} + +/* +** Clear the screen +*/ + +doclear() +{ + 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; + } +} + +/* + * Go to home position + */ +home() +{ + tputs(Home,1,putch); +} + +static int lastcmd, lastarg, lastp; +static int lastcolon; +char shell_line[132]; + +/* +** 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. +*/ + +command (filename, f) +char *filename; +register FILE *f; +{ + register int nlines; + register int retval; + register char c; + char colonch; + FILE *helpf; + int done; + char comchar, cmdbuf[80], *p; + +#define ret(val) retval=val;done++;break + + done = 0; + if (!errors) + prompt (filename); + else + errors = 0; + if (MBIT == RAW && slow_tty) { + otty.sg_flags |= MBIT; + stty(fileno(stderr), &otty); + } + 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.sg_erase) { + kill_line (); + prompt (filename); + continue; + } + switch (comchar) { + case ':': + retval = colon (filename, colonch, nlines); + if (retval >= 0) + done++; + break; + case 'b': + case ctrl('B'): + { + register int initline; + + if (no_intty) { + write(2, &bell, 1); + return (-1); + } + + if (nlines == 0) nlines++; + + putchar ('\r'); + erase (0); + prtf ("\n"); + if (clreol) + cleareol (); + prtf ("...back %d page", nlines); + if (nlines > 1) + pr ("s\n"); + else + pr ("\n"); + + if (clreol) + cleareol (); + pr ("\n"); + + initline = Currline - dlines * (nlines + 1); + if (! noscroll) + --initline; + if (initline < 0) initline = 0; + Fseek(f, 0L); + Currline = 0; /* skiplns() will make Currline correct */ + skiplns(initline, f); + if (! noscroll) { + ret(dlines + 1); + } + else { + 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'); + erase (0); + prtf ("\n"); + if (clreol) + cleareol (); + prtf ("...skipping %d line", nlines); + if (nlines > 1) + pr ("s\n"); + else + pr ("\n"); + + if (clreol) + cleareol (); + pr ("\n"); + + while (nlines > 0) { + while ((c = Getc (f)) != '\n') + if (c == 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 (2, &bell, 1); + break; + } + case '\'': + if (!no_intty) { + kill_line (); + pr ("\n***Back***\n\n"); + Fseek (f, context.chrctr); + Currline = context.line; + ret (dlines); + } + else { + write (2, &bell, 1); + break; + } + case '=': + kill_line (); + promptlen = printd (Currline); + fflush (stdout); + break; + case 'n': + lastp++; + case '/': + if (nlines == 0) nlines++; + kill_line (); + pr ("/"); + promptlen = 1; + fflush (stdout); + if (lastp) { + write (2,"\r", 1); + search (NULL, f, nlines); /* Use previous r.e. */ + } + else { + ttyin (cmdbuf, 78, '/'); + write (2, "\r", 1); + search (cmdbuf, f, nlines); + } + ret (dlines-1); + case '!': + do_shell (filename); + break; + case '?': + case 'h': + if ((helpf = fopen (HELPFILE, "r")) == NULL) + error ("Can't open help file"); + if (noscroll) doclear (); + copy_file (helpf); + fclose (helpf); + prompt (filename); + break; + case 'v': /* This case should go right before default */ + if (!no_intty) { + kill_line (); + cmdbuf[0] = '+'; + scanstr (Currline - dlines < 0 ? 0 + : Currline - (dlines + 1) / 2, &cmdbuf[1]); + pr ("vi "); pr (cmdbuf); putchar (' '); pr (fnames[fnum]); + execute (filename, _PATH_VI, "vi", cmdbuf, fnames[fnum], 0); + break; + } + default: + if (dum_opt) { + kill_line (); + if (Senter && Sexit) { + tputs (Senter, 1, putch); + promptlen = pr ("[Press 'h' for instructions.]") + (2 * soglitch); + tputs (Sexit, 1, putch); + } + else + promptlen = pr ("[Press 'h' for instructions.]"); + fflush (stdout); + } + else + write (2, &bell, 1); + break; + } + if (done) break; + } + putchar ('\r'); +endsw: + inwait = 0; + notell++; + if (MBIT == RAW && slow_tty) { + otty.sg_flags &= ~MBIT; + stty(fileno(stderr), &otty); + } + return (retval); +} + +char ch; + +/* + * Execute a colon-prefixed command. + * Returns <0 if not a command that should cause + * more of the file to be printed. + */ + +colon (filename, cmd, nlines) +char *filename; +int cmd; +int nlines; +{ + if (cmd == 0) + ch = readch (); + else + ch = cmd; + lastcolon = ch; + switch (ch) { + case 'f': + kill_line (); + if (!no_intty) + promptlen = prtf ("\"%s\" line %d", fnames[fnum], Currline); + else + promptlen = prtf ("[Not a file] line %d", Currline); + fflush (stdout); + return (-1); + case 'n': + if (nlines == 0) { + if (fnum >= nfiles - 1) + end_it (); + nlines++; + } + putchar ('\r'); + erase (0); + skipf (nlines); + return (0); + case 'p': + if (no_intty) { + write (2, &bell, 1); + return (-1); + } + putchar ('\r'); + erase (0); + if (nlines == 0) + nlines++; + skipf (-nlines); + return (0); + case '!': + do_shell (filename); + return (-1); + case 'q': + case 'Q': + end_it (); + default: + write (2, &bell, 1); + return (-1); + } +} + +/* +** Read a decimal number from the terminal. Set cmd to the non-digit which +** terminates the number. +*/ + +number(cmd) +char *cmd; +{ + register int i; + + i = 0; ch = otty.sg_kill; + for (;;) { + ch = readch (); + if (ch >= '0' && ch <= '9') + i = i*10 + ch - '0'; + else if (ch == otty.sg_kill) + i = 0; + else { + *cmd = ch; + break; + } + } + return (i); +} + +do_shell (filename) +char *filename; +{ + char cmdbuf[80]; + + kill_line (); + pr ("!"); + fflush (stdout); + promptlen = 1; + if (lastp) + pr (shell_line); + else { + ttyin (cmdbuf, 78, '!'); + if (expand (shell_line, cmdbuf)) { + kill_line (); + promptlen = prtf ("!%s", shell_line); + } + } + fflush (stdout); + write (2, "\n", 1); + promptlen = 0; + shellp = 1; + execute (filename, shell, shell, "-c", shell_line, 0); +} + +/* +** Search for nth ocurrence of regular expression contained in buf in the file +*/ + +search (buf, file, n) +char buf[]; +FILE *file; +register int n; +{ + long startline = Ftell (file); + register long line1 = startline; + register long line2 = startline; + register long line3 = startline; + register int lncount; + int saveln, rv, re_exec(); + char *s, *re_comp(); + + context.line = saveln = Currline; + context.chrctr = startline; + lncount = 0; + if ((s = re_comp (buf)) != 0) + error (s); + while (!feof (file)) { + line3 = line2; + line2 = line1; + line1 = Ftell (file); + rdline (file); + lncount++; + if ((rv = re_exec (Line)) == 1) + if (--n == 0) { + if (lncount > 3 || (lncount > 1 && no_intty)) + { + pr ("\n"); + if (clreol) + cleareol (); + pr("...skipping\n"); + } + 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 (); + pr (Line); + putchar ('\n'); + } + break; + } + else if (rv == -1) + error ("Regular expression botch"); + } + if (feof (file)) { + if (!no_intty) { + /* file->_flag &= ~_IOEOF; /* why doesn't fseek do this ??!!??! */ + Currline = saveln; + Fseek (file, startline); + } + else { + pr ("\nPattern not found\n"); + end_it (); + } + error ("Pattern not found"); + } +} + +/*VARARGS2*/ +execute (filename, cmd, va_alist) +char *filename; +char *cmd; +va_dcl +{ + int id; + int n; + va_list argp; + + fflush (stdout); + reset_tty (); + for (n = 10; (id = fork ()) < 0 && n > 0; n--) + sleep (5); + if (id == 0) { + if (!isatty(0)) { + close(0); + open("/dev/tty", 0); + } + va_start(argp); + execv (cmd, argp); + write (2, "exec failed\n", 12); + exit (1); + va_end(argp); /* balance {}'s for some UNIX's */ + } + if (id > 0) { + signal (SIGINT, SIG_IGN); + signal (SIGQUIT, SIG_IGN); + if (catch_susp) + signal(SIGTSTP, SIG_DFL); + while (wait(0) > 0); + signal (SIGINT, end_it); + signal (SIGQUIT, onquit); + if (catch_susp) + signal(SIGTSTP, onsusp); + } else + write(2, "can't fork\n", 11); + set_tty (); + pr ("------------------------\n"); + prompt (filename); +} +/* +** Skip n lines in the file f +*/ + +skiplns (n, f) +register int n; +register FILE *f; +{ + register char c; + + while (n > 0) { + while ((c = Getc (f)) != '\n') + if (c == EOF) + return; + n--; + Currline++; + } +} + +/* +** Skip nskip files in the file list (from the command line). Nskip may be +** negative. +*/ + +skipf (nskip) +register 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; + pr ("\n...Skipping "); + pr ("\n"); + if (clreol) + cleareol (); + pr ("...Skipping "); + pr (nskip > 0 ? "to file " : "back to file "); + pr (fnames[fnum]); + pr ("\n"); + if (clreol) + cleareol (); + pr ("\n"); + --fnum; +} + +/*----------------------------- Terminal I/O -------------------------------*/ + +initterm () +{ + char buf[TBUFSIZ]; + static char clearbuf[TBUFSIZ]; + char *clearptr, *padstr; + int ldisc; + int lmode; + char *term; + int tgrp; + struct winsize win; + char *tgoto(); + +retry: + if (!(no_tty = ioctl(fileno(stdout), TIOCGETP, &otty))) { + if (ioctl(fileno(stdout), TIOCLGET, &lmode) < 0) { + perror("TIOCLGET"); + exit(1); + } + docrterase = ((lmode & LCRTERA) != 0); + docrtkill = ((lmode & LCRTKIL) != 0); + /* + * Wait until we're in the foreground before we save the + * the terminal modes. + */ + if (ioctl(fileno(stdout), TIOCGPGRP, &tgrp) < 0) { + perror("TIOCGPGRP"); + exit(1); + } + if (tgrp != getpgrp(0)) { + kill(0, SIGTTOU); + goto retry; + } + if ((term = getenv("TERM")) == 0 || tgetent(buf, term) <= 0) { + dumb++; ul_opt = 0; + } + else { + if (ioctl(fileno(stdout), TIOCGWINSZ, &win) < 0) { + 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")) + eatnl++; /* Eat newline at last column + 1; dec, concept */ + if (Mcol <= 0) + Mcol = 80; + + if (tailequ (fnames[0], "page") || !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; + + /* + * Set up 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 sequence + * 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') + { + if ((cursorm = tgetstr("cm", &clearptr)) != NULL) { + strcpy(cursorhome, tgoto(cursorm, 0, 0)); + Home = cursorhome; + } + } + EodClr = tgetstr("cd", &clearptr); + if ((chBS = tgetstr("bc", &clearptr)) == NULL) + chBS = "\b"; + + } + if ((shell = getenv("SHELL")) == NULL) + shell = "/bin/sh"; + } + no_intty = ioctl(fileno(stdin), TIOCGETP, &otty); + (void)ioctl(fileno(stderr), TIOCGETP, &otty); + savetty = otty; + ospeed = otty.sg_ospeed; + slow_tty = ospeed < B1200; + hardtabs = (otty.sg_flags & TBDELAY) != XTABS; + if (!no_tty) { + otty.sg_flags &= ~ECHO; + if (MBIT == CBREAK || !slow_tty) + otty.sg_flags |= MBIT; + } +} + +readch () +{ + char ch; + extern int errno; + + errno = 0; + if (read (2, &ch, 1) <= 0) + if (errno != EINTR) + end_it(); + else + ch = otty.sg_kill; + return (ch); +} + +static char BS = '\b'; +static char *BSB = "\b \b"; +static char CARAT = '^'; +#define ERASEONECHAR \ + if (docrterase) \ + write (2, BSB, sizeof(BSB)); \ + else \ + write (2, &BS, sizeof(BS)); + +ttyin (buf, nmax, pchar) +char buf[]; +register int nmax; +char pchar; +{ + register char *sptr; + register char ch; + register int slash = 0; + int maxlen; + char cbuf; + + sptr = buf; + maxlen = 0; + while (sptr - buf < nmax) { + if (promptlen > maxlen) maxlen = promptlen; + ch = readch (); + if (ch == '\\') { + slash++; + } + else if ((ch == otty.sg_erase) && !slash) { + if (sptr > buf) { + --promptlen; + ERASEONECHAR + --sptr; + if ((*sptr < ' ' && *sptr != '\n') || *sptr == RUBOUT) { + --promptlen; + ERASEONECHAR + } + continue; + } + else { + if (!eraseln) promptlen = maxlen; + longjmp (restore, 1); + } + } + else if ((ch == otty.sg_kill) && !slash) { + if (hard) { + show (ch); + putchar ('\n'); + putchar (pchar); + } + else { + putchar ('\r'); + putchar (pchar); + if (eraseln) + erase (1); + else if (docrtkill) + while (promptlen-- > 1) + write (2, BSB, sizeof(BSB)); + promptlen = 1; + } + sptr = buf; + fflush (stdout); + continue; + } + if (slash && (ch == otty.sg_kill || ch == otty.sg_erase)) { + ERASEONECHAR + --sptr; + } + if (ch != '\\') + slash = 0; + *sptr++ = ch; + if ((ch < ' ' && ch != '\n' && ch != ESC) || ch == RUBOUT) { + ch += ch == RUBOUT ? -0100 : 0100; + write (2, &CARAT, 1); + promptlen++; + } + cbuf = ch; + if (ch != '\n' && ch != ESC) { + write (2, &cbuf, 1); + promptlen++; + } + else + break; + } + *--sptr = '\0'; + if (!eraseln) promptlen = maxlen; + if (sptr - buf >= nmax - 1) + error ("Line too long"); +} + +expand (outbuf, inbuf) +char *outbuf; +char *inbuf; +{ + register char *instr; + register char *outstr; + register char ch; + char temp[200]; + int changed = 0; + + instr = inbuf; + outstr = temp; + while ((ch = *instr++) != '\0') + switch (ch) { + case '%': + if (!no_intty) { + strcpy (outstr, fnames[fnum]); + outstr += strlen (fnames[fnum]); + changed++; + } + else + *outstr++ = ch; + break; + case '!': + if (!shellp) + error ("No previous command to substitute for"); + strcpy (outstr, shell_line); + outstr += strlen (shell_line); + changed++; + break; + case '\\': + if (*instr == '%' || *instr == '!') { + *outstr++ = *instr++; + break; + } + default: + *outstr++ = ch; + } + *outstr++ = '\0'; + strcpy (outbuf, temp); + return (changed); +} + +show (ch) +register char ch; +{ + char cbuf; + + if ((ch < ' ' && ch != '\n' && ch != ESC) || ch == RUBOUT) { + ch += ch == RUBOUT ? -0100 : 0100; + write (2, &CARAT, 1); + promptlen++; + } + cbuf = ch; + write (2, &cbuf, 1); + promptlen++; +} + +error (mess) +char *mess; +{ + if (clreol) + cleareol (); + else + kill_line (); + promptlen += strlen (mess); + if (Senter && Sexit) { + tputs (Senter, 1, putch); + pr(mess); + tputs (Sexit, 1, putch); + } + else + pr (mess); + fflush(stdout); + errors++; + longjmp (restore, 1); +} + + +set_tty () +{ + otty.sg_flags |= MBIT; + otty.sg_flags &= ~ECHO; + stty(fileno(stderr), &otty); +} + +reset_tty () +{ + if (no_tty) + return; + if (pstate) { + tputs(ULexit, 1, putch); + fflush(stdout); + pstate = 0; + } + otty.sg_flags |= ECHO; + otty.sg_flags &= ~MBIT; + stty(fileno(stderr), &savetty); +} + +rdline (f) +register FILE *f; +{ + register char c; + register char *p; + + p = Line; + while ((c = Getc (f)) != '\n' && c != EOF && p - Line < LINSIZ - 1) + *p++ = c; + if (c == '\n') + Currline++; + *p = '\0'; +} + +/* Come here when we get a suspend signal from the terminal */ + +void +onsusp () +{ + /* ignore SIGTTOU so we don't get stopped if csh grabs the tty */ + signal(SIGTTOU, SIG_IGN); + reset_tty (); + fflush (stdout); + signal(SIGTTOU, SIG_DFL); + /* Send the TSTP signal to suspend our process group */ + signal(SIGTSTP, SIG_DFL); + sigsetmask(0); + kill (0, SIGTSTP); + /* Pause for station break */ + + /* We're back */ + signal (SIGTSTP, onsusp); + set_tty (); + if (inwait) + longjmp (restore, 1); +} diff --git a/distrib/special/more/more.help b/distrib/special/more/more.help new file mode 100644 index 00000000000..1ced5c9d688 --- /dev/null +++ b/distrib/special/more/more.help @@ -0,0 +1,24 @@ + +Most commands optionally preceded by integer argument k. Defaults in brackets. +Star (*) indicates argument becomes new default. +------------------------------------------------------------------------------- +<space> Display next k lines of text [current screen size] +z Display next k lines of text [current screen size]* +<return> Display next k lines of text [1]* +d or ctrl-D Scroll k lines [current scroll size, initially 11]* +q or Q or <interrupt> Exit from more +s Skip forward k lines of text [1] +f Skip forward k screenfuls of text [1] +b or ctrl-B Skip backwards k screenfuls of text [1] +' Go to place where previous search started += Display current line number +/<regular expression> Search for kth occurrence of regular expression [1] +n Search for kth occurrence of last r.e [1] +!<cmd> or :!<cmd> Execute <cmd> in a subshell +v Start up /usr/ucb/vi at current line +ctrl-L Redraw screen +:n Go to kth next file [1] +:p Go to kth previous file [1] +:f Display current file name and line number +. Repeat previous command +------------------------------------------------------------------------------- diff --git a/distrib/special/more/pathnames.h b/distrib/special/more/pathnames.h new file mode 100644 index 00000000000..296d60aba3e --- /dev/null +++ b/distrib/special/more/pathnames.h @@ -0,0 +1,38 @@ +/*- + * Copyright (c) 1989 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. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. 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. + * + * @(#)pathnames.h 5.2 (Berkeley) 4/18/91 + */ + +#include <paths.h> + +#define HELPFILE "/usr/share/misc/omore.help" |