![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to more.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd|
Return to more.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd |
1.1 ! root 1: #include <whoami.h> ! 2: #include <stdio.h> ! 3: #include <signal.h> ! 4: #include <sgtty.h> ! 5: #include <setjmp.h> ! 6: #include <sys/types.h> ! 7: #include <sys/dir.h> ! 8: #include <sys/stat.h> ! 9: ! 10: #ifdef CORY ! 11: #define MBIT RAW ! 12: #else ! 13: #include <ctype.h> ! 14: #define MBIT CBREAK ! 15: #endif ! 16: ! 17: #define TBUFSIZ 1024 ! 18: #define LINSIZ 256 ! 19: #define ctrl(letter) ('letter' & 077) ! 20: #define RUBOUT '\177' ! 21: #define ESC '\033' ! 22: #define QUIT '\034' ! 23: ! 24: struct sgttyb otty; ! 25: int fnum, no_intty, no_tty, slow_tty; ! 26: int dum_opt, dlines, onquit(), end_it(); ! 27: int stop_opt = 1; ! 28: int promptlen; ! 29: int startup = 1; ! 30: int firstf = 1; ! 31: int notell = 1; ! 32: int inwait, pause, errors; ! 33: int within; /* true if we are within a file, ! 34: false if we are between files */ ! 35: int hard, dumb, noscroll, hardtabs; ! 36: char **fnames; ! 37: int nfiles; ! 38: char *shell; ! 39: char ch; ! 40: jmp_buf restore; ! 41: char obuf[BUFSIZ]; /* stdout buffer */ ! 42: char Line[LINSIZ]; ! 43: int Lpp = 24; /* lines per page */ ! 44: char *Clear; /* clear screen */ ! 45: char *eraseln; /* erase line */ ! 46: char *Senter, *Sexit;/* enter and exit standout mode */ ! 47: char *tgetstr(); ! 48: int Mcol = 80; /* number of columns */ ! 49: int Wrap = 1; /* set if automargins */ ! 50: extern char PC; /* pad character */ ! 51: extern short ospeed; ! 52: ! 53: ! 54: main(argc, argv) ! 55: int argc; ! 56: char *argv[]; ! 57: { ! 58: register FILE *f; ! 59: register char *s; ! 60: register char *p; ! 61: register char ch; ! 62: register int left; ! 63: int prnames = 0; ! 64: int initopt = 0; ! 65: int srchopt = 0; ! 66: int initline; ! 67: char buf[TBUFSIZ]; ! 68: char clearbuf[100]; ! 69: char initbuf[80]; ! 70: char *clearptr; ! 71: char *getenv(); ! 72: FILE *checkf(); ! 73: ! 74: nfiles = argc; ! 75: fnames = argv; ! 76: /* Put terminal setup stuff in separate procedure ?? (From here...) */ ! 77: setbuf(stdout, obuf); ! 78: if (!(no_tty = gtty(1, &otty))) { ! 79: if (tgetent(buf, getenv("TERM")) <= 0) { ! 80: dumb++; ! 81: } ! 82: else { ! 83: if (((Lpp = tgetnum("li")) < 0) || tgetflag("hc")) { ! 84: hard++; /* Hard copy terminal */ ! 85: Lpp = 24; ! 86: } ! 87: if (!hard && tgetflag("ns")) ! 88: noscroll++; ! 89: if ((Mcol = tgetnum("co")) < 0) ! 90: Mcol = 80; ! 91: Wrap = tgetflag("am"); ! 92: clearptr = clearbuf; ! 93: eraseln = tgetstr("ce",&clearptr); ! 94: Clear = tgetstr("cl", &clearptr); ! 95: Senter = tgetstr("so", &clearptr); ! 96: Sexit = tgetstr("se", &clearptr); ! 97: PC = *tgetstr("pc", &clearptr); ! 98: } ! 99: if ((shell = getenv("SHELL")) == NULL) ! 100: shell = "/bin/sh"; ! 101: } ! 102: no_intty = gtty(0, &otty); ! 103: gtty(2, &otty); ! 104: ospeed = otty.sg_ospeed; ! 105: slow_tty = ospeed < B1200; ! 106: hardtabs = !(otty.sg_flags & XTABS); ! 107: if (!no_tty) { ! 108: otty.sg_flags &= ~ECHO; ! 109: if (MBIT == CBREAK || !slow_tty) ! 110: otty.sg_flags |= MBIT; ! 111: } ! 112: /* ... until here or so */ ! 113: while (--nfiles > 0) { ! 114: if ((ch = (*++fnames)[0]) == '-') { ! 115: for (s = fnames[0] + 1, dlines = 0; *s != '\0'; s++) ! 116: if (isdigit(*s)) ! 117: dlines = dlines*10 + *s - '0'; ! 118: else if (*s == 'd') ! 119: dum_opt = 1; ! 120: else if (*s == 'l') ! 121: stop_opt = 0; ! 122: } ! 123: else if (ch == '+') { ! 124: s = *fnames; ! 125: if (*++s == '/') { ! 126: srchopt++; ! 127: for (++s, p = initbuf; p < initbuf + 79 && *s != '\0';) ! 128: *p++ = *s++; ! 129: *p = '\0'; ! 130: } ! 131: else { ! 132: initopt++; ! 133: for (initline = 0; *s != '\0'; s++) ! 134: if (isdigit (*s)) ! 135: initline = initline*10 + *s -'0'; ! 136: --initline; ! 137: } ! 138: } ! 139: else break; ! 140: } ! 141: if (dlines == 0) ! 142: dlines = Lpp - 2; ! 143: left = dlines; ! 144: if (nfiles > 1) ! 145: prnames++; ! 146: if (!no_intty && nfiles == 0) { ! 147: fputs("Usage: ",stderr); ! 148: fputs(argv[0],stderr); ! 149: fputs(" [-dn] name1 name2 ...\n",stderr); ! 150: exit(1); ! 151: } ! 152: else ! 153: f = stdin; ! 154: if (!no_tty) { ! 155: signal(SIGQUIT, onquit); ! 156: signal(SIGINT, end_it); ! 157: stty (2, &otty); ! 158: } ! 159: if (no_intty) { ! 160: if (no_tty) ! 161: copy_file (stdin); ! 162: else { ! 163: if (srchopt) ! 164: search (initbuf, stdin, 1); ! 165: else if (initopt) ! 166: skiplns (initline, stdin); ! 167: screen (stdin, left); ! 168: } ! 169: end_it (); ! 170: } ! 171: ! 172: while (fnum < nfiles) { ! 173: if ((f = checkf (fnames[fnum])) != NULL) { ! 174: if (firstf) setjmp (restore); ! 175: if (firstf) { ! 176: firstf = 0; ! 177: if (srchopt) ! 178: search (initbuf, f, 1); ! 179: else if (initopt) ! 180: skiplns (initline, f); ! 181: } ! 182: else if (fnum < nfiles && !no_tty) { ! 183: setjmp (restore); ! 184: left = command (fnames[fnum], f); ! 185: } ! 186: if (left != 0) { ! 187: if (prnames) { ! 188: pr("::::::::::::::"); ! 189: if (promptlen > 14) ! 190: erase (14); ! 191: putchar ('\n'); ! 192: pr(fnames[fnum]); ! 193: pr("\n::::::::::::::\n"); ! 194: if (left > Lpp - 4) ! 195: left = Lpp - 4; ! 196: } ! 197: if (no_tty) ! 198: copy_file (f); ! 199: else { ! 200: within++; ! 201: screen(f, left); ! 202: within = 0; ! 203: } ! 204: } ! 205: setjmp (restore); ! 206: fflush(stdout); ! 207: fclose(f); ! 208: } ! 209: fnum++; ! 210: firstf = 0; ! 211: } ! 212: otty.sg_flags |= ECHO; ! 213: otty.sg_flags &= ~MBIT; ! 214: stty(2, &otty); ! 215: exit(0); ! 216: } ! 217: ! 218: /* ! 219: ** Check whether the file named by fs is an ASCII file which the user may ! 220: ** access. If it is, return the opened file. Otherwise return NULL. ! 221: */ ! 222: ! 223: FILE * ! 224: checkf (fs) ! 225: register char *fs; ! 226: { ! 227: #ifdef CORY ! 228: int space[3]; /* Why doesn't libretro have a V7 stat? */ ! 229: #endif ! 230: struct stat stbuf; ! 231: register FILE *f; ! 232: char c; ! 233: ! 234: if (stat (fs, &stbuf) == -1) { ! 235: fflush(stdout); ! 236: perror(fs); ! 237: return (NULL); ! 238: } ! 239: if (stbuf.st_mode & S_IFDIR) { ! 240: pr("\n*** "); ! 241: pr(fs); ! 242: pr(": directory ***\n\n"); ! 243: return (NULL); ! 244: } ! 245: if ((f=fopen(fs, "r")) == NULL) { ! 246: fflush(stdout); ! 247: perror(fs); ! 248: return (NULL); ! 249: } ! 250: c = getc(f); ! 251: ! 252: /* Try to see whether it is an ASCII file */ ! 253: ! 254: switch ((c | *f->_ptr << 8) & 0177777) { ! 255: case 0405: ! 256: case 0407: ! 257: case 0410: ! 258: case 0411: ! 259: case 0177545: ! 260: pr("\n******** "); ! 261: pr(fs); ! 262: pr(": Not a text file ********\n\n"); ! 263: fclose (f); ! 264: return (NULL); ! 265: default: ! 266: break; ! 267: } ! 268: if (c == '\f') { ! 269: c = 0; ! 270: doclear (); ! 271: } ! 272: ungetc (c, f); ! 273: return (f); ! 274: } ! 275: ! 276: /* ! 277: ** A real function, for the tputs routine in termlib ! 278: */ ! 279: ! 280: putch (ch) ! 281: register char ch; ! 282: { ! 283: putchar (ch); ! 284: } ! 285: ! 286: /* ! 287: ** Print out the contents of the file f, one screenful at a time. ! 288: */ ! 289: ! 290: #define STOP -10 ! 291: ! 292: screen (f, num_lines) ! 293: register FILE *f; ! 294: register int num_lines; ! 295: { ! 296: register int c; ! 297: int nchars; ! 298: ! 299: for (;;) { ! 300: while (num_lines > 0 && !pause) { ! 301: if ((nchars = getline (f)) == EOF) ! 302: return; ! 303: if (Senter && *Senter == ' ' && promptlen > 0) ! 304: erase (0); ! 305: pr (Line); ! 306: if (nchars < promptlen) ! 307: erase (nchars); /* erase () sets promptlen to 0 */ ! 308: else promptlen = 0; ! 309: if (nchars < Mcol) ! 310: putchar('\n'); ! 311: if (nchars == STOP) ! 312: break; ! 313: num_lines--; ! 314: } ! 315: fflush(stdout); ! 316: if ((c = getc(f)) == EOF) { ! 317: if (noscroll) ! 318: doclear(); ! 319: else ! 320: erase (0); ! 321: return; ! 322: } ! 323: ungetc (c, f); ! 324: setjmp (restore); ! 325: pause = 0; startup = 0; ! 326: if ((num_lines = command (NULL, f)) == 0) ! 327: return; ! 328: } ! 329: } ! 330: ! 331: /* ! 332: ** Come here if a quit signal is received ! 333: */ ! 334: ! 335: onquit() ! 336: { ! 337: signal(SIGQUIT, SIG_IGN); ! 338: if (!inwait) { ! 339: putchar ('\n'); ! 340: if (!startup) { ! 341: signal(SIGQUIT, onquit); ! 342: longjmp (restore, 1); ! 343: } ! 344: else ! 345: pause++; ! 346: } ! 347: else if (!dum_opt && notell) { ! 348: write (2, "[Use q or Q to quit]", 20); ! 349: promptlen += 20; ! 350: notell = 0; ! 351: } ! 352: signal(SIGQUIT, onquit); ! 353: } ! 354: ! 355: /* ! 356: ** Clean up terminal state and exit. Also come here if interrupt signal received ! 357: */ ! 358: ! 359: end_it () ! 360: { ! 361: ! 362: otty.sg_flags &= ~MBIT; ! 363: otty.sg_flags |= ECHO; ! 364: stty(2, &otty); ! 365: if (promptlen > 0) ! 366: kill_line (); ! 367: else ! 368: putchar ('\n'); ! 369: exit(0); ! 370: } ! 371: ! 372: copy_file(f) ! 373: register FILE *f; ! 374: { ! 375: register int c; ! 376: ! 377: while ((c = getc(f)) != EOF) ! 378: putchar(c); ! 379: } ! 380: ! 381: ! 382: printd (n) ! 383: register int n; ! 384: { ! 385: register int a; ! 386: ! 387: if (a = n/10) ! 388: printd(a); ! 389: putchar(n % 10 + '0'); ! 390: } ! 391: ! 392: static char bell = ctrl(G); ! 393: ! 394: strlen (s) ! 395: char *s; ! 396: { ! 397: register char *p; ! 398: ! 399: p = s; ! 400: while (*p++) ! 401: ; ! 402: return (p - s - 1); ! 403: } ! 404: ! 405: prompt (filename) ! 406: char *filename; ! 407: { ! 408: if (promptlen > 0) ! 409: kill_line (); ! 410: if (!hard) { ! 411: promptlen = 8; ! 412: if (Senter && Sexit) ! 413: tputs (Senter, 1, putch); ! 414: pr("--More--"); ! 415: if (filename != NULL) { ! 416: pr("(Next file: "); ! 417: pr(filename); ! 418: putchar(')'); ! 419: promptlen += 13 + strlen(filename); ! 420: } ! 421: if (dum_opt) { ! 422: pr("[Hit space to continue, Rubout to abort]"); ! 423: promptlen += 40; ! 424: } ! 425: if (Senter && Sexit) ! 426: tputs (Sexit, 1, putch); ! 427: fflush(stdout); ! 428: } ! 429: else ! 430: write (2, &bell, 1); ! 431: inwait++; ! 432: } ! 433: ! 434: /* ! 435: ** Get a logical line ! 436: */ ! 437: ! 438: getline(f) ! 439: register FILE *f; ! 440: { ! 441: register char c; ! 442: register char *p; ! 443: register int column; ! 444: register int i; ! 445: static int colflg; ! 446: ! 447: p = Line; ! 448: i = column = 0; ! 449: c = getc (f); ! 450: if (colflg && c == '\n') c = getc (f); ! 451: for (i = 1; i < LINSIZ; i++) { ! 452: if (c == EOF) { ! 453: if (p > Line) { ! 454: *p = '\0'; ! 455: return (column); ! 456: } ! 457: return (EOF); ! 458: } ! 459: if (c == '\n') ! 460: break; ! 461: *p++ = c; ! 462: if (c == '\t') ! 463: if (hardtabs && column < promptlen && !hard) { ! 464: if (eraseln && !dumb) { ! 465: tputs (eraseln, 1, putch); ! 466: promptlen = 0; ! 467: } ! 468: else { ! 469: for (--p; column & 7; column++) ! 470: *p++ = ' '; ! 471: if (column >= promptlen) promptlen = 0; ! 472: } ! 473: } ! 474: else ! 475: column = 1 + (column | 7); ! 476: else if (c == '\b') ! 477: column--; ! 478: else if (c == '\r') ! 479: column = 0; ! 480: else if (c == '\f' && stop_opt) { ! 481: p[-1] = '^'; ! 482: *p++ = 'L'; ! 483: break; ! 484: } ! 485: else if (c == EOF) ! 486: return (column); ! 487: else if (c >= ' ') ! 488: column++; ! 489: if (column >= Mcol) break; ! 490: c = getc (f); ! 491: } ! 492: if (Mcol > 0 && column >= Mcol) { ! 493: if (!Wrap) { ! 494: *p++ = '\n'; ! 495: i++; ! 496: } ! 497: } ! 498: colflg = (column == Mcol) || c == '\f'; ! 499: *p = 0; ! 500: if (c == '\f' && stop_opt) ! 501: return (STOP); ! 502: return (column); ! 503: } ! 504: ! 505: /* ! 506: ** Erase the rest of the prompt, assuming we are starting column col. ! 507: */ ! 508: ! 509: erase (col) ! 510: register int col; ! 511: { ! 512: ! 513: if (hard || promptlen == 0) ! 514: return; ! 515: if (col == 0) ! 516: putchar ('\r'); ! 517: if (!dumb && eraseln) ! 518: tputs (eraseln, 1, putch); ! 519: else ! 520: for (col = promptlen - col; col > 0; col--) ! 521: putchar (' '); ! 522: promptlen = 0; ! 523: } ! 524: ! 525: /* ! 526: ** Erase the current line entirely ! 527: */ ! 528: ! 529: kill_line () ! 530: { ! 531: erase (0); ! 532: if (!eraseln || dumb) putchar ('\r'); ! 533: } ! 534: ! 535: /* ! 536: ** Print string ! 537: */ ! 538: ! 539: pr(s1) ! 540: char *s1; ! 541: { ! 542: register char *s; ! 543: register char c; ! 544: ! 545: for (s = s1; c = *s++; ) ! 546: putchar(c); ! 547: } ! 548: ! 549: /* ! 550: ** Clear the screen ! 551: */ ! 552: ! 553: doclear() ! 554: { ! 555: if (Clear && Lpp > 0) ! 556: tputs(Clear, 1, putch); ! 557: } ! 558: ! 559: ! 560: /* ! 561: ** Read a command and do it. A command consists of an optional integer ! 562: ** argument followed by the command character. Return the number of lines ! 563: ** to display in the next screenful. If there is nothing more to display ! 564: ** in the current file, zero is returned. ! 565: */ ! 566: ! 567: command (filename, f) ! 568: char *filename; ! 569: register FILE *f; ! 570: { ! 571: register int nlines; ! 572: register int retval; ! 573: register char c; ! 574: int id, done; ! 575: char comchar, cmdbuf[80], *p; ! 576: ! 577: #define ret(val) retval=val;done++;break ! 578: ! 579: done = 0; ! 580: if (!errors) ! 581: prompt (filename); ! 582: else ! 583: errors = 0; ! 584: if (MBIT == RAW && slow_tty) { ! 585: otty.sg_flags |= MBIT; ! 586: stty(2, &otty); ! 587: } ! 588: for (;;) { ! 589: nlines = number (&comchar); ! 590: switch (comchar) { ! 591: case ' ': ! 592: case 'z': ! 593: if (nlines == 0) nlines = dlines; ! 594: else if (comchar == 'z') dlines = nlines; ! 595: ret (nlines); ! 596: case 'd': ! 597: case ctrl(D): ! 598: ret (11); ! 599: case RUBOUT: ! 600: case 'q': ! 601: case 'Q': ! 602: end_it (); ! 603: case 's': ! 604: case 'f': ! 605: if (nlines == 0) nlines++; ! 606: if (comchar == 'f') ! 607: nlines *= dlines; ! 608: putchar ('\r'); ! 609: erase (0); ! 610: pr("\n...skipping "); ! 611: printd(nlines); ! 612: pr(" line"); ! 613: if (nlines > 1) ! 614: pr("s\n\n"); ! 615: else ! 616: pr("\n\n"); ! 617: while (nlines > 0) { ! 618: while ((c = getc (f)) != '\n') ! 619: if (c == EOF) { ! 620: retval = 0; ! 621: done++; ! 622: goto endsw; ! 623: } ! 624: nlines--; ! 625: } ! 626: ret (dlines); ! 627: break; ! 628: case '\n': ! 629: ret (1); ! 630: case 'n': ! 631: if (nlines == 0) ! 632: nlines++; ! 633: putchar ('\r'); ! 634: erase (0); ! 635: skipf (nlines); ! 636: ret (0); ! 637: case 'p': ! 638: if (no_intty) { ! 639: write (2, &bell, 1); ! 640: break; ! 641: } ! 642: putchar ('\r'); ! 643: erase (0); ! 644: if (nlines == 0) ! 645: nlines++; ! 646: skipf (-nlines); ! 647: ret (0); ! 648: case '/': ! 649: kill_line (); ! 650: pr ("/"); ! 651: promptlen = 1; ! 652: fflush (stdout); ! 653: ttyin (cmdbuf, 78, '/'); ! 654: if (nlines == 0) nlines++; ! 655: write (2, "\r", 1); ! 656: search (cmdbuf, f, nlines); ! 657: ret (dlines); ! 658: case '!': ! 659: kill_line (); ! 660: pr ("!"); ! 661: promptlen = 1; ! 662: fflush (stdout); ! 663: ttyin (cmdbuf, 78, '!'); ! 664: write (2, "\n", 1); ! 665: promptlen = 0; ! 666: otty.sg_flags |= ECHO; ! 667: otty.sg_flags &= ~MBIT; ! 668: stty(2, &otty); ! 669: while ((id = fork ()) < 0) ! 670: ; ! 671: if (id == 0) { ! 672: execl (shell, shell, "-c", cmdbuf, 0); ! 673: write (2, "exec failed\n", 12); ! 674: exit (1); ! 675: } ! 676: signal (SIGINT, SIG_IGN); ! 677: signal (SIGQUIT, SIG_IGN); ! 678: wait (0); ! 679: signal (SIGINT, end_it); ! 680: signal (SIGQUIT, onquit); ! 681: otty.sg_flags |= MBIT; ! 682: otty.sg_flags &= ~ECHO; ! 683: stty(2, &otty); ! 684: pr ("----------\n(continue)\n"); ! 685: fflush (stdout); ! 686: break; ! 687: default: ! 688: write (2, &bell, 1); ! 689: break; ! 690: } ! 691: if (done) break; ! 692: } ! 693: putchar ('\r'); ! 694: endsw: ! 695: inwait = 0; ! 696: notell++; ! 697: if (MBIT == RAW && slow_tty) { ! 698: otty.sg_flags &= ~MBIT; ! 699: stty(2, &otty); ! 700: } ! 701: return (retval); ! 702: } ! 703: ! 704: char ch; ! 705: ! 706: /* ! 707: ** Read a decimal number from the terminal. Set cmd to the non-digit which ! 708: ** terminates the number. ! 709: */ ! 710: ! 711: number(cmd) ! 712: char *cmd; ! 713: { ! 714: register int i; ! 715: ! 716: i = 0; ch = otty.sg_kill; ! 717: for (;;) { ! 718: read (2, &ch, 1); ! 719: if (ch >= '0' && ch <= '9') ! 720: i = i*10 + ch - '0'; ! 721: else if (ch == otty.sg_kill) ! 722: i = 0; ! 723: else { ! 724: *cmd = ch; ! 725: break; ! 726: } ! 727: } ! 728: return (i); ! 729: } ! 730: ! 731: /* ! 732: ** Skip n lines in the file f ! 733: */ ! 734: ! 735: skiplns (n, f) ! 736: register int n; ! 737: register FILE *f; ! 738: { ! 739: register char c; ! 740: ! 741: while (n > 0) { ! 742: while ((c = getc (f)) != '\n') ! 743: if (c == EOF) ! 744: return; ! 745: n--; ! 746: } ! 747: } ! 748: ! 749: /* ! 750: ** Skip nskip files in the file list (from the command line). Nskip may be ! 751: ** negative. ! 752: */ ! 753: ! 754: skipf (nskip) ! 755: register int nskip; ! 756: { ! 757: if (nskip == 0) return; ! 758: if (nskip > 0) { ! 759: if (fnum > nfiles - 1) ! 760: end_it (); ! 761: } ! 762: else if (within) ! 763: ++fnum; ! 764: fnum += nskip; ! 765: if (fnum < 0) ! 766: fnum = 0; ! 767: else if (fnum > nfiles - 1) ! 768: fnum = nfiles -1; ! 769: pr ("\n...Skipping "); ! 770: pr (nskip > 0 ? "to file " : "back to file "); ! 771: pr (fnames[fnum]); ! 772: pr ("\n\n"); ! 773: --fnum; ! 774: } ! 775: ! 776: readch () ! 777: { ! 778: char ch; ! 779: ! 780: read (2, &ch, 1); ! 781: return (ch); ! 782: } ! 783: ! 784: static char BS = '\b'; ! 785: static char CARAT = '^'; ! 786: ! 787: ttyin (buf, nmax, pchar) ! 788: char buf[]; ! 789: register int nmax; ! 790: char pchar; ! 791: { ! 792: register char *sptr; ! 793: register char ch; ! 794: register int slash = 0; ! 795: int maxlen; ! 796: char cbuf; ! 797: ! 798: sptr = buf; ! 799: maxlen = 0; ! 800: while (sptr - buf < nmax) { ! 801: if (promptlen > maxlen) maxlen = promptlen; ! 802: ch = readch (); ! 803: if (ch == '\\') { ! 804: slash++; ! 805: } ! 806: else if (ch == otty.sg_erase && !slash) { ! 807: if (sptr > buf) { ! 808: --promptlen; ! 809: write (2, &BS, 1); ! 810: --sptr; ! 811: if (*sptr < ' ' && *sptr != '\n') { ! 812: --promptlen; ! 813: write (2, &BS, 1); ! 814: } ! 815: continue; ! 816: } ! 817: else { ! 818: if (!eraseln) promptlen = maxlen; ! 819: longjmp (restore, 1); ! 820: } ! 821: } ! 822: else if (ch == otty.sg_kill && !slash) { ! 823: if (hard) ! 824: pr (" XXX\n"); ! 825: else { ! 826: putchar ('\r'); ! 827: putchar (pchar); ! 828: if (eraseln) ! 829: erase (1); ! 830: promptlen = 1; ! 831: sptr = buf; ! 832: } ! 833: fflush (stdout); ! 834: continue; ! 835: } ! 836: if (slash && (ch == otty.sg_kill || ch == otty.sg_erase)) { ! 837: write (2, &BS, 1); ! 838: --sptr; ! 839: } ! 840: if (ch != '\\') ! 841: slash = 0; ! 842: *sptr++ = ch; ! 843: if (ch < ' ' && ch != '\n' && ch != ESC) { ! 844: ch += 0100; ! 845: write (2, &CARAT, 1); ! 846: promptlen++; ! 847: } ! 848: cbuf = ch; ! 849: if (ch != '\n' && ch != ESC) { ! 850: write (2, &cbuf, 1); ! 851: promptlen++; ! 852: } ! 853: else break; ! 854: } ! 855: *--sptr = '\0'; ! 856: if (!eraseln) promptlen = maxlen; ! 857: if (sptr - buf >= nmax - 1) ! 858: error ("Line too long"); ! 859: } ! 860: ! 861: /* ! 862: ** Search for nth ocurrence of regular expression contained in buf in the file ! 863: */ ! 864: ! 865: search (buf, file, n) ! 866: char buf[]; ! 867: FILE *file; ! 868: register int n; ! 869: { ! 870: long startline = ftell (file); ! 871: register long line1 = startline; ! 872: register long line2 = startline; ! 873: register long line3 = startline; ! 874: register int lncount; ! 875: ! 876: lncount = 0; ! 877: compile (buf); ! 878: while (!feof (file)) { ! 879: line3 = line2; ! 880: line2 = line1; ! 881: line1 = ftell (file); ! 882: rdline (file); ! 883: lncount++; ! 884: if (execute (Line)) ! 885: if (--n == 0) { ! 886: if (lncount > 3 || (lncount > 1 && no_intty)) ! 887: pr ("\n...skipping\n"); ! 888: if (!no_intty) ! 889: fseek (file, line3, 0); ! 890: else { ! 891: kill_line (); ! 892: pr (Line); ! 893: putchar ('\n'); ! 894: } ! 895: break; ! 896: } ! 897: } ! 898: if (feof (file)) { ! 899: if (!no_intty) { ! 900: #ifdef CORY ! 901: file->_flag &= ~_IOEOF; /* why doesn't fseek do this ??!!??! */ ! 902: #endif ! 903: fseek (file, startline, 0); ! 904: } ! 905: else { ! 906: pr ("\nPattern not found\n"); ! 907: end_it (); ! 908: } ! 909: error ("Pattern not found"); ! 910: } ! 911: } ! 912: ! 913: /* ! 914: * The following are adapted from the editor ! 915: */ ! 916: ! 917: /* ! 918: * Internal form of regular expressions. ! 919: */ ! 920: #define CBRA 1 /* left \( bracket */ ! 921: #define CCHR 2 /* a particular character */ ! 922: #define CDOT 4 /* any char (.) */ ! 923: #define CCL 6 /* begin class ([) */ ! 924: #define NCCL 8 /* begin not class ([^) */ ! 925: #define CDOL 10 /* end of line ($) */ ! 926: #define CEOF 11 /* end of pattern */ ! 927: #define CKET 12 /* right \) bracket */ ! 928: #define CBACK 14 /* repeat previous match (\1, etc on lhs) */ ! 929: ! 930: #define STAR 01 /* or'ed with some symbols to indicate * suffix */ ! 931: ! 932: #define NBRA 5 /* max # of \( \) pairs */ ! 933: ! 934: char expbuf[BUFSIZ]; ! 935: char *braslist[NBRA]; ! 936: char *braelist[NBRA]; ! 937: int nbra; ! 938: int circfl; ! 939: char *loc1; ! 940: char *loc2; ! 941: char *locs; ! 942: ! 943: ! 944: /* ! 945: * compile: convert typed in regular expression into internal form. ! 946: * eof is the char that delimits the r.e. ! 947: * General structure of compiled r.e. in expbuf: A sequence of codes ! 948: * from #defines above (CCHR, CDOT, etc). Some of these take arguments ! 949: * which follow in line (e.g. CCHR is followed by the particular character ! 950: * it is required to match.) CEOF terminates the r.e. ! 951: */ ! 952: compile(inbuf) ! 953: char inbuf[]; ! 954: { ! 955: register char c; ! 956: register char *ep; ! 957: register char *bp = inbuf; ! 958: char *lastep; ! 959: char bracket[NBRA], *bracketp; ! 960: int cclcnt; ! 961: ! 962: /* comerr: compilation error. Don't leave half baked r.e. around. */ ! 963: #define comerr(msg) {expbuf[0] = 0; nbra = 0; error(msg); } ! 964: ep = expbuf; ! 965: bracketp = bracket; ! 966: if ((c = *bp++) == '\0') { ! 967: /* null r.e.: just re-use last r.e., which is still there */ ! 968: if (*ep==0) ! 969: error("No previous regular expression"); ! 970: return; ! 971: } ! 972: nbra = 0; ! 973: /* circfl: true if have ^ (anchored search). */ ! 974: circfl = 0; ! 975: if (c == '^') { ! 976: c = *bp++; ! 977: circfl++; ! 978: } ! 979: lastep = 0; ! 980: --bp; ! 981: for (;;) { /* for each character in the r.e. */ ! 982: if (ep >= &expbuf[BUFSIZ]) ! 983: comerr("r.e. too long"); ! 984: c = *bp++; ! 985: if (c == '\0') { ! 986: /* Hit trailing delim: clean up and quit */ ! 987: if (bracketp != bracket) ! 988: comerr("unmatched \\("); ! 989: *ep++ = CEOF; ! 990: *ep++ = 0; ! 991: return; ! 992: } ! 993: if (c!='*') ! 994: lastep = ep; ! 995: switch (c) { ! 996: ! 997: case '\\': ! 998: if ((c = *bp++)=='(') { ! 999: /* \(: start of subexpression */ ! 1000: if (nbra >= NBRA) ! 1001: comerr("too many \\(\\) pairs"); ! 1002: *bracketp++ = nbra; ! 1003: *ep++ = CBRA; ! 1004: *ep++ = nbra++; ! 1005: continue; ! 1006: } ! 1007: if (c == ')') { ! 1008: /* \): end of sub exp */ ! 1009: if (bracketp <= bracket) ! 1010: comerr("unmatched \\)"); ! 1011: *ep++ = CKET; ! 1012: *ep++ = *--bracketp; ! 1013: continue; ! 1014: } ! 1015: if (c>='1' && c<'1'+NBRA) { ! 1016: /* \1, \2, ...: rematch previous subexp */ ! 1017: *ep++ = CBACK; ! 1018: *ep++ = c-'1'; ! 1019: continue; ! 1020: } ! 1021: /* Otherwise just force that char, not specially */ ! 1022: *ep++ = CCHR; ! 1023: if (c=='\n') ! 1024: /* Newlines can't possibly be in lines */ ! 1025: comerr("multi line r.e. not allowed"); ! 1026: *ep++ = c; ! 1027: continue; ! 1028: ! 1029: case '.': ! 1030: /* .: match any character */ ! 1031: *ep++ = CDOT; ! 1032: continue; ! 1033: ! 1034: case '*': ! 1035: /* *: Repeat last char indefinitely */ ! 1036: if (lastep==0 || *lastep==CBRA || *lastep==CKET) ! 1037: /* Not that smart, so treat * as nonspecial */ ! 1038: goto defchar; ! 1039: *lastep |= STAR; ! 1040: continue; ! 1041: ! 1042: case '$': ! 1043: /* $: match end of line */ ! 1044: if (*bp != '\0') ! 1045: /* $ only special at end of r.e. */ ! 1046: goto defchar; ! 1047: *ep++ = CDOL; ! 1048: continue; ! 1049: ! 1050: case '[': ! 1051: /* ! 1052: * [...]: any of chars enclosed in brackets. ! 1053: * Compiled form: CCL or NCCL, # of possible chars, ! 1054: * then each char. -'s are expanded. ! 1055: */ ! 1056: *ep++ = CCL; ! 1057: *ep++ = 0; ! 1058: cclcnt = 1; ! 1059: if ((c = *bp++) == '^') { ! 1060: /* [^...]: reverse sense of match */ ! 1061: c = *bp++; ! 1062: ep[-2] = NCCL; ! 1063: } ! 1064: do { /* for each char in brackets */ ! 1065: if (c=='\n') ! 1066: comerr("missing ]"); ! 1067: if (c == '-' && ep[-1] != 0) { ! 1068: /* form ...a-z... but [- not special */ ! 1069: if ((c = *bp++) == ']') { ! 1070: /* -] not special either */ ! 1071: *ep++ = '-'; ! 1072: cclcnt++; ! 1073: break; ! 1074: } ! 1075: while (ep[-1]<c) { ! 1076: /* insert all chars between */ ! 1077: *ep = ep[-1]+1; ! 1078: ep++; ! 1079: cclcnt++; ! 1080: if (ep>=&expbuf[BUFSIZ]) ! 1081: comerr("Too long"); ! 1082: } ! 1083: } ! 1084: *ep++ = c; ! 1085: cclcnt++; ! 1086: if (ep >= &expbuf[BUFSIZ]) ! 1087: comerr("Too long"); ! 1088: } while ((c = *bp++) != ']'); ! 1089: lastep[1] = cclcnt; /* backpatch count */ ! 1090: continue; ! 1091: ! 1092: defchar: ! 1093: default: ! 1094: /* ! 1095: * An ordinary char or one treated as ordinary. ! 1096: * Store CCHR followed by that char, rather than ! 1097: * just the char. This causes most r.e.'s to take ! 1098: * up about twice the space you would expect. ! 1099: * On the other hand, it makes r.e.'s beautifully ! 1100: * portable, even though the codes could be real ! 1101: * characters. ! 1102: */ ! 1103: *ep++ = CCHR; ! 1104: *ep++ = c; ! 1105: } ! 1106: } ! 1107: } ! 1108: ! 1109: /* ! 1110: * execute: look for the compiled r.e. on line addr. ! 1111: * gf is 0 if this is the first time on this line, otherwise nonzero. ! 1112: * If not first, start looking at locs, otherwise at beg of linebuf. ! 1113: * loc1 and loc2 are set to the ends of the pattern found, if any. ! 1114: * 1 is returned if successful, otherwise 0. ! 1115: */ ! 1116: execute(lptr) ! 1117: char *lptr; ! 1118: { ! 1119: register char *p1, *p2; ! 1120: register int c; ! 1121: ! 1122: for (c=0; c<NBRA; c++) { ! 1123: braslist[c] = 0; ! 1124: braelist[c] = 0; ! 1125: } ! 1126: p1 = lptr; ! 1127: p2 = expbuf; ! 1128: if (circfl) { ! 1129: /* anchored search (^): just try one advance. */ ! 1130: loc1 = p1; ! 1131: return(advance(p1, p2)); ! 1132: } ! 1133: /* fast check for first character */ ! 1134: if (*p2==CCHR) { ! 1135: c = p2[1]; ! 1136: do { ! 1137: if (*p1!=c) ! 1138: continue; ! 1139: if (advance(p1, p2)) { ! 1140: loc1 = p1; ! 1141: return(1); ! 1142: } ! 1143: } while (*p1++); ! 1144: return(0); ! 1145: } ! 1146: /* regular algorithm, try advance starting at each char position. */ ! 1147: do { ! 1148: if (advance(p1, p2)) { ! 1149: loc1 = p1; ! 1150: return(1); ! 1151: } ! 1152: } while (*p1++); ! 1153: return(0); ! 1154: } ! 1155: ! 1156: /* ! 1157: * advance: does an anchored search for expression starting at ep, ! 1158: * looking in line starting at lp. Returns 1 if matches, else 0. ! 1159: * If found, loc2 is set to end of pattern. ! 1160: */ ! 1161: advance(lp, ep) ! 1162: register char *ep, *lp; ! 1163: { ! 1164: register char *curlp; ! 1165: int i; ! 1166: ! 1167: for (;;) switch (*ep++) { /* for each code in r.e., look at it..*/ ! 1168: ! 1169: case CCHR: ! 1170: if (*ep++ == *lp++) ! 1171: continue; ! 1172: return(0); ! 1173: ! 1174: case CDOT: ! 1175: if (*lp++) ! 1176: continue; ! 1177: return(0); ! 1178: ! 1179: case CDOL: ! 1180: if (*lp==0) ! 1181: continue; ! 1182: return(0); ! 1183: ! 1184: case CEOF: ! 1185: loc2 = lp; ! 1186: return(1); ! 1187: ! 1188: case CCL: ! 1189: if (cclass(ep, *lp++, 1)) { ! 1190: ep += *ep; ! 1191: continue; ! 1192: } ! 1193: return(0); ! 1194: ! 1195: case NCCL: ! 1196: if (cclass(ep, *lp++, 0)) { ! 1197: ep += *ep; ! 1198: continue; ! 1199: } ! 1200: return(0); ! 1201: ! 1202: case CBRA: ! 1203: braslist[*ep++] = lp; ! 1204: continue; ! 1205: ! 1206: case CKET: ! 1207: braelist[*ep++] = lp; ! 1208: continue; ! 1209: ! 1210: case CBACK: ! 1211: if (braelist[i = *ep++]==0) ! 1212: error("bad back reference"); ! 1213: if (backref(i, lp)) { ! 1214: lp += braelist[i] - braslist[i]; ! 1215: continue; ! 1216: } ! 1217: return(0); ! 1218: ! 1219: case CBACK|STAR: ! 1220: if (braelist[i = *ep++] == 0) ! 1221: error("bad back reference"); ! 1222: curlp = lp; ! 1223: while (backref(i, lp)) ! 1224: lp += braelist[i] - braslist[i]; ! 1225: while (lp >= curlp) { ! 1226: if (advance(lp, ep)) ! 1227: return(1); ! 1228: lp -= braelist[i] - braslist[i]; ! 1229: } ! 1230: continue; ! 1231: ! 1232: case CDOT|STAR: ! 1233: curlp = lp; ! 1234: while (*lp++) ! 1235: ; ! 1236: goto star; ! 1237: ! 1238: case CCHR|STAR: ! 1239: curlp = lp; ! 1240: while (*lp++ == *ep) ! 1241: ; ! 1242: ep++; ! 1243: goto star; ! 1244: ! 1245: case CCL|STAR: ! 1246: case NCCL|STAR: ! 1247: curlp = lp; ! 1248: while (cclass(ep, *lp++, ep[-1]==(CCL|STAR))) ! 1249: ; ! 1250: ep += *ep; ! 1251: goto star; ! 1252: ! 1253: star: ! 1254: /* ! 1255: * star: special treatment. We have found as many of them ! 1256: * as there are to find. Maybe this was too many, as dictated ! 1257: * by what follows in the pattern. Try, starting from the ! 1258: * end, to recursively advance after each char found, ! 1259: * and return after first successful advance (thus finding ! 1260: * largest possible string that matches). ! 1261: */ ! 1262: do { ! 1263: lp--; ! 1264: if (lp==locs) ! 1265: break; ! 1266: if (advance(lp, ep)) ! 1267: return(1); ! 1268: } while (lp > curlp); ! 1269: /* star failed at all attempts, so whole pattern fails. */ ! 1270: return(0); ! 1271: ! 1272: default: ! 1273: longjmp (restore, 1); ! 1274: } ! 1275: } ! 1276: ! 1277: /* ! 1278: * backref: checks to see that text starting at lp matches previous ! 1279: * sub-expression #i. Returns 1 if successful, else 0. (Used for \k ! 1280: * on lhs.) ! 1281: */ ! 1282: backref(i, lp) ! 1283: register int i; ! 1284: register char *lp; ! 1285: { ! 1286: register char *bp; ! 1287: ! 1288: bp = braslist[i]; ! 1289: while (*bp++ == *lp++) ! 1290: if (bp >= braelist[i]) ! 1291: return(1); ! 1292: return(0); ! 1293: } ! 1294: ! 1295: /* ! 1296: * cclass: check to see if character c is in class starting at set. ! 1297: * ([...] construction on lhs of r.e.) af is sense of success/failure: ! 1298: * af=1 is normal (success returns 1), af=0 is reversed for [^ (success ! 1299: * returns 0). ! 1300: */ ! 1301: int ! 1302: cclass(set, c, af) ! 1303: register char *set, c; ! 1304: int af; ! 1305: { ! 1306: register n; ! 1307: ! 1308: if (c==0) ! 1309: return(0); ! 1310: n = *set++; ! 1311: while (--n) ! 1312: if (*set++ == c) ! 1313: return(af); ! 1314: return(!af); ! 1315: } ! 1316: ! 1317: error (mess) ! 1318: char *mess; ! 1319: { ! 1320: if (promptlen > 0) ! 1321: if (hard) ! 1322: putchar ('\n'); ! 1323: else ! 1324: kill_line (); ! 1325: promptlen += strlen (mess); ! 1326: if (Senter && Sexit) { ! 1327: tputs (Senter, 1, putch); ! 1328: pr(mess); ! 1329: tputs (Sexit, 1, putch); ! 1330: } ! 1331: else ! 1332: pr (mess); ! 1333: if (hard) ! 1334: putchar ('\n'); ! 1335: fflush(stdout); ! 1336: errors++; ! 1337: longjmp (restore, 1); ! 1338: } ! 1339: ! 1340: rdline (f) ! 1341: register FILE *f; ! 1342: { ! 1343: register char c; ! 1344: register char *p; ! 1345: ! 1346: p = Line; ! 1347: while ((c = getc (f)) != '\n' && c != EOF && p - Line < LINSIZ - 1) ! 1348: *p++ = c; ! 1349: *p = '\0'; ! 1350: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.