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;
compile_pattern_1 (cp, pattern, translate, regp, posix)
struct regexp_cache *cp;
Lisp_Object pattern;
- char *translate;
+ Lisp_Object *translate;
struct re_registers *regp;
int posix;
{
compile_pattern (pattern, regp, translate, posix)
Lisp_Object pattern;
struct re_registers *regp;
- char *translate;
+ Lisp_Object *translate;
int posix;
{
struct regexp_cache *cp, **cpp;
bufp = compile_pattern (regexp, &search_regs,
(!NILP (current_buffer->case_fold_search)
? DOWNCASE_TABLE : 0),
- 0);
+ posix);
immediate_quit = 1;
val = re_search (bufp, (char *) XSTRING (string)->data,
XSTRING (string)->size, s, XSTRING (string)->size - s,
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)
{
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;
{
struct re_pattern_buffer *bufp;
- bufp = compile_pattern (string, &search_regs, (char *) trt, posix);
+ bufp = compile_pattern (string, &search_regs, trt, posix);
immediate_quit = 1; /* Quit immediately if user types ^G,
because letting this function finish
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
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))
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')
{
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));
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,
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++)