GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
+the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
#include <sys/types.h>
#include "regex.h"
-/* We compile regexps into this buffer and then use it for searching. */
+#define REGEXP_CACHE_SIZE 5
-struct re_pattern_buffer searchbuf;
+/* If the regexp is non-nil, then the buffer contains the compiled form
+ of that regexp, suitable for searching. */
+struct regexp_cache {
+ struct regexp_cache *next;
+ Lisp_Object regexp;
+ struct re_pattern_buffer buf;
+ char fastmap[0400];
+ /* Nonzero means regexp was compiled to do full POSIX backtracking. */
+ char posix;
+};
-char search_fastmap[0400];
+/* The instances of that struct. */
+struct regexp_cache searchbufs[REGEXP_CACHE_SIZE];
-/* Last regexp we compiled */
+/* The head of the linked list; points to the most recently used buffer. */
+struct regexp_cache *searchbuf_head;
-Lisp_Object last_regexp;
/* Every call to re_match, etc., must pass &search_regs as the regs
argument unless you can show it is unnecessary (i.e., if re_match
been allocated by checking search_regs.num_regs.
The regex code keeps track of whether it has allocated the search
- buffer using bits in searchbuf. This means that whenever you
- compile a new pattern, it completely forgets whether it has
+ buffer using bits in the re_pattern_buffer. This means that whenever
+ you compile a new pattern, it completely forgets whether it has
allocated any registers, and will allocate new registers the next
time you call a searching or matching function. Therefore, we need
to call re_set_registers after compiling a new pattern or after
Qnil if no searching has been done yet. */
static Lisp_Object last_thing_searched;
-/* error condition signalled when regexp compile_pattern fails */
+/* error condition signaled when regexp compile_pattern fails */
Lisp_Object Qinvalid_regexp;
static void set_search_regs ();
+static void save_search_regs ();
+
+static int search_buffer ();
static void
matcher_overflow ()
#define CONST
#endif
-/* Compile a regexp and signal a Lisp error if anything goes wrong. */
+/* Compile a regexp and signal a Lisp error if anything goes wrong.
+ PATTERN is the pattern to compile.
+ CP is the place to put the result.
+ TRANSLATE is a translation table for ignoring case, or NULL 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. */
-compile_pattern (pattern, bufp, regp, translate)
+static void
+compile_pattern_1 (cp, pattern, translate, regp, posix)
+ struct regexp_cache *cp;
Lisp_Object pattern;
- struct re_pattern_buffer *bufp;
+ Lisp_Object *translate;
struct re_registers *regp;
- char *translate;
+ int posix;
{
CONST char *val;
- Lisp_Object dummy;
-
- if (EQ (pattern, last_regexp)
- && translate == bufp->translate)
- return;
+ reg_syntax_t old;
- last_regexp = Qnil;
- bufp->translate = translate;
+ cp->regexp = Qnil;
+ cp->buf.translate = translate;
+ cp->posix = posix;
BLOCK_INPUT;
+ old = re_set_syntax (RE_SYNTAX_EMACS
+ | (posix ? 0 : RE_NO_POSIX_BACKTRACKING));
val = (CONST char *) re_compile_pattern ((char *) XSTRING (pattern)->data,
- XSTRING (pattern)->size, bufp);
+ XSTRING (pattern)->size, &cp->buf);
+ re_set_syntax (old);
UNBLOCK_INPUT;
if (val)
+ Fsignal (Qinvalid_regexp, Fcons (build_string (val), Qnil));
+
+ cp->regexp = Fcopy_sequence (pattern);
+}
+
+/* Compile a regexp if necessary, but first check to see if there's one in
+ the cache.
+ PATTERN is the pattern to compile.
+ TRANSLATE is a translation table for ignoring case, or NULL 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. */
+
+struct re_pattern_buffer *
+compile_pattern (pattern, regp, translate, posix)
+ Lisp_Object pattern;
+ struct re_registers *regp;
+ Lisp_Object *translate;
+ int posix;
+{
+ struct regexp_cache *cp, **cpp;
+
+ for (cpp = &searchbuf_head; ; cpp = &cp->next)
{
- dummy = build_string (val);
- while (1)
- Fsignal (Qinvalid_regexp, Fcons (dummy, Qnil));
+ cp = *cpp;
+ if (!NILP (Fstring_equal (cp->regexp, pattern))
+ && cp->buf.translate == translate
+ && cp->posix == posix)
+ break;
+
+ /* If we're at the end of the cache, compile into the last cell. */
+ if (cp->next == 0)
+ {
+ compile_pattern_1 (cp, pattern, translate, regp, posix);
+ break;
+ }
}
- last_regexp = pattern;
+ /* When we get here, cp (aka *cpp) contains the compiled pattern,
+ either because we found it in the cache or because we just compiled it.
+ Move it to the front of the queue to mark it as most recently used. */
+ *cpp = cp->next;
+ cp->next = searchbuf_head;
+ searchbuf_head = cp;
/* Advise the searching functions about the space we have allocated
for register data. */
- BLOCK_INPUT;
if (regp)
- re_set_registers (bufp, regp, regp->num_regs, regp->start, regp->end);
- UNBLOCK_INPUT;
+ re_set_registers (&cp->buf, regp, regp->num_regs, regp->start, regp->end);
- return;
+ return &cp->buf;
}
/* Error condition used for failing searches */
return Qnil;
}
\f
-DEFUN ("looking-at", Flooking_at, Slooking_at, 1, 1, 0,
- "Return t if text after point matches regular expression PAT.\n\
-This function modifies the match data that `match-beginning',\n\
-`match-end' and `match-data' access; save and restore the match\n\
-data if you want to preserve them.")
- (string)
+static Lisp_Object
+looking_at_1 (string, posix)
Lisp_Object string;
+ int posix;
{
Lisp_Object val;
unsigned char *p1, *p2;
int s1, s2;
register int i;
+ struct re_pattern_buffer *bufp;
+
+ if (running_asynch_code)
+ save_search_regs ();
CHECK_STRING (string, 0);
- compile_pattern (string, &searchbuf, &search_regs,
- !NILP (current_buffer->case_fold_search) ? DOWNCASE_TABLE : 0);
+ bufp = compile_pattern (string, &search_regs,
+ (!NILP (current_buffer->case_fold_search)
+ ? DOWNCASE_TABLE : 0),
+ posix);
immediate_quit = 1;
QUIT; /* Do a pending quit right away, to avoid paradoxical behavior */
s2 = 0;
}
- i = re_match_2 (&searchbuf, (char *) p1, s1, (char *) p2, s2,
+ i = re_match_2 (bufp, (char *) p1, s1, (char *) p2, s2,
point - BEGV, &search_regs,
ZV - BEGV);
if (i == -2)
return val;
}
-DEFUN ("string-match", Fstring_match, Sstring_match, 2, 3, 0,
- "Return index of start of first match for REGEXP in STRING, or nil.\n\
-If third arg START is non-nil, start search at that index in STRING.\n\
-For index of first char beyond the match, do (match-end 0).\n\
-`match-end' and `match-beginning' also give indices of substrings\n\
-matched by parenthesis constructs in the pattern.")
- (regexp, string, start)
+DEFUN ("looking-at", Flooking_at, Slooking_at, 1, 1, 0,
+ "Return t if text after point matches regular expression REGEXP.\n\
+This function modifies the match data that `match-beginning',\n\
+`match-end' and `match-data' access; save and restore the match\n\
+data if you want to preserve them.")
+ (regexp)
+ Lisp_Object regexp;
+{
+ return looking_at_1 (regexp, 0);
+}
+
+DEFUN ("posix-looking-at", Fposix_looking_at, Sposix_looking_at, 1, 1, 0,
+ "Return t if text after point matches regular expression REGEXP.\n\
+Find the longest match, in accord with Posix regular expression rules.\n\
+This function modifies the match data that `match-beginning',\n\
+`match-end' and `match-data' access; save and restore the match\n\
+data if you want to preserve them.")
+ (regexp)
+ Lisp_Object regexp;
+{
+ return looking_at_1 (regexp, 1);
+}
+\f
+static Lisp_Object
+string_match_1 (regexp, string, start, posix)
Lisp_Object regexp, string, start;
+ int posix;
{
int val;
int s;
+ struct re_pattern_buffer *bufp;
+
+ if (running_asynch_code)
+ save_search_regs ();
CHECK_STRING (regexp, 0);
CHECK_STRING (string, 1);
args_out_of_range (string, start);
}
- compile_pattern (regexp, &searchbuf, &search_regs,
- !NILP (current_buffer->case_fold_search) ? DOWNCASE_TABLE : 0);
+ bufp = compile_pattern (regexp, &search_regs,
+ (!NILP (current_buffer->case_fold_search)
+ ? DOWNCASE_TABLE : 0),
+ posix);
immediate_quit = 1;
- val = re_search (&searchbuf, (char *) XSTRING (string)->data,
+ val = re_search (bufp, (char *) XSTRING (string)->data,
XSTRING (string)->size, s, XSTRING (string)->size - s,
&search_regs);
immediate_quit = 0;
return make_number (val);
}
+DEFUN ("string-match", Fstring_match, Sstring_match, 2, 3, 0,
+ "Return index of start of first match for REGEXP in STRING, or nil.\n\
+If third arg START is non-nil, start search at that index in STRING.\n\
+For index of first char beyond the match, do (match-end 0).\n\
+`match-end' and `match-beginning' also give indices of substrings\n\
+matched by parenthesis constructs in the pattern.")
+ (regexp, string, start)
+ Lisp_Object regexp, string, start;
+{
+ return string_match_1 (regexp, string, start, 0);
+}
+
+DEFUN ("posix-string-match", Fposix_string_match, Sposix_string_match, 2, 3, 0,
+ "Return index of start of first match for REGEXP in STRING, or nil.\n\
+Find the longest match, in accord with Posix regular expression rules.\n\
+If third arg START is non-nil, start search at that index in STRING.\n\
+For index of first char beyond the match, do (match-end 0).\n\
+`match-end' and `match-beginning' also give indices of substrings\n\
+matched by parenthesis constructs in the pattern.")
+ (regexp, string, start)
+ Lisp_Object regexp, string, start;
+{
+ return string_match_1 (regexp, string, start, 1);
+}
+
/* Match REGEXP against STRING, searching all of STRING,
and return the index of the match, or negative on failure.
This does not clobber the match data. */
Lisp_Object regexp, string;
{
int val;
+ struct re_pattern_buffer *bufp;
- compile_pattern (regexp, &searchbuf, 0, 0);
+ bufp = compile_pattern (regexp, 0, 0, 0);
immediate_quit = 1;
- val = re_search (&searchbuf, (char *) XSTRING (string)->data,
+ val = re_search (bufp, (char *) XSTRING (string)->data,
XSTRING (string)->size, 0, XSTRING (string)->size,
0);
immediate_quit = 0;
/* Subroutines of Lisp buffer search functions. */
static Lisp_Object
-search_command (string, bound, noerror, count, direction, RE)
+search_command (string, bound, noerror, count, direction, RE, posix)
Lisp_Object string, bound, noerror, count;
int direction;
int RE;
+ int posix;
{
register int np;
int lim;
np = search_buffer (string, point, lim, n, RE,
(!NILP (current_buffer->case_fold_search)
- ? XSTRING (current_buffer->case_canon_table)->data : 0),
+ ? XCHAR_TABLE (current_buffer->case_canon_table)->contents
+ : 0),
(!NILP (current_buffer->case_fold_search)
- ? XSTRING (current_buffer->case_eqv_table)->data : 0));
+ ? XCHAR_TABLE (current_buffer->case_eqv_table)->contents
+ : 0),
+ posix);
if (np <= 0)
{
if (NILP (noerror))
{
case '|': case '(': case ')': case '`': case '\'': case 'b':
case 'B': case '<': case '>': case 'w': case 'W': case 's':
- case 'S': case '1': case '2': case '3': case '4': case '5':
+ case 'S': case '=':
+ case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9':
return 0;
}
/* Search for the n'th occurrence of STRING in the current buffer,
starting at position POS and stopping at position LIM,
- treating PAT as a literal string if RE is false or as
+ treating STRING as a literal string if RE is false or as
a regular expression if RE is true.
If N is positive, searching is forward and LIM must be greater than POS.
Returns -x if only N-x occurrences found (x > 0),
or else the position at the beginning of the Nth occurrence
- (if searching backward) or the end (if searching forward). */
+ (if searching backward) or the end (if searching forward).
-search_buffer (string, pos, lim, n, RE, trt, inverse_trt)
+ POSIX is nonzero if we want full backtracking (POSIX style)
+ for this pattern. 0 means backtrack only enough to get a valid match. */
+
+static int
+search_buffer (string, pos, lim, n, RE, trt, inverse_trt, posix)
Lisp_Object string;
int pos;
int lim;
int n;
int RE;
- register unsigned char *trt;
- register unsigned char *inverse_trt;
+ Lisp_Object *trt;
+ Lisp_Object *inverse_trt;
+ int posix;
{
int len = XSTRING (string)->size;
unsigned char *base_pat = XSTRING (string)->data;
unsigned char *p1, *p2;
int s1, s2;
+ if (running_asynch_code)
+ save_search_regs ();
+
/* Null string is found at starting position. */
if (len == 0)
{
if (RE && !trivial_regexp_p (string))
{
- compile_pattern (string, &searchbuf, &search_regs, (char *) trt);
+ struct re_pattern_buffer *bufp;
+
+ bufp = compile_pattern (string, &search_regs, trt, posix);
immediate_quit = 1; /* Quit immediately if user types ^G,
because letting this function finish
while (n < 0)
{
int val;
- val = re_search_2 (&searchbuf, (char *) p1, s1, (char *) p2, s2,
+ val = re_search_2 (bufp, (char *) p1, s1, (char *) p2, s2,
pos - BEGV, lim - pos, &search_regs,
/* Don't allow match past current point */
pos - BEGV);
while (n > 0)
{
int val;
- val = re_search_2 (&searchbuf, (char *) p1, s1, (char *) p2, s2,
+ val = re_search_2 (bufp, (char *) p1, s1, (char *) p2, s2,
pos - BEGV, lim - pos, &search_regs,
lim - BEGV);
if (val == -2)
{
j = pat[i]; i += direction;
if (i == dirlen) i = infinity;
- if ((int) trt)
+ if (trt != 0)
{
k = (j = trt[j]);
if (i == infinity)
BM_tab[j] = dirlen - i;
/* A translation table is accompanied by its inverse -- see */
/* comment following downcase_table for details */
- while ((j = inverse_trt[j]) != k)
+ while ((j = (unsigned char) inverse_trt[j]) != k)
BM_tab[j] = dirlen - i;
}
else
either kind of comparison will work as long
as we don't step by infinity. So pick the kind
that works when we do step by infinity. */
- if ((int) (p_limit + infinity) > (int) p_limit)
- while ((int) cursor <= (int) p_limit)
+ if ((EMACS_INT) (p_limit + infinity) > (EMACS_INT) p_limit)
+ while ((EMACS_INT) cursor <= (EMACS_INT) p_limit)
cursor += BM_tab[*cursor];
else
- while ((unsigned int) cursor <= (unsigned int) p_limit)
+ while ((unsigned EMACS_INT) cursor <= (unsigned EMACS_INT) p_limit)
cursor += BM_tab[*cursor];
}
else
{
- if ((int) (p_limit + infinity) < (int) p_limit)
- while ((int) cursor >= (int) p_limit)
+ if ((EMACS_INT) (p_limit + infinity) < (EMACS_INT) p_limit)
+ while ((EMACS_INT) cursor >= (EMACS_INT) p_limit)
cursor += BM_tab[*cursor];
else
- while ((unsigned int) cursor >= (unsigned int) p_limit)
+ while ((unsigned EMACS_INT) cursor >= (unsigned EMACS_INT) p_limit)
cursor += BM_tab[*cursor];
}
/* If you are here, cursor is beyond the end of the searched region. */
break; /* a small overrun is genuine */
cursor -= infinity; /* large overrun = hit */
i = dirlen - direction;
- if ((int) trt)
+ if (trt != 0)
{
while ((i -= direction) + direction != 0)
if (pat[i] != trt[*(cursor -= direction)])
while ((i -= direction) + direction != 0)
{
pos -= direction;
- if (pat[i] != (((int) trt)
+ if (pat[i] != (trt != 0
? trt[FETCH_CHAR(pos)]
: FETCH_CHAR (pos)))
break;
the match position. */
if (search_regs.num_regs == 0)
{
- regoff_t *starts, *ends;
-
- starts = (regoff_t *) xmalloc (2 * sizeof (regoff_t));
- ends = (regoff_t *) xmalloc (2 * sizeof (regoff_t));
- BLOCK_INPUT;
- re_set_registers (&searchbuf,
- &search_regs,
- 2, starts, ends);
- UNBLOCK_INPUT;
+ search_regs.start = (regoff_t *) xmalloc (2 * sizeof (regoff_t));
+ search_regs.end = (regoff_t *) xmalloc (2 * sizeof (regoff_t));
+ search_regs.num_regs = 2;
}
search_regs.start[0] = beg;
(string, bound, noerror, count)
Lisp_Object string, bound, noerror, count;
{
- return search_command (string, bound, noerror, count, -1, 0);
+ return search_command (string, bound, noerror, count, -1, 0, 0);
}
DEFUN ("search-forward", Fsearch_forward, Ssearch_forward, 1, 4, "sSearch: ",
(string, bound, noerror, count)
Lisp_Object string, bound, noerror, count;
{
- return search_command (string, bound, noerror, count, 1, 0);
+ return search_command (string, bound, noerror, count, 1, 0, 0);
}
DEFUN ("word-search-backward", Fword_search_backward, Sword_search_backward, 1, 4,
(string, bound, noerror, count)
Lisp_Object string, bound, noerror, count;
{
- return search_command (wordify (string), bound, noerror, count, -1, 1);
+ return search_command (wordify (string), bound, noerror, count, -1, 1, 0);
}
DEFUN ("word-search-forward", Fword_search_forward, Sword_search_forward, 1, 4,
(string, bound, noerror, count)
Lisp_Object string, bound, noerror, count;
{
- return search_command (wordify (string), bound, noerror, count, 1, 1);
+ return search_command (wordify (string), bound, noerror, count, 1, 1, 0);
}
DEFUN ("re-search-backward", Fre_search_backward, Sre_search_backward, 1, 4,
(regexp, bound, noerror, count)
Lisp_Object regexp, bound, noerror, count;
{
- return search_command (regexp, bound, noerror, count, -1, 1);
+ return search_command (regexp, bound, noerror, count, -1, 1, 0);
}
DEFUN ("re-search-forward", Fre_search_forward, Sre_search_forward, 1, 4,
(regexp, bound, noerror, count)
Lisp_Object regexp, bound, noerror, count;
{
- return search_command (regexp, bound, noerror, count, 1, 1);
+ return search_command (regexp, bound, noerror, count, 1, 1, 0);
+}
+
+DEFUN ("posix-search-backward", Fposix_search_backward, Sposix_search_backward, 1, 4,
+ "sPosix search backward: ",
+ "Search backward from point for match for regular expression REGEXP.\n\
+Find the longest match in accord with Posix regular expression rules.\n\
+Set point to the beginning of the match, and return point.\n\
+The match found is the one starting last in the buffer\n\
+and yet ending before the origin of the search.\n\
+An optional second argument bounds the search; it is a buffer position.\n\
+The match found must start at or after that position.\n\
+Optional third argument, if t, means if fail just return nil (no error).\n\
+ If not nil and not t, move to limit of search and return nil.\n\
+Optional fourth argument is repeat count--search for successive occurrences.\n\
+See also the functions `match-beginning', `match-end' and `replace-match'.")
+ (regexp, bound, noerror, count)
+ Lisp_Object regexp, bound, noerror, count;
+{
+ return search_command (regexp, bound, noerror, count, -1, 1, 1);
+}
+
+DEFUN ("posix-search-forward", Fposix_search_forward, Sposix_search_forward, 1, 4,
+ "sPosix search: ",
+ "Search forward from point for regular expression REGEXP.\n\
+Find the longest match in accord with Posix regular expression rules.\n\
+Set point to the end of the occurrence found, and return point.\n\
+An optional second argument bounds the search; it is a buffer position.\n\
+The match found must not extend after that position.\n\
+Optional third argument, if t, means if fail just return nil (no error).\n\
+ If not nil and not t, move to limit of search and return nil.\n\
+Optional fourth argument is repeat count--search for successive occurrences.\n\
+See also the functions `match-beginning', `match-end' and `replace-match'.")
+ (regexp, bound, noerror, count)
+ Lisp_Object regexp, bound, noerror, count;
+{
+ return search_command (regexp, bound, noerror, count, 1, 1, 1);
}
\f
-DEFUN ("replace-match", Freplace_match, Sreplace_match, 1, 4, 0,
+DEFUN ("replace-match", Freplace_match, Sreplace_match, 1, 5, 0,
"Replace text matched by last search with NEWTEXT.\n\
If second arg FIXEDCASE is non-nil, do not alter case of replacement text.\n\
Otherwise maybe capitalize the whole text, or maybe just word initials,\n\
\n\
The optional fourth argument STRING can be a string to modify.\n\
In that case, this function creates and returns a new string\n\
-which is made by replacing the part of STRING that was matched.")
- (newtext, fixedcase, literal, string)
- Lisp_Object newtext, fixedcase, literal, string;
+which is made by replacing the part of STRING that was matched.\n\
+\n\
+The optional fifth argument SUBEXP specifies a subexpression of the match.\n\
+It says to replace just that subexpression instead of the whole match.\n\
+This is useful only after a regular expression search or match\n\
+since only regular expressions have distinguished subexpressions.")
+ (newtext, fixedcase, literal, string, subexp)
+ Lisp_Object newtext, fixedcase, literal, string, subexp;
{
enum { nochange, all_caps, cap_initial } case_action;
register int pos, last;
int some_nonuppercase_initial;
register int c, prevc;
int inslen;
+ int sub;
CHECK_STRING (newtext, 0);
if (search_regs.num_regs <= 0)
error ("replace-match called before any match found");
+ if (NILP (subexp))
+ sub = 0;
+ else
+ {
+ CHECK_NUMBER (subexp, 3);
+ sub = XINT (subexp);
+ if (sub < 0 || sub >= search_regs.num_regs)
+ args_out_of_range (subexp, make_number (search_regs.num_regs));
+ }
+
if (NILP (string))
{
- if (search_regs.start[0] < BEGV
- || search_regs.start[0] > search_regs.end[0]
- || search_regs.end[0] > ZV)
- args_out_of_range (make_number (search_regs.start[0]),
- make_number (search_regs.end[0]));
+ if (search_regs.start[sub] < BEGV
+ || search_regs.start[sub] > search_regs.end[sub]
+ || search_regs.end[sub] > ZV)
+ args_out_of_range (make_number (search_regs.start[sub]),
+ make_number (search_regs.end[sub]));
}
else
{
- if (search_regs.start[0] < 0
- || search_regs.start[0] > search_regs.end[0]
- || search_regs.end[0] > XSTRING (string)->size)
- args_out_of_range (make_number (search_regs.start[0]),
- make_number (search_regs.end[0]));
+ if (search_regs.start[sub] < 0
+ || search_regs.start[sub] > search_regs.end[sub]
+ || search_regs.end[sub] > XSTRING (string)->size)
+ args_out_of_range (make_number (search_regs.start[sub]),
+ make_number (search_regs.end[sub]));
}
if (NILP (fixedcase))
{
/* Decide how to casify by examining the matched text. */
- last = search_regs.end[0];
+ last = search_regs.end[sub];
prevc = '\n';
case_action = all_caps;
some_nonuppercase_initial = 0;
some_uppercase = 0;
- for (pos = search_regs.start[0]; pos < last; pos++)
+ for (pos = search_regs.start[sub]; pos < last; pos++)
{
if (NILP (string))
c = FETCH_CHAR (pos);
Lisp_Object before, after;
before = Fsubstring (string, make_number (0),
- make_number (search_regs.start[0]));
- after = Fsubstring (string, make_number (search_regs.end[0]), Qnil);
+ make_number (search_regs.start[sub]));
+ after = Fsubstring (string, make_number (search_regs.end[sub]), Qnil);
/* Do case substitution into NEWTEXT if desired. */
if (NILP (literal))
{
int substart = -1;
int subend;
+ int delbackslash = 0;
c = XSTRING (newtext)->data[pos];
if (c == '\\')
c = XSTRING (newtext)->data[++pos];
if (c == '&')
{
- substart = search_regs.start[0];
- subend = search_regs.end[0];
+ substart = search_regs.start[sub];
+ subend = search_regs.end[sub];
}
else if (c >= '1' && c <= '9' && c <= search_regs.num_regs + '0')
{
- if (search_regs.start[c - '0'] >= 1)
+ if (search_regs.start[c - '0'] >= 0)
{
substart = search_regs.start[c - '0'];
subend = search_regs.end[c - '0'];
}
}
+ else if (c == '\\')
+ delbackslash = 1;
}
if (substart >= 0)
{
if (pos - 1 != lastpos + 1)
- middle = Fsubstring (newtext, lastpos + 1, pos - 1);
+ middle = Fsubstring (newtext,
+ make_number (lastpos + 1),
+ make_number (pos - 1));
else
middle = Qnil;
accum = concat3 (accum, middle,
make_number (subend)));
lastpos = pos;
}
+ else if (delbackslash)
+ {
+ middle = Fsubstring (newtext, make_number (lastpos + 1),
+ make_number (pos));
+ accum = concat2 (accum, middle);
+ lastpos = pos;
+ }
}
if (pos != lastpos + 1)
- middle = Fsubstring (newtext, lastpos + 1, pos);
+ middle = Fsubstring (newtext, make_number (lastpos + 1),
+ make_number (pos));
else
middle = Qnil;
if (case_action == all_caps)
newtext = Fupcase (newtext);
else if (case_action == cap_initial)
- newtext = upcase_initials (newtext);
+ newtext = Fupcase_initials (newtext);
return concat3 (before, newtext, after);
}
delete the original text. This means that markers at the
beginning or end of the original will float to the corresponding
position in the replacement. */
- SET_PT (search_regs.start[0]);
+ SET_PT (search_regs.start[sub]);
if (!NILP (literal))
Finsert_and_inherit (1, &newtext);
else
for (pos = 0; pos < XSTRING (newtext)->size; pos++)
{
- int offset = point - search_regs.start[0];
+ int offset = point - search_regs.start[sub];
c = XSTRING (newtext)->data[pos];
if (c == '\\')
if (c == '&')
Finsert_buffer_substring
(Fcurrent_buffer (),
- make_number (search_regs.start[0] + offset),
- make_number (search_regs.end[0] + offset));
+ make_number (search_regs.start[sub] + offset),
+ make_number (search_regs.end[sub] + offset));
else if (c >= '1' && c <= '9' && c <= search_regs.num_regs + '0')
{
if (search_regs.start[c - '0'] >= 1)
UNGCPRO;
}
- inslen = point - (search_regs.start[0]);
- del_range (search_regs.start[0] + inslen, search_regs.end[0] + inslen);
+ inslen = point - (search_regs.start[sub]);
+ del_range (search_regs.start[sub] + inslen, search_regs.end[sub] + inslen);
if (case_action == all_caps)
Fupcase_region (make_number (point - inslen), make_number (point));
else if (case_action == cap_initial)
- upcase_initials_region (make_number (point - inslen), make_number (point));
+ Fupcase_initials_region (make_number (point - inslen), make_number (point));
return Qnil;
}
\f
DEFUN ("match-beginning", Fmatch_beginning, Smatch_beginning, 1, 1, 0,
"Return position of start of text matched by last search.\n\
-NUM specifies which parenthesized expression in the last regexp.\n\
- Value is nil if NUMth pair didn't match, or there were less than NUM pairs.\n\
+SUBEXP, a number, specifies which parenthesized expression in the last\n\
+ regexp.\n\
+Value is nil if SUBEXPth pair didn't match, or there were less than\n\
+ SUBEXP pairs.\n\
Zero means the entire text matched by the whole regexp or whole string.")
- (num)
- Lisp_Object num;
+ (subexp)
+ Lisp_Object subexp;
{
- return match_limit (num, 1);
+ return match_limit (subexp, 1);
}
DEFUN ("match-end", Fmatch_end, Smatch_end, 1, 1, 0,
"Return position of end of text matched by last search.\n\
-ARG, a number, specifies which parenthesized expression in the last regexp.\n\
- Value is nil if ARGth pair didn't match, or there were less than ARG pairs.\n\
+SUBEXP, a number, specifies which parenthesized expression in the last\n\
+ regexp.\n\
+Value is nil if SUBEXPth pair didn't match, or there were less than\n\
+ SUBEXP pairs.\n\
Zero means the entire text matched by the whole regexp or whole string.")
- (num)
- Lisp_Object num;
+ (subexp)
+ Lisp_Object subexp;
{
- return match_limit (num, 0);
+ return match_limit (subexp, 0);
}
DEFUN ("match-data", Fmatch_data, Smatch_data, 0, 0, 0,
register int i;
register Lisp_Object marker;
+ if (running_asynch_code)
+ save_search_regs ();
+
if (!CONSP (list) && !NILP (list))
list = wrong_type_argument (Qconsp, list);
length * sizeof (regoff_t));
}
- BLOCK_INPUT;
- re_set_registers (&searchbuf, &search_regs, length,
- search_regs.start, search_regs.end);
- UNBLOCK_INPUT;
+ search_regs.num_regs = length;
}
}
return Qnil;
}
+/* If non-zero the match data have been saved in saved_search_regs
+ during the execution of a sentinel or filter. */
+static int search_regs_saved;
+static struct re_registers saved_search_regs;
+
+/* Called from Flooking_at, Fstring_match, search_buffer, Fstore_match_data
+ if asynchronous code (filter or sentinel) is running. */
+static void
+save_search_regs ()
+{
+ if (!search_regs_saved)
+ {
+ saved_search_regs.num_regs = search_regs.num_regs;
+ saved_search_regs.start = search_regs.start;
+ saved_search_regs.end = search_regs.end;
+ search_regs.num_regs = 0;
+ search_regs.start = 0;
+ search_regs.end = 0;
+
+ search_regs_saved = 1;
+ }
+}
+
+/* Called upon exit from filters and sentinels. */
+void
+restore_match_data ()
+{
+ if (search_regs_saved)
+ {
+ if (search_regs.num_regs > 0)
+ {
+ xfree (search_regs.start);
+ xfree (search_regs.end);
+ }
+ search_regs.num_regs = saved_search_regs.num_regs;
+ search_regs.start = saved_search_regs.start;
+ search_regs.end = saved_search_regs.end;
+
+ search_regs_saved = 0;
+ }
+}
+
/* Quote a string to inactivate reg-expr chars */
DEFUN ("regexp-quote", Fregexp_quote, Sregexp_quote, 1, 1, 0,
"Return a regexp string which matches exactly STRING and nothing else.")
- (str)
- Lisp_Object str;
+ (string)
+ Lisp_Object string;
{
register unsigned char *in, *out, *end;
register unsigned char *temp;
- CHECK_STRING (str, 0);
+ CHECK_STRING (string, 0);
- temp = (unsigned char *) alloca (XSTRING (str)->size * 2);
+ temp = (unsigned char *) alloca (XSTRING (string)->size * 2);
/* Now copy the data into the new string, inserting escapes. */
- in = XSTRING (str)->data;
- end = in + XSTRING (str)->size;
+ in = XSTRING (string)->data;
+ end = in + XSTRING (string)->size;
out = temp;
for (; in != end; in++)
{
register int i;
- searchbuf.allocated = 100;
- searchbuf.buffer = (unsigned char *) malloc (searchbuf.allocated);
- searchbuf.fastmap = search_fastmap;
+ for (i = 0; i < REGEXP_CACHE_SIZE; ++i)
+ {
+ searchbufs[i].buf.allocated = 100;
+ searchbufs[i].buf.buffer = (unsigned char *) malloc (100);
+ searchbufs[i].buf.fastmap = searchbufs[i].fastmap;
+ searchbufs[i].regexp = Qnil;
+ staticpro (&searchbufs[i].regexp);
+ searchbufs[i].next = (i == REGEXP_CACHE_SIZE-1 ? 0 : &searchbufs[i+1]);
+ }
+ searchbuf_head = &searchbufs[0];
Qsearch_failed = intern ("search-failed");
staticpro (&Qsearch_failed);
Fput (Qinvalid_regexp, Qerror_message,
build_string ("Invalid regexp"));
- last_regexp = Qnil;
- staticpro (&last_regexp);
-
last_thing_searched = Qnil;
staticpro (&last_thing_searched);
- defsubr (&Sstring_match);
defsubr (&Slooking_at);
+ defsubr (&Sposix_looking_at);
+ defsubr (&Sstring_match);
+ defsubr (&Sposix_string_match);
defsubr (&Sskip_chars_forward);
defsubr (&Sskip_chars_backward);
defsubr (&Sskip_syntax_forward);
defsubr (&Sword_search_backward);
defsubr (&Sre_search_forward);
defsubr (&Sre_search_backward);
+ defsubr (&Sposix_search_forward);
+ defsubr (&Sposix_search_backward);
defsubr (&Sreplace_match);
defsubr (&Smatch_beginning);
defsubr (&Smatch_end);
HCoop / bpt / emacs.git / blobdiff