1 /* $NetBSD: search.c,v 1.3 2011/07/03 20:14:13 tron Exp $ */ 2 3 /* 4 * Copyright (C) 1984-2011 Mark Nudelman 5 * 6 * You may distribute under the terms of either the GNU General Public 7 * License or the Less License, as specified in the README file. 8 * 9 * For more information about less, or for information on how to 10 * contact the author, see the README file. 11 */ 12 13 14 /* 15 * Routines to search a file for a pattern. 16 */ 17 18 #include "less.h" 19 #include "pattern.h" 20 #include "position.h" 21 #include "charset.h" 22 23 #define MINPOS(a,b) (((a) < (b)) ? (a) : (b)) 24 #define MAXPOS(a,b) (((a) > (b)) ? (a) : (b)) 25 26 extern int sigs; 27 extern int how_search; 28 extern int caseless; 29 extern int linenums; 30 extern int sc_height; 31 extern int jump_sline; 32 extern int bs_mode; 33 extern int ctldisp; 34 extern int status_col; 35 extern void * constant ml_search; 36 extern POSITION start_attnpos; 37 extern POSITION end_attnpos; 38 extern int utf_mode; 39 extern int screen_trashed; 40 #if HILITE_SEARCH 41 extern int hilite_search; 42 extern int size_linebuf; 43 extern int squished; 44 extern int can_goto_line; 45 static int hide_hilite; 46 static POSITION prep_startpos; 47 static POSITION prep_endpos; 48 static int is_caseless; 49 static int is_ucase_pattern; 50 51 struct hilite 52 { 53 struct hilite *hl_next; 54 POSITION hl_startpos; 55 POSITION hl_endpos; 56 }; 57 static struct hilite hilite_anchor = { NULL, NULL_POSITION, NULL_POSITION }; 58 static struct hilite filter_anchor = { NULL, NULL_POSITION, NULL_POSITION }; 59 #define hl_first hl_next 60 #endif 61 62 /* 63 * These are the static variables that represent the "remembered" 64 * search pattern and filter pattern. 65 */ 66 struct pattern_info { 67 DEFINE_PATTERN(compiled); 68 char* text; 69 int search_type; 70 }; 71 72 static struct pattern_info search_info; 73 static struct pattern_info filter_info; 74 75 /* 76 * Are there any uppercase letters in this string? 77 */ 78 static int 79 is_ucase(str) 80 char *str; 81 { 82 char *str_end = str + strlen(str); 83 LWCHAR ch; 84 85 while (str < str_end) 86 { 87 ch = step_char(&str, +1, str_end); 88 if (IS_UPPER(ch)) 89 return (1); 90 } 91 return (0); 92 } 93 94 /* 95 * Compile and save a search pattern. 96 */ 97 static int 98 set_pattern(info, pattern, search_type) 99 struct pattern_info *info; 100 char *pattern; 101 int search_type; 102 { 103 if (pattern == NULL) 104 CLEAR_PATTERN(search_info.compiled); 105 else if (compile_pattern(pattern, search_type, &info->compiled) < 0) 106 return -1; 107 /* Pattern compiled successfully; save the text too. */ 108 if (info->text != NULL) 109 free(info->text); 110 info->text = NULL; 111 if (pattern != NULL) 112 { 113 info->text = (char *) ecalloc(1, strlen(pattern)+1); 114 strcpy(info->text, pattern); 115 } 116 info->search_type = search_type; 117 118 /* 119 * Ignore case if -I is set OR 120 * -i is set AND the pattern is all lowercase. 121 */ 122 is_ucase_pattern = is_ucase(pattern); 123 if (is_ucase_pattern && caseless != OPT_ONPLUS) 124 is_caseless = 0; 125 else 126 is_caseless = caseless; 127 return 0; 128 } 129 130 /* 131 * Discard a saved pattern. 132 */ 133 static void 134 clear_pattern(info) 135 struct pattern_info *info; 136 { 137 if (info->text != NULL) 138 free(info->text); 139 info->text = NULL; 140 uncompile_pattern(&info->compiled); 141 } 142 143 /* 144 * Initialize saved pattern to nothing. 145 */ 146 static void 147 init_pattern(info) 148 struct pattern_info *info; 149 { 150 CLEAR_PATTERN(info->compiled); 151 info->text = NULL; 152 info->search_type = 0; 153 } 154 155 /* 156 * Initialize search variables. 157 */ 158 public void 159 init_search() 160 { 161 init_pattern(&search_info); 162 init_pattern(&filter_info); 163 } 164 165 /* 166 * Determine which text conversions to perform before pattern matching. 167 */ 168 static int 169 get_cvt_ops() 170 { 171 int ops = 0; 172 if (is_caseless || bs_mode == BS_SPECIAL) 173 { 174 if (is_caseless) 175 ops |= CVT_TO_LC; 176 if (bs_mode == BS_SPECIAL) 177 ops |= CVT_BS; 178 if (bs_mode != BS_CONTROL) 179 ops |= CVT_CRLF; 180 } else if (bs_mode != BS_CONTROL) 181 { 182 ops |= CVT_CRLF; 183 } 184 if (ctldisp == OPT_ONPLUS) 185 ops |= CVT_ANSI; 186 return (ops); 187 } 188 189 /* 190 * Is there a previous (remembered) search pattern? 191 */ 192 static int 193 prev_pattern(info) 194 struct pattern_info *info; 195 { 196 if (info->search_type & SRCH_NO_REGEX) 197 return (info->text != NULL); 198 return (!is_null_pattern(info->compiled)); 199 } 200 201 #if HILITE_SEARCH 202 /* 203 * Repaint the hilites currently displayed on the screen. 204 * Repaint each line which contains highlighted text. 205 * If on==0, force all hilites off. 206 */ 207 public void 208 repaint_hilite(on) 209 int on; 210 { 211 int slinenum; 212 POSITION pos; 213 POSITION epos; 214 int save_hide_hilite; 215 216 if (squished) 217 repaint(); 218 219 save_hide_hilite = hide_hilite; 220 if (!on) 221 { 222 if (hide_hilite) 223 return; 224 hide_hilite = 1; 225 } 226 227 if (!can_goto_line) 228 { 229 repaint(); 230 hide_hilite = save_hide_hilite; 231 return; 232 } 233 234 for (slinenum = TOP; slinenum < TOP + sc_height-1; slinenum++) 235 { 236 pos = position(slinenum); 237 if (pos == NULL_POSITION) 238 continue; 239 epos = position(slinenum+1); 240 (void) forw_line(pos); 241 goto_line(slinenum); 242 put_line(); 243 } 244 lower_left(); 245 hide_hilite = save_hide_hilite; 246 } 247 248 /* 249 * Clear the attn hilite. 250 */ 251 public void 252 clear_attn() 253 { 254 int slinenum; 255 POSITION old_start_attnpos; 256 POSITION old_end_attnpos; 257 POSITION pos; 258 POSITION epos; 259 int moved = 0; 260 261 if (start_attnpos == NULL_POSITION) 262 return; 263 old_start_attnpos = start_attnpos; 264 old_end_attnpos = end_attnpos; 265 start_attnpos = end_attnpos = NULL_POSITION; 266 267 if (!can_goto_line) 268 { 269 repaint(); 270 return; 271 } 272 if (squished) 273 repaint(); 274 275 for (slinenum = TOP; slinenum < TOP + sc_height-1; slinenum++) 276 { 277 pos = position(slinenum); 278 if (pos == NULL_POSITION) 279 continue; 280 epos = position(slinenum+1); 281 if (pos < old_end_attnpos && 282 (epos == NULL_POSITION || epos > old_start_attnpos)) 283 { 284 (void) forw_line(pos); 285 goto_line(slinenum); 286 put_line(); 287 moved = 1; 288 } 289 } 290 if (moved) 291 lower_left(); 292 } 293 #endif 294 295 /* 296 * Hide search string highlighting. 297 */ 298 public void 299 undo_search() 300 { 301 if (!prev_pattern(&search_info)) 302 { 303 error("No previous regular expression", NULL_PARG); 304 return; 305 } 306 #if HILITE_SEARCH 307 hide_hilite = !hide_hilite; 308 repaint_hilite(1); 309 #endif 310 } 311 312 #if HILITE_SEARCH 313 /* 314 * Clear the hilite list. 315 */ 316 public void 317 clr_hlist(anchor) 318 struct hilite *anchor; 319 { 320 struct hilite *hl; 321 struct hilite *nexthl; 322 323 for (hl = anchor->hl_first; hl != NULL; hl = nexthl) 324 { 325 nexthl = hl->hl_next; 326 free((void*)hl); 327 } 328 anchor->hl_first = NULL; 329 prep_startpos = prep_endpos = NULL_POSITION; 330 } 331 332 public void 333 clr_hilite() 334 { 335 clr_hlist(&hilite_anchor); 336 } 337 338 public void 339 clr_filter() 340 { 341 clr_hlist(&filter_anchor); 342 } 343 344 /* 345 * Should any characters in a specified range be highlighted? 346 */ 347 static int 348 is_hilited_range(pos, epos) 349 POSITION pos; 350 POSITION epos; 351 { 352 struct hilite *hl; 353 354 /* 355 * Look at each highlight and see if any part of it falls in the range. 356 */ 357 for (hl = hilite_anchor.hl_first; hl != NULL; hl = hl->hl_next) 358 { 359 if (hl->hl_endpos > pos && 360 (epos == NULL_POSITION || epos > hl->hl_startpos)) 361 return (1); 362 } 363 return (0); 364 } 365 366 /* 367 * Is a line "filtered" -- that is, should it be hidden? 368 */ 369 public int 370 is_filtered(pos) 371 POSITION pos; 372 { 373 struct hilite *hl; 374 375 if (ch_getflags() & CH_HELPFILE) 376 return (0); 377 378 /* 379 * Look at each filter and see if the start position 380 * equals the start position of the line. 381 */ 382 for (hl = filter_anchor.hl_first; hl != NULL; hl = hl->hl_next) 383 { 384 if (hl->hl_startpos == pos) 385 return (1); 386 } 387 return (0); 388 } 389 390 /* 391 * Should any characters in a specified range be highlighted? 392 * If nohide is nonzero, don't consider hide_hilite. 393 */ 394 public int 395 is_hilited(pos, epos, nohide, p_matches) 396 POSITION pos; 397 POSITION epos; 398 int nohide; 399 int *p_matches; 400 { 401 int match; 402 403 if (p_matches != NULL) 404 *p_matches = 0; 405 406 if (!status_col && 407 start_attnpos != NULL_POSITION && 408 pos < end_attnpos && 409 (epos == NULL_POSITION || epos > start_attnpos)) 410 /* 411 * The attn line overlaps this range. 412 */ 413 return (1); 414 415 match = is_hilited_range(pos, epos); 416 if (!match) 417 return (0); 418 419 if (p_matches != NULL) 420 /* 421 * Report matches, even if we're hiding highlights. 422 */ 423 *p_matches = 1; 424 425 if (hilite_search == 0) 426 /* 427 * Not doing highlighting. 428 */ 429 return (0); 430 431 if (!nohide && hide_hilite) 432 /* 433 * Highlighting is hidden. 434 */ 435 return (0); 436 437 return (1); 438 } 439 440 /* 441 * Add a new hilite to a hilite list. 442 */ 443 static void 444 add_hilite(anchor, hl) 445 struct hilite *anchor; 446 struct hilite *hl; 447 { 448 struct hilite *ihl; 449 450 /* 451 * Hilites are sorted in the list; find where new one belongs. 452 * Insert new one after ihl. 453 */ 454 for (ihl = anchor; ihl->hl_next != NULL; ihl = ihl->hl_next) 455 { 456 if (ihl->hl_next->hl_startpos > hl->hl_startpos) 457 break; 458 } 459 460 /* 461 * Truncate hilite so it doesn't overlap any existing ones 462 * above and below it. 463 */ 464 if (ihl != anchor) 465 hl->hl_startpos = MAXPOS(hl->hl_startpos, ihl->hl_endpos); 466 if (ihl->hl_next != NULL) 467 hl->hl_endpos = MINPOS(hl->hl_endpos, ihl->hl_next->hl_startpos); 468 if (hl->hl_startpos >= hl->hl_endpos) 469 { 470 /* 471 * Hilite was truncated out of existence. 472 */ 473 free(hl); 474 return; 475 } 476 hl->hl_next = ihl->hl_next; 477 ihl->hl_next = hl; 478 } 479 480 /* 481 * Make a hilite for each string in a physical line which matches 482 * the current pattern. 483 * sp,ep delimit the first match already found. 484 */ 485 static void 486 hilite_line(linepos, line, line_len, chpos, sp, ep, cvt_ops) 487 POSITION linepos; 488 char *line; 489 int line_len; 490 int *chpos; 491 char *sp; 492 char *ep; 493 int cvt_ops; 494 { 495 char *searchp; 496 char *line_end = line + line_len; 497 struct hilite *hl; 498 499 if (sp == NULL || ep == NULL) 500 return; 501 /* 502 * sp and ep delimit the first match in the line. 503 * Mark the corresponding file positions, then 504 * look for further matches and mark them. 505 * {{ This technique, of calling match_pattern on subsequent 506 * substrings of the line, may mark more than is correct 507 * if the pattern starts with "^". This bug is fixed 508 * for those regex functions that accept a notbol parameter 509 * (currently POSIX, PCRE and V8-with-regexec2). }} 510 */ 511 searchp = line; 512 do { 513 if (ep > sp) 514 { 515 hl = (struct hilite *) ecalloc(1, sizeof(struct hilite)); 516 hl->hl_startpos = linepos + chpos[sp-line]; 517 hl->hl_endpos = linepos + chpos[ep-line]; 518 add_hilite(&hilite_anchor, hl); 519 } 520 /* 521 * If we matched more than zero characters, 522 * move to the first char after the string we matched. 523 * If we matched zero, just move to the next char. 524 */ 525 if (ep > searchp) 526 searchp = ep; 527 else if (searchp != line_end) 528 searchp++; 529 else /* end of line */ 530 break; 531 } while (match_pattern(search_info.compiled, search_info.text, 532 searchp, line_end - searchp, &sp, &ep, 1, search_info.search_type)); 533 } 534 #endif 535 536 /* 537 * Change the caseless-ness of searches. 538 * Updates the internal search state to reflect a change in the -i flag. 539 */ 540 public void 541 chg_caseless() 542 { 543 if (!is_ucase_pattern) 544 /* 545 * Pattern did not have uppercase. 546 * Just set the search caselessness to the global caselessness. 547 */ 548 is_caseless = caseless; 549 else 550 /* 551 * Pattern did have uppercase. 552 * Discard the pattern; we can't change search caselessness now. 553 */ 554 clear_pattern(&search_info); 555 } 556 557 #if HILITE_SEARCH 558 /* 559 * Find matching text which is currently on screen and highlight it. 560 */ 561 static void 562 hilite_screen() 563 { 564 struct scrpos scrpos; 565 566 get_scrpos(&scrpos); 567 if (scrpos.pos == NULL_POSITION) 568 return; 569 prep_hilite(scrpos.pos, position(BOTTOM_PLUS_ONE), -1); 570 repaint_hilite(1); 571 } 572 573 /* 574 * Change highlighting parameters. 575 */ 576 public void 577 chg_hilite() 578 { 579 /* 580 * Erase any highlights currently on screen. 581 */ 582 clr_hilite(); 583 hide_hilite = 0; 584 585 if (hilite_search == OPT_ONPLUS) 586 /* 587 * Display highlights. 588 */ 589 hilite_screen(); 590 } 591 #endif 592 593 /* 594 * Figure out where to start a search. 595 */ 596 static POSITION 597 search_pos(search_type) 598 int search_type; 599 { 600 POSITION pos; 601 int linenum; 602 603 if (empty_screen()) 604 { 605 /* 606 * Start at the beginning (or end) of the file. 607 * The empty_screen() case is mainly for 608 * command line initiated searches; 609 * for example, "+/xyz" on the command line. 610 * Also for multi-file (SRCH_PAST_EOF) searches. 611 */ 612 if (search_type & SRCH_FORW) 613 { 614 pos = ch_zero(); 615 } else 616 { 617 pos = ch_length(); 618 if (pos == NULL_POSITION) 619 { 620 (void) ch_end_seek(); 621 pos = ch_length(); 622 } 623 } 624 linenum = 0; 625 } else 626 { 627 int add_one = 0; 628 629 if (how_search == OPT_ON) 630 { 631 /* 632 * Search does not include current screen. 633 */ 634 if (search_type & SRCH_FORW) 635 linenum = BOTTOM_PLUS_ONE; 636 else 637 linenum = TOP; 638 } else if (how_search == OPT_ONPLUS && !(search_type & SRCH_AFTER_TARGET)) 639 { 640 /* 641 * Search includes all of displayed screen. 642 */ 643 if (search_type & SRCH_FORW) 644 linenum = TOP; 645 else 646 linenum = BOTTOM_PLUS_ONE; 647 } else 648 { 649 /* 650 * Search includes the part of current screen beyond the jump target. 651 * It starts at the jump target (if searching backwards), 652 * or at the jump target plus one (if forwards). 653 */ 654 linenum = jump_sline; 655 if (search_type & SRCH_FORW) 656 add_one = 1; 657 } 658 linenum = adjsline(linenum); 659 pos = position(linenum); 660 if (add_one) 661 pos = forw_raw_line(pos, (char **)NULL, (int *)NULL); 662 } 663 664 /* 665 * If the line is empty, look around for a plausible starting place. 666 */ 667 if (search_type & SRCH_FORW) 668 { 669 while (pos == NULL_POSITION) 670 { 671 if (++linenum >= sc_height) 672 break; 673 pos = position(linenum); 674 } 675 } else 676 { 677 while (pos == NULL_POSITION) 678 { 679 if (--linenum < 0) 680 break; 681 pos = position(linenum); 682 } 683 } 684 return (pos); 685 } 686 687 /* 688 * Search a subset of the file, specified by start/end position. 689 */ 690 static int 691 search_range(pos, endpos, search_type, matches, maxlines, plinepos, pendpos) 692 POSITION pos; 693 POSITION endpos; 694 int search_type; 695 int matches; 696 int maxlines; 697 POSITION *plinepos; 698 POSITION *pendpos; 699 { 700 char *line; 701 char *cline; 702 int line_len; 703 LINENUM linenum; 704 char *sp = NULL, *ep = NULL; /* XXX: GCC */ 705 int line_match; 706 int cvt_ops; 707 int cvt_len; 708 int *chpos; 709 POSITION linepos, oldpos; 710 711 linenum = find_linenum(pos); 712 oldpos = pos; 713 for (;;) 714 { 715 /* 716 * Get lines until we find a matching one or until 717 * we hit end-of-file (or beginning-of-file if we're 718 * going backwards), or until we hit the end position. 719 */ 720 if (ABORT_SIGS()) 721 { 722 /* 723 * A signal aborts the search. 724 */ 725 return (-1); 726 } 727 728 if ((endpos != NULL_POSITION && pos >= endpos) || maxlines == 0) 729 { 730 /* 731 * Reached end position without a match. 732 */ 733 if (pendpos != NULL) 734 *pendpos = pos; 735 return (matches); 736 } 737 if (maxlines > 0) 738 maxlines--; 739 740 if (search_type & SRCH_FORW) 741 { 742 /* 743 * Read the next line, and save the 744 * starting position of that line in linepos. 745 */ 746 linepos = pos; 747 pos = forw_raw_line(pos, &line, &line_len); 748 if (linenum != 0) 749 linenum++; 750 } else 751 { 752 /* 753 * Read the previous line and save the 754 * starting position of that line in linepos. 755 */ 756 pos = back_raw_line(pos, &line, &line_len); 757 linepos = pos; 758 if (linenum != 0) 759 linenum--; 760 } 761 762 if (pos == NULL_POSITION) 763 { 764 /* 765 * Reached EOF/BOF without a match. 766 */ 767 if (pendpos != NULL) 768 *pendpos = oldpos; 769 return (matches); 770 } 771 772 /* 773 * If we're using line numbers, we might as well 774 * remember the information we have now (the position 775 * and line number of the current line). 776 * Don't do it for every line because it slows down 777 * the search. Remember the line number only if 778 * we're "far" from the last place we remembered it. 779 */ 780 if (linenums && abs((int)(pos - oldpos)) > 2048) 781 add_lnum(linenum, pos); 782 oldpos = pos; 783 784 if (is_filtered(linepos)) 785 continue; 786 787 /* 788 * If it's a caseless search, convert the line to lowercase. 789 * If we're doing backspace processing, delete backspaces. 790 */ 791 cvt_ops = get_cvt_ops(); 792 cvt_len = cvt_length(line_len, cvt_ops); 793 cline = (char *) ecalloc(1, cvt_len); 794 chpos = cvt_alloc_chpos(cvt_len); 795 cvt_text(cline, line, chpos, &line_len, cvt_ops); 796 797 #if HILITE_SEARCH 798 /* 799 * Check to see if the line matches the filter pattern. 800 * If so, add an entry to the filter list. 801 */ 802 if ((search_type & SRCH_FIND_ALL) && prev_pattern(&filter_info)) { 803 int line_filter = match_pattern(filter_info.compiled, filter_info.text, 804 cline, line_len, &sp, &ep, 0, filter_info.search_type); 805 if (line_filter) 806 { 807 struct hilite *hl = (struct hilite *) 808 ecalloc(1, sizeof(struct hilite)); 809 hl->hl_startpos = linepos; 810 hl->hl_endpos = pos; 811 add_hilite(&filter_anchor, hl); 812 } 813 } 814 #endif 815 816 /* 817 * Test the next line to see if we have a match. 818 * We are successful if we either want a match and got one, 819 * or if we want a non-match and got one. 820 */ 821 if (prev_pattern(&search_info)) 822 { 823 line_match = match_pattern(search_info.compiled, search_info.text, 824 cline, line_len, &sp, &ep, 0, search_type); 825 if (line_match) 826 { 827 /* 828 * Got a match. 829 */ 830 if (search_type & SRCH_FIND_ALL) 831 { 832 #if HILITE_SEARCH 833 /* 834 * We are supposed to find all matches in the range. 835 * Just add the matches in this line to the 836 * hilite list and keep searching. 837 */ 838 hilite_line(linepos, cline, line_len, chpos, sp, ep, cvt_ops); 839 #endif 840 } else if (--matches <= 0) 841 { 842 /* 843 * Found the one match we're looking for. 844 * Return it. 845 */ 846 #if HILITE_SEARCH 847 if (hilite_search == OPT_ON) 848 { 849 /* 850 * Clear the hilite list and add only 851 * the matches in this one line. 852 */ 853 clr_hilite(); 854 hilite_line(linepos, cline, line_len, chpos, sp, ep, cvt_ops); 855 } 856 #endif 857 free(cline); 858 free(chpos); 859 if (plinepos != NULL) 860 *plinepos = linepos; 861 return (0); 862 } 863 } 864 } 865 free(cline); 866 free(chpos); 867 } 868 } 869 870 /* 871 * search for a pattern in history. If found, compile that pattern. 872 */ 873 static int 874 hist_pattern(search_type) 875 int search_type; 876 { 877 #if CMD_HISTORY 878 char *pattern; 879 880 set_mlist(ml_search, 0); 881 pattern = cmd_lastpattern(); 882 if (pattern == NULL) 883 return (0); 884 885 if (set_pattern(&search_info, pattern, search_type) < 0) 886 return (0); 887 888 #if HILITE_SEARCH 889 if (hilite_search == OPT_ONPLUS && !hide_hilite) 890 hilite_screen(); 891 #endif 892 893 return (1); 894 #else /* CMD_HISTORY */ 895 return (0); 896 #endif /* CMD_HISTORY */ 897 } 898 899 /* 900 * Search for the n-th occurrence of a specified pattern, 901 * either forward or backward. 902 * Return the number of matches not yet found in this file 903 * (that is, n minus the number of matches found). 904 * Return -1 if the search should be aborted. 905 * Caller may continue the search in another file 906 * if less than n matches are found in this file. 907 */ 908 public int 909 search(search_type, pattern, n) 910 int search_type; 911 char *pattern; 912 int n; 913 { 914 POSITION pos; 915 916 if (pattern == NULL || *pattern == '\0') 917 { 918 /* 919 * A null pattern means use the previously compiled pattern. 920 */ 921 search_type |= SRCH_AFTER_TARGET; 922 if (!prev_pattern(&search_info) && !hist_pattern(search_type)) 923 { 924 error("No previous regular expression", NULL_PARG); 925 return (-1); 926 } 927 if ((search_type & SRCH_NO_REGEX) != 928 (search_info.search_type & SRCH_NO_REGEX)) 929 { 930 error("Please re-enter search pattern", NULL_PARG); 931 return -1; 932 } 933 #if HILITE_SEARCH 934 if (hilite_search == OPT_ON) 935 { 936 /* 937 * Erase the highlights currently on screen. 938 * If the search fails, we'll redisplay them later. 939 */ 940 repaint_hilite(0); 941 } 942 if (hilite_search == OPT_ONPLUS && hide_hilite) 943 { 944 /* 945 * Highlight any matches currently on screen, 946 * before we actually start the search. 947 */ 948 hide_hilite = 0; 949 hilite_screen(); 950 } 951 hide_hilite = 0; 952 #endif 953 } else 954 { 955 /* 956 * Compile the pattern. 957 */ 958 if (set_pattern(&search_info, pattern, search_type) < 0) 959 return (-1); 960 #if HILITE_SEARCH 961 if (hilite_search) 962 { 963 /* 964 * Erase the highlights currently on screen. 965 * Also permanently delete them from the hilite list. 966 */ 967 repaint_hilite(0); 968 hide_hilite = 0; 969 clr_hilite(); 970 } 971 if (hilite_search == OPT_ONPLUS) 972 { 973 /* 974 * Highlight any matches currently on screen, 975 * before we actually start the search. 976 */ 977 hilite_screen(); 978 } 979 #endif 980 } 981 982 /* 983 * Figure out where to start the search. 984 */ 985 pos = search_pos(search_type); 986 if (pos == NULL_POSITION) 987 { 988 /* 989 * Can't find anyplace to start searching from. 990 */ 991 if (search_type & SRCH_PAST_EOF) 992 return (n); 993 /* repaint(); -- why was this here? */ 994 error("Nothing to search", NULL_PARG); 995 return (-1); 996 } 997 998 n = search_range(pos, NULL_POSITION, search_type, n, -1, 999 &pos, (POSITION*)NULL); 1000 if (n != 0) 1001 { 1002 /* 1003 * Search was unsuccessful. 1004 */ 1005 #if HILITE_SEARCH 1006 if (hilite_search == OPT_ON && n > 0) 1007 /* 1008 * Redisplay old hilites. 1009 */ 1010 repaint_hilite(1); 1011 #endif 1012 return (n); 1013 } 1014 1015 if (!(search_type & SRCH_NO_MOVE)) 1016 { 1017 /* 1018 * Go to the matching line. 1019 */ 1020 jump_loc(pos, jump_sline); 1021 } 1022 1023 #if HILITE_SEARCH 1024 if (hilite_search == OPT_ON) 1025 /* 1026 * Display new hilites in the matching line. 1027 */ 1028 repaint_hilite(1); 1029 #endif 1030 return (0); 1031 } 1032 1033 1034 #if HILITE_SEARCH 1035 /* 1036 * Prepare hilites in a given range of the file. 1037 * 1038 * The pair (prep_startpos,prep_endpos) delimits a contiguous region 1039 * of the file that has been "prepared"; that is, scanned for matches for 1040 * the current search pattern, and hilites have been created for such matches. 1041 * If prep_startpos == NULL_POSITION, the prep region is empty. 1042 * If prep_endpos == NULL_POSITION, the prep region extends to EOF. 1043 * prep_hilite asks that the range (spos,epos) be covered by the prep region. 1044 */ 1045 public void 1046 prep_hilite(spos, epos, maxlines) 1047 POSITION spos; 1048 POSITION epos; 1049 int maxlines; 1050 { 1051 POSITION nprep_startpos = prep_startpos; 1052 POSITION nprep_endpos = prep_endpos; 1053 POSITION new_epos; 1054 POSITION max_epos; 1055 int result; 1056 int i; 1057 1058 /* 1059 * Search beyond where we're asked to search, so the prep region covers 1060 * more than we need. Do one big search instead of a bunch of small ones. 1061 */ 1062 #define SEARCH_MORE (3*size_linebuf) 1063 1064 if (!prev_pattern(&search_info) && !is_filtering()) 1065 return; 1066 1067 /* 1068 * If we're limited to a max number of lines, figure out the 1069 * file position we should stop at. 1070 */ 1071 if (maxlines < 0) 1072 max_epos = NULL_POSITION; 1073 else 1074 { 1075 max_epos = spos; 1076 for (i = 0; i < maxlines; i++) 1077 max_epos = forw_raw_line(max_epos, (char **)NULL, (int *)NULL); 1078 } 1079 1080 /* 1081 * Find two ranges: 1082 * The range that we need to search (spos,epos); and the range that 1083 * the "prep" region will then cover (nprep_startpos,nprep_endpos). 1084 */ 1085 1086 if (prep_startpos == NULL_POSITION || 1087 (epos != NULL_POSITION && epos < prep_startpos) || 1088 spos > prep_endpos) 1089 { 1090 /* 1091 * New range is not contiguous with old prep region. 1092 * Discard the old prep region and start a new one. 1093 */ 1094 clr_hilite(); 1095 clr_filter(); 1096 if (epos != NULL_POSITION) 1097 epos += SEARCH_MORE; 1098 nprep_startpos = spos; 1099 } else 1100 { 1101 /* 1102 * New range partially or completely overlaps old prep region. 1103 */ 1104 if (epos == NULL_POSITION) 1105 { 1106 /* 1107 * New range goes to end of file. 1108 */ 1109 ; 1110 } else if (epos > prep_endpos) 1111 { 1112 /* 1113 * New range ends after old prep region. 1114 * Extend prep region to end at end of new range. 1115 */ 1116 epos += SEARCH_MORE; 1117 } else /* (epos <= prep_endpos) */ 1118 { 1119 /* 1120 * New range ends within old prep region. 1121 * Truncate search to end at start of old prep region. 1122 */ 1123 epos = prep_startpos; 1124 } 1125 1126 if (spos < prep_startpos) 1127 { 1128 /* 1129 * New range starts before old prep region. 1130 * Extend old prep region backwards to start at 1131 * start of new range. 1132 */ 1133 if (spos < SEARCH_MORE) 1134 spos = 0; 1135 else 1136 spos -= SEARCH_MORE; 1137 nprep_startpos = spos; 1138 } else /* (spos >= prep_startpos) */ 1139 { 1140 /* 1141 * New range starts within or after old prep region. 1142 * Trim search to start at end of old prep region. 1143 */ 1144 spos = prep_endpos; 1145 } 1146 } 1147 1148 if (epos != NULL_POSITION && max_epos != NULL_POSITION && 1149 epos > max_epos) 1150 /* 1151 * Don't go past the max position we're allowed. 1152 */ 1153 epos = max_epos; 1154 1155 if (epos == NULL_POSITION || epos > spos) 1156 { 1157 int search_type = SRCH_FORW | SRCH_FIND_ALL; 1158 search_type |= (search_info.search_type & SRCH_NO_REGEX); 1159 result = search_range(spos, epos, search_type, 0, 1160 maxlines, (POSITION*)NULL, &new_epos); 1161 if (result < 0) 1162 return; 1163 if (prep_endpos == NULL_POSITION || new_epos > prep_endpos) 1164 nprep_endpos = new_epos; 1165 } 1166 prep_startpos = nprep_startpos; 1167 prep_endpos = nprep_endpos; 1168 } 1169 1170 /* 1171 * Set the pattern to be used for line filtering. 1172 */ 1173 public void 1174 set_filter_pattern(pattern, search_type) 1175 char *pattern; 1176 int search_type; 1177 { 1178 clr_filter(); 1179 if (pattern == NULL || *pattern == '\0') 1180 clear_pattern(&filter_info); 1181 else 1182 set_pattern(&filter_info, pattern, search_type); 1183 screen_trashed = 1; 1184 } 1185 1186 /* 1187 * Is there a line filter in effect? 1188 */ 1189 public int 1190 is_filtering() 1191 { 1192 if (ch_getflags() & CH_HELPFILE) 1193 return (0); 1194 return prev_pattern(&filter_info); 1195 } 1196 #endif 1197 1198 #if HAVE_V8_REGCOMP 1199 /* 1200 * This function is called by the V8 regcomp to report 1201 * errors in regular expressions. 1202 */ 1203 void 1204 regerror(s) 1205 char *s; 1206 { 1207 PARG parg; 1208 1209 parg.p_string = s; 1210 error("%s", &parg); 1211 } 1212 #endif 1213 1214