static EMACS_INT simple_search (EMACS_INT, unsigned char *, EMACS_INT,
EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT,
EMACS_INT, EMACS_INT);
-static EMACS_INT boyer_moore (EMACS_INT, unsigned char *, EMACS_INT, EMACS_INT,
- Lisp_Object, Lisp_Object,
- EMACS_INT, EMACS_INT,
- EMACS_INT, EMACS_INT, int);
+static EMACS_INT boyer_moore (EMACS_INT, unsigned char *, EMACS_INT,
+ Lisp_Object, Lisp_Object, EMACS_INT,
+ EMACS_INT, int);
static EMACS_INT search_buffer (Lisp_Object, EMACS_INT, EMACS_INT,
EMACS_INT, EMACS_INT, EMACS_INT, int,
Lisp_Object, Lisp_Object, int);
PATTERN is the pattern to compile.
CP is the place to put the result.
TRANSLATE is a translation table for ignoring case, or nil for none.
- REGP is the structure that says where to store the "register"
- values that will result from matching this pattern.
- If it is 0, we should compile the pattern not to record any
- subexpression bounds.
POSIX is nonzero if we want full backtracking (POSIX style)
for this pattern. 0 means backtrack only enough to get a valid match.
The behavior also depends on Vsearch_spaces_regexp. */
static void
-compile_pattern_1 (struct regexp_cache *cp, Lisp_Object pattern, Lisp_Object translate, struct re_registers *regp, int posix)
+compile_pattern_1 (struct regexp_cache *cp, Lisp_Object pattern, Lisp_Object translate, int posix)
{
char *val;
reg_syntax_t old;
if (cp->next == 0)
{
compile_it:
- compile_pattern_1 (cp, pattern, translate, regp, posix);
+ compile_pattern_1 (cp, pattern, translate, posix);
break;
}
}
static Lisp_Object
string_match_1 (Lisp_Object regexp, Lisp_Object string, Lisp_Object start, int posix)
{
- int val;
+ EMACS_INT val;
struct re_pattern_buffer *bufp;
EMACS_INT pos, pos_byte;
int i;
return make_number (string_byte_to_char (string, val));
}
-DEFUN ("string-match", Fstring_match, Sstring_match, 2, 3, 0,
+DEFUE ("string-match", Fstring_match, Sstring_match, 2, 3, 0,
doc: /* Return index of start of first match for REGEXP in STRING, or nil.
Matching ignores case if `case-fold-search' is non-nil.
If third arg START is non-nil, start search at that index in STRING.
and return the index of the match, or negative on failure.
This does not clobber the match data. */
-int
+EMACS_INT
fast_string_match (Lisp_Object regexp, Lisp_Object string)
{
- int val;
+ EMACS_INT val;
struct re_pattern_buffer *bufp;
bufp = compile_pattern (regexp, 0, Qnil,
This does not clobber the match data.
We assume that STRING contains single-byte characters. */
-int
+EMACS_INT
fast_c_string_match_ignore_case (Lisp_Object regexp, const char *string)
{
- int val;
+ EMACS_INT val;
struct re_pattern_buffer *bufp;
size_t len = strlen (string);
/* Like fast_string_match but ignore case. */
-int
+EMACS_INT
fast_string_match_ignore_case (Lisp_Object regexp, Lisp_Object string)
{
- int val;
+ EMACS_INT val;
struct re_pattern_buffer *bufp;
bufp = compile_pattern (regexp, 0, Vascii_canon_table,
EMACS_INT
scan_buffer (register int target, EMACS_INT start, EMACS_INT end,
- EMACS_INT count, int *shortage, int allow_quit)
+ EMACS_INT count, EMACS_INT *shortage, int allow_quit)
{
struct region_cache *newline_cache;
int direction;
EMACS_INT
find_next_newline_no_quit (EMACS_INT from, EMACS_INT cnt)
{
- return scan_buffer ('\n', from, 0, cnt, (int *) 0, 0);
+ return scan_buffer ('\n', from, 0, cnt, (EMACS_INT *) 0, 0);
}
/* Like find_next_newline, but returns position before the newline,
EMACS_INT
find_before_next_newline (EMACS_INT from, EMACS_INT to, EMACS_INT cnt)
{
- int shortage;
+ EMACS_INT shortage;
EMACS_INT pos = scan_buffer ('\n', from, to, cnt, &shortage, 1);
if (shortage == 0)
search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror,
Lisp_Object count, int direction, int RE, int posix)
{
- register int np;
+ register EMACS_INT np;
EMACS_INT lim, lim_byte;
- int n = direction;
+ EMACS_INT n = direction;
if (!NILP (count))
{
}
len_byte = pat - patbuf;
- len = raw_pattern_size;
pat = base_pat = patbuf;
if (boyer_moore_ok)
- return boyer_moore (n, pat, len, len_byte, trt, inverse_trt,
- pos, pos_byte, lim, lim_byte,
+ return boyer_moore (n, pat, len_byte, trt, inverse_trt,
+ pos_byte, lim_byte,
char_base);
else
- return simple_search (n, pat, len, len_byte, trt,
+ return simple_search (n, pat, raw_pattern_size, len_byte, trt,
pos, pos_byte, lim, lim_byte);
}
}
while (this_len > 0)
{
- int charlen;
int pat_ch, buf_ch;
DEC_BOTH (this_pos, this_pos_byte);
}
\f
/* Do Boyer-Moore search N times for the string BASE_PAT,
- whose length is LEN/LEN_BYTE,
- from buffer position POS/POS_BYTE until LIM/LIM_BYTE.
+ whose length is LEN_BYTE,
+ from buffer position POS_BYTE until LIM_BYTE.
DIRECTION says which direction we search in.
TRT and INVERSE_TRT are translation tables.
Characters in PAT are already translated by TRT.
static EMACS_INT
boyer_moore (EMACS_INT n, unsigned char *base_pat,
- EMACS_INT len, EMACS_INT len_byte,
+ EMACS_INT len_byte,
Lisp_Object trt, Lisp_Object inverse_trt,
- EMACS_INT pos, EMACS_INT pos_byte,
- EMACS_INT lim, EMACS_INT lim_byte, int char_base)
+ EMACS_INT pos_byte, EMACS_INT lim_byte,
+ int char_base)
{
int direction = ((n > 0) ? 1 : -1);
register EMACS_INT dirlen;
int translate_prev_byte1 = 0;
int translate_prev_byte2 = 0;
int translate_prev_byte3 = 0;
- int translate_prev_byte4 = 0;
/* The general approach is that we are going to maintain that we know
the first (closest to the present position, in whatever direction
/* Setup translate_prev_byte1/2/3/4 from CHAR_BASE. Only a
byte following them are the target of translation. */
unsigned char str[MAX_MULTIBYTE_LENGTH];
- int len = CHAR_STRING (char_base, str);
+ int cblen = CHAR_STRING (char_base, str);
- translate_prev_byte1 = str[len - 2];
- if (len > 2)
+ translate_prev_byte1 = str[cblen - 2];
+ if (cblen > 2)
{
- translate_prev_byte2 = str[len - 3];
- if (len > 3)
- {
- translate_prev_byte3 = str[len - 4];
- if (len > 4)
- translate_prev_byte4 = str[len - 5];
- }
+ translate_prev_byte2 = str[cblen - 3];
+ if (cblen > 3)
+ translate_prev_byte3 = str[cblen - 4];
}
}
stride_for_teases = BM_tab[j];
BM_tab[j] = dirlen - i;
- /* A translation table is accompanied by its inverse -- see */
- /* comment following downcase_table for details */
+ /* A translation table is accompanied by its inverse -- see
+ comment following downcase_table for details. */
if (ch >= 0)
{
int starting_ch = ch;
static Lisp_Object
wordify (Lisp_Object string, int lax)
{
- register unsigned char *p, *o;
+ register unsigned char *o;
register EMACS_INT i, i_byte, len, punct_count = 0, word_count = 0;
Lisp_Object val;
int prev_c = 0;
int whitespace_at_end;
CHECK_STRING (string);
- p = SDATA (string);
len = SCHARS (string);
for (i = 0, i_byte = 0; i < len; )
if (SYNTAX (c) != Sword)
{
punct_count++;
- if (i > 0 && SYNTAX (prev_c) == Sword)
+ if (SYNTAX (prev_c) == Sword)
word_count++;
}
whitespace_at_end = 0;
}
else
- whitespace_at_end = 1;
-
- if (!word_count)
- return empty_unibyte_string;
+ {
+ whitespace_at_end = 1;
+ if (!word_count)
+ return empty_unibyte_string;
+ }
adjust = - punct_count + 5 * (word_count - 1)
+ ((lax && !whitespace_at_end) ? 2 : 4);
memcpy (o, SDATA (string) + i_byte_orig, i_byte - i_byte_orig);
o += i_byte - i_byte_orig;
}
- else if (i > 0 && SYNTAX (prev_c) == Sword && --word_count)
+ else if (SYNTAX (prev_c) == Sword && --word_count)
{
*o++ = '\\';
*o++ = 'W';
else
FETCH_STRING_CHAR_AS_MULTIBYTE_ADVANCE (c, string, pos, pos_byte);
- if (LOWERCASEP (c))
+ if (lowercasep (c))
{
/* Cannot be all caps if any original char is lower case */
else
some_multiletter_word = 1;
}
- else if (UPPERCASEP (c))
+ else if (uppercasep (c))
{
some_uppercase = 1;
if (SYNTAX (prevc) != Sword)
/* We build up the substituted string in ACCUM. */
Lisp_Object accum;
Lisp_Object middle;
- int length = SBYTES (newtext);
+ EMACS_INT length = SBYTES (newtext);
accum = Qnil;
EMACS_INT substed_alloc_size, substed_len;
int buf_multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
int str_multibyte = STRING_MULTIBYTE (newtext);
- Lisp_Object rev_tbl;
int really_changed = 0;
- rev_tbl = Qnil;
-
substed_alloc_size = length * 2 + 100;
substed = (unsigned char *) xmalloc (substed_alloc_size + 1);
substed_len = 0;
{
FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c, newtext, pos, pos_byte);
if (!buf_multibyte)
- c = multibyte_char_to_unibyte (c, rev_tbl);
+ c = multibyte_char_to_unibyte (c);
}
else
{
FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c, newtext,
pos, pos_byte);
if (!buf_multibyte && !ASCII_CHAR_P (c))
- c = multibyte_char_to_unibyte (c, rev_tbl);
+ c = multibyte_char_to_unibyte (c);
}
else
{
: search_regs.end[n]));
}
-DEFUN ("match-beginning", Fmatch_beginning, Smatch_beginning, 1, 1, 0,
+DEFUE ("match-beginning", Fmatch_beginning, Smatch_beginning, 1, 1, 0,
doc: /* Return position of start of text matched by last search.
SUBEXP, a number, specifies which parenthesized expression in the last
regexp.
return match_limit (subexp, 1);
}
-DEFUN ("match-end", Fmatch_end, Smatch_end, 1, 1, 0,
+DEFUE ("match-end", Fmatch_end, Smatch_end, 1, 1, 0,
doc: /* Return position of end of text matched by last search.
SUBEXP, a number, specifies which parenthesized expression in the last
regexp.
return match_limit (subexp, 0);
}
-DEFUN ("match-data", Fmatch_data, Smatch_data, 0, 3, 0,
+DEFUE ("match-data", Fmatch_data, Smatch_data, 0, 3, 0,
doc: /* Return a list containing all info on what the last search matched.
Element 2N is `(match-beginning N)'; element 2N + 1 is `(match-end N)'.
All the elements are markers or nil (nil if the Nth pair didn't match)
len = 0;
for (i = 0; i < search_regs.num_regs; i++)
{
- int start = search_regs.start[i];
+ EMACS_INT start = search_regs.start[i];
if (start >= 0)
{
if (EQ (last_thing_searched, Qt)
But it was ill-conceived: those supposedly-internal markers get exposed via
the undo-list, so freeing them here is unsafe. */
-DEFUN ("set-match-data", Fset_match_data, Sset_match_data, 1, 2, 0,
+DEFUE ("set-match-data", Fset_match_data, Sset_match_data, 1, 2, 0,
doc: /* Set internal data on last search match from elements of LIST.
LIST should have been created by calling `match-data' previously.
HCoop / bpt / emacs.git / blobdiff