X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fsearch.c;h=46feb9cad5a65129d8afcb58e5103ef0cfd2a584;hb=975655e6b5b1526ee82b159b3eadf69888c42090;hp=82e27cac37050616b32cf9b5ad948a8aed8f7ef2;hpb=2e3e3f9ee27fec50f45c282d71eaddf7c673bc56;p=chise%2Fxemacs-chise.git- diff --git a/src/search.c b/src/search.c index 82e27ca..46feb9c 100644 --- a/src/search.c +++ b/src/search.c @@ -29,7 +29,6 @@ Boston, MA 02111-1307, USA. */ #include "lisp.h" #include "buffer.h" -#include "commands.h" #include "insdel.h" #include "opaque.h" #ifdef REGION_CACHE_NEEDS_WORK @@ -55,10 +54,10 @@ struct regexp_cache { }; /* The instances of that struct. */ -struct regexp_cache searchbufs[REGEXP_CACHE_SIZE]; +static struct regexp_cache searchbufs[REGEXP_CACHE_SIZE]; /* The head of the linked list; points to the most recently used buffer. */ -struct regexp_cache *searchbuf_head; +static struct regexp_cache *searchbuf_head; /* Every call to re_match, etc., must pass &search_regs as the regs @@ -132,7 +131,7 @@ compile_pattern_1 (struct regexp_cache *cp, Lisp_Object pattern, char *translate, struct re_registers *regp, int posix, Error_behavior errb) { - CONST char *val; + const char *val; reg_syntax_t old; cp->regexp = Qnil; @@ -140,7 +139,7 @@ compile_pattern_1 (struct regexp_cache *cp, Lisp_Object pattern, cp->posix = posix; old = re_set_syntax (RE_SYNTAX_EMACS | (posix ? 0 : RE_NO_POSIX_BACKTRACKING)); - val = (CONST char *) + val = (const char *) re_compile_pattern ((char *) XSTRING_DATA (pattern), XSTRING_LENGTH (pattern), &cp->buf); re_set_syntax (old); @@ -443,7 +442,7 @@ tables) and defaults to the current buffer. This does not clobber the match data. */ Bytecount -fast_string_match (Lisp_Object regexp, CONST Bufbyte *nonreloc, +fast_string_match (Lisp_Object regexp, const Bufbyte *nonreloc, Lisp_Object reloc, Bytecount offset, Bytecount length, int case_fold_search, Error_behavior errb, int no_quit) @@ -684,31 +683,75 @@ scan_buffer (struct buffer *buf, Emchar target, Bufpos start, Bufpos end, } Bytind -bi_find_next_newline_no_quit (struct buffer *buf, Bytind from, int cnt) +bi_find_next_newline_no_quit (struct buffer *buf, Bytind from, int count) { - return bi_scan_buffer (buf, '\n', from, 0, cnt, 0, 0); + return bi_scan_buffer (buf, '\n', from, 0, count, 0, 0); } Bufpos -find_next_newline_no_quit (struct buffer *buf, Bufpos from, int cnt) +find_next_newline_no_quit (struct buffer *buf, Bufpos from, int count) { - return scan_buffer (buf, '\n', from, 0, cnt, 0, 0); + return scan_buffer (buf, '\n', from, 0, count, 0, 0); } Bufpos -find_next_newline (struct buffer *buf, Bufpos from, int cnt) +find_next_newline (struct buffer *buf, Bufpos from, int count) { - return scan_buffer (buf, '\n', from, 0, cnt, 0, 1); + return scan_buffer (buf, '\n', from, 0, count, 0, 1); +} + +Bytind +bi_find_next_emchar_in_string (Lisp_String* str, Emchar target, Bytind st, + EMACS_INT count) +{ + /* This function has been Mule-ized. */ + Bytind lim = string_length (str) -1; + Bufbyte* s = string_data (str); + + assert (count >= 0); + +#ifdef MULE + /* Due to the Mule representation of characters in a buffer, + we can simply search for characters in the range 0 - 127 + directly. For other characters, we do it the "hard" way. + Note that this way works for all characters but the other + way is faster. */ + if (target >= 0200) + { + while (st < lim && count > 0) + { + if (string_char (str, st) == target) + count--; + INC_CHARBYTIND (s, st); + } + } + else +#endif + { + while (st < lim && count > 0) + { + Bufbyte *bufptr = (Bufbyte *) memchr (charptr_n_addr (s, st), + (int) target, lim - st); + if (bufptr) + { + count--; + st = (Bytind)(bufptr - s) + 1; + } + else + st = lim; + } + } + return st; } /* Like find_next_newline, but returns position before the newline, not after, and only search up to TO. This isn't just find_next_newline (...)-1, because you might hit TO. */ Bufpos -find_before_next_newline (struct buffer *buf, Bufpos from, Bufpos to, int cnt) +find_before_next_newline (struct buffer *buf, Bufpos from, Bufpos to, int count) { EMACS_INT shortage; - Bufpos pos = scan_buffer (buf, '\n', from, to, cnt, &shortage, 1); + Bufpos pos = scan_buffer (buf, '\n', from, to, count, &shortage, 1); if (shortage == 0) pos--; @@ -728,22 +771,22 @@ skip_chars (struct buffer *buf, int forwardp, int syntaxp, unsigned char fastmap[0400]; int negate = 0; REGISTER int i; - struct Lisp_Char_Table *syntax_table = - XCHAR_TABLE (buf->mirror_syntax_table); - - CHECK_STRING (string); + Lisp_Char_Table *syntax_table = XCHAR_TABLE (buf->mirror_syntax_table); + Bufpos limit; if (NILP (lim)) - XSETINT (lim, forwardp ? BUF_ZV (buf) : BUF_BEGV (buf)); + limit = forwardp ? BUF_ZV (buf) : BUF_BEGV (buf); else - CHECK_INT_COERCE_MARKER (lim); + { + CHECK_INT_COERCE_MARKER (lim); + limit = XINT (lim); - /* In any case, don't allow scan outside bounds of buffer. */ - if (XINT (lim) > BUF_ZV (buf)) - lim = make_int (BUF_ZV (buf)); - if (XINT (lim) < BUF_BEGV (buf)) - lim = make_int (BUF_BEGV (buf)); + /* In any case, don't allow scan outside bounds of buffer. */ + if (limit > BUF_ZV (buf)) limit = BUF_ZV (buf); + if (limit < BUF_BEGV (buf)) limit = BUF_BEGV (buf); + } + CHECK_STRING (string); p = XSTRING_DATA (string); pend = p + XSTRING_LENGTH (string); memset (fastmap, 0, sizeof (fastmap)); @@ -828,7 +871,7 @@ skip_chars (struct buffer *buf, int forwardp, int syntaxp, to worry about */ if (forwardp) { - while (BUF_PT (buf) < XINT (lim) + while (BUF_PT (buf) < limit && fastmap[(unsigned char) syntax_code_spec [(int) SYNTAX (syntax_table, @@ -838,7 +881,7 @@ skip_chars (struct buffer *buf, int forwardp, int syntaxp, } else { - while (BUF_PT (buf) > XINT (lim) + while (BUF_PT (buf) > limit && fastmap[(unsigned char) syntax_code_spec [(int) SYNTAX (syntax_table, @@ -851,7 +894,7 @@ skip_chars (struct buffer *buf, int forwardp, int syntaxp, { if (forwardp) { - while (BUF_PT (buf) < XINT (lim)) + while (BUF_PT (buf) < limit) { Emchar ch = BUF_FETCH_CHAR (buf, BUF_PT (buf)); if ((ch < 0400) ? fastmap[ch] : @@ -866,7 +909,7 @@ skip_chars (struct buffer *buf, int forwardp, int syntaxp, } else { - while (BUF_PT (buf) > XINT (lim)) + while (BUF_PT (buf) > limit) { Emchar ch = BUF_FETCH_CHAR (buf, BUF_PT (buf) - 1); if ((ch < 0400) ? fastmap[ch] : @@ -1383,7 +1426,7 @@ search_buffer (struct buffer *buf, Lisp_Object string, Bufpos bufpos, (EMACS_UINT) p_limit) cursor += BM_tab[*cursor]; } -/* If you are here, cursor is beyond the end of the searched region. */ + /* If you are here, cursor is beyond the end of the searched region. */ /* This can happen if you match on the far character of the pattern, */ /* because the "stride" of that character is infinity, a number able */ /* to throw you well beyond the end of the search. It can also */ @@ -1540,8 +1583,7 @@ wordify (Lisp_Object buffer, Lisp_Object string) Charcount i, len; EMACS_INT punct_count = 0, word_count = 0; struct buffer *buf = decode_buffer (buffer, 0); - struct Lisp_Char_Table *syntax_table = - XCHAR_TABLE (buf->mirror_syntax_table); + Lisp_Char_Table *syntax_table = XCHAR_TABLE (buf->mirror_syntax_table); CHECK_STRING (string); len = XSTRING_CHAR_LENGTH (string); @@ -1801,7 +1843,7 @@ and you do not need to specify it.) Emchar c, prevc; Charcount inslen; struct buffer *buf; - struct Lisp_Char_Table *syntax_table; + Lisp_Char_Table *syntax_table; int mc_count; Lisp_Object buffer; int_dynarr *ul_action_dynarr = 0; @@ -1837,7 +1879,7 @@ and you do not need to specify it.) case_action = nochange; /* We tried an initialization */ /* but some C compilers blew it */ - if (search_regs.num_regs <= 0) + if (search_regs.num_regs == 0) error ("replace-match called before any match found"); if (NILP (string)) @@ -1963,7 +2005,7 @@ and you do not need to specify it.) Charcount subend = -1; c = string_char (XSTRING (newtext), strpos); - if (c == '\\') + if (c == '\\' && strpos < stlen - 1) { c = string_char (XSTRING (newtext), ++strpos); if (c == '&') @@ -2109,7 +2151,7 @@ and you do not need to specify it.) Charcount offset = BUF_PT (buf) - search_regs.start[0]; c = string_char (XSTRING (newtext), strpos); - if (c == '\\') + if (c == '\\' && strpos < stlen - 1) { c = string_char (XSTRING (newtext), ++strpos); if (c == '&') @@ -2219,7 +2261,7 @@ match_limit (Lisp_Object num, int beginningp) n = XINT (num); if (n < 0 || n >= search_regs.num_regs) args_out_of_range (num, make_int (search_regs.num_regs)); - if (search_regs.num_regs <= 0 || + if (search_regs.num_regs == 0 || search_regs.start[n] < 0) return Qnil; return make_int (beginningp ? search_regs.start[n] : search_regs.end[n]); @@ -2310,7 +2352,7 @@ to hold all the values, and if INTEGERS is non-nil, no consing is done. /* If REUSE is a list, store as many value elements as will fit into the elements of REUSE. */ - for (i = 0, tail = reuse; CONSP (tail); i++, tail = XCDR (tail)) + for (prev = Qnil, i = 0, tail = reuse; CONSP (tail); i++, tail = XCDR (tail)) { if (i < 2 * len + 2) XCAR (tail) = data[i]; @@ -2530,9 +2572,12 @@ syms_of_search (void) } void -vars_of_search (void) +reinit_vars_of_search (void) { - REGISTER int i; + int i; + + last_thing_searched = Qnil; + staticpro_nodump (&last_thing_searched); for (i = 0; i < REGEXP_CACHE_SIZE; ++i) { @@ -2540,13 +2585,16 @@ vars_of_search (void) searchbufs[i].buf.buffer = (unsigned char *) xmalloc (100); searchbufs[i].buf.fastmap = searchbufs[i].fastmap; searchbufs[i].regexp = Qnil; - staticpro (&searchbufs[i].regexp); + staticpro_nodump (&searchbufs[i].regexp); searchbufs[i].next = (i == REGEXP_CACHE_SIZE-1 ? 0 : &searchbufs[i+1]); } searchbuf_head = &searchbufs[0]; +} - last_thing_searched = Qnil; - staticpro (&last_thing_searched); +void +vars_of_search (void) +{ + reinit_vars_of_search (); DEFVAR_LISP ("forward-word-regexp", &Vforward_word_regexp /* *Regular expression to be used in `forward-word'.