=================================================================== RCS file: /cvsrepo/anoncvs/cvs/src/usr.bin/less/search.c,v retrieving revision 1.9 retrieving revision 1.10 diff -u -r1.9 -r1.10 --- src/usr.bin/less/search.c 2014/05/28 11:39:15 1.9 +++ src/usr.bin/less/search.c 2015/11/05 22:08:44 1.10 @@ -6,8 +6,11 @@ * * For more information, see the README file. */ +/* + * Modified for use with illumos. + * Copyright 2014 Garrett D'Amore + */ - /* * Routines to search a file for a pattern. */ @@ -17,8 +20,8 @@ #include "position.h" #include "charset.h" -#define MINPOS(a,b) (((a) < (b)) ? (a) : (b)) -#define MAXPOS(a,b) (((a) > (b)) ? (a) : (b)) +#define MINPOS(a, b) (((a) < (b)) ? (a) : (b)) +#define MAXPOS(a, b) (((a) > (b)) ? (a) : (b)) extern volatile sig_atomic_t sigs; extern int how_search; @@ -29,67 +32,57 @@ extern int bs_mode; extern int ctldisp; extern int status_col; -extern void * constant ml_search; -extern POSITION start_attnpos; -extern POSITION end_attnpos; +extern void *const ml_search; +extern off_t start_attnpos; +extern off_t end_attnpos; extern int utf_mode; extern int screen_trashed; -#if HILITE_SEARCH extern int hilite_search; extern int size_linebuf; extern int squished; extern int can_goto_line; -extern int less_is_more; static int hide_hilite; -static POSITION prep_startpos; -static POSITION prep_endpos; +static off_t prep_startpos; +static off_t prep_endpos; static int is_caseless; static int is_ucase_pattern; -struct hilite -{ +struct hilite { struct hilite *hl_next; - POSITION hl_startpos; - POSITION hl_endpos; + off_t hl_startpos; + off_t hl_endpos; }; -static struct hilite hilite_anchor = { NULL, NULL_POSITION, NULL_POSITION }; -static struct hilite filter_anchor = { NULL, NULL_POSITION, NULL_POSITION }; +static struct hilite hilite_anchor = { NULL, -1, -1 }; +static struct hilite filter_anchor = { NULL, -1, -1 }; #define hl_first hl_next -#endif /* * These are the static variables that represent the "remembered" * search pattern and filter pattern. */ struct pattern_info { - DEFINE_PATTERN(compiled); - char* text; + regex_t *compiled; + char *text; int search_type; }; -#if NO_REGEX -#define info_compiled(info) ((void*)0) -#else -#define info_compiled(info) ((info)->compiled) -#endif - +#define info_compiled(info) ((info)->compiled) + static struct pattern_info search_info; static struct pattern_info filter_info; /* * Are there any uppercase letters in this string? */ - static int -is_ucase(str) - char *str; +static int +is_ucase(char *str) { char *str_end = str + strlen(str); LWCHAR ch; - while (str < str_end) - { + while (str < str_end) { ch = step_char(&str, +1, str_end); - if (IS_UPPER(ch)) + if (isupper(ch)) return (1); } return (0); @@ -98,24 +91,20 @@ /* * Compile and save a search pattern. */ - static int -set_pattern(info, pattern, search_type) - struct pattern_info *info; - char *pattern; - int search_type; +static int +set_pattern(struct pattern_info *info, char *pattern, int search_type) { -#if !NO_REGEX if (pattern == NULL) - CLEAR_PATTERN(info->compiled); + info->compiled = NULL; else if (compile_pattern(pattern, search_type, &info->compiled) < 0) - return -1; -#endif + return (-1); /* Pattern compiled successfully; save the text too. */ if (info->text != NULL) free(info->text); info->text = NULL; - if (pattern != NULL) - info->text = save(pattern); + if (pattern != NULL) { + info->text = estrdup(pattern); + } info->search_type = search_type; /* @@ -123,36 +112,32 @@ * -i is set AND the pattern is all lowercase. */ is_ucase_pattern = is_ucase(pattern); - if (is_ucase_pattern && caseless != OPT_ONPLUS && (caseless != OPT_ON || !less_is_more)) + if (is_ucase_pattern && caseless != OPT_ONPLUS) is_caseless = 0; else is_caseless = caseless; - return 0; + return (0); } /* * Discard a saved pattern. */ - static void -clear_pattern(info) - struct pattern_info *info; +static void +clear_pattern(struct pattern_info *info) { if (info->text != NULL) free(info->text); info->text = NULL; -#if !NO_REGEX uncompile_pattern(&info->compiled); -#endif } /* * Initialize saved pattern to nothing. */ - static void -init_pattern(info) - struct pattern_info *info; +static void +init_pattern(struct pattern_info *info) { - CLEAR_PATTERN(info->compiled); + info->compiled = NULL; info->text = NULL; info->search_type = 0; } @@ -160,8 +145,8 @@ /* * Initialize search variables. */ - public void -init_search() +void +init_search(void) { init_pattern(&search_info); init_pattern(&filter_info); @@ -170,20 +155,18 @@ /* * Determine which text conversions to perform before pattern matching. */ - static int -get_cvt_ops() +static int +get_cvt_ops(void) { int ops = 0; - if (is_caseless || bs_mode == BS_SPECIAL) - { - if (is_caseless) + if (is_caseless || bs_mode == BS_SPECIAL) { + if (is_caseless) ops |= CVT_TO_LC; if (bs_mode == BS_SPECIAL) ops |= CVT_BS; if (bs_mode != BS_CONTROL) ops |= CVT_CRLF; - } else if (bs_mode != BS_CONTROL) - { + } else if (bs_mode != BS_CONTROL) { ops |= CVT_CRLF; } if (ctldisp == OPT_ONPLUS) @@ -194,56 +177,46 @@ /* * Is there a previous (remembered) search pattern? */ - static int -prev_pattern(info) - struct pattern_info *info; +static int +prev_pattern(struct pattern_info *info) { -#if !NO_REGEX if ((info->search_type & SRCH_NO_REGEX) == 0) return (!is_null_pattern(info->compiled)); -#endif return (info->text != NULL); } -#if HILITE_SEARCH /* * Repaint the hilites currently displayed on the screen. * Repaint each line which contains highlighted text. * If on==0, force all hilites off. */ - public void -repaint_hilite(on) - int on; +void +repaint_hilite(int on) { int slinenum; - POSITION pos; - POSITION epos; + off_t pos; int save_hide_hilite; if (squished) repaint(); save_hide_hilite = hide_hilite; - if (!on) - { + if (!on) { if (hide_hilite) return; hide_hilite = 1; } - if (!can_goto_line) - { + if (!can_goto_line) { repaint(); hide_hilite = save_hide_hilite; return; } - for (slinenum = TOP; slinenum < TOP + sc_height-1; slinenum++) - { + for (slinenum = TOP; slinenum < TOP + sc_height-1; slinenum++) { pos = position(slinenum); - if (pos == NULL_POSITION) + if (pos == -1) continue; - epos = position(slinenum+1); (void) forw_line(pos); goto_line(slinenum); put_line(); @@ -255,39 +228,36 @@ /* * Clear the attn hilite. */ - public void -clear_attn() +void +clear_attn(void) { int slinenum; - POSITION old_start_attnpos; - POSITION old_end_attnpos; - POSITION pos; - POSITION epos; + off_t old_start_attnpos; + off_t old_end_attnpos; + off_t pos; + off_t epos; int moved = 0; - if (start_attnpos == NULL_POSITION) + if (start_attnpos == -1) return; old_start_attnpos = start_attnpos; old_end_attnpos = end_attnpos; - start_attnpos = end_attnpos = NULL_POSITION; + start_attnpos = end_attnpos = -1; - if (!can_goto_line) - { + if (!can_goto_line) { repaint(); return; } if (squished) repaint(); - for (slinenum = TOP; slinenum < TOP + sc_height-1; slinenum++) - { + for (slinenum = TOP; slinenum < TOP + sc_height-1; slinenum++) { pos = position(slinenum); - if (pos == NULL_POSITION) + if (pos == -1) continue; epos = position(slinenum+1); if (pos < old_end_attnpos && - (epos == NULL_POSITION || epos > old_start_attnpos)) - { + (epos == -1 || epos > old_start_attnpos)) { (void) forw_line(pos); goto_line(slinenum); put_line(); @@ -297,53 +267,46 @@ if (moved) lower_left(); } -#endif /* * Hide search string highlighting. */ - public void -undo_search() +void +undo_search(void) { - if (!prev_pattern(&search_info)) - { + if (!prev_pattern(&search_info)) { error("No previous regular expression", NULL_PARG); return; } -#if HILITE_SEARCH hide_hilite = !hide_hilite; repaint_hilite(1); -#endif } -#if HILITE_SEARCH /* * Clear the hilite list. */ - public void -clr_hlist(anchor) - struct hilite *anchor; +static void +clr_hlist(struct hilite *anchor) { struct hilite *hl; struct hilite *nexthl; - for (hl = anchor->hl_first; hl != NULL; hl = nexthl) - { + for (hl = anchor->hl_first; hl != NULL; hl = nexthl) { nexthl = hl->hl_next; free((void*)hl); } anchor->hl_first = NULL; - prep_startpos = prep_endpos = NULL_POSITION; + prep_startpos = prep_endpos = -1; } - public void -clr_hilite() +void +clr_hilite(void) { clr_hlist(&hilite_anchor); } - public void -clr_filter() +static void +clr_filter(void) { clr_hlist(&filter_anchor); } @@ -352,30 +315,26 @@ * Should any characters in a specified range be highlighted? */ static int -is_hilited_range(pos, epos) - POSITION pos; - POSITION epos; +is_hilited_range(off_t pos, off_t epos) { struct hilite *hl; /* * Look at each highlight and see if any part of it falls in the range. */ - for (hl = hilite_anchor.hl_first; hl != NULL; hl = hl->hl_next) - { + for (hl = hilite_anchor.hl_first; hl != NULL; hl = hl->hl_next) { if (hl->hl_endpos > pos && - (epos == NULL_POSITION || epos > hl->hl_startpos)) + (epos == -1 || epos > hl->hl_startpos)) return (1); } return (0); } -/* +/* * Is a line "filtered" -- that is, should it be hidden? */ - public int -is_filtered(pos) - POSITION pos; +int +is_filtered(off_t pos) { struct hilite *hl; @@ -386,8 +345,7 @@ * Look at each filter and see if the start position * equals the start position of the line. */ - for (hl = filter_anchor.hl_first; hl != NULL; hl = hl->hl_next) - { + for (hl = filter_anchor.hl_first; hl != NULL; hl = hl->hl_next) { if (hl->hl_startpos == pos) return (1); } @@ -398,12 +356,8 @@ * Should any characters in a specified range be highlighted? * If nohide is nonzero, don't consider hide_hilite. */ - public int -is_hilited(pos, epos, nohide, p_matches) - POSITION pos; - POSITION epos; - int nohide; - int *p_matches; +int +is_hilited(off_t pos, off_t epos, int nohide, int *p_matches) { int match; @@ -411,9 +365,9 @@ *p_matches = 0; if (!status_col && - start_attnpos != NULL_POSITION && + start_attnpos != -1 && pos < end_attnpos && - (epos == NULL_POSITION || epos > start_attnpos)) + (epos == -1 || epos > start_attnpos)) /* * The attn line overlaps this range. */ @@ -447,10 +401,8 @@ /* * Add a new hilite to a hilite list. */ - static void -add_hilite(anchor, hl) - struct hilite *anchor; - struct hilite *hl; +static void +add_hilite(struct hilite *anchor, struct hilite *hl) { struct hilite *ihl; @@ -471,9 +423,9 @@ if (ihl != anchor) hl->hl_startpos = MAXPOS(hl->hl_startpos, ihl->hl_endpos); if (ihl->hl_next != NULL) - hl->hl_endpos = MINPOS(hl->hl_endpos, ihl->hl_next->hl_startpos); - if (hl->hl_startpos >= hl->hl_endpos) - { + hl->hl_endpos = MINPOS(hl->hl_endpos, + ihl->hl_next->hl_startpos); + if (hl->hl_startpos >= hl->hl_endpos) { /* * Hilite was truncated out of existence. */ @@ -487,18 +439,14 @@ /* * Hilight every character in a range of displayed characters. */ - static void -create_hilites(linepos, start_index, end_index, chpos) - POSITION linepos; - int start_index; - int end_index; - int *chpos; +static void +create_hilites(off_t linepos, int start_index, int end_index, int *chpos) { struct hilite *hl; int i; /* Start the first hilite. */ - hl = (struct hilite *) ecalloc(1, sizeof(struct hilite)); + hl = ecalloc(1, sizeof (struct hilite)); hl->hl_startpos = linepos + chpos[start_index]; /* @@ -509,16 +457,13 @@ * Otherwise (there are backspaces or something involved), * finish the current hilite and start a new one. */ - for (i = start_index+1; i <= end_index; i++) - { - if (chpos[i] != chpos[i-1] + 1 || i == end_index) - { + for (i = start_index+1; i <= end_index; i++) { + if (chpos[i] != chpos[i-1] + 1 || i == end_index) { hl->hl_endpos = linepos + chpos[i-1] + 1; add_hilite(&hilite_anchor, hl); /* Start new hilite unless this is the last char. */ - if (i < end_index) - { - hl = (struct hilite *) ecalloc(1, sizeof(struct hilite)); + if (i < end_index) { + hl = ecalloc(1, sizeof (struct hilite)); hl->hl_startpos = linepos + chpos[i]; } } @@ -526,19 +471,13 @@ } /* - * Make a hilite for each string in a physical line which matches + * Make a hilite for each string in a physical line which matches * the current pattern. * sp,ep delimit the first match already found. */ - static void -hilite_line(linepos, line, line_len, chpos, sp, ep, cvt_ops) - POSITION linepos; - char *line; - int line_len; - int *chpos; - char *sp; - char *ep; - int cvt_ops; +static void +hilite_line(off_t linepos, char *line, int line_len, int *chpos, + char *sp, char *ep) { char *searchp; char *line_end = line + line_len; @@ -557,7 +496,8 @@ */ searchp = line; do { - create_hilites(linepos, sp-line, ep-line, chpos); + create_hilites(linepos, (intptr_t)sp - (intptr_t)line, + (intptr_t)ep - (intptr_t)line, chpos); /* * If we matched more than zero characters, * move to the first char after the string we matched. @@ -570,16 +510,16 @@ else /* end of line */ break; } while (match_pattern(info_compiled(&search_info), search_info.text, - searchp, line_end - searchp, &sp, &ep, 1, search_info.search_type)); + searchp, (intptr_t)line_end - (intptr_t)searchp, &sp, &ep, 1, + search_info.search_type)); } -#endif /* - * Change the caseless-ness of searches. + * Change the caseless-ness of searches. * Updates the internal search state to reflect a change in the -i flag. */ - public void -chg_caseless() +void +chg_caseless(void) { if (!is_ucase_pattern) /* @@ -595,17 +535,16 @@ clear_pattern(&search_info); } -#if HILITE_SEARCH /* * Find matching text which is currently on screen and highlight it. */ - static void -hilite_screen() +static void +hilite_screen(void) { struct scrpos scrpos; get_scrpos(&scrpos); - if (scrpos.pos == NULL_POSITION) + if (scrpos.pos == -1) return; prep_hilite(scrpos.pos, position(BOTTOM_PLUS_ONE), -1); repaint_hilite(1); @@ -614,8 +553,8 @@ /* * Change highlighting parameters. */ - public void -chg_hilite() +void +chg_hilite(void) { /* * Erase any highlights currently on screen. @@ -629,46 +568,38 @@ */ hilite_screen(); } -#endif /* * Figure out where to start a search. */ - static POSITION -search_pos(search_type) - int search_type; +static off_t +search_pos(int search_type) { - POSITION pos; + off_t pos; int linenum; - if (empty_screen()) - { + if (empty_screen()) { /* * Start at the beginning (or end) of the file. - * The empty_screen() case is mainly for + * The empty_screen() case is mainly for * command line initiated searches; * for example, "+/xyz" on the command line. * Also for multi-file (SRCH_PAST_EOF) searches. */ - if (search_type & SRCH_FORW) - { + if (search_type & SRCH_FORW) { pos = ch_zero(); - } else - { + } else { pos = ch_length(); - if (pos == NULL_POSITION) - { + if (pos == -1) { (void) ch_end_seek(); pos = ch_length(); } } linenum = 0; - } else - { + } else { int add_one = 0; - if (how_search == OPT_ON) - { + if (how_search == OPT_ON) { /* * Search does not include current screen. */ @@ -676,8 +607,8 @@ linenum = BOTTOM_PLUS_ONE; else linenum = TOP; - } else if (how_search == OPT_ONPLUS && !(search_type & SRCH_AFTER_TARGET)) - { + } else if (how_search == OPT_ONPLUS && + !(search_type & SRCH_AFTER_TARGET)) { /* * Search includes all of displayed screen. */ @@ -685,42 +616,39 @@ linenum = TOP; else linenum = BOTTOM_PLUS_ONE; - } else - { + } else { /* - * Search includes the part of current screen beyond the jump target. - * It starts at the jump target (if searching backwards), - * or at the jump target plus one (if forwards). + * Search includes the part of current screen beyond + * the jump target. + * It starts at the jump target (if searching + * backwards), or at the jump target plus one + * (if forwards). */ linenum = jump_sline; - if (search_type & SRCH_FORW) - add_one = 1; + if (search_type & SRCH_FORW) + add_one = 1; } linenum = adjsline(linenum); pos = position(linenum); if (add_one) - pos = forw_raw_line(pos, (char **)NULL, (int *)NULL); + pos = forw_raw_line(pos, NULL, NULL); } /* * If the line is empty, look around for a plausible starting place. */ - if (search_type & SRCH_FORW) - { - while (pos == NULL_POSITION) - { - if (++linenum >= sc_height) - break; - pos = position(linenum); - } - } else - { - while (pos == NULL_POSITION) - { - if (--linenum < 0) - break; - pos = position(linenum); - } + if (search_type & SRCH_FORW) { + while (pos == -1) { + if (++linenum >= sc_height) + break; + pos = position(linenum); + } + } else { + while (pos == -1) { + if (--linenum < 0) + break; + pos = position(linenum); + } } return (pos); } @@ -728,15 +656,9 @@ /* * Search a subset of the file, specified by start/end position. */ - static int -search_range(pos, endpos, search_type, matches, maxlines, plinepos, pendpos) - POSITION pos; - POSITION endpos; - int search_type; - int matches; - int maxlines; - POSITION *plinepos; - POSITION *pendpos; +static int +search_range(off_t pos, off_t endpos, int search_type, int matches, + int maxlines, off_t *plinepos, off_t *pendpos) { char *line; char *cline; @@ -747,27 +669,25 @@ int cvt_ops; int cvt_len; int *chpos; - POSITION linepos, oldpos; + off_t linepos, oldpos; linenum = find_linenum(pos); oldpos = pos; - for (;;) - { + for (;;) { /* * Get lines until we find a matching one or until - * we hit end-of-file (or beginning-of-file if we're + * we hit end-of-file (or beginning-of-file if we're * going backwards), or until we hit the end position. */ - if (ABORT_SIGS()) - { + if (ABORT_SIGS()) { /* * A signal aborts the search. */ return (-1); } - if ((endpos != NULL_POSITION && pos >= endpos) || maxlines == 0) - { + if ((endpos != -1 && pos >= endpos) || + maxlines == 0) { /* * Reached end position without a match. */ @@ -778,18 +698,16 @@ if (maxlines > 0) maxlines--; - if (search_type & SRCH_FORW) - { + if (search_type & SRCH_FORW) { /* - * Read the next line, and save the + * Read the next line, and save the * starting position of that line in linepos. */ linepos = pos; pos = forw_raw_line(pos, &line, &line_len); if (linenum != 0) linenum++; - } else - { + } else { /* * Read the previous line and save the * starting position of that line in linepos. @@ -800,8 +718,7 @@ linenum--; } - if (pos == NULL_POSITION) - { + if (pos == -1) { /* * Reached EOF/BOF without a match. */ @@ -830,71 +747,68 @@ * If we're doing backspace processing, delete backspaces. */ cvt_ops = get_cvt_ops(); - cvt_len = cvt_length(line_len, cvt_ops); - cline = (char *) ecalloc(1, cvt_len); + cvt_len = cvt_length(line_len); + cline = ecalloc(1, cvt_len); chpos = cvt_alloc_chpos(cvt_len); cvt_text(cline, line, chpos, &line_len, cvt_ops); -#if HILITE_SEARCH /* * Check to see if the line matches the filter pattern. * If so, add an entry to the filter list. */ - if ((search_type & SRCH_FIND_ALL) && prev_pattern(&filter_info)) { - int line_filter = match_pattern(info_compiled(&filter_info), filter_info.text, - cline, line_len, &sp, &ep, 0, filter_info.search_type); - if (line_filter) - { - struct hilite *hl = (struct hilite *) - ecalloc(1, sizeof(struct hilite)); + if ((search_type & SRCH_FIND_ALL) && + prev_pattern(&filter_info)) { + int line_filter = + match_pattern(info_compiled(&filter_info), + filter_info.text, cline, line_len, &sp, &ep, 0, + filter_info.search_type); + if (line_filter) { + struct hilite *hl = + ecalloc(1, sizeof (struct hilite)); hl->hl_startpos = linepos; hl->hl_endpos = pos; add_hilite(&filter_anchor, hl); } } -#endif /* * Test the next line to see if we have a match. * We are successful if we either want a match and got one, * or if we want a non-match and got one. */ - if (prev_pattern(&search_info)) - { - line_match = match_pattern(info_compiled(&search_info), search_info.text, - cline, line_len, &sp, &ep, 0, search_type); - if (line_match) - { + if (prev_pattern(&search_info)) { + line_match = match_pattern(info_compiled(&search_info), + search_info.text, cline, line_len, &sp, &ep, 0, + search_type); + if (line_match) { /* * Got a match. */ - if (search_type & SRCH_FIND_ALL) - { -#if HILITE_SEARCH + if (search_type & SRCH_FIND_ALL) { /* - * We are supposed to find all matches in the range. - * Just add the matches in this line to the - * hilite list and keep searching. + * We are supposed to find all matches + * in the range. + * Just add the matches in this line + * to the hilite list and keep + * searching. */ - hilite_line(linepos, cline, line_len, chpos, sp, ep, cvt_ops); -#endif - } else if (--matches <= 0) - { + hilite_line(linepos, cline, line_len, + chpos, sp, ep); + } else if (--matches <= 0) { /* - * Found the one match we're looking for. - * Return it. + * Found the one match we're looking + * for. Return it. */ -#if HILITE_SEARCH - if (hilite_search == OPT_ON) - { + if (hilite_search == OPT_ON) { /* - * Clear the hilite list and add only + * Clear the hilite list and + * add only * the matches in this one line. */ clr_hilite(); - hilite_line(linepos, cline, line_len, chpos, sp, ep, cvt_ops); + hilite_line(linepos, cline, + line_len, chpos, sp, ep); } -#endif free(cline); free(chpos); if (plinepos != NULL) @@ -911,11 +825,9 @@ /* * search for a pattern in history. If found, compile that pattern. */ - static int -hist_pattern(search_type) - int search_type; +static int +hist_pattern(int search_type) { -#if CMD_HISTORY char *pattern; set_mlist(ml_search, 0); @@ -926,62 +838,48 @@ if (set_pattern(&search_info, pattern, search_type) < 0) return (0); -#if HILITE_SEARCH if (hilite_search == OPT_ONPLUS && !hide_hilite) hilite_screen(); -#endif return (1); -#else /* CMD_HISTORY */ - return (0); -#endif /* CMD_HISTORY */ } /* - * Search for the n-th occurrence of a specified pattern, + * Search for the n-th occurrence of a specified pattern, * either forward or backward. * Return the number of matches not yet found in this file * (that is, n minus the number of matches found). * Return -1 if the search should be aborted. - * Caller may continue the search in another file + * Caller may continue the search in another file * if less than n matches are found in this file. */ - public int -search(search_type, pattern, n) - int search_type; - char *pattern; - int n; +int +search(int search_type, char *pattern, int n) { - POSITION pos; + off_t pos; - if (pattern == NULL || *pattern == '\0') - { + if (pattern == NULL || *pattern == '\0') { /* * A null pattern means use the previously compiled pattern. */ search_type |= SRCH_AFTER_TARGET; - if (!prev_pattern(&search_info) && !hist_pattern(search_type)) - { + if (!prev_pattern(&search_info) && !hist_pattern(search_type)) { error("No previous regular expression", NULL_PARG); return (-1); } - if ((search_type & SRCH_NO_REGEX) != - (search_info.search_type & SRCH_NO_REGEX)) - { + if ((search_type & SRCH_NO_REGEX) != + (search_info.search_type & SRCH_NO_REGEX)) { error("Please re-enter search pattern", NULL_PARG); - return -1; + return (-1); } -#if HILITE_SEARCH - if (hilite_search == OPT_ON) - { + if (hilite_search == OPT_ON) { /* * Erase the highlights currently on screen. * If the search fails, we'll redisplay them later. */ repaint_hilite(0); } - if (hilite_search == OPT_ONPLUS && hide_hilite) - { + if (hilite_search == OPT_ONPLUS && hide_hilite) { /* * Highlight any matches currently on screen, * before we actually start the search. @@ -990,17 +888,13 @@ hilite_screen(); } hide_hilite = 0; -#endif - } else - { + } else { /* * Compile the pattern. */ if (set_pattern(&search_info, pattern, search_type) < 0) return (-1); -#if HILITE_SEARCH - if (hilite_search) - { + if (hilite_search) { /* * Erase the highlights currently on screen. * Also permanently delete them from the hilite list. @@ -1009,23 +903,20 @@ hide_hilite = 0; clr_hilite(); } - if (hilite_search == OPT_ONPLUS) - { + if (hilite_search == OPT_ONPLUS) { /* * Highlight any matches currently on screen, * before we actually start the search. */ hilite_screen(); } -#endif } /* * Figure out where to start the search. */ pos = search_pos(search_type); - if (pos == NULL_POSITION) - { + if (pos == -1) { /* * Can't find anyplace to start searching from. */ @@ -1036,63 +927,52 @@ return (-1); } - n = search_range(pos, NULL_POSITION, search_type, n, -1, - &pos, (POSITION*)NULL); - if (n != 0) - { + n = search_range(pos, -1, search_type, n, -1, &pos, NULL); + if (n != 0) { /* * Search was unsuccessful. */ -#if HILITE_SEARCH if (hilite_search == OPT_ON && n > 0) /* * Redisplay old hilites. */ repaint_hilite(1); -#endif return (n); } - if (!(search_type & SRCH_NO_MOVE)) - { + if (!(search_type & SRCH_NO_MOVE)) { /* * Go to the matching line. */ jump_loc(pos, jump_sline); } -#if HILITE_SEARCH if (hilite_search == OPT_ON) /* * Display new hilites in the matching line. */ repaint_hilite(1); -#endif return (0); } -#if HILITE_SEARCH /* * Prepare hilites in a given range of the file. * * The pair (prep_startpos,prep_endpos) delimits a contiguous region * of the file that has been "prepared"; that is, scanned for matches for * the current search pattern, and hilites have been created for such matches. - * If prep_startpos == NULL_POSITION, the prep region is empty. - * If prep_endpos == NULL_POSITION, the prep region extends to EOF. + * If prep_startpos == -1, the prep region is empty. + * If prep_endpos == -1, the prep region extends to EOF. * prep_hilite asks that the range (spos,epos) be covered by the prep region. */ - public void -prep_hilite(spos, epos, maxlines) - POSITION spos; - POSITION epos; - int maxlines; +void +prep_hilite(off_t spos, off_t epos, int maxlines) { - POSITION nprep_startpos = prep_startpos; - POSITION nprep_endpos = prep_endpos; - POSITION new_epos; - POSITION max_epos; + off_t nprep_startpos = prep_startpos; + off_t nprep_endpos = prep_endpos; + off_t new_epos; + off_t max_epos; int result; int i; @@ -1109,13 +989,12 @@ * If we're limited to a max number of lines, figure out the * file position we should stop at. */ - if (maxlines < 0) - max_epos = NULL_POSITION; - else - { + if (maxlines < 0) { + max_epos = -1; + } else { max_epos = spos; - for (i = 0; i < maxlines; i++) - max_epos = forw_raw_line(max_epos, (char **)NULL, (int *)NULL); + for (i = 0; i < maxlines; i++) + max_epos = forw_raw_line(max_epos, NULL, NULL); } /* @@ -1124,51 +1003,45 @@ * the "prep" region will then cover (nprep_startpos,nprep_endpos). */ - if (prep_startpos == NULL_POSITION || - (epos != NULL_POSITION && epos < prep_startpos) || - spos > prep_endpos) - { + if (prep_startpos == -1 || + (epos != -1 && epos < prep_startpos) || + spos > prep_endpos) { /* * New range is not contiguous with old prep region. * Discard the old prep region and start a new one. */ clr_hilite(); clr_filter(); - if (epos != NULL_POSITION) + if (epos != -1) epos += SEARCH_MORE; nprep_startpos = spos; - } else - { + } else { /* * New range partially or completely overlaps old prep region. */ - if (epos == NULL_POSITION) - { - /* - * New range goes to end of file. - */ - ; - } else if (epos > prep_endpos) - { - /* - * New range ends after old prep region. - * Extend prep region to end at end of new range. - */ - epos += SEARCH_MORE; - } else /* (epos <= prep_endpos) */ - { - /* - * New range ends within old prep region. - * Truncate search to end at start of old prep region. - */ - epos = prep_startpos; + if (epos != -1) { + if (epos > prep_endpos) { + /* + * New range ends after old prep region. + * Extend prep region to end at end of new + * range. + */ + epos += SEARCH_MORE; + + } else { + /* + * New range ends within old prep region. + * Truncate search to end at start of old prep + * region. + */ + epos = prep_startpos; + } } - if (spos < prep_startpos) - { + if (spos < prep_startpos) { /* * New range starts before old prep region. - * Extend old prep region backwards to start at + * Extend old prep region backwards to start at * start of new range. */ if (spos < SEARCH_MORE) @@ -1176,8 +1049,7 @@ else spos -= SEARCH_MORE; nprep_startpos = spos; - } else /* (spos >= prep_startpos) */ - { + } else { /* (spos >= prep_startpos) */ /* * New range starts within or after old prep region. * Trim search to start at end of old prep region. @@ -1186,22 +1058,21 @@ } } - if (epos != NULL_POSITION && max_epos != NULL_POSITION && + if (epos != -1 && max_epos != -1 && epos > max_epos) /* * Don't go past the max position we're allowed. */ epos = max_epos; - if (epos == NULL_POSITION || epos > spos) - { + if (epos == -1 || epos > spos) { int search_type = SRCH_FORW | SRCH_FIND_ALL; search_type |= (search_info.search_type & SRCH_NO_REGEX); result = search_range(spos, epos, search_type, 0, - maxlines, (POSITION*)NULL, &new_epos); + maxlines, NULL, &new_epos); if (result < 0) return; - if (prep_endpos == NULL_POSITION || new_epos > prep_endpos) + if (prep_endpos == -1 || new_epos > prep_endpos) nprep_endpos = new_epos; } prep_startpos = nprep_startpos; @@ -1211,44 +1082,24 @@ /* * Set the pattern to be used for line filtering. */ - public void -set_filter_pattern(pattern, search_type) - char *pattern; - int search_type; +void +set_filter_pattern(char *pattern, int search_type) { clr_filter(); if (pattern == NULL || *pattern == '\0') clear_pattern(&filter_info); else - set_pattern(&filter_info, pattern, search_type); + (void) set_pattern(&filter_info, pattern, search_type); screen_trashed = 1; } /* * Is there a line filter in effect? */ - public int -is_filtering() +int +is_filtering(void) { if (ch_getflags() & CH_HELPFILE) return (0); - return prev_pattern(&filter_info); + return (prev_pattern(&filter_info)); } -#endif - -#if HAVE_V8_REGCOMP -/* - * This function is called by the V8 regcomp to report - * errors in regular expressions. - */ - void -regerror(s) - char *s; -{ - PARG parg; - - parg.p_string = s; - error("%s", &parg); -} -#endif -