usr/src/cmd/pg/pg.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright (c) 2016 by Delphix. All rights reserved.
  25  */
  26
  27 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  28 /*        All Rights Reserved   */
  29
  30 #include <signal.h>
  31 #include <setjmp.h>
  32 #include <sys/types.h>
  33 #include <sys/dirent.h>
  34 #include <sys/stat.h>
  35 #include <fcntl.h>
  36 #include <ctype.h>
  37 #include <stdio.h>
  38 #include <wchar.h>
  39 #include <curses.h>
  40 #include <term.h>
  41 #include <sys/termio.h>
  42 #include <errno.h>
  43 #include <stdlib.h>
  44 #include <regexpr.h>
  45 #include <limits.h>
  46 #include <locale.h>
  47 #include <wctype.h> /* iswprint() */
  48 #include <string.h>
  49 #include <unistd.h>
  50 #include <wait.h>
  51 #include <libw.h>
  52 #include <regexpr.h>
  53
  54
  55 /*
  56  *      pg -- paginator for crt terminals
  57  *
  58  *      Includes the ability to display pages that have
  59  *      already passed by. Also gives the user the ability
  60  *      to search forward and backwards for regular expressions.
  61  *      This works for piped input by copying to a temporary file,
  62  *      and resolving backreferences from there.
  63  *
  64  *      Note:   The reason that there are so many commands to do
  65  *              the same types of things is to try to accommodate
  66  *              users of other paginators.
  67  */
  68
  69 #define LINSIZ  1024
  70 #define QUIT    '\034'
  71 #define BOF     (EOF - 1)       /* Begining of File */
  72 #define STOP    (EOF - 2)
  73 #define PROMPTSIZE      256
  74
  75 /*
  76  * Function definitions
  77  */
  78 static  void    lineset(int);
  79 static  char    *setprompt();
  80 static  int     set_state(int *, wchar_t, char *);
  81 static  void    help();
  82 static  void    copy_file(FILE *, FILE *);
  83 static  void    re_error(int);
  84 static  void    save_input(FILE *);
  85 static  void    save_pipe();
  86 static  void    newdol(FILE *);
  87 static  void    erase_line(int);
  88 static  void    kill_line();
  89 static  void    doclear();
  90 static  void    sopr(char *, int);
  91 static  void    prompt(char *);
  92 static  void    error(char *);
  93 static  void    terminit();
  94 static  void    compact();
  95 static  off_t   getaline(FILE *);
  96 static  int     mrdchar();
  97 static  off_t   find(int, off_t);
  98 static  int     search(char *, off_t);
  99 static  FILE    *checkf(char *);
 100 static  int     skipf(int);
 101 static  int     readch();
 102 static  int     ttyin();
 103 static  int     number();
 104 static  int     command(char *);
 105 static  int     screen(char *);
 106 static  int     fgetputc();
 107 static  char    *pg_strchr();
 108
 109
 110 struct line {                   /* how line addresses are stored */
 111         off_t   l_addr;         /* file offset */
 112         off_t   l_no;           /* line number in file */
 113 };
 114
 115 typedef struct line     LINE;
 116
 117 static  LINE    *zero = NULL,   /* first line */
 118                 *dot,           /* current line */
 119                 *dol,           /* last line */
 120                 *contig;        /* where contiguous (non-aged) lines start */
 121 static  long    nlall;          /* room for how many LINEs in memory */
 122
 123 static  FILE    *in_file,       /* current input stream */
 124                 *tmp_fin,       /* pipe temporary file in */
 125                 *tmp_fou;       /* pipe temporary file out */
 126 static  char    tmp_name[] = "/tmp/pgXXXXXX";
 127
 128 static  short   sign;           /* sign of command input */
 129
 130 static  int     fnum,           /* which file argument we're in */
 131                 pipe_in,        /* set when stdin is a pipe */
 132                 out_is_tty;     /* set if stdout is a tty */
 133 static  pid_t   my_pgid;
 134
 135 static  void    on_brk(),
 136                 end_it();
 137 static  short   brk_hit;        /* interrupt handling is pending flag */
 138
 139 static  int     window = 0;     /* window size in lines */
 140 static  short   eof_pause = 1;  /* pause w/ prompt at end of files */
 141 static  short   rmode = 0;      /* deny shell escape in restricted mode */
 142 static  short   soflag = 0;     /* output all messages in standout mode */
 143 static  short   promptlen;      /* length of the current prompt */
 144 static  short   firstf = 1;     /* set before first file has been processed */
 145 static  short   inwait,         /* set while waiting for user input */
 146                 errors;         /* set if error message has been printed. */
 147                                 /* if so, need to erase it and prompt */
 148
 149 static  char    **fnames;
 150 static  short   status = 0;     /* set > 0 if error detected */
 151 static  short   fflag = 0;      /* set if the f option is used */
 152 static  short   nflag = 0;      /* set for "no newline" input option */
 153 static  short   clropt = 0;     /* set if the clear option is used */
 154 static  int     initopt = 0;    /* set if the line option is used */
 155 static  int     srchopt = 0;    /* set if the search option is used */
 156 static  int     initline;
 157 static  char    initbuf[BUFSIZ];
 158 static  wchar_t leave_search = L't';
 159                                 /* where on the page to leave a found string */
 160 static  short   nfiles;
 161 static  char    *shell;
 162 static  char    *promptstr = ":";
 163 static  off_t   nchars;                 /* return from getaline in find() */
 164 static  jmp_buf restore;
 165 static  char    Line[LINSIZ+2];
 166
 167 static  int     catch_susp;
 168
 169 static  void    onsusp();
 170
 171 struct screen_stat {
 172         off_t   first_line;
 173         off_t   last_line;
 174         short   is_eof;
 175         };
 176
 177 static  struct screen_stat old_ss = { 0, 0, 0 };
 178 static  struct screen_stat new_ss;
 179 static  struct termio otty;     /* to save old terminal settings */
 180
 181 static  short   termflg = 0;    /* set once terminal is initialized */
 182 static  short   eoflag;         /* set whenever at end of current file */
 183 static  short   doliseof;       /* set when last line of file is known */
 184 static  off_t   eofl_no;        /* what the last line of the file is */
 185 static  void    usage(void);
 186 static FILE     *pg_stdin;
 187
 188 int
 189 main(int argc, char **argv)
 190 {
 191         char    *s;
 192         char    *p;
 193         int             prnames = 0;
 194         int             opt;
 195         int             i;
 196
 197         (void) setlocale(LC_ALL, "");
 198 #if !defined(TEXT_DOMAIN)       /* Should be defined by cc -D */
 199 #define TEXT_DOMAIN "SYS_TEST"  /* Use this only if it weren't */
 200 #endif
 201         (void) textdomain(TEXT_DOMAIN);
 202
 203         /* check for non-standard "-#" option */
 204         for (i = 1; i < argc; i++) {
 205                 if (strcmp(argv[i], "--") == 0)
 206                         break;
 207
 208                 if ((argv[i][0] == '-') && isdigit(argv[i][1])) {
 209                         if (strlen(&argv[i][1]) !=
 210                             strspn(&argv[i][1], "0123456789")) {
 211                                 (void) fprintf(stderr, gettext(
 212                                     "pg: Badly formed number\n"));
 213                                 usage();
 214                         }
 215
 216                         window = (int)strtol(&argv[i][1], (char **)NULL, 10);
 217
 218                         while (i < argc) {
 219                                 argv[i] = argv[i + 1];
 220                                 i++;
 221                         }
 222                         i--;
 223                         argc--;
 224                 }
 225         }
 226
 227         /* check for non-standard + option */
 228         for (i = 1; i < argc; i++) {
 229                 if (strcmp(argv[i], "--") == 0)
 230                 break;
 231
 232                 if (argv[i][0] == '+') {
 233                         if (argv[i][1] == '/') {
 234                                 srchopt++;
 235                                 initopt = 0;
 236                                 for (s = &argv[i][2], p = initbuf; *s != '\0'; )
 237                                         if (p < initbuf + sizeof (initbuf))
 238                                                 *p++ = *s++;
 239                                         else {
 240                                                 (void) fprintf(stderr, gettext(
 241                                                     "pg: pattern too long\n"));
 242                                                 return (1);
 243                                         }
 244                                 *p = '\0';
 245                         } else {
 246                                 initopt++;
 247                                 srchopt = 0;
 248                                 s = &argv[i][2];
 249                                 for (; isdigit(*s); s++)
 250                                         initline = initline*10 + *s -'0';
 251                                 if (*s != '\0')
 252                                         usage();
 253                         }
 254
 255                         while (i < argc) {
 256                                 argv[i] = argv[i + 1];
 257                                 i++;
 258                         }
 259                         i--;
 260                         argc--;
 261                 }
 262         }
 263
 264         while ((opt = getopt(argc, argv, "cefnrsp:")) != EOF) {
 265                 switch (opt) {
 266                 case 'c':
 267                         clropt = 1;
 268                         break;
 269
 270                 case 'e':
 271                         eof_pause = 0;
 272                         break;
 273
 274                 case 'f':
 275                         fflag = 1;
 276                         break;
 277
 278                 case 'n':
 279                         nflag = 1;
 280                         break;
 281
 282                 case 'r':
 283                         rmode = 1;      /* restricted mode */
 284                         break;
 285
 286                 case 's':
 287                         soflag = 1;     /* standout mode */
 288                         break;
 289
 290                 case 'p':
 291                         promptstr = setprompt(optarg);
 292                         break;
 293
 294                 default:
 295                         usage();
 296                 }
 297         }
 298
 299         nfiles = argc - optind;
 300         fnames = &argv[optind];
 301
 302         (void) signal(SIGQUIT, end_it);
 303         (void) signal(SIGINT, end_it);
 304         out_is_tty = isatty(1);
 305         my_pgid = getpgrp();
 306         if (out_is_tty) {
 307                 terminit();
 308                 (void) signal(SIGQUIT, on_brk);
 309                 (void) signal(SIGINT, on_brk);
 310                 if (signal(SIGTSTP, SIG_IGN) == SIG_DFL) {
 311                         (void) signal(SIGTSTP, onsusp);
 312                         catch_susp++;
 313                 }
 314         }
 315         if (window == 0)
 316                 window = lines - 1;
 317         if (window <= 1)
 318                 window = 2;
 319         if (initline <= 0)
 320                 initline = 1;
 321         if (nfiles > 1)
 322                 prnames++;
 323
 324         if (nfiles == 0) {
 325                 fnames[0] = "-";
 326                 nfiles++;
 327         }
 328         while (fnum < nfiles) {
 329                 if (strcmp(fnames[fnum], "") == 0)
 330                         fnames[fnum] = "-";
 331                 if ((in_file = checkf(fnames[fnum])) == NULL) {
 332                         status = 2;
 333                         fnum++;
 334                 } else {
 335                         status = 0;
 336                         if (out_is_tty)
 337                                 fnum += screen(fnames[fnum]);
 338                         else {
 339                                 if (prnames) {
 340                                         (void) fputs("::::::::::::::\n",
 341                                             stdout);
 342                                         (void) fputs(fnames[fnum], stdout);
 343                                         (void) fputs("\n::::::::::::::\n",
 344                                             stdout);
 345                                 }
 346                                 copy_file(in_file, stdout);
 347                                 fnum++;
 348                         }
 349                         (void) fflush(stdout);
 350                         if (pipe_in)
 351                                 save_pipe();
 352                         else
 353                         if (in_file != tmp_fin)
 354                                 (void) fclose(in_file);
 355                 }
 356         }
 357         end_it();
 358
 359         /*NOTREACHED*/
 360         return (0);
 361 }
 362
 363 static  char *
 364 setprompt(char *s)
 365 {
 366         int i = 0;
 367         int pct_d = 0;
 368         static char pstr[PROMPTSIZE];
 369
 370         while (i < PROMPTSIZE - 2)
 371                 switch (pstr[i++] = *s++) {
 372                 case '\0':
 373                         return (pstr);
 374                 case '%':
 375                         if (*s == 'd' && !pct_d) {
 376                                 pct_d++;
 377                         } else if (*s != '%')
 378                                 pstr[i++] = '%';
 379                         if ((pstr[i++] = *s++) == '\0')
 380                                 return (pstr);
 381                         break;
 382                 default:
 383                         break;
 384                 }
 385         (void) fprintf(stderr, gettext("pg: prompt too long\n"));
 386         exit(1);
 387         /*NOTREACHED*/
 388 }
 389
 390
 391 /*
 392  * Print out the contents of the file f, one screenful at a time.
 393  */
 394
 395 static int
 396 screen(char *file_name)
 397 {
 398         int cmd_ret = 0;
 399         off_t start;
 400         short hadchance = 0;
 401
 402         old_ss.is_eof = 0;
 403         old_ss.first_line = 0;
 404         old_ss.last_line = 0;
 405         new_ss = old_ss;
 406         if (!firstf)
 407                 cmd_ret = command(file_name);
 408         else {
 409                 firstf = 0;
 410                 if (initopt) {
 411                         initopt = 0;
 412                         new_ss.first_line = initline;
 413                         new_ss.last_line = initline + (off_t)window - 1;
 414                 } else if (srchopt) {
 415                         srchopt = 0;
 416                         if (!search(initbuf, (off_t)1))
 417                                 cmd_ret = command(file_name);
 418                 } else {
 419                         new_ss.first_line = 1;
 420                         new_ss.last_line = (off_t)window;
 421                 }
 422         }
 423
 424         for (;;) {
 425                 if (cmd_ret)
 426                         return (cmd_ret);
 427                 if (hadchance && new_ss.last_line >= eofl_no)
 428                         return (1);
 429                 hadchance = 0;
 430
 431                 if (new_ss.last_line < (off_t)window)
 432                         new_ss.last_line = (off_t)window;
 433                 if (find(0, new_ss.last_line + 1) != EOF)
 434                         new_ss.is_eof = 0;
 435                 else {
 436                         new_ss.is_eof = 1;
 437                         new_ss.last_line = eofl_no - 1;
 438                         new_ss.first_line = new_ss.last_line -
 439                             (off_t)window + 1;
 440                 }
 441
 442                 if (new_ss.first_line < 1)
 443                         new_ss.first_line = 1;
 444                 if (clropt) {
 445                         doclear();
 446                         start = new_ss.first_line;
 447                 } else {
 448                         if (new_ss.first_line == old_ss.last_line)
 449                                 start = new_ss.first_line + 1;
 450                         else
 451                         if (new_ss.first_line > old_ss.last_line)
 452                                 start = new_ss.first_line;
 453                         else
 454                         if (old_ss.first_line < new_ss.first_line)
 455                                 start = old_ss.last_line + 1;
 456                         else
 457                                 start = new_ss.first_line;
 458
 459                         if (start < old_ss.first_line)
 460                                 sopr(gettext("...skipping backward\n"), 0);
 461                         else
 462                         if (start > old_ss.last_line + 1)
 463                                 sopr(gettext("...skipping forward\n"), 0);
 464                 }
 465
 466                 for (; start <= new_ss.last_line; start++) {
 467                         (void) find(0, start);
 468                         (void) fputs(Line, stdout);
 469                         if (brk_hit) {
 470                                 new_ss.last_line = find(1, 0);
 471                                 new_ss.is_eof = 0;
 472                                 break;
 473                         }
 474                 }
 475
 476                 brk_hit = 0;
 477                 (void) fflush(stdout);
 478                 if (new_ss.is_eof) {
 479                         if (!eof_pause || eofl_no == 1)
 480                                 return (1);
 481                         hadchance++;
 482                         error("(EOF)");
 483                 }
 484                 old_ss = new_ss;
 485                 cmd_ret = command(NULL);
 486         }
 487 }
 488
 489 static  char    cmdbuf[LINSIZ], *cmdptr;
 490 #define BEEP()          if (bell) { (void) putp(bell); (void) fflush(stdout); }
 491 #define BLANKS(p)       while (*p == ' ' || *p == '\t') p++
 492 #define CHECKEND()      BLANKS(cmdptr); if (*cmdptr) { BEEP(); break; }
 493
 494 /*
 495  * Read a command and do it. A command consists of an optional integer
 496  * argument followed by the command character.  Return the number of files
 497  * to skip, 0 if we're still talking about the same file.
 498  */
 499
 500 static int
 501 command(char *filename)
 502 {
 503         off_t nlines;
 504         FILE *sf;
 505         char *cmdend;
 506         pid_t id;
 507         int skip;
 508         int     len;
 509         wchar_t wc;
 510         wchar_t wc_e;
 511         wchar_t wc_e1;
 512         char    *p;
 513
 514         for (;;) {
 515                 /*
 516                  * Wait for output to drain before going on.
 517                  * This is done so that the user will not hit
 518                  * break and quit before they have seen the prompt.
 519                  */
 520                 (void) ioctl(1, TCSBRK, 1);
 521                 if (setjmp(restore) > 0)
 522                         end_it();
 523                 inwait = 1;
 524                 brk_hit = 0;
 525                 if (errors)
 526                         errors = 0;
 527                 else {
 528                         kill_line();
 529                         prompt(filename);
 530                 }
 531                 (void) fflush(stdout);
 532                 if (ttyin())
 533                         continue;
 534                 cmdptr = cmdbuf;
 535                 nlines = number();
 536                 BLANKS(cmdptr);
 537
 538                 if ((len = mbtowc(&wc, cmdptr, MB_CUR_MAX)) <= 0) {
 539                         wc = *cmdptr;
 540                         len = 1;
 541                 }
 542                 cmdptr += len;
 543                 switch (wc) {
 544                 case 'h':
 545                         CHECKEND();
 546                         help();
 547                         break;
 548                 case '\014': /* ^L */
 549                 case '.':       /* redisplay current window */
 550                         CHECKEND();
 551                         new_ss.first_line = old_ss.first_line;
 552                         new_ss.last_line = old_ss.last_line;
 553                         inwait = 0;
 554                         return (0);
 555                 case 'w':       /* set window size */
 556                 case 'z':
 557                         if (sign == -1) {
 558                                 BEEP();
 559                                 break;
 560                         }
 561                         CHECKEND();
 562                         if (nlines == 0)
 563                                 nlines = (off_t)window;
 564                         else
 565                         if (nlines > 1)
 566                                 window = (int)nlines;
 567                         else {
 568                                 BEEP();
 569                                 break;
 570                         }
 571                         new_ss.first_line = old_ss.last_line;
 572                         new_ss.last_line = new_ss.first_line +
 573                             (off_t)window - 1;
 574                         inwait = 0;
 575                         return (0);
 576                 case '\004': /* ^D */
 577                 case 'd':
 578                         CHECKEND();
 579                         if (sign == 0)
 580                                 sign = 1;
 581                         new_ss.last_line = old_ss.last_line +
 582                             (off_t)sign*window/2;
 583                         new_ss.first_line = new_ss.last_line -
 584                             (off_t)window + 1;
 585                         inwait = 0;
 586                         return (0);
 587                 case 's':
 588                         /*
 589                          * save input in filename.
 590                          * Check for filename, access, etc.
 591                          */
 592                         BLANKS(cmdptr);
 593                         if (!*cmdptr) {
 594                                 BEEP();
 595                                 break;
 596                         }
 597                         if (setjmp(restore) > 0) {
 598                                 BEEP();
 599                         } else {
 600                                 char outstr[PROMPTSIZE];
 601                                 if ((sf = fopen(cmdptr, "w")) == NULL) {
 602                                         error("cannot open save file");
 603                                         break;
 604                                 }
 605                                 kill_line();
 606                                 (void) sprintf(outstr, gettext(
 607                                     "saving file %s"), cmdptr);
 608                                 sopr(outstr, 1);
 609                                 (void) fflush(stdout);
 610                                 save_input(sf);
 611                                 error("saved");
 612                         }
 613                         (void) fclose(sf);
 614                         break;
 615                 case 'q':
 616                 case 'Q':
 617                         CHECKEND();
 618                         inwait = 0;
 619                         end_it();
 620                         /*FALLTHROUGH*/
 621
 622                 case 'f':       /* skip forward screenfuls */
 623                         CHECKEND();
 624                         if (sign == 0)
 625                                 sign++; /* skips are always relative */
 626                         if (nlines == 0)
 627                                 nlines++;
 628                         nlines = nlines * (window - 1);
 629                         if (sign == 1)
 630                                 new_ss.first_line = old_ss.last_line + nlines;
 631                         else
 632                                 new_ss.first_line = old_ss.first_line - nlines;
 633                         new_ss.last_line = new_ss.first_line +
 634                             (off_t)window - 1;
 635                         inwait = 0;
 636                         return (0);
 637                 case 'l':       /* get a line */
 638                         CHECKEND();
 639                         if (nlines == 0) {
 640                                 nlines++;
 641                                 if (sign == 0)
 642                                         sign = 1;
 643                         }
 644                         switch (sign) {
 645                         case 1:
 646                                 new_ss.last_line = old_ss.last_line + nlines;
 647                                 new_ss.first_line =
 648                                     new_ss.last_line - (off_t)window + 1;
 649                                 break;
 650                         case 0:  /* leave addressed line at top */
 651                                 new_ss.first_line = nlines;
 652                                 new_ss.last_line = nlines + (off_t)window - 1;
 653                                 break;
 654                         case -1:
 655                                 new_ss.first_line = old_ss.first_line - nlines;
 656                                 new_ss.last_line =
 657                                     new_ss.first_line + (off_t)window - 1;
 658                                 break;
 659                         }
 660                         inwait = 0;
 661                         return (0);
 662                 case '\0': /* \n or blank */
 663                         if (nlines == 0) {
 664                                 nlines++;
 665                                 if (sign == 0)
 666                                         sign = 1;
 667                         }
 668                         nlines = (nlines - 1) * (window - 1);
 669                         switch (sign) {
 670                         case 1:
 671                                 new_ss.first_line = old_ss.last_line + nlines;
 672                                 new_ss.last_line =
 673                                     new_ss.first_line + (off_t)window - 1;
 674                                 break;
 675                         case 0:
 676                                 new_ss.first_line = nlines + 1;
 677                                 new_ss.last_line = nlines + (off_t)window;
 678                                 /*
 679                                  * This if statement is to fix the obscure bug
 680                                  * where you have a file that has less lines
 681                                  * than a screen holds, and the user types '1',
 682                                  * expecting to have the 1st page (re)displayed.
 683                                  * If we didn't set the new last_line to
 684                                  * eofl_no-1, the screen() routine
 685                                  * would cause pg to exit.
 686                                  */
 687                                 if (new_ss.first_line == 1 &&
 688                                     new_ss.last_line >= eofl_no)
 689                                         new_ss.last_line = eofl_no - 1;
 690                                 break;
 691                         case -1:
 692                                 new_ss.last_line = old_ss.first_line - nlines;
 693                                 new_ss.first_line =
 694                                     new_ss.last_line - (off_t)window + 1;
 695                                 break;
 696                         }
 697                         inwait = 0;
 698                         return (0);
 699                 case 'n':       /* switch to next file in arglist */
 700                         CHECKEND();
 701                         if (sign == 0)
 702                                 sign = 1;
 703                         if (nlines == 0)
 704                                 nlines++;
 705                         if ((skip = skipf(sign *nlines)) == 0) {
 706                                 BEEP();
 707                                 break;
 708                         }
 709                         inwait = 0;
 710                         return (skip);
 711                 case 'p':       /* switch to previous file in arglist */
 712                         CHECKEND();
 713                         if (sign == 0)
 714                                 sign = 1;
 715                         if (nlines == 0)
 716                                 nlines++;
 717                         if ((skip = skipf(-sign * nlines)) == 0) {
 718                                 BEEP();
 719                                 break;
 720                         }
 721                         inwait = 0;
 722                         return (skip);
 723                 case '$':       /* go to end of file */
 724                         CHECKEND();
 725                         sign = 1;
 726                         while (find(1, (off_t)10000) != EOF)
 727                                 /* any large number will do */;
 728                         new_ss.last_line = eofl_no - 1;
 729                         new_ss.first_line = eofl_no - (off_t)window;
 730                         inwait = 0;
 731                         return (0);
 732                 case '/':       /* search forward for r.e. */
 733                 case '?':       /*   "  backwards */
 734                 case '^':       /* this ones a ? for regent100s */
 735                         if (sign < 0) {
 736                                 BEEP();
 737                                 break;
 738                         }
 739                         if (nlines == 0)
 740                                 nlines++;
 741                         cmdptr--;
 742                         cmdend = cmdptr + (strlen(cmdptr) - 1);
 743                         wc_e1 = -1;
 744                         wc_e = -1;
 745                         for (p = cmdptr; p <= cmdend; p += len) {
 746                                 wc_e1 = wc_e;
 747                                 if ((len = mbtowc(&wc_e, p, MB_CUR_MAX)) <= 0) {
 748                                         wc_e = *p;
 749                                         len = 1;
 750                                 }
 751                         }
 752
 753                         if (cmdend > cmdptr + 1) {
 754                                 if ((wc_e1 == *cmdptr) &&
 755                                     ((wc_e == L't') ||
 756                                     (wc_e == L'm') || (wc_e == L'b'))) {
 757                                         leave_search = wc_e;
 758                                         wc_e = wc_e1;
 759                                         cmdend--;
 760                                 }
 761                         }
 762                         if ((cmdptr < cmdend) && (wc_e == *cmdptr))
 763                                 *cmdend = '\0';
 764                         if (*cmdptr != '/')  /* signify back search by - */
 765                                 nlines = -nlines;
 766                         if (!search(++cmdptr, (off_t)nlines))
 767                                 break;
 768                         else {
 769                                 inwait = 0;
 770                                 return (0);
 771                         }
 772                 case '!':       /* shell escape */
 773                         if (rmode) {    /* restricted mode */
 774                                 (void) fprintf(stderr, gettext(
 775                                 "!command not allowed in restricted mode.\n"));
 776                                 break;
 777                         }
 778                         if (!hard_copy) { /* redisplay the command */
 779                                 (void) fputs(cmdbuf, stdout);
 780                                 (void) fputs("\n", stdout);
 781                         }
 782                         if ((id = fork()) < 0) {
 783                                 error("cannot fork, try again later");
 784                                 break;
 785                         }
 786                         if (id == (pid_t)0) {
 787                                 /*
 788                                  * if stdin is a pipe, need to close it so
 789                                  * that the terminal is really stdin for
 790                                  * the command
 791                                  */
 792                                 (void) fclose(stdin);
 793                                 (void) fclose(pg_stdin);
 794                                 (void) dup(fileno(stdout));
 795                                 (void) execl(shell, shell, "-c", cmdptr, 0);
 796                                 (void) perror("exec");
 797                                 exit(1);
 798                         }
 799                         (void) signal(SIGINT, SIG_IGN);
 800                         (void) signal(SIGQUIT, SIG_IGN);
 801                         if (catch_susp)
 802                                 (void) signal(SIGTSTP, SIG_DFL);
 803                         while (wait(NULL) != id) {
 804                                 if (errno == ECHILD)
 805                                         break;
 806                                 else
 807                                         errno = 0;
 808                         }
 809                         (void) fputs("!\n", stdout);
 810                         (void) fflush(stdout);
 811                         (void) signal(SIGINT, on_brk);
 812                         (void) signal(SIGQUIT, on_brk);
 813                         if (catch_susp)
 814                                 (void) signal(SIGTSTP, onsusp);
 815                         break;
 816                 default:
 817                         BEEP();
 818                         break;
 819                 }
 820         }
 821 }
 822
 823 static int
 824 number()
 825 {
 826         int i;
 827         char *p;
 828
 829         i = 0;
 830         sign = 0;
 831         p = cmdptr;
 832         BLANKS(p);
 833         if (*p == '+') {
 834                 p++;
 835                 sign = 1;
 836         }
 837         else
 838         if (*p == '-') {
 839                 p++;
 840                 sign = -1;
 841         }
 842         while (isdigit(*p))
 843                 i = i * 10 + *p++ - '0';
 844         cmdptr = p;
 845         return (i);
 846 }
 847
 848 static int
 849 ttyin(void)
 850 {
 851         char *sptr, *p;
 852         wchar_t ch;
 853         int slash = 0;
 854         int state = 0;
 855         int width, length;
 856         char multic[MB_LEN_MAX];
 857         int     len;
 858
 859         (void) fixterm();
 860         /* initialize state processing */
 861         (void) set_state(&state, ' ', (char *)0);
 862         sptr = cmdbuf;
 863         while (state != 10) {
 864                 if ((ch = readch()) < 0 || !iswascii(ch) && !iswprint(ch)) {
 865                         BEEP();
 866                         continue;
 867                 }
 868
 869                 if ((length = wctomb(multic, ch)) < 0)
 870                         length = 0;
 871                 multic[length] = 0;
 872
 873                 if (ch == '\n' && !slash)
 874                         break;
 875                 if (ch == erasechar() && !slash) {
 876                         if (sptr > cmdbuf) {
 877                                 char *oldp = cmdbuf;
 878                                 wchar_t wchar;
 879                                 p = cmdbuf;
 880                                 while (p  < sptr) {
 881                                         oldp = p;
 882                                         len = mbtowc(&wchar, p, MB_CUR_MAX);
 883                                         if (len <= 0) {
 884                                                 wchar = (unsigned char)*p;
 885                                                 len = 1;
 886                                         }
 887                                         p += len;
 888                                 }
 889                                 if ((width = wcwidth(wchar)) <= 0)
 890                                         /* ascii control character */
 891                                         width = 2;
 892                                 promptlen -= width;
 893                                 while (width--)
 894                                         (void) fputs("\b \b", stdout);
 895                                 sptr = oldp;
 896                         }
 897                         (void) set_state(&state, ch, sptr);
 898                         (void) fflush(stdout);
 899                         continue;
 900                 }
 901                 else
 902                 if (ch == killchar() && !slash) {
 903                         if (hard_copy)
 904                                 (void) putwchar(ch);
 905                         (void) resetterm();
 906                         return (1);
 907                 }
 908                 if (ch < ' ')
 909                         width = 2;
 910                 else
 911                         if ((width = wcwidth(ch)) <= 0)
 912                                 width = 0;
 913                 if (slash) {
 914                         slash = 0;
 915                         (void) fputs("\b \b", stdout);
 916                         sptr--;
 917                         promptlen--;
 918                 } else /* is there room to keep this character? */
 919                 if (sptr >= cmdbuf + sizeof (cmdbuf) ||
 920                     promptlen + width >= columns) {
 921                         BEEP();
 922                         continue;
 923                 }
 924                 else
 925                 if (ch == '\\')
 926                         slash++;
 927                 if (set_state(&state, ch, sptr) == 0) {
 928                         BEEP();
 929                         continue;
 930                 }
 931                 (void) strncpy(sptr, multic, (size_t)length);
 932                 sptr += length;
 933                 if (ch < ' ') {
 934                         ch += 0100;
 935                         multic[0] = '^';
 936                         multic[1] = ch;
 937                         length = 2;
 938                 }
 939                 p = multic;
 940                 while (length--)
 941                         (void) putchar(*p++);
 942                 promptlen += width;
 943                 (void) fflush(stdout);
 944         }
 945
 946         *sptr = '\0';
 947         kill_line();
 948         (void) fflush(stdout);
 949         (void) resetterm();
 950         return (0);
 951 }
 952
 953 static  int
 954 set_state(int *pstate, wchar_t c, char *pc)
 955 {
 956         static char *psign;
 957         static char *pnumber;
 958         static char *pcommand;
 959         static int slash;
 960
 961         if (*pstate == 0) {
 962                 psign = NULL;
 963                 pnumber = NULL;
 964                 pcommand = NULL;
 965                 *pstate = 1;
 966                 slash = 0;
 967                 return (1);
 968         }
 969         if (c == '\\' && !slash) {
 970                 slash++;
 971                 return (1);
 972         }
 973         if (c == erasechar() && !slash)
 974                 switch (*pstate) {
 975                 case 4:
 976                         if (pc > pcommand)
 977                                 return (1);
 978                         pcommand = NULL;
 979                         /*FALLTHROUGH*/
 980
 981                 case 3:
 982                         if (pnumber && pc > pnumber) {
 983                                 *pstate = 3;
 984                                 return (1);
 985                         }
 986                         pnumber = NULL;
 987                         /*FALLTHROUGH*/
 988
 989                 case 2:
 990                         if (psign && pc > psign) {
 991                                 *pstate = 2;
 992                                 return (1);
 993                         }
 994                         psign = NULL;
 995                         /*FALLTHROUGH*/
 996
 997                 case 1:
 998                         *pstate = 1;
 999                         return (1);
1000                 }
1001
1002         slash = 0;
1003         switch (*pstate) {
1004         case 1: /* before recieving anything interesting */
1005                 if (c == '\t' || (!nflag && c == ' '))
1006                         return (1);
1007                 if (c == '+' || c == '-') {
1008                         psign = pc;
1009                         *pstate = 2;
1010                         return (1);
1011                 }
1012                 /*FALLTHROUGH*/
1013
1014         case 2: /* recieved sign, waiting for digit */
1015                 if (iswascii(c) && isdigit(c)) {
1016                         pnumber = pc;
1017                         *pstate = 3;
1018                         return (1);
1019                 }
1020                 /*FALLTHROUGH*/
1021
1022         case 3: /* recieved digit, waiting for the rest of the number */
1023                 if (iswascii(c) && isdigit(c))
1024                         return (1);
1025                 if (iswascii(c) && pg_strchr("h\014.wz\004dqQfl np$", c)) {
1026                         pcommand = pc;
1027                         if (nflag)
1028                                 *pstate = 10;
1029                         else
1030                                 *pstate = 4;
1031                         return (1);
1032                 }
1033                 if (iswascii(c) && pg_strchr("s/^?!", c)) {
1034                         pcommand = pc;
1035                         *pstate = 4;
1036                         return (1);
1037                 }
1038                 return (0);
1039         case 4:
1040                 return (1);
1041         }
1042         return (0);
1043 }
1044
1045 static int
1046 readch(void)
1047 {
1048         return (fgetwc(pg_stdin));
1049 }
1050
1051 static void
1052 help(void)
1053 {
1054         if (clropt)
1055                 doclear();
1056
1057         (void) fputs(gettext(
1058 "-------------------------------------------------------\n"
1059 "  h                     help\n"
1060 "  q or Q                quit\n"
1061 "  <blank> or <newline>  next page\n"
1062 "  l                     next line\n"
1063 "  d or <^D>             display half a page more\n"
1064 "  . or <^L>             redisplay current page\n"
1065 "  f                     skip the next page forward\n"
1066 "  n                     next file\n"
1067 "  p                     previous file\n"
1068 "  $                     last page\n"
1069 "  w or z                set window size and display next page\n"
1070 "  s savefile            save current file in savefile\n"
1071 "  /pattern/             search forward for pattern\n"
1072 "  ?pattern? or\n"
1073 "  ^pattern^             search backward for pattern\n"
1074 "  !command              execute command\n"
1075 "\n"
1076 "Most commands can be preceeded by a number, as in:\n"
1077 "+1<newline> (next page); -1<newline> (previous page); 1<newline> (page 1).\n"
1078 "\n"
1079 "See the manual page for more detail.\n"
1080 "-------------------------------------------------------\n"),
1081             stdout);
1082 }
1083
1084 /*
1085  * Skip nskip files in the file list (from the command line). Nskip may be
1086  * negative.
1087  */
1088
1089 static int
1090 skipf(int nskip)
1091 {
1092         if (fnum + nskip < 0) {
1093                 nskip = -fnum;
1094                 if (nskip == 0)
1095                         error("No previous file");
1096         }
1097         else
1098         if (fnum + nskip > nfiles - 1) {
1099                 nskip = (nfiles - 1) - fnum;
1100                 if (nskip == 0)
1101                         error("No next file");
1102         }
1103         return (nskip);
1104 }
1105
1106 /*
1107  * Check whether the file named by fs is a file which the user may
1108  * access.  If it is, return the opened file. Otherwise return NULL.
1109  */
1110
1111 static FILE *
1112 checkf(char *fs)
1113 {
1114         struct stat stbuf;
1115         FILE *f;
1116         int fd;
1117         int f_was_opened;
1118
1119         pipe_in = 0;
1120         if (strcmp(fs, "-") == 0) {
1121                 if (tmp_fin == NULL)
1122                         f = stdin;
1123                 else {
1124                         rewind(tmp_fin);
1125                         f = tmp_fin;
1126                 }
1127                 f_was_opened = 0;
1128         } else {
1129                 if ((f = fopen(fs, "r")) == NULL) {
1130                         (void) fflush(stdout);
1131                         perror(fs);
1132                         return (NULL);
1133                 }
1134                 f_was_opened = 1;
1135         }
1136         if (fstat(fileno(f), &stbuf) == -1) {
1137                 if (f_was_opened)
1138                         (void) fclose(f);
1139                 (void) fflush(stdout);
1140                 perror(fs);
1141                 return (NULL);
1142         }
1143         if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {
1144                 if (f_was_opened)
1145                         (void) fclose(f);
1146                 (void) fprintf(stderr, "pg: ");
1147                 (void) fprintf(stderr, gettext("%s is a directory\n"), fs);
1148                 return (NULL);
1149         }
1150         if ((stbuf.st_mode & S_IFMT) == S_IFREG) {
1151                 if (f == stdin)         /* It may have been read from */
1152                         rewind(f);      /* already, and not reopened  */
1153         } else {
1154                 if (f != stdin) {
1155                         if (f_was_opened)
1156                                 (void) fclose(f);
1157                         (void) fprintf(stderr, "pg: ");
1158                         (void) fprintf(stderr, gettext(
1159                         "special files only handled as standard input\n"));
1160                         return (NULL);
1161                 } else {
1162                         if ((fd = mkstemp(tmp_name)) < 0) {
1163                                 (void) perror(tmp_name);
1164                                 return (NULL);
1165                         }
1166                         (void) close(fd);
1167                         if ((tmp_fou = fopen(tmp_name, "w")) == NULL) {
1168                                 (void) perror(tmp_name);
1169                                 return (NULL);
1170                         }
1171                         if ((tmp_fin = fopen(tmp_name, "r")) == NULL) {
1172                                 (void) perror(tmp_name);
1173                                 return (NULL);
1174                         }
1175                         pipe_in = 1;
1176                 }
1177         }
1178         lineset(BOF);
1179         return (f);
1180 }
1181
1182 static void
1183 copy_file(FILE *f, FILE *out)
1184 {
1185         int c;
1186
1187         while ((c = getc(f)) != EOF)
1188                 (void) putc(c, out);
1189
1190 }
1191
1192 static void
1193 re_error(int i)
1194 {
1195         int j;
1196         static struct messages {
1197                 char *message;
1198                 int number;
1199                 } re_errmsg[] = {
1200                 "Pattern not found",                            1,
1201                 "Range endpoint too large",                     11,
1202                 "Bad number",                                   16,
1203                 "`\\digit' out of range",                       25,
1204                 "No remembered search string",                  41,
1205                 "\\( \\) imbalance",                            42,
1206                 "Too many \\(",                                 43,
1207                 "More than two numbers given in \\{ \\}",       44,
1208                 "} expected after \\",                          45,
1209                 "First number exceeds second in \\{ \\}",       46,
1210                 "[] imbalance",                                 49,
1211                 "Regular expression overflow",                  50,
1212                 "Illegal byte sequence",                        67,
1213                 "Bad regular expression",                       0
1214                 };
1215
1216         for (j = 0; re_errmsg[j].number != 0; j++)
1217                 if (re_errmsg[j].number == i)
1218                         break;
1219         error(re_errmsg[j].message);
1220         longjmp(restore, 1);  /* restore to search() */
1221 }
1222
1223 /*
1224  * Search for nth ocurrence of regular expression contained in buf in the file
1225  *      negative n implies backward search
1226  *      n 'guaranteed' non-zero
1227  */
1228 static int
1229 search(char *buf, off_t n)
1230 {
1231         int direction;
1232         static char *expbuf;
1233         char *nexpbuf;
1234         int END_COND;
1235
1236         if (setjmp(restore) <= 0) {
1237                 nexpbuf = compile(buf, (char *)0, (char *)0);
1238                 if (regerrno) {
1239                         if (regerrno != 41 || expbuf == NULL)
1240                                 re_error(regerrno);
1241                 } else {
1242                         if (expbuf)
1243                                 free(expbuf);
1244                         expbuf = nexpbuf;
1245                 }
1246
1247                 if (n < 0) {    /* search back */
1248                         direction = -1;
1249                         (void) find(0, old_ss.first_line);
1250                         END_COND = BOF;
1251                 } else {
1252                         direction = 1;
1253                         (void) find(0, old_ss.last_line);
1254                         END_COND = EOF;
1255                 }
1256
1257                 while (find(1, direction) != END_COND) {
1258                         if (brk_hit)
1259                                 break;
1260                         if (step(Line, expbuf))
1261                                 if ((n -= direction) == 0) {
1262                                         switch (leave_search) {
1263                                         case 't':
1264                                                 new_ss.first_line =
1265                                                     find(1, (off_t)0);
1266                                                 new_ss.last_line =
1267                                                     new_ss.first_line +
1268                                                     (off_t)window
1269                                                     - 1;
1270                                                 break;
1271                                         case 'b':
1272                                                 new_ss.last_line =
1273                                                     find(1, (off_t)0);
1274                                                 new_ss.first_line =
1275                                                     new_ss.last_line -
1276                                                     (off_t)window
1277                                                     + 1;
1278                                                 break;
1279                                         case 'm':
1280                                                 new_ss.first_line =
1281                                                     find(1, (off_t)0) -
1282                                                     ((off_t)window - 1)/2;
1283                                                 new_ss.last_line =
1284                                                     new_ss.first_line +
1285                                                     (off_t)window
1286                                                     - 1;
1287                                                 break;
1288                                         }
1289                                         return (1);
1290                                 }
1291                 }
1292                 re_error(1); /* Pattern not found */
1293         }
1294         BEEP();
1295         return (0);
1296 }
1297
1298 /*
1299  *      find -- find line in file f, subject to certain constraints.
1300  *
1301  *      This is the reason for all the funny stuff with sign and nlines.
1302  *      We need to be able to differentiate between relative and abosolute
1303  *      address specifications.
1304  *
1305  *      So...there are basically three cases that this routine
1306  *      handles. Either line is zero, which  means there is to be
1307  *      no motion (because line numbers start at one), or
1308  *      how and line specify a number, or line itself is negative,
1309  *      which is the same as having how == -1 and line == abs(line).
1310  *
1311  *      Then, figure where exactly it is that we are going (an absolute
1312  *      line number). Find out if it is within what we have read,
1313  *      if so, go there without further ado. Otherwise, do some
1314  *      magic to get there, saving all the intervening lines,
1315  *      in case the user wants to see them some time later.
1316  *
1317  *      In any case, return the line number that we end up at.
1318  *      (This is used by search() and screen()). If we go past EOF,
1319  *      return EOF.
1320  *      This EOF will go away eventually, as pg is expanded to
1321  *      handle multiple files as one huge one. Then EOF will
1322  *      mean we have run off the file list.
1323  *      If the requested line number is too far back, return BOF.
1324  */
1325
1326 static off_t
1327 find(int how, off_t line)
1328 {
1329         /* no compacted memory yet */
1330         FILE *f = in_file;
1331         off_t where;
1332
1333         if (how == 0)
1334                 where = line;
1335         else
1336                 if (dot == zero - 1)
1337                         where = how * line;
1338                 else
1339                         where = how * line + dot->l_no;
1340
1341         /* now, where is either at, before, or after dol */
1342         /* most likely case is after, so do it first */
1343
1344         eoflag = 0;
1345         if (where >= dol->l_no) {
1346                 if (doliseof) {
1347                         dot = dol;
1348                         eoflag++;
1349                         return (EOF);
1350                 }
1351                 if (pipe_in)
1352                         in_file = f = stdin;
1353                 else
1354                         (void) fseeko(f, (off_t)dol->l_addr, SEEK_SET);
1355                 dot = dol - 1;
1356                 while ((nchars = getaline(f)) != EOF) {
1357                         dot++;
1358                         newdol(f);
1359                         if (where == dot->l_no || brk_hit)
1360                                 break;
1361                 }
1362                 if (nchars != EOF)
1363                         return (dot->l_no);
1364                 else { /* EOF */
1365                         dot = dol;
1366                         eoflag++;
1367                         doliseof++;
1368                         eofl_no = dol->l_no;
1369                         return (EOF);
1370                 }
1371         } else { /* where < dol->l_no */
1372                 if (pipe_in) {
1373                         (void) fflush(tmp_fou);
1374                         in_file = f = tmp_fin;
1375                 }
1376                 if (where < zero->l_no) {
1377                         (void) fseeko(f, (off_t)zero->l_addr, SEEK_SET);
1378                         dot = zero - 1;
1379                         return (BOF);
1380                 } else {
1381                         dot = zero + where - 1;
1382                         (void) fseeko(f, (off_t)dot->l_addr, SEEK_SET);
1383                         nchars = getaline(f);
1384                         return (dot->l_no);
1385                 }
1386         }
1387 }
1388
1389 static FILE *fileptr;
1390 static int (*rdchar)();
1391
1392 static int
1393 mrdchar()
1394 {
1395         return (rdchar(fileptr));
1396 }
1397
1398 /*
1399  * Get a logical line
1400  */
1401 static off_t
1402 getaline(FILE *f)
1403 {
1404         char    *p;
1405         int     column;
1406         static char multic[MB_LEN_MAX];
1407         static int savlength;
1408         wchar_t c;
1409         int length, width;
1410
1411         if (pipe_in && f == stdin)
1412                 rdchar = fgetputc;
1413         else
1414                 rdchar = (int (*)())fgetwc;
1415
1416         fileptr = f;
1417         /* copy overlap from previous call to getaline */
1418         if (savlength)
1419                 (void) strncpy(Line, multic, (size_t)savlength);
1420         for (column = 0, p = Line + savlength; ; ) {
1421                 if ((c = mrdchar()) <= 0) {
1422                         clearerr(f);
1423                         if (p > Line) { /* last line doesn't have '\n', */
1424                                 *p++ = '\n';
1425                                 *p = '\0';      /* print it any way */
1426                                 return (column);
1427                         }
1428                         return (EOF);
1429                 }
1430                 length = wctomb(multic, c);
1431                 if (length < 0) {
1432                         length = -length;
1433                         c = 0;
1434                 }
1435                 if ((width = wcwidth(c)) < 0)
1436                         width = 0;
1437                 if (column + width > columns && !fflag)
1438                         break;
1439
1440                 if (p + length > &Line[LINSIZ - 2] && c != '\n')
1441                         break;
1442                 (void) strncpy(p, multic, (size_t)length);
1443                 p += length;
1444                 column += width;
1445                 /* don't have any overlap here */
1446                 length = 0;
1447                 switch (c) {
1448                 case '\t': /* just a guess */
1449                         column = 1 + (column | 7);
1450                         break;
1451                 case '\b':
1452                         if (column > 0)
1453                                 column--;
1454                         break;
1455                 case '\r':
1456                         column = 0;
1457                         break;
1458                 }
1459                 if (c == '\n')
1460                         break;
1461                 if (column >= columns && !fflag)
1462                         break;
1463         }
1464         if (c != '\n') { /* We're stopping in the middle of the line */
1465                 if (column != columns || !auto_right_margin)
1466                         *p++ = '\n';    /* for the display */
1467                 /* save overlap for next call to getaline */
1468                 savlength = length;
1469                 if (savlength == 0) {
1470                         /*
1471                          * check if following byte is newline and get
1472                          * it if it is
1473                          */
1474                         c = fgetwc(f);
1475                         if (c == '\n') {
1476                                 /* gobble and copy (if necessary) newline */
1477                                 (void) ungetwc(c, f);
1478                                 (void) (*rdchar)(f);
1479                         } else if (c == EOF)
1480                                 clearerr(f);
1481                         else
1482                                 (void) ungetwc(c, f);
1483                 }
1484         } else
1485                 savlength = 0;
1486         *p = 0;
1487         return (column);
1488 }
1489
1490 static void
1491 save_input(FILE *f)
1492 {
1493         if (pipe_in) {
1494                 save_pipe();
1495                 in_file = tmp_fin;
1496                 pipe_in = 0;
1497         }
1498         (void) fseeko(in_file, (off_t)0, SEEK_SET);
1499         copy_file(in_file, f);
1500 }
1501
1502 static void
1503 save_pipe(void)
1504 {
1505         if (!doliseof)
1506                 while (fgetputc(stdin) != EOF)
1507                         if (brk_hit) {
1508                                 brk_hit = 0;
1509                                 error("Piped input only partially saved");
1510                                 break;
1511                         }
1512         (void) fclose(tmp_fou);
1513 }
1514
1515 /*
1516  * copy anything read from a pipe to tmp_fou
1517  */
1518 static int
1519 fgetputc(FILE *f)
1520 {
1521         int c;
1522
1523         if ((c = fgetwc(f)) != EOF)
1524                 (void) fputwc(c, tmp_fou);
1525         return (c);
1526 }
1527
1528 /*
1529  * initialize line memory
1530  */
1531 static void
1532 lineset(int how)
1533 {
1534         if (zero == NULL) {
1535                 nlall = 128;
1536                 zero = (LINE *) malloc(nlall * sizeof (LINE));
1537         }
1538         dol = contig = zero;
1539         zero->l_no = 1;
1540         zero->l_addr = 0l;
1541         if (how == BOF) {
1542                 dot = zero - 1;
1543                 eoflag = 0;
1544                 doliseof = 0;
1545                 eofl_no = -1;
1546         } else {
1547                 dot = dol;
1548                 eoflag = 1;
1549                 doliseof = 1;
1550                 eofl_no = 1;
1551         }
1552 }
1553
1554 /*
1555  *  add address of new 'dol'
1556  * assumes that f is currently at beginning of said line
1557  * updates dol
1558  */
1559 static void
1560 newdol(FILE *f)
1561 {
1562         int diff;
1563
1564         if ((dol - zero) + 1 >= nlall) {
1565                 LINE *ozero = zero;
1566
1567                 nlall += 512;
1568                 if ((zero = (LINE *)realloc((char *)zero,
1569                     (unsigned)(nlall * sizeof (LINE)))) == NULL) {
1570                         zero = ozero;
1571                         compact();
1572                 }
1573                 diff = (int)((int)zero - (int)ozero);
1574                 dot = (LINE *)((int)dot + diff);
1575                 dol = (LINE *)((int)dol + diff);
1576                 contig = (LINE *)((int)contig + diff);
1577         }
1578         dol++;
1579         if (!pipe_in)
1580                 dol->l_addr = (off_t)ftello(f);
1581         else {
1582                 (void) fflush(tmp_fou);
1583                 dol->l_addr = (off_t)ftello(tmp_fou);
1584         }
1585         dol->l_no = (dol-1)->l_no + 1;
1586 }
1587
1588 static void
1589 compact(void)
1590 {
1591         (void) perror("realloc");
1592         end_it();
1593
1594 }
1595
1596 static void
1597 terminit(void)  /* set up terminal dependencies from termlib */
1598 {
1599         int err_ret;
1600         struct termio ntty;
1601
1602         for (;;) {
1603                 pid_t my_tgid;
1604                 my_tgid = tcgetpgrp(1);
1605                 if (my_tgid == -1 || my_tgid == my_pgid)
1606                         break;
1607                 (void) kill(-my_pgid, SIGTTOU);
1608         }
1609
1610         if ((freopen("/dev/tty", "r+", stdout)) == NULL) {
1611                 (void) perror("open");
1612                 exit(1);
1613         }
1614         (void) ioctl(fileno(stdout), TCGETA, &otty);
1615         termflg = 1;
1616
1617         (void) setupterm(0, fileno(stdout), &err_ret);
1618         (void) ioctl(fileno(stdout), TCGETA, &ntty);
1619         ntty.c_lflag &= ~(ECHONL | ECHO | ICANON);
1620         ntty.c_cc[VMIN] = 1;
1621         ntty.c_cc[VTIME] = 1;
1622         (void) ioctl(fileno(stdout), TCSETAW, &ntty);
1623         pg_stdin = fdopen(dup(fileno(stdout)), "r");
1624         (void) saveterm();
1625         (void) resetterm();
1626         if (lines <= 0 || hard_copy) {
1627                 hard_copy = 1;
1628                 lines = 24;
1629         }
1630         if (columns <= 0)
1631                 columns = 80;
1632         if (clropt && !clear_screen)
1633                 clropt = 0;
1634         if ((shell = getenv("SHELL")) == NULL)
1635                         shell = "/usr/bin/sh";
1636 }
1637
1638 static void
1639 error(char *mess)
1640 {
1641         kill_line();
1642         sopr(gettext(mess), 1);
1643         prompt(NULL);
1644         errors++;
1645 }
1646
1647 static void
1648 prompt(char *filename)
1649 {
1650         char outstr[PROMPTSIZE+6];
1651         int pagenum;
1652         if (filename != NULL) {
1653                 /*
1654                  * TRANSLATION_NOTE
1655                  *      %s is a filename.
1656                  */
1657                 (void) sprintf(outstr, gettext("(Next file: %s)"), filename);
1658         } else {
1659                 if ((pagenum = (int)((new_ss.last_line-2)/(window-1)+1)) >
1660                     999999) {
1661                         pagenum = 999999;
1662                 }
1663                 (void) sprintf(outstr, promptstr, pagenum);
1664         }
1665         sopr(outstr, 1);
1666         (void) fflush(stdout);
1667 }
1668
1669 /*
1670  *  sopr puts out the message (please no \n's) surrounded by standout
1671  *  begins and ends
1672  */
1673
1674 static void
1675 sopr(char *m, int count)
1676 {
1677         wchar_t wc;
1678         int     len, n;
1679         char    *p;
1680
1681         if (count) {
1682                 p = m;
1683                 for (; *p; p += len) {
1684                         if ((len = mbtowc(&wc, p, MB_CUR_MAX)) <= 0) {
1685                                 len = 1;
1686                                 continue;
1687                         }
1688                         if ((n = wcwidth(wc)) > 0)
1689                                 promptlen += n;
1690                 }
1691         }
1692         if (soflag && enter_standout_mode && exit_standout_mode) {
1693                 (void) putp(enter_standout_mode);
1694                 (void) fputs(m, stdout);
1695                 (void) putp(exit_standout_mode);
1696         }
1697         else
1698                 (void) fputs(m, stdout);
1699 }
1700
1701 static void
1702 doclear(void)
1703 {
1704         if (clear_screen)
1705                 (void) putp(clear_screen);
1706         (void) putchar('\r');  /* this resets the terminal drivers character */
1707                         /* count in case it is trying to expand tabs  */
1708
1709 }
1710
1711 static void
1712 kill_line(void)
1713 {
1714         erase_line(0);
1715         if (!clr_eol) (void) putchar('\r');
1716
1717 }
1718
1719 /* erase from after col to end of prompt */
1720 static void
1721 erase_line(int col)
1722 {
1723
1724         if (promptlen == 0)
1725                 return;
1726         if (hard_copy)
1727                 (void) putchar('\n');
1728         else {
1729                 if (col == 0)
1730                         (void) putchar('\r');
1731                 if (clr_eol) {
1732                         (void) putp(clr_eol);
1733                         /* for the terminal driver again */
1734                         (void) putchar('\r');
1735                 }
1736                 else
1737                         for (col = promptlen - col; col > 0; col--)
1738                                 (void) putchar(' ');
1739         }
1740         promptlen = 0;
1741 }
1742
1743 /*
1744  * Come here if a quit or interrupt signal is received
1745  */
1746
1747 static void
1748 on_brk(int sno)
1749 {
1750         (void) signal(sno, on_brk);
1751         if (!inwait) {
1752                 BEEP();
1753                 brk_hit = 1;
1754         } else {
1755                 brk_hit = 0;
1756                 longjmp(restore, 1);
1757         }
1758 }
1759
1760 /*
1761  * Clean up terminal state and exit.
1762  */
1763
1764 void
1765 end_it(void)
1766 {
1767
1768         if (out_is_tty) {
1769                 kill_line();
1770                 (void) resetterm();
1771                 if (termflg)
1772                         (void) ioctl(fileno(stdout), TCSETAW, &otty);
1773         }
1774         if (tmp_fin)
1775                 (void) fclose(tmp_fin);
1776         if (tmp_fou)
1777                 (void) fclose(tmp_fou);
1778         if (tmp_fou || tmp_fin)
1779                 (void) unlink(tmp_name);
1780         exit(status);
1781 }
1782
1783 void
1784 onsusp(void)
1785 {
1786         int ttou_is_dfl;
1787
1788         /* ignore SIGTTOU so following resetterm and flush works */
1789         ttou_is_dfl = (signal(SIGTTOU, SIG_IGN) == SIG_DFL);
1790         (void) resetterm();
1791         (void) fflush(stdout);
1792         if (ttou_is_dfl)
1793                 (void) signal(SIGTTOU, SIG_DFL);
1794
1795         /* send SIGTSTP to stop this process group */
1796         (void) signal(SIGTSTP, SIG_DFL);
1797         (void) kill(-my_pgid, SIGTSTP);
1798
1799         /* continued - reset the terminal */
1800 #ifdef __STDC__
1801         (void) signal(SIGTSTP, (void (*)(int))onsusp);
1802 #else
1803         (void) signal(SIGTSTP, (void (*))onsusp);
1804 #endif
1805         (void) resetterm();
1806         if (inwait)
1807                 longjmp(restore, -1);
1808
1809 }
1810
1811 static char *
1812 pg_strchr(char *str, wchar_t c)
1813 {
1814         while (*str) {
1815                 if (c == *str)
1816                         return (str);
1817                 str++;
1818         }
1819         return (0);
1820 }
1821
1822 void
1823 usage(void)
1824 {
1825         (void) fprintf(stderr, gettext(
1826 "Usage: pg [-number] [-p string] [-cefnrs] [+line] [+/pattern/] files\n"));
1827         exit(1);
1828 }