![[BACK]](/icons/back.gif){kind=icon}
Return to prim.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / more|
Return to prim.c CVS log | Up to [local] / src / usr.bin / more |
1.1 ! deraadt 1: /*
! 2: * Copyright (c) 1988 Mark Nudleman
! 3: * Copyright (c) 1988 Regents of the University of California.
! 4: * All rights reserved.
! 5: *
! 6: * Redistribution and use in source and binary forms, with or without
! 7: * modification, are permitted provided that the following conditions
! 8: * are met:
! 9: * 1. Redistributions of source code must retain the above copyright
! 10: * notice, this list of conditions and the following disclaimer.
! 11: * 2. Redistributions in binary form must reproduce the above copyright
! 12: * notice, this list of conditions and the following disclaimer in the
! 13: * documentation and/or other materials provided with the distribution.
! 14: * 3. All advertising materials mentioning features or use of this software
! 15: * must display the following acknowledgement:
! 16: * This product includes software developed by the University of
! 17: * California, Berkeley and its contributors.
! 18: * 4. Neither the name of the University nor the names of its contributors
! 19: * may be used to endorse or promote products derived from this software
! 20: * without specific prior written permission.
! 21: *
! 22: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 23: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 24: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 25: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 26: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 27: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 28: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 29: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 30: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 31: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 32: * SUCH DAMAGE.
! 33: */
! 34:
! 35: #ifndef lint
! 36: /* from: static char sccsid[] = "@(#)prim.c 5.8 (Berkeley) 6/1/90"; */
! 37: static char *rcsid = "$Id: prim.c,v 1.4 1994/12/24 17:17:12 cgd Exp $";
! 38: #endif /* not lint */
! 39:
! 40: /*
! 41: * Primitives for displaying the file on the screen.
! 42: */
! 43:
! 44: #include <sys/types.h>
! 45: #include <stdio.h>
! 46: #include <stdlib.h>
! 47: #include <ctype.h>
! 48: #include <less.h>
! 49:
! 50: #ifdef REGEX
! 51: #include <regex.h>
! 52: #endif
! 53:
! 54: int back_scroll = -1;
! 55: int hit_eof; /* keeps track of how many times we hit end of file */
! 56: int screen_trashed;
! 57:
! 58: static int squished;
! 59:
! 60: extern int sigs;
! 61: extern int top_scroll;
! 62: extern int sc_width, sc_height;
! 63: extern int caseless;
! 64: extern int linenums;
! 65: extern int tagoption;
! 66: extern char *line;
! 67:
! 68: off_t position(), forw_line(), back_line(), forw_raw_line(), back_raw_line();
! 69: off_t ch_length(), ch_tell();
! 70:
! 71: /*
! 72: * Check to see if the end of file is currently "displayed".
! 73: */
! 74: eof_check()
! 75: {
! 76: off_t pos;
! 77:
! 78: if (sigs)
! 79: return;
! 80: /*
! 81: * If the bottom line is empty, we are at EOF.
! 82: * If the bottom line ends at the file length,
! 83: * we must be just at EOF.
! 84: */
! 85: pos = position(BOTTOM_PLUS_ONE);
! 86: if (pos == NULL_POSITION || pos == ch_length())
! 87: hit_eof++;
! 88: }
! 89:
! 90: /*
! 91: * If the screen is "squished", repaint it.
! 92: * "Squished" means the first displayed line is not at the top
! 93: * of the screen; this can happen when we display a short file
! 94: * for the first time.
! 95: */
! 96: squish_check()
! 97: {
! 98: if (squished) {
! 99: squished = 0;
! 100: repaint();
! 101: }
! 102: }
! 103:
! 104: /*
! 105: * Display n lines, scrolling forward, starting at position pos in the
! 106: * input file. "only_last" means display only the last screenful if
! 107: * n > screen size.
! 108: */
! 109: forw(n, pos, only_last)
! 110: register int n;
! 111: off_t pos;
! 112: int only_last;
! 113: {
! 114: extern int short_file;
! 115: static int first_time = 1;
! 116: int eof = 0, do_repaint;
! 117:
! 118: squish_check();
! 119:
! 120: /*
! 121: * do_repaint tells us not to display anything till the end,
! 122: * then just repaint the entire screen.
! 123: */
! 124: do_repaint = (only_last && n > sc_height-1);
! 125:
! 126: if (!do_repaint) {
! 127: if (top_scroll && n >= sc_height - 1) {
! 128: /*
! 129: * Start a new screen.
! 130: * {{ This is not really desirable if we happen
! 131: * to hit eof in the middle of this screen,
! 132: * but we don't yet know if that will happen. }}
! 133: */
! 134: clear();
! 135: home();
! 136: } else {
! 137: lower_left();
! 138: clear_eol();
! 139: }
! 140:
! 141: /*
! 142: * This is not contiguous with what is currently displayed.
! 143: * Clear the screen image (position table) and start a new
! 144: * screen.
! 145: */
! 146: if (pos != position(BOTTOM_PLUS_ONE)) {
! 147: pos_clear();
! 148: add_forw_pos(pos);
! 149: if (top_scroll) {
! 150: clear();
! 151: home();
! 152: } else if (!first_time)
! 153: putstr("...skipping...\n");
! 154: }
! 155: }
! 156:
! 157: for (short_file = 0; --n >= 0;) {
! 158: /*
! 159: * Read the next line of input.
! 160: */
! 161: pos = forw_line(pos);
! 162: if (pos == NULL_POSITION) {
! 163: /*
! 164: * end of file; copy the table if the file was
! 165: * too small for an entire screen.
! 166: */
! 167: eof = 1;
! 168: if (position(TOP) == NULL_POSITION) {
! 169: copytable();
! 170: if (!position(TOP))
! 171: short_file = 1;
! 172: }
! 173: break;
! 174: }
! 175: /*
! 176: * Add the position of the next line to the position table.
! 177: * Display the current line on the screen.
! 178: */
! 179: add_forw_pos(pos);
! 180: if (do_repaint)
! 181: continue;
! 182: /*
! 183: * If this is the first screen displayed and we hit an early
! 184: * EOF (i.e. before the requested number of lines), we
! 185: * "squish" the display down at the bottom of the screen.
! 186: * But don't do this if a -t option was given; it can cause
! 187: * us to start the display after the beginning of the file,
! 188: * and it is not appropriate to squish in that case.
! 189: */
! 190: if (first_time && line == NULL && !top_scroll && !tagoption) {
! 191: squished = 1;
! 192: continue;
! 193: }
! 194: put_line();
! 195: }
! 196:
! 197: if (eof && !sigs)
! 198: hit_eof++;
! 199: else
! 200: eof_check();
! 201: if (do_repaint)
! 202: repaint();
! 203: first_time = 0;
! 204: (void) currline(BOTTOM);
! 205: }
! 206:
! 207: /*
! 208: * Display n lines, scrolling backward.
! 209: */
! 210: back(n, pos, only_last)
! 211: register int n;
! 212: off_t pos;
! 213: int only_last;
! 214: {
! 215: int do_repaint;
! 216:
! 217: squish_check();
! 218: do_repaint = (n > get_back_scroll() || (only_last && n > sc_height-1));
! 219: hit_eof = 0;
! 220: while (--n >= 0)
! 221: {
! 222: /*
! 223: * Get the previous line of input.
! 224: */
! 225: pos = back_line(pos);
! 226: if (pos == NULL_POSITION)
! 227: break;
! 228: /*
! 229: * Add the position of the previous line to the position table.
! 230: * Display the line on the screen.
! 231: */
! 232: add_back_pos(pos);
! 233: if (!do_repaint)
! 234: {
! 235: home();
! 236: add_line();
! 237: put_line();
! 238: }
! 239: }
! 240:
! 241: eof_check();
! 242: if (do_repaint)
! 243: repaint();
! 244: (void) currline(BOTTOM);
! 245: }
! 246:
! 247: /*
! 248: * Display n more lines, forward.
! 249: * Start just after the line currently displayed at the bottom of the screen.
! 250: */
! 251: forward(n, only_last)
! 252: int n;
! 253: int only_last;
! 254: {
! 255: off_t pos;
! 256:
! 257: if (hit_eof) {
! 258: /*
! 259: * If we're trying to go forward from end-of-file,
! 260: * go on to the next file.
! 261: */
! 262: next_file(1);
! 263: return;
! 264: }
! 265:
! 266: pos = position(BOTTOM_PLUS_ONE);
! 267: if (pos == NULL_POSITION)
! 268: {
! 269: hit_eof++;
! 270: return;
! 271: }
! 272: forw(n, pos, only_last);
! 273: }
! 274:
! 275: /*
! 276: * Display n more lines, backward.
! 277: * Start just before the line currently displayed at the top of the screen.
! 278: */
! 279: backward(n, only_last)
! 280: int n;
! 281: int only_last;
! 282: {
! 283: off_t pos;
! 284:
! 285: pos = position(TOP);
! 286: /*
! 287: * This will almost never happen, because the top line is almost
! 288: * never empty.
! 289: */
! 290: if (pos == NULL_POSITION)
! 291: return;
! 292: back(n, pos, only_last);
! 293: }
! 294:
! 295: /*
! 296: * Repaint the screen, starting from a specified position.
! 297: */
! 298: prepaint(pos)
! 299: off_t pos;
! 300: {
! 301: hit_eof = 0;
! 302: forw(sc_height-1, pos, 0);
! 303: screen_trashed = 0;
! 304: }
! 305:
! 306: /*
! 307: * Repaint the screen.
! 308: */
! 309: repaint()
! 310: {
! 311: /*
! 312: * Start at the line currently at the top of the screen
! 313: * and redisplay the screen.
! 314: */
! 315: prepaint(position(TOP));
! 316: }
! 317:
! 318: /*
! 319: * Jump to the end of the file.
! 320: * It is more convenient to paint the screen backward,
! 321: * from the end of the file toward the beginning.
! 322: */
! 323: jump_forw()
! 324: {
! 325: off_t pos;
! 326:
! 327: if (ch_end_seek())
! 328: {
! 329: error("Cannot seek to end of file");
! 330: return;
! 331: }
! 332: lastmark();
! 333: pos = ch_tell();
! 334: clear();
! 335: pos_clear();
! 336: add_back_pos(pos);
! 337: back(sc_height - 1, pos, 0);
! 338: }
! 339:
! 340: /*
! 341: * Jump to line n in the file.
! 342: */
! 343: jump_back(n)
! 344: register int n;
! 345: {
! 346: register int c, nlines;
! 347:
! 348: /*
! 349: * This is done the slow way, by starting at the beginning
! 350: * of the file and counting newlines.
! 351: *
! 352: * {{ Now that we have line numbering (in linenum.c),
! 353: * we could improve on this by starting at the
! 354: * nearest known line rather than at the beginning. }}
! 355: */
! 356: if (ch_seek((off_t)0)) {
! 357: /*
! 358: * Probably a pipe with beginning of file no longer buffered.
! 359: * If he wants to go to line 1, we do the best we can,
! 360: * by going to the first line which is still buffered.
! 361: */
! 362: if (n <= 1 && ch_beg_seek() == 0)
! 363: jump_loc(ch_tell());
! 364: error("Cannot get to beginning of file");
! 365: return;
! 366: }
! 367:
! 368: /*
! 369: * Start counting lines.
! 370: */
! 371: for (nlines = 1; nlines < n; nlines++)
! 372: while ((c = ch_forw_get()) != '\n')
! 373: if (c == EOI) {
! 374: char message[40];
! 375: (void)sprintf(message, "File has only %d lines",
! 376: nlines - 1);
! 377: error(message);
! 378: return;
! 379: }
! 380: jump_loc(ch_tell());
! 381: }
! 382:
! 383: /*
! 384: * Jump to a specified percentage into the file.
! 385: * This is a poor compensation for not being able to
! 386: * quickly jump to a specific line number.
! 387: */
! 388: jump_percent(percent)
! 389: int percent;
! 390: {
! 391: off_t pos, len, ch_length();
! 392: register int c;
! 393:
! 394: /*
! 395: * Determine the position in the file
! 396: * (the specified percentage of the file's length).
! 397: */
! 398: if ((len = ch_length()) == NULL_POSITION)
! 399: {
! 400: error("Don't know length of file");
! 401: return;
! 402: }
! 403: pos = (percent * len) / 100;
! 404:
! 405: /*
! 406: * Back up to the beginning of the line.
! 407: */
! 408: if (ch_seek(pos) == 0)
! 409: {
! 410: while ((c = ch_back_get()) != '\n' && c != EOI)
! 411: ;
! 412: if (c == '\n')
! 413: (void) ch_forw_get();
! 414: pos = ch_tell();
! 415: }
! 416: jump_loc(pos);
! 417: }
! 418:
! 419: /*
! 420: * Jump to a specified position in the file.
! 421: */
! 422: jump_loc(pos)
! 423: off_t pos;
! 424: {
! 425: register int nline;
! 426: off_t tpos;
! 427:
! 428: if ((nline = onscreen(pos)) >= 0) {
! 429: /*
! 430: * The line is currently displayed.
! 431: * Just scroll there.
! 432: */
! 433: forw(nline, position(BOTTOM_PLUS_ONE), 0);
! 434: return;
! 435: }
! 436:
! 437: /*
! 438: * Line is not on screen.
! 439: * Seek to the desired location.
! 440: */
! 441: if (ch_seek(pos)) {
! 442: error("Cannot seek to that position");
! 443: return;
! 444: }
! 445:
! 446: /*
! 447: * See if the desired line is BEFORE the currently displayed screen.
! 448: * If so, then move forward far enough so the line we're on will be
! 449: * at the bottom of the screen, in order to be able to call back()
! 450: * to make the screen scroll backwards & put the line at the top of
! 451: * the screen.
! 452: * {{ This seems inefficient, but it's not so bad,
! 453: * since we can never move forward more than a
! 454: * screenful before we stop to redraw the screen. }}
! 455: */
! 456: tpos = position(TOP);
! 457: if (tpos != NULL_POSITION && pos < tpos) {
! 458: off_t npos = pos;
! 459: /*
! 460: * Note that we can't forw_line() past tpos here,
! 461: * so there should be no EOI at this stage.
! 462: */
! 463: for (nline = 0; npos < tpos && nline < sc_height - 1; nline++)
! 464: npos = forw_line(npos);
! 465:
! 466: if (npos < tpos) {
! 467: /*
! 468: * More than a screenful back.
! 469: */
! 470: lastmark();
! 471: clear();
! 472: pos_clear();
! 473: add_back_pos(npos);
! 474: }
! 475:
! 476: /*
! 477: * Note that back() will repaint() if nline > back_scroll.
! 478: */
! 479: back(nline, npos, 0);
! 480: return;
! 481: }
! 482: /*
! 483: * Remember where we were; clear and paint the screen.
! 484: */
! 485: lastmark();
! 486: prepaint(pos);
! 487: }
! 488:
! 489: /*
! 490: * The table of marks.
! 491: * A mark is simply a position in the file.
! 492: */
! 493: #define NMARKS (27) /* 26 for a-z plus one for quote */
! 494: #define LASTMARK (NMARKS-1) /* For quote */
! 495: static off_t marks[NMARKS];
! 496:
! 497: /*
! 498: * Initialize the mark table to show no marks are set.
! 499: */
! 500: init_mark()
! 501: {
! 502: int i;
! 503:
! 504: for (i = 0; i < NMARKS; i++)
! 505: marks[i] = NULL_POSITION;
! 506: }
! 507:
! 508: /*
! 509: * See if a mark letter is valid (between a and z).
! 510: */
! 511: static int
! 512: badmark(c)
! 513: int c;
! 514: {
! 515: if (c < 'a' || c > 'z')
! 516: {
! 517: error("Choose a letter between 'a' and 'z'");
! 518: return (1);
! 519: }
! 520: return (0);
! 521: }
! 522:
! 523: /*
! 524: * Set a mark.
! 525: */
! 526: setmark(c)
! 527: int c;
! 528: {
! 529: if (badmark(c))
! 530: return;
! 531: marks[c-'a'] = position(TOP);
! 532: }
! 533:
! 534: lastmark()
! 535: {
! 536: marks[LASTMARK] = position(TOP);
! 537: }
! 538:
! 539: /*
! 540: * Go to a previously set mark.
! 541: */
! 542: gomark(c)
! 543: int c;
! 544: {
! 545: off_t pos;
! 546:
! 547: if (c == '\'') {
! 548: pos = marks[LASTMARK];
! 549: if (pos == NULL_POSITION)
! 550: pos = 0;
! 551: }
! 552: else {
! 553: if (badmark(c))
! 554: return;
! 555: pos = marks[c-'a'];
! 556: if (pos == NULL_POSITION) {
! 557: error("mark not set");
! 558: return;
! 559: }
! 560: }
! 561: jump_loc(pos);
! 562: }
! 563:
! 564: /*
! 565: * Get the backwards scroll limit.
! 566: * Must call this function instead of just using the value of
! 567: * back_scroll, because the default case depends on sc_height and
! 568: * top_scroll, as well as back_scroll.
! 569: */
! 570: get_back_scroll()
! 571: {
! 572: if (back_scroll >= 0)
! 573: return (back_scroll);
! 574: if (top_scroll)
! 575: return (sc_height - 2);
! 576: return (sc_height - 1);
! 577: }
! 578:
! 579: /*
! 580: * Search for the n-th occurence of a specified pattern,
! 581: * either forward or backward.
! 582: */
! 583: search(search_forward, pattern, n, wantmatch)
! 584: register int search_forward;
! 585: register char *pattern;
! 586: register int n;
! 587: int wantmatch;
! 588: {
! 589: off_t pos, linepos;
! 590: register char *p;
! 591: register char *q;
! 592: int linenum;
! 593: int linematch;
! 594: #ifdef REGEX
! 595: static regex_t *cpattern = NULL;
! 596: #else
! 597: #ifdef RECOMP
! 598: char *re_comp();
! 599: char *errmsg;
! 600: #else
! 601: #ifdef REGCMP
! 602: char *regcmp();
! 603: static char *cpattern = NULL;
! 604: #else
! 605: static char lpbuf[100];
! 606: static char *last_pattern = NULL;
! 607: char *strcpy();
! 608: #endif
! 609: #endif
! 610: #endif /*REGEX */
! 611: /*
! 612: * For a caseless search, convert any uppercase in the pattern to
! 613: * lowercase.
! 614: */
! 615: if (caseless && pattern != NULL)
! 616: for (p = pattern; *p; p++)
! 617: if (isupper(*p))
! 618: *p = tolower(*p);
! 619: #ifdef REGEX
! 620: if (pattern == NULL || *pattern == '\0')
! 621: {
! 622: /*
! 623: * A null pattern means use the previous pattern.
! 624: * The compiled previous pattern is in cpattern, so just use it.
! 625: */
! 626: if (cpattern == NULL)
! 627: {
! 628: error("No previous regular expression");
! 629: return(0);
! 630: }
! 631: } else
! 632: {
! 633: /*
! 634: * Otherwise compile the given pattern.
! 635: */
! 636: if (cpattern == NULL
! 637: && (cpattern = (regex_t *) malloc(sizeof(regex_t))) == NULL) {
! 638: error("cannot allocate memory");
! 639: quit();
! 640: }
! 641: else
! 642: regfree(cpattern);
! 643: if (regcomp(cpattern, pattern, 0))
! 644: {
! 645: error("Invalid pattern");
! 646: return(0);
! 647: }
! 648: }
! 649: #else
! 650: #ifdef RECOMP
! 651:
! 652: /*
! 653: * (re_comp handles a null pattern internally,
! 654: * so there is no need to check for a null pattern here.)
! 655: */
! 656: if ((errmsg = re_comp(pattern)) != NULL)
! 657: {
! 658: error(errmsg);
! 659: return(0);
! 660: }
! 661: #else
! 662: #ifdef REGCMP
! 663: if (pattern == NULL || *pattern == '\0')
! 664: {
! 665: /*
! 666: * A null pattern means use the previous pattern.
! 667: * The compiled previous pattern is in cpattern, so just use it.
! 668: */
! 669: if (cpattern == NULL)
! 670: {
! 671: error("No previous regular expression");
! 672: return(0);
! 673: }
! 674: } else
! 675: {
! 676: /*
! 677: * Otherwise compile the given pattern.
! 678: */
! 679: char *s;
! 680: if ((s = regcmp(pattern, 0)) == NULL)
! 681: {
! 682: error("Invalid pattern");
! 683: return(0);
! 684: }
! 685: if (cpattern != NULL)
! 686: free(cpattern);
! 687: cpattern = s;
! 688: }
! 689: #else
! 690: if (pattern == NULL || *pattern == '\0')
! 691: {
! 692: /*
! 693: * Null pattern means use the previous pattern.
! 694: */
! 695: if (last_pattern == NULL)
! 696: {
! 697: error("No previous regular expression");
! 698: return(0);
! 699: }
! 700: pattern = last_pattern;
! 701: } else
! 702: {
! 703: (void)strcpy(lpbuf, pattern);
! 704: last_pattern = lpbuf;
! 705: }
! 706: #endif
! 707: #endif
! 708: #endif /* REGEX */
! 709:
! 710: /*
! 711: * Figure out where to start the search.
! 712: */
! 713:
! 714: if (position(TOP) == NULL_POSITION) {
! 715: /*
! 716: * Nothing is currently displayed. Start at the beginning
! 717: * of the file. (This case is mainly for searches from the
! 718: * command line.
! 719: */
! 720: pos = (off_t)0;
! 721: } else if (!search_forward) {
! 722: /*
! 723: * Backward search: start just before the top line
! 724: * displayed on the screen.
! 725: */
! 726: pos = position(TOP);
! 727: } else {
! 728: /*
! 729: * Start at the second screen line displayed on the screen.
! 730: */
! 731: pos = position(TOP_PLUS_ONE);
! 732: }
! 733:
! 734: if (pos == NULL_POSITION)
! 735: {
! 736: /*
! 737: * Can't find anyplace to start searching from.
! 738: */
! 739: error("Nothing to search");
! 740: return(0);
! 741: }
! 742:
! 743: linenum = find_linenum(pos);
! 744: for (;;)
! 745: {
! 746: /*
! 747: * Get lines until we find a matching one or
! 748: * until we hit end-of-file (or beginning-of-file
! 749: * if we're going backwards).
! 750: */
! 751: if (sigs)
! 752: /*
! 753: * A signal aborts the search.
! 754: */
! 755: return(0);
! 756:
! 757: if (search_forward)
! 758: {
! 759: /*
! 760: * Read the next line, and save the
! 761: * starting position of that line in linepos.
! 762: */
! 763: linepos = pos;
! 764: pos = forw_raw_line(pos);
! 765: if (linenum != 0)
! 766: linenum++;
! 767: } else
! 768: {
! 769: /*
! 770: * Read the previous line and save the
! 771: * starting position of that line in linepos.
! 772: */
! 773: pos = back_raw_line(pos);
! 774: linepos = pos;
! 775: if (linenum != 0)
! 776: linenum--;
! 777: }
! 778:
! 779: if (pos == NULL_POSITION)
! 780: {
! 781: /*
! 782: * We hit EOF/BOF without a match.
! 783: */
! 784: error("Pattern not found");
! 785: return(0);
! 786: }
! 787:
! 788: /*
! 789: * If we're using line numbers, we might as well
! 790: * remember the information we have now (the position
! 791: * and line number of the current line).
! 792: */
! 793: if (linenums)
! 794: add_lnum(linenum, pos);
! 795:
! 796: /*
! 797: * If this is a caseless search, convert uppercase in the
! 798: * input line to lowercase.
! 799: */
! 800: if (caseless)
! 801: for (p = q = line; *p; p++, q++)
! 802: *q = isupper(*p) ? tolower(*p) : *p;
! 803:
! 804: /*
! 805: * Remove any backspaces along with the preceeding char.
! 806: * This allows us to match text which is underlined or
! 807: * overstruck.
! 808: */
! 809: for (p = q = line; *p; p++, q++)
! 810: if (q > line && *p == '\b')
! 811: /* Delete BS and preceeding char. */
! 812: q -= 2;
! 813: else
! 814: /* Otherwise, just copy. */
! 815: *q = *p;
! 816:
! 817: /*
! 818: * Test the next line to see if we have a match.
! 819: * This is done in a variety of ways, depending
! 820: * on what pattern matching functions are available.
! 821: */
! 822: #ifdef REGEX
! 823: linematch = !regexec(cpattern, line, 0, NULL, 0);
! 824: #else
! 825: #ifdef REGCMP
! 826: linematch = (regex(cpattern, line) != NULL);
! 827: #else
! 828: #ifdef RECOMP
! 829: linematch = (re_exec(line) == 1);
! 830: #else
! 831: linematch = match(pattern, line);
! 832: #endif
! 833: #endif
! 834: #endif /* REGEX */
! 835: /*
! 836: * We are successful if wantmatch and linematch are
! 837: * both true (want a match and got it),
! 838: * or both false (want a non-match and got it).
! 839: */
! 840: if (((wantmatch && linematch) || (!wantmatch && !linematch)) &&
! 841: --n <= 0)
! 842: /*
! 843: * Found the line.
! 844: */
! 845: break;
! 846: }
! 847: jump_loc(linepos);
! 848: return(1);
! 849: }
! 850:
! 851: #if !defined(REGCMP) && !defined(RECOMP) && !defined(REGEX)
! 852: /*
! 853: * We have neither regcmp() nor re_comp().
! 854: * We use this function to do simple pattern matching.
! 855: * It supports no metacharacters like *, etc.
! 856: */
! 857: static
! 858: match(pattern, buf)
! 859: char *pattern, *buf;
! 860: {
! 861: register char *pp, *lp;
! 862:
! 863: for ( ; *buf != '\0'; buf++)
! 864: {
! 865: for (pp = pattern, lp = buf; *pp == *lp; pp++, lp++)
! 866: if (*pp == '\0' || *lp == '\0')
! 867: break;
! 868: if (*pp == '\0')
! 869: return (1);
! 870: }
! 871: return (0);
! 872: }
! 873: #endif