| /* isearch.c |
| * |
| * The functions in this file implement commands that perform incremental |
| * searches in the forward and backward directions. This "ISearch" command |
| * is intended to emulate the same command from the original EMACS |
| * implementation (ITS). Contains references to routines internal to |
| * SEARCH.C. |
| * |
| * REVISION HISTORY: |
| * |
| * D. R. Banks 9-May-86 |
| * - added ITS EMACSlike ISearch |
| * |
| * John M. Gamble 5-Oct-86 |
| * - Made iterative search use search.c's scanner() routine. |
| * This allowed the elimination of bakscan(). |
| * - Put isearch constants into estruct.h |
| * - Eliminated the passing of 'status' to scanmore() and |
| * checknext(), since there were no circumstances where |
| * it ever equalled FALSE. |
| * |
| * Modified by Petri Kutvonen |
| */ |
| |
| #include <stdio.h> |
| |
| #include "estruct.h" |
| #include "edef.h" |
| #include "efunc.h" |
| #include "line.h" |
| |
| #if ISRCH |
| |
| static int echo_char(int c, int col); |
| |
| /* A couple of "own" variables for re-eat */ |
| |
| static int (*saved_get_char) (void); /* Get character routine */ |
| static int eaten_char = -1; /* Re-eaten char */ |
| |
| /* A couple more "own" variables for the command string */ |
| |
| static int cmd_buff[CMDBUFLEN]; /* Save the command args here */ |
| static int cmd_offset; /* Current offset into command buff */ |
| static int cmd_reexecute = -1; /* > 0 if re-executing command */ |
| |
| |
| /* |
| * Subroutine to do incremental reverse search. It actually uses the |
| * same code as the normal incremental search, as both can go both ways. |
| */ |
| int risearch(int f, int n) |
| { |
| struct line *curline; /* Current line on entry */ |
| int curoff; /* Current offset on entry */ |
| |
| /* remember the initial . on entry: */ |
| |
| curline = curwp->w_dotp; /* Save the current line pointer */ |
| curoff = curwp->w_doto; /* Save the current offset */ |
| |
| /* Make sure the search doesn't match where we already are: */ |
| |
| backchar(TRUE, 1); /* Back up a character */ |
| |
| if (!(isearch(f, -n))) { /* Call ISearch backwards *//* If error in search: */ |
| curwp->w_dotp = curline; /* Reset the line pointer */ |
| curwp->w_doto = curoff; /* and the offset to original value */ |
| curwp->w_flag |= WFMOVE; /* Say we've moved */ |
| update(FALSE); /* And force an update */ |
| mlwrite("(search failed)"); /* Say we died */ |
| #if PKCODE |
| matchlen = strlen(pat); |
| #endif |
| } else |
| mlerase(); /* If happy, just erase the cmd line */ |
| #if PKCODE |
| matchlen = strlen(pat); |
| #endif |
| return TRUE; |
| } |
| |
| /* |
| * Again, but for the forward direction |
| */ |
| int fisearch(int f, int n) |
| { |
| struct line *curline; /* Current line on entry */ |
| int curoff; /* Current offset on entry */ |
| |
| /* remember the initial . on entry: */ |
| |
| curline = curwp->w_dotp; /* Save the current line pointer */ |
| curoff = curwp->w_doto; /* Save the current offset */ |
| |
| /* do the search */ |
| |
| if (!(isearch(f, n))) { /* Call ISearch forwards *//* If error in search: */ |
| curwp->w_dotp = curline; /* Reset the line pointer */ |
| curwp->w_doto = curoff; /* and the offset to original value */ |
| curwp->w_flag |= WFMOVE; /* Say we've moved */ |
| update(FALSE); /* And force an update */ |
| mlwrite("(search failed)"); /* Say we died */ |
| #if PKCODE |
| matchlen = strlen(pat); |
| #endif |
| } else |
| mlerase(); /* If happy, just erase the cmd line */ |
| #if PKCODE |
| matchlen = strlen(pat); |
| #endif |
| return TRUE; |
| } |
| |
| /* |
| * Subroutine to do an incremental search. In general, this works similarly |
| * to the older micro-emacs search function, except that the search happens |
| * as each character is typed, with the screen and cursor updated with each |
| * new search character. |
| * |
| * While searching forward, each successive character will leave the cursor |
| * at the end of the entire matched string. Typing a Control-S or Control-X |
| * will cause the next occurrence of the string to be searched for (where the |
| * next occurrence does NOT overlap the current occurrence). A Control-R will |
| * change to a backwards search, META will terminate the search and Control-G |
| * will abort the search. Rubout will back up to the previous match of the |
| * string, or if the starting point is reached first, it will delete the |
| * last character from the search string. |
| * |
| * While searching backward, each successive character will leave the cursor |
| * at the beginning of the matched string. Typing a Control-R will search |
| * backward for the next occurrence of the string. Control-S or Control-X |
| * will revert the search to the forward direction. In general, the reverse |
| * incremental search is just like the forward incremental search inverted. |
| * |
| * In all cases, if the search fails, the user will be feeped, and the search |
| * will stall until the pattern string is edited back into something that |
| * exists (or until the search is aborted). |
| */ |
| |
| int isearch(int f, int n) |
| { |
| int status; /* Search status */ |
| int col; /* prompt column */ |
| int cpos; /* character number in search string */ |
| int c; /* current input character */ |
| int expc; /* function expanded input char */ |
| char pat_save[NPAT]; /* Saved copy of the old pattern str */ |
| struct line *curline; /* Current line on entry */ |
| int curoff; /* Current offset on entry */ |
| int init_direction; /* The initial search direction */ |
| |
| /* Initialize starting conditions */ |
| |
| cmd_reexecute = -1; /* We're not re-executing (yet?) */ |
| cmd_offset = 0; /* Start at the beginning of the buff */ |
| cmd_buff[0] = '\0'; /* Init the command buffer */ |
| strncpy(pat_save, pat, NPAT); /* Save the old pattern string */ |
| curline = curwp->w_dotp; /* Save the current line pointer */ |
| curoff = curwp->w_doto; /* Save the current offset */ |
| init_direction = n; /* Save the initial search direction */ |
| |
| /* This is a good place to start a re-execution: */ |
| |
| start_over: |
| |
| /* ask the user for the text of a pattern */ |
| col = promptpattern("ISearch: "); /* Prompt, remember the col */ |
| |
| cpos = 0; /* Start afresh */ |
| status = TRUE; /* Assume everything's cool */ |
| |
| /* |
| Get the first character in the pattern. If we get an initial Control-S |
| or Control-R, re-use the old search string and find the first occurrence |
| */ |
| |
| c = ectoc(expc = get_char()); /* Get the first character */ |
| if ((c == IS_FORWARD) || (c == IS_REVERSE) || (c == IS_VMSFORW)) { /* Reuse old search string? */ |
| for (cpos = 0; pat[cpos] != 0; cpos++) /* Yup, find the length */ |
| col = echo_char(pat[cpos], col); /* and re-echo the string */ |
| if (c == IS_REVERSE) { /* forward search? */ |
| n = -1; /* No, search in reverse */ |
| backchar(TRUE, 1); /* Be defensive about EOB */ |
| } else |
| n = 1; /* Yes, search forward */ |
| status = scanmore(pat, n); /* Do the search */ |
| c = ectoc(expc = get_char()); /* Get another character */ |
| } |
| |
| /* Top of the per character loop */ |
| |
| for (;;) { /* ISearch per character loop */ |
| /* Check for special characters first: */ |
| /* Most cases here change the search */ |
| |
| if (expc == metac) /* Want to quit searching? */ |
| return TRUE; /* Quit searching now */ |
| |
| switch (c) { /* dispatch on the input char */ |
| case IS_ABORT: /* If abort search request */ |
| return FALSE; /* Quit searching again */ |
| |
| case IS_REVERSE: /* If backward search */ |
| case IS_FORWARD: /* If forward search */ |
| case IS_VMSFORW: /* of either flavor */ |
| if (c == IS_REVERSE) /* If reverse search */ |
| n = -1; /* Set the reverse direction */ |
| else /* Otherwise, */ |
| n = 1; /* go forward */ |
| status = scanmore(pat, n); /* Start the search again */ |
| c = ectoc(expc = get_char()); /* Get the next char */ |
| continue; /* Go continue with the search */ |
| |
| case IS_NEWLINE: /* Carriage return */ |
| c = '\n'; /* Make it a new line */ |
| break; /* Make sure we use it */ |
| |
| case IS_QUOTE: /* Quote character */ |
| case IS_VMSQUOTE: /* of either variety */ |
| c = ectoc(expc = get_char()); /* Get the next char */ |
| |
| case IS_TAB: /* Generically allowed */ |
| case '\n': /* controlled characters */ |
| break; /* Make sure we use it */ |
| |
| case IS_BACKSP: /* If a backspace: */ |
| case IS_RUBOUT: /* or if a Rubout: */ |
| if (cmd_offset <= 1) /* Anything to delete? */ |
| return TRUE; /* No, just exit */ |
| --cmd_offset; /* Back up over the Rubout */ |
| cmd_buff[--cmd_offset] = '\0'; /* Yes, delete last char */ |
| curwp->w_dotp = curline; /* Reset the line pointer */ |
| curwp->w_doto = curoff; /* and the offset */ |
| n = init_direction; /* Reset the search direction */ |
| strncpy(pat, pat_save, NPAT); /* Restore the old search str */ |
| cmd_reexecute = 0; /* Start the whole mess over */ |
| goto start_over; /* Let it take care of itself */ |
| |
| /* Presumably a quasi-normal character comes here */ |
| |
| default: /* All other chars */ |
| if (c < ' ') { /* Is it printable? *//* Nope. */ |
| reeat(c); /* Re-eat the char */ |
| return TRUE; /* And return the last status */ |
| } |
| } /* Switch */ |
| |
| /* I guess we got something to search for, so search for it */ |
| |
| pat[cpos++] = c; /* put the char in the buffer */ |
| if (cpos >= NPAT) { /* too many chars in string? *//* Yup. Complain about it */ |
| mlwrite("? Search string too long"); |
| return TRUE; /* Return an error */ |
| } |
| pat[cpos] = 0; /* null terminate the buffer */ |
| col = echo_char(c, col); /* Echo the character */ |
| if (!status) { /* If we lost last time */ |
| TTputc(BELL); /* Feep again */ |
| TTflush(); /* see that the feep feeps */ |
| } else /* Otherwise, we must have won */ if (!(status = checknext(c, pat, n))) /* See if match */ |
| status = scanmore(pat, n); /* or find the next match */ |
| c = ectoc(expc = get_char()); /* Get the next char */ |
| } /* for {;;} */ |
| } |
| |
| /* |
| * Trivial routine to insure that the next character in the search string is |
| * still true to whatever we're pointing to in the buffer. This routine will |
| * not attempt to move the "point" if the match fails, although it will |
| * implicitly move the "point" if we're forward searching, and find a match, |
| * since that's the way forward isearch works. |
| * |
| * If the compare fails, we return FALSE and assume the caller will call |
| * scanmore or something. |
| * |
| * char chr; Next char to look for |
| * char *patrn; The entire search string (incl chr) |
| * int dir; Search direction |
| */ |
| int checknext(char chr, char *patrn, int dir) /* Check next character in search string */ |
| { |
| struct line *curline; /* current line during scan */ |
| int curoff; /* position within current line */ |
| int buffchar; /* character at current position */ |
| int status; /* how well things go */ |
| |
| |
| /* setup the local scan pointer to current "." */ |
| |
| curline = curwp->w_dotp; /* Get the current line structure */ |
| curoff = curwp->w_doto; /* Get the offset within that line */ |
| |
| if (dir > 0) { /* If searching forward */ |
| if (curoff == llength(curline)) { /* If at end of line */ |
| curline = lforw(curline); /* Skip to the next line */ |
| if (curline == curbp->b_linep) |
| return FALSE; /* Abort if at end of buffer */ |
| curoff = 0; /* Start at the beginning of the line */ |
| buffchar = '\n'; /* And say the next char is NL */ |
| } else |
| buffchar = lgetc(curline, curoff++); /* Get the next char */ |
| if ((status = eq(buffchar, chr)) != 0) { /* Is it what we're looking for? */ |
| curwp->w_dotp = curline; /* Yes, set the buffer's point */ |
| curwp->w_doto = curoff; /* to the matched character */ |
| curwp->w_flag |= WFMOVE; /* Say that we've moved */ |
| } |
| return status; /* And return the status */ |
| } else /* Else, if reverse search: */ |
| return match_pat(patrn); /* See if we're in the right place */ |
| } |
| |
| /* |
| * This hack will search for the next occurrence of <pat> in the buffer, either |
| * forward or backward. It is called with the status of the prior search |
| * attempt, so that it knows not to bother if it didn't work last time. If |
| * we can't find any more matches, "point" is left where it was before. If |
| * we do find a match, "point" will be at the end of the matched string for |
| * forward searches and at the beginning of the matched string for reverse |
| * searches. |
| * |
| * char *patrn; string to scan for |
| * int dir; direction to search |
| */ |
| int scanmore(char *patrn, int dir) /* search forward or back for a pattern */ |
| { |
| int sts; /* search status */ |
| |
| if (dir < 0) { /* reverse search? */ |
| rvstrcpy(tap, patrn); /* Put reversed string in tap */ |
| sts = scanner(tap, REVERSE, PTBEG); |
| } else |
| sts = scanner(patrn, FORWARD, PTEND); /* Nope. Go forward */ |
| |
| if (!sts) { |
| TTputc(BELL); /* Feep if search fails */ |
| TTflush(); /* see that the feep feeps */ |
| } |
| |
| return sts; /* else, don't even try */ |
| } |
| |
| /* |
| * The following is a worker subroutine used by the reverse search. It |
| * compares the pattern string with the characters at "." for equality. If |
| * any characters mismatch, it will return FALSE. |
| * |
| * This isn't used for forward searches, because forward searches leave "." |
| * at the end of the search string (instead of in front), so all that needs to |
| * be done is match the last char input. |
| * |
| * char *patrn; String to match to buffer |
| */ |
| int match_pat(char *patrn) /* See if the pattern string matches string at "." */ |
| { |
| int i; /* Generic loop index/offset */ |
| int buffchar; /* character at current position */ |
| struct line *curline; /* current line during scan */ |
| int curoff; /* position within current line */ |
| |
| /* setup the local scan pointer to current "." */ |
| |
| curline = curwp->w_dotp; /* Get the current line structure */ |
| curoff = curwp->w_doto; /* Get the offset within that line */ |
| |
| /* top of per character compare loop: */ |
| |
| for (i = 0; i < strlen(patrn); i++) { /* Loop for all characters in patrn */ |
| if (curoff == llength(curline)) { /* If at end of line */ |
| curline = lforw(curline); /* Skip to the next line */ |
| curoff = 0; /* Start at the beginning of the line */ |
| if (curline == curbp->b_linep) |
| return FALSE; /* Abort if at end of buffer */ |
| buffchar = '\n'; /* And say the next char is NL */ |
| } else |
| buffchar = lgetc(curline, curoff++); /* Get the next char */ |
| if (!eq(buffchar, patrn[i])) /* Is it what we're looking for? */ |
| return FALSE; /* Nope, just punt it then */ |
| } |
| return TRUE; /* Everything matched? Let's celebrate */ |
| } |
| |
| /* |
| * Routine to prompt for I-Search string. |
| */ |
| int promptpattern(char *prompt) |
| { |
| char tpat[NPAT + 20]; |
| |
| strcpy(tpat, prompt); /* copy prompt to output string */ |
| strcat(tpat, " ("); /* build new prompt string */ |
| expandp(pat, &tpat[strlen(tpat)], NPAT / 2); /* add old pattern */ |
| strcat(tpat, ")<Meta>: "); |
| |
| /* check to see if we are executing a command line */ |
| if (!clexec) { |
| mlwrite(tpat); |
| } |
| return strlen(tpat); |
| } |
| |
| /* |
| * routine to echo i-search characters |
| * |
| * int c; character to be echoed |
| * int col; column to be echoed in |
| */ |
| static int echo_char(int c, int col) |
| { |
| movecursor(term.t_nrow, col); /* Position the cursor */ |
| if ((c < ' ') || (c == 0x7F)) { /* Control character? */ |
| switch (c) { /* Yes, dispatch special cases */ |
| case '\n': /* Newline */ |
| TTputc('<'); |
| TTputc('N'); |
| TTputc('L'); |
| TTputc('>'); |
| col += 3; |
| break; |
| |
| case '\t': /* Tab */ |
| TTputc('<'); |
| TTputc('T'); |
| TTputc('A'); |
| TTputc('B'); |
| TTputc('>'); |
| col += 4; |
| break; |
| |
| case 0x7F: /* Rubout: */ |
| TTputc('^'); /* Output a funny looking */ |
| TTputc('?'); /* indication of Rubout */ |
| col++; /* Count the extra char */ |
| break; |
| |
| default: /* Vanilla control char */ |
| TTputc('^'); /* Yes, output prefix */ |
| TTputc(c + 0x40); /* Make it "^X" */ |
| col++; /* Count this char */ |
| } |
| } else |
| TTputc(c); /* Otherwise, output raw char */ |
| TTflush(); /* Flush the output */ |
| return ++col; /* return the new column no */ |
| } |
| |
| /* |
| * Routine to get the next character from the input stream. If we're reading |
| * from the real terminal, force a screen update before we get the char. |
| * Otherwise, we must be re-executing the command string, so just return the |
| * next character. |
| */ |
| int get_char(void) |
| { |
| int c; /* A place to get a character */ |
| |
| /* See if we're re-executing: */ |
| |
| if (cmd_reexecute >= 0) /* Is there an offset? */ |
| if ((c = cmd_buff[cmd_reexecute++]) != 0) |
| return c; /* Yes, return any character */ |
| |
| /* We're not re-executing (or aren't any more). Try for a real char */ |
| |
| cmd_reexecute = -1; /* Say we're in real mode again */ |
| update(FALSE); /* Pretty up the screen */ |
| if (cmd_offset >= CMDBUFLEN - 1) { /* If we're getting too big ... */ |
| mlwrite("? command too long"); /* Complain loudly and bitterly */ |
| return metac; /* And force a quit */ |
| } |
| c = get1key(); /* Get the next character */ |
| cmd_buff[cmd_offset++] = c; /* Save the char for next time */ |
| cmd_buff[cmd_offset] = '\0'; /* And terminate the buffer */ |
| return c; /* Return the character */ |
| } |
| |
| /* |
| * Hacky routine to re-eat a character. This will save the character to be |
| * re-eaten by redirecting the input call to a routine here. Hack, etc. |
| */ |
| |
| /* Come here on the next term.t_getchar call: */ |
| |
| int uneat(void) |
| { |
| int c; |
| |
| term.t_getchar = saved_get_char; /* restore the routine address */ |
| c = eaten_char; /* Get the re-eaten char */ |
| eaten_char = -1; /* Clear the old char */ |
| return c; /* and return the last char */ |
| } |
| |
| void reeat(int c) |
| { |
| if (eaten_char != -1) /* If we've already been here */ |
| return /*(NULL) */ ; /* Don't do it again */ |
| eaten_char = c; /* Else, save the char for later */ |
| saved_get_char = term.t_getchar; /* Save the char get routine */ |
| term.t_getchar = uneat; /* Replace it with ours */ |
| } |
| #else |
| int isearch(int f, int n) |
| { |
| } |
| #endif |
