1 /* String search routines for GNU Emacs.
2 Copyright (C) 1985, 1986, 1987, 1993, 1994 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 1, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
25 #include "region-cache.h"
27 #include "blockinput.h"
29 #include <sys/types.h>
32 #define REGEXP_CACHE_SIZE 5
34 /* If the regexp is non-nil, then the buffer contains the compiled form
35 of that regexp, suitable for searching. */
37 struct regexp_cache
*next
;
39 struct re_pattern_buffer buf
;
41 /* Nonzero means regexp was compiled to do full POSIX backtracking. */
45 /* The instances of that struct. */
46 struct regexp_cache searchbufs
[REGEXP_CACHE_SIZE
];
48 /* The head of the linked list; points to the most recently used buffer. */
49 struct regexp_cache
*searchbuf_head
;
52 /* Every call to re_match, etc., must pass &search_regs as the regs
53 argument unless you can show it is unnecessary (i.e., if re_match
54 is certainly going to be called again before region-around-match
57 Since the registers are now dynamically allocated, we need to make
58 sure not to refer to the Nth register before checking that it has
59 been allocated by checking search_regs.num_regs.
61 The regex code keeps track of whether it has allocated the search
62 buffer using bits in the re_pattern_buffer. This means that whenever
63 you compile a new pattern, it completely forgets whether it has
64 allocated any registers, and will allocate new registers the next
65 time you call a searching or matching function. Therefore, we need
66 to call re_set_registers after compiling a new pattern or after
67 setting the match registers, so that the regex functions will be
68 able to free or re-allocate it properly. */
69 static struct re_registers search_regs
;
71 /* The buffer in which the last search was performed, or
72 Qt if the last search was done in a string;
73 Qnil if no searching has been done yet. */
74 static Lisp_Object last_thing_searched
;
76 /* error condition signalled when regexp compile_pattern fails */
78 Lisp_Object Qinvalid_regexp
;
80 static void set_search_regs ();
82 static int search_buffer ();
87 error ("Stack overflow in regexp matcher");
96 /* Compile a regexp and signal a Lisp error if anything goes wrong.
97 PATTERN is the pattern to compile.
98 CP is the place to put the result.
99 TRANSLATE is a translation table for ignoring case, or NULL for none.
100 REGP is the structure that says where to store the "register"
101 values that will result from matching this pattern.
102 If it is 0, we should compile the pattern not to record any
103 subexpression bounds.
104 POSIX is nonzero if we want full backtracking (POSIX style)
105 for this pattern. 0 means backtrack only enough to get a valid match. */
108 compile_pattern_1 (cp
, pattern
, translate
, regp
, posix
)
109 struct regexp_cache
*cp
;
112 struct re_registers
*regp
;
119 cp
->buf
.translate
= translate
;
122 old
= re_set_syntax (RE_SYNTAX_EMACS
123 | (posix
? 0 : RE_NO_POSIX_BACKTRACKING
));
124 val
= (CONST
char *) re_compile_pattern ((char *) XSTRING (pattern
)->data
,
125 XSTRING (pattern
)->size
, &cp
->buf
);
129 Fsignal (Qinvalid_regexp
, Fcons (build_string (val
), Qnil
));
131 cp
->regexp
= Fcopy_sequence (pattern
);
133 /* Advise the searching functions about the space we have allocated
134 for register data. */
137 re_set_registers (&cp
->buf
, regp
, regp
->num_regs
, regp
->start
, regp
->end
);
141 /* Compile a regexp if necessary, but first check to see if there's one in
143 PATTERN is the pattern to compile.
144 TRANSLATE is a translation table for ignoring case, or NULL for none.
145 REGP is the structure that says where to store the "register"
146 values that will result from matching this pattern.
147 If it is 0, we should compile the pattern not to record any
148 subexpression bounds.
149 POSIX is nonzero if we want full backtracking (POSIX style)
150 for this pattern. 0 means backtrack only enough to get a valid match. */
152 struct re_pattern_buffer
*
153 compile_pattern (pattern
, regp
, translate
, posix
)
155 struct re_registers
*regp
;
159 struct regexp_cache
*cp
, **cpp
;
161 for (cpp
= &searchbuf_head
; ; cpp
= &cp
->next
)
164 if (!NILP (Fstring_equal (cp
->regexp
, pattern
))
165 && cp
->buf
.translate
== translate
166 && cp
->posix
== posix
)
169 /* If we're at the end of the cache, compile into the last cell. */
172 compile_pattern_1 (cp
, pattern
, translate
, regp
, posix
);
177 /* When we get here, cp (aka *cpp) contains the compiled pattern,
178 either because we found it in the cache or because we just compiled it.
179 Move it to the front of the queue to mark it as most recently used. */
181 cp
->next
= searchbuf_head
;
187 /* Error condition used for failing searches */
188 Lisp_Object Qsearch_failed
;
194 Fsignal (Qsearch_failed
, Fcons (arg
, Qnil
));
199 looking_at_1 (string
, posix
)
204 unsigned char *p1
, *p2
;
207 struct re_pattern_buffer
*bufp
;
209 if (running_asynch_code
)
212 CHECK_STRING (string
, 0);
213 bufp
= compile_pattern (string
, &search_regs
,
214 (!NILP (current_buffer
->case_fold_search
)
215 ? DOWNCASE_TABLE
: 0),
219 QUIT
; /* Do a pending quit right away, to avoid paradoxical behavior */
221 /* Get pointers and sizes of the two strings
222 that make up the visible portion of the buffer. */
240 i
= re_match_2 (bufp
, (char *) p1
, s1
, (char *) p2
, s2
,
241 point
- BEGV
, &search_regs
,
246 val
= (0 <= i
? Qt
: Qnil
);
247 for (i
= 0; i
< search_regs
.num_regs
; i
++)
248 if (search_regs
.start
[i
] >= 0)
250 search_regs
.start
[i
] += BEGV
;
251 search_regs
.end
[i
] += BEGV
;
253 XSETBUFFER (last_thing_searched
, current_buffer
);
258 DEFUN ("looking-at", Flooking_at
, Slooking_at
, 1, 1, 0,
259 "Return t if text after point matches regular expression PAT.\n\
260 This function modifies the match data that `match-beginning',\n\
261 `match-end' and `match-data' access; save and restore the match\n\
262 data if you want to preserve them.")
266 return looking_at_1 (string
, 0);
269 DEFUN ("posix-looking-at", Fposix_looking_at
, Sposix_looking_at
, 1, 1, 0,
270 "Return t if text after point matches regular expression PAT.\n\
271 Find the longest match, in accord with Posix regular expression rules.\n\
272 This function modifies the match data that `match-beginning',\n\
273 `match-end' and `match-data' access; save and restore the match\n\
274 data if you want to preserve them.")
278 return looking_at_1 (string
, 1);
282 string_match_1 (regexp
, string
, start
, posix
)
283 Lisp_Object regexp
, string
, start
;
288 struct re_pattern_buffer
*bufp
;
290 if (running_asynch_code
)
293 CHECK_STRING (regexp
, 0);
294 CHECK_STRING (string
, 1);
300 int len
= XSTRING (string
)->size
;
302 CHECK_NUMBER (start
, 2);
304 if (s
< 0 && -s
<= len
)
306 else if (0 > s
|| s
> len
)
307 args_out_of_range (string
, start
);
310 bufp
= compile_pattern (regexp
, &search_regs
,
311 (!NILP (current_buffer
->case_fold_search
)
312 ? DOWNCASE_TABLE
: 0),
315 val
= re_search (bufp
, (char *) XSTRING (string
)->data
,
316 XSTRING (string
)->size
, s
, XSTRING (string
)->size
- s
,
319 last_thing_searched
= Qt
;
322 if (val
< 0) return Qnil
;
323 return make_number (val
);
326 DEFUN ("string-match", Fstring_match
, Sstring_match
, 2, 3, 0,
327 "Return index of start of first match for REGEXP in STRING, or nil.\n\
328 If third arg START is non-nil, start search at that index in STRING.\n\
329 For index of first char beyond the match, do (match-end 0).\n\
330 `match-end' and `match-beginning' also give indices of substrings\n\
331 matched by parenthesis constructs in the pattern.")
332 (regexp
, string
, start
)
333 Lisp_Object regexp
, string
, start
;
335 return string_match_1 (regexp
, string
, start
, 0);
338 DEFUN ("posix-string-match", Fposix_string_match
, Sposix_string_match
, 2, 3, 0,
339 "Return index of start of first match for REGEXP in STRING, or nil.\n\
340 Find the longest match, in accord with Posix regular expression rules.\n\
341 If third arg START is non-nil, start search at that index in STRING.\n\
342 For index of first char beyond the match, do (match-end 0).\n\
343 `match-end' and `match-beginning' also give indices of substrings\n\
344 matched by parenthesis constructs in the pattern.")
345 (regexp
, string
, start
)
346 Lisp_Object regexp
, string
, start
;
348 return string_match_1 (regexp
, string
, start
, 1);
351 /* Match REGEXP against STRING, searching all of STRING,
352 and return the index of the match, or negative on failure.
353 This does not clobber the match data. */
356 fast_string_match (regexp
, string
)
357 Lisp_Object regexp
, string
;
360 struct re_pattern_buffer
*bufp
;
362 bufp
= compile_pattern (regexp
, 0, 0, 0);
364 val
= re_search (bufp
, (char *) XSTRING (string
)->data
,
365 XSTRING (string
)->size
, 0, XSTRING (string
)->size
,
377 return ((a
> b
) ? a
: b
);
384 return ((a
< b
) ? a
: b
);
388 /* The newline cache: remembering which sections of text have no newlines. */
390 /* If the user has requested newline caching, make sure it's on.
391 Otherwise, make sure it's off.
392 This is our cheezy way of associating an action with the change of
393 state of a buffer-local variable. */
395 newline_cache_on_off (buf
)
398 if (NILP (buf
->cache_long_line_scans
))
400 /* It should be off. */
401 if (buf
->newline_cache
)
403 free_region_cache (buf
->newline_cache
);
404 buf
->newline_cache
= 0;
409 /* It should be on. */
410 if (buf
->newline_cache
== 0)
411 buf
->newline_cache
= new_region_cache ();
416 /* Search for COUNT instances of the character TARGET between START and END.
418 If COUNT is positive, search forwards; END must be >= START.
419 If COUNT is negative, search backwards for the -COUNTth instance;
420 END must be <= START.
421 If COUNT is zero, do anything you please; run rogue, for all I care.
423 If END is zero, use BEGV or ZV instead, as appropriate for the
424 direction indicated by COUNT.
426 If we find COUNT instances, set *SHORTAGE to zero, and return the
427 position after the COUNTth match. Note that for reverse motion
428 this is not the same as the usual convention for Emacs motion commands.
430 If we don't find COUNT instances before reaching END, set *SHORTAGE
431 to the number of TARGETs left unfound, and return END.
433 If ALLOW_QUIT is non-zero, set immediate_quit. That's good to do
434 except when inside redisplay. */
436 scan_buffer (target
, start
, end
, count
, shortage
, allow_quit
)
443 struct region_cache
*newline_cache
;
454 if (! end
) end
= BEGV
;
457 newline_cache_on_off (current_buffer
);
458 newline_cache
= current_buffer
->newline_cache
;
463 immediate_quit
= allow_quit
;
468 /* Our innermost scanning loop is very simple; it doesn't know
469 about gaps, buffer ends, or the newline cache. ceiling is
470 the position of the last character before the next such
471 obstacle --- the last character the dumb search loop should
473 register int ceiling
= end
- 1;
475 /* If we're looking for a newline, consult the newline cache
476 to see where we can avoid some scanning. */
477 if (target
== '\n' && newline_cache
)
481 while (region_cache_forward
482 (current_buffer
, newline_cache
, start
, &next_change
))
484 immediate_quit
= allow_quit
;
486 /* start should never be after end. */
490 /* Now the text after start is an unknown region, and
491 next_change is the position of the next known region. */
492 ceiling
= min (next_change
- 1, ceiling
);
495 /* The dumb loop can only scan text stored in contiguous
496 bytes. BUFFER_CEILING_OF returns the last character
497 position that is contiguous, so the ceiling is the
498 position after that. */
499 ceiling
= min (BUFFER_CEILING_OF (start
), ceiling
);
502 /* The termination address of the dumb loop. */
503 register unsigned char *ceiling_addr
= &FETCH_CHAR (ceiling
) + 1;
504 register unsigned char *cursor
= &FETCH_CHAR (start
);
505 unsigned char *base
= cursor
;
507 while (cursor
< ceiling_addr
)
509 unsigned char *scan_start
= cursor
;
512 while (*cursor
!= target
&& ++cursor
< ceiling_addr
)
515 /* If we're looking for newlines, cache the fact that
516 the region from start to cursor is free of them. */
517 if (target
== '\n' && newline_cache
)
518 know_region_cache (current_buffer
, newline_cache
,
519 start
+ scan_start
- base
,
520 start
+ cursor
- base
);
522 /* Did we find the target character? */
523 if (cursor
< ceiling_addr
)
528 return (start
+ cursor
- base
+ 1);
534 start
+= cursor
- base
;
540 /* The last character to check before the next obstacle. */
541 register int ceiling
= end
;
543 /* Consult the newline cache, if appropriate. */
544 if (target
== '\n' && newline_cache
)
548 while (region_cache_backward
549 (current_buffer
, newline_cache
, start
, &next_change
))
551 immediate_quit
= allow_quit
;
553 /* Start should never be at or before end. */
557 /* Now the text before start is an unknown region, and
558 next_change is the position of the next known region. */
559 ceiling
= max (next_change
, ceiling
);
562 /* Stop scanning before the gap. */
563 ceiling
= max (BUFFER_FLOOR_OF (start
- 1), ceiling
);
566 /* The termination address of the dumb loop. */
567 register unsigned char *ceiling_addr
= &FETCH_CHAR (ceiling
);
568 register unsigned char *cursor
= &FETCH_CHAR (start
- 1);
569 unsigned char *base
= cursor
;
571 while (cursor
>= ceiling_addr
)
573 unsigned char *scan_start
= cursor
;
575 while (*cursor
!= target
&& --cursor
>= ceiling_addr
)
578 /* If we're looking for newlines, cache the fact that
579 the region from after the cursor to start is free of them. */
580 if (target
== '\n' && newline_cache
)
581 know_region_cache (current_buffer
, newline_cache
,
582 start
+ cursor
- base
,
583 start
+ scan_start
- base
);
585 /* Did we find the target character? */
586 if (cursor
>= ceiling_addr
)
591 return (start
+ cursor
- base
);
597 start
+= cursor
- base
;
603 *shortage
= count
* direction
;
608 find_next_newline_no_quit (from
, cnt
)
609 register int from
, cnt
;
611 return scan_buffer ('\n', from
, 0, cnt
, (int *) 0, 0);
615 find_next_newline (from
, cnt
)
616 register int from
, cnt
;
618 return scan_buffer ('\n', from
, 0, cnt
, (int *) 0, 1);
622 /* Like find_next_newline, but returns position before the newline,
623 not after, and only search up to TO. This isn't just
624 find_next_newline (...)-1, because you might hit TO. */
626 find_before_next_newline (from
, to
, cnt
)
630 int pos
= scan_buffer ('\n', from
, to
, cnt
, &shortage
, 1);
638 Lisp_Object
skip_chars ();
640 DEFUN ("skip-chars-forward", Fskip_chars_forward
, Sskip_chars_forward
, 1, 2, 0,
641 "Move point forward, stopping before a char not in STRING, or at pos LIM.\n\
642 STRING is like the inside of a `[...]' in a regular expression\n\
643 except that `]' is never special and `\\' quotes `^', `-' or `\\'.\n\
644 Thus, with arg \"a-zA-Z\", this skips letters stopping before first nonletter.\n\
645 With arg \"^a-zA-Z\", skips nonletters stopping before first letter.\n\
646 Returns the distance traveled, either zero or positive.")
648 Lisp_Object string
, lim
;
650 return skip_chars (1, 0, string
, lim
);
653 DEFUN ("skip-chars-backward", Fskip_chars_backward
, Sskip_chars_backward
, 1, 2, 0,
654 "Move point backward, stopping after a char not in STRING, or at pos LIM.\n\
655 See `skip-chars-forward' for details.\n\
656 Returns the distance traveled, either zero or negative.")
658 Lisp_Object string
, lim
;
660 return skip_chars (0, 0, string
, lim
);
663 DEFUN ("skip-syntax-forward", Fskip_syntax_forward
, Sskip_syntax_forward
, 1, 2, 0,
664 "Move point forward across chars in specified syntax classes.\n\
665 SYNTAX is a string of syntax code characters.\n\
666 Stop before a char whose syntax is not in SYNTAX, or at position LIM.\n\
667 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
668 This function returns the distance traveled, either zero or positive.")
670 Lisp_Object syntax
, lim
;
672 return skip_chars (1, 1, syntax
, lim
);
675 DEFUN ("skip-syntax-backward", Fskip_syntax_backward
, Sskip_syntax_backward
, 1, 2, 0,
676 "Move point backward across chars in specified syntax classes.\n\
677 SYNTAX is a string of syntax code characters.\n\
678 Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.\n\
679 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
680 This function returns the distance traveled, either zero or negative.")
682 Lisp_Object syntax
, lim
;
684 return skip_chars (0, 1, syntax
, lim
);
688 skip_chars (forwardp
, syntaxp
, string
, lim
)
689 int forwardp
, syntaxp
;
690 Lisp_Object string
, lim
;
692 register unsigned char *p
, *pend
;
693 register unsigned char c
;
694 unsigned char fastmap
[0400];
698 CHECK_STRING (string
, 0);
701 XSETINT (lim
, forwardp
? ZV
: BEGV
);
703 CHECK_NUMBER_COERCE_MARKER (lim
, 1);
705 /* In any case, don't allow scan outside bounds of buffer. */
706 /* jla turned this off, for no known reason.
707 bfox turned the ZV part on, and rms turned the
708 BEGV part back on. */
710 XSETFASTINT (lim
, ZV
);
711 if (XINT (lim
) < BEGV
)
712 XSETFASTINT (lim
, BEGV
);
714 p
= XSTRING (string
)->data
;
715 pend
= p
+ XSTRING (string
)->size
;
716 bzero (fastmap
, sizeof fastmap
);
718 if (p
!= pend
&& *p
== '^')
723 /* Find the characters specified and set their elements of fastmap.
724 If syntaxp, each character counts as itself.
725 Otherwise, handle backslashes and ranges specially */
736 if (p
== pend
) break;
739 if (p
!= pend
&& *p
== '-')
742 if (p
== pend
) break;
755 if (syntaxp
&& fastmap
['-'] != 0)
758 /* If ^ was the first character, complement the fastmap. */
761 for (i
= 0; i
< sizeof fastmap
; i
++)
765 int start_point
= point
;
773 while (point
< XINT (lim
)
774 && fastmap
[(unsigned char) syntax_code_spec
[(int) SYNTAX (FETCH_CHAR (point
))]])
779 while (point
> XINT (lim
)
780 && fastmap
[(unsigned char) syntax_code_spec
[(int) SYNTAX (FETCH_CHAR (point
- 1))]])
788 while (point
< XINT (lim
) && fastmap
[FETCH_CHAR (point
)])
793 while (point
> XINT (lim
) && fastmap
[FETCH_CHAR (point
- 1)])
799 return make_number (point
- start_point
);
803 /* Subroutines of Lisp buffer search functions. */
806 search_command (string
, bound
, noerror
, count
, direction
, RE
, posix
)
807 Lisp_Object string
, bound
, noerror
, count
;
818 CHECK_NUMBER (count
, 3);
822 CHECK_STRING (string
, 0);
824 lim
= n
> 0 ? ZV
: BEGV
;
827 CHECK_NUMBER_COERCE_MARKER (bound
, 1);
829 if (n
> 0 ? lim
< point
: lim
> point
)
830 error ("Invalid search bound (wrong side of point)");
837 np
= search_buffer (string
, point
, lim
, n
, RE
,
838 (!NILP (current_buffer
->case_fold_search
)
839 ? XSTRING (current_buffer
->case_canon_table
)->data
: 0),
840 (!NILP (current_buffer
->case_fold_search
)
841 ? XSTRING (current_buffer
->case_eqv_table
)->data
: 0),
846 return signal_failure (string
);
847 if (!EQ (noerror
, Qt
))
849 if (lim
< BEGV
|| lim
> ZV
)
853 #if 0 /* This would be clean, but maybe programs depend on
854 a value of nil here. */
862 if (np
< BEGV
|| np
> ZV
)
867 return make_number (np
);
871 trivial_regexp_p (regexp
)
874 int len
= XSTRING (regexp
)->size
;
875 unsigned char *s
= XSTRING (regexp
)->data
;
881 case '.': case '*': case '+': case '?': case '[': case '^': case '$':
888 case '|': case '(': case ')': case '`': case '\'': case 'b':
889 case 'B': case '<': case '>': case 'w': case 'W': case 's':
890 case 'S': case '1': case '2': case '3': case '4': case '5':
891 case '6': case '7': case '8': case '9':
899 /* Search for the n'th occurrence of STRING in the current buffer,
900 starting at position POS and stopping at position LIM,
901 treating STRING as a literal string if RE is false or as
902 a regular expression if RE is true.
904 If N is positive, searching is forward and LIM must be greater than POS.
905 If N is negative, searching is backward and LIM must be less than POS.
907 Returns -x if only N-x occurrences found (x > 0),
908 or else the position at the beginning of the Nth occurrence
909 (if searching backward) or the end (if searching forward).
911 POSIX is nonzero if we want full backtracking (POSIX style)
912 for this pattern. 0 means backtrack only enough to get a valid match. */
915 search_buffer (string
, pos
, lim
, n
, RE
, trt
, inverse_trt
, posix
)
921 register unsigned char *trt
;
922 register unsigned char *inverse_trt
;
925 int len
= XSTRING (string
)->size
;
926 unsigned char *base_pat
= XSTRING (string
)->data
;
927 register int *BM_tab
;
929 register int direction
= ((n
> 0) ? 1 : -1);
931 int infinity
, limit
, k
, stride_for_teases
;
932 register unsigned char *pat
, *cursor
, *p_limit
;
934 unsigned char *p1
, *p2
;
937 if (running_asynch_code
)
940 /* Null string is found at starting position. */
943 set_search_regs (pos
, 0);
947 /* Searching 0 times means don't move. */
951 if (RE
&& !trivial_regexp_p (string
))
953 struct re_pattern_buffer
*bufp
;
955 bufp
= compile_pattern (string
, &search_regs
, (char *) trt
, posix
);
957 immediate_quit
= 1; /* Quit immediately if user types ^G,
958 because letting this function finish
959 can take too long. */
960 QUIT
; /* Do a pending quit right away,
961 to avoid paradoxical behavior */
962 /* Get pointers and sizes of the two strings
963 that make up the visible portion of the buffer. */
983 val
= re_search_2 (bufp
, (char *) p1
, s1
, (char *) p2
, s2
,
984 pos
- BEGV
, lim
- pos
, &search_regs
,
985 /* Don't allow match past current point */
994 for (i
= 0; i
< search_regs
.num_regs
; i
++)
995 if (search_regs
.start
[i
] >= 0)
997 search_regs
.start
[i
] += j
;
998 search_regs
.end
[i
] += j
;
1000 XSETBUFFER (last_thing_searched
, current_buffer
);
1001 /* Set pos to the new position. */
1002 pos
= search_regs
.start
[0];
1014 val
= re_search_2 (bufp
, (char *) p1
, s1
, (char *) p2
, s2
,
1015 pos
- BEGV
, lim
- pos
, &search_regs
,
1019 matcher_overflow ();
1024 for (i
= 0; i
< search_regs
.num_regs
; i
++)
1025 if (search_regs
.start
[i
] >= 0)
1027 search_regs
.start
[i
] += j
;
1028 search_regs
.end
[i
] += j
;
1030 XSETBUFFER (last_thing_searched
, current_buffer
);
1031 pos
= search_regs
.end
[0];
1043 else /* non-RE case */
1046 int BM_tab_space
[0400];
1047 BM_tab
= &BM_tab_space
[0];
1049 BM_tab
= (int *) alloca (0400 * sizeof (int));
1052 unsigned char *patbuf
= (unsigned char *) alloca (len
);
1056 /* If we got here and the RE flag is set, it's because we're
1057 dealing with a regexp known to be trivial, so the backslash
1058 just quotes the next character. */
1059 if (RE
&& *base_pat
== '\\')
1064 *pat
++ = (trt
? trt
[*base_pat
++] : *base_pat
++);
1067 pat
= base_pat
= patbuf
;
1069 /* The general approach is that we are going to maintain that we know */
1070 /* the first (closest to the present position, in whatever direction */
1071 /* we're searching) character that could possibly be the last */
1072 /* (furthest from present position) character of a valid match. We */
1073 /* advance the state of our knowledge by looking at that character */
1074 /* and seeing whether it indeed matches the last character of the */
1075 /* pattern. If it does, we take a closer look. If it does not, we */
1076 /* move our pointer (to putative last characters) as far as is */
1077 /* logically possible. This amount of movement, which I call a */
1078 /* stride, will be the length of the pattern if the actual character */
1079 /* appears nowhere in the pattern, otherwise it will be the distance */
1080 /* from the last occurrence of that character to the end of the */
1082 /* As a coding trick, an enormous stride is coded into the table for */
1083 /* characters that match the last character. This allows use of only */
1084 /* a single test, a test for having gone past the end of the */
1085 /* permissible match region, to test for both possible matches (when */
1086 /* the stride goes past the end immediately) and failure to */
1087 /* match (where you get nudged past the end one stride at a time). */
1089 /* Here we make a "mickey mouse" BM table. The stride of the search */
1090 /* is determined only by the last character of the putative match. */
1091 /* If that character does not match, we will stride the proper */
1092 /* distance to propose a match that superimposes it on the last */
1093 /* instance of a character that matches it (per trt), or misses */
1094 /* it entirely if there is none. */
1096 dirlen
= len
* direction
;
1097 infinity
= dirlen
- (lim
+ pos
+ len
+ len
) * direction
;
1099 pat
= (base_pat
+= len
- 1);
1100 BM_tab_base
= BM_tab
;
1102 j
= dirlen
; /* to get it in a register */
1103 /* A character that does not appear in the pattern induces a */
1104 /* stride equal to the pattern length. */
1105 while (BM_tab_base
!= BM_tab
)
1113 while (i
!= infinity
)
1115 j
= pat
[i
]; i
+= direction
;
1116 if (i
== dirlen
) i
= infinity
;
1121 stride_for_teases
= BM_tab
[j
];
1122 BM_tab
[j
] = dirlen
- i
;
1123 /* A translation table is accompanied by its inverse -- see */
1124 /* comment following downcase_table for details */
1125 while ((j
= inverse_trt
[j
]) != k
)
1126 BM_tab
[j
] = dirlen
- i
;
1131 stride_for_teases
= BM_tab
[j
];
1132 BM_tab
[j
] = dirlen
- i
;
1134 /* stride_for_teases tells how much to stride if we get a */
1135 /* match on the far character but are subsequently */
1136 /* disappointed, by recording what the stride would have been */
1137 /* for that character if the last character had been */
1140 infinity
= dirlen
- infinity
;
1141 pos
+= dirlen
- ((direction
> 0) ? direction
: 0);
1142 /* loop invariant - pos points at where last char (first char if reverse)
1143 of pattern would align in a possible match. */
1146 /* It's been reported that some (broken) compiler thinks that
1147 Boolean expressions in an arithmetic context are unsigned.
1148 Using an explicit ?1:0 prevents this. */
1149 if ((lim
- pos
- ((direction
> 0) ? 1 : 0)) * direction
< 0)
1150 return (n
* (0 - direction
));
1151 /* First we do the part we can by pointers (maybe nothing) */
1154 limit
= pos
- dirlen
+ direction
;
1155 limit
= ((direction
> 0)
1156 ? BUFFER_CEILING_OF (limit
)
1157 : BUFFER_FLOOR_OF (limit
));
1158 /* LIMIT is now the last (not beyond-last!) value
1159 POS can take on without hitting edge of buffer or the gap. */
1160 limit
= ((direction
> 0)
1161 ? min (lim
- 1, min (limit
, pos
+ 20000))
1162 : max (lim
, max (limit
, pos
- 20000)));
1163 if ((limit
- pos
) * direction
> 20)
1165 p_limit
= &FETCH_CHAR (limit
);
1166 p2
= (cursor
= &FETCH_CHAR (pos
));
1167 /* In this loop, pos + cursor - p2 is the surrogate for pos */
1168 while (1) /* use one cursor setting as long as i can */
1170 if (direction
> 0) /* worth duplicating */
1172 /* Use signed comparison if appropriate
1173 to make cursor+infinity sure to be > p_limit.
1174 Assuming that the buffer lies in a range of addresses
1175 that are all "positive" (as ints) or all "negative",
1176 either kind of comparison will work as long
1177 as we don't step by infinity. So pick the kind
1178 that works when we do step by infinity. */
1179 if ((int) (p_limit
+ infinity
) > (int) p_limit
)
1180 while ((int) cursor
<= (int) p_limit
)
1181 cursor
+= BM_tab
[*cursor
];
1183 while ((unsigned int) cursor
<= (unsigned int) p_limit
)
1184 cursor
+= BM_tab
[*cursor
];
1188 if ((int) (p_limit
+ infinity
) < (int) p_limit
)
1189 while ((int) cursor
>= (int) p_limit
)
1190 cursor
+= BM_tab
[*cursor
];
1192 while ((unsigned int) cursor
>= (unsigned int) p_limit
)
1193 cursor
+= BM_tab
[*cursor
];
1195 /* If you are here, cursor is beyond the end of the searched region. */
1196 /* This can happen if you match on the far character of the pattern, */
1197 /* because the "stride" of that character is infinity, a number able */
1198 /* to throw you well beyond the end of the search. It can also */
1199 /* happen if you fail to match within the permitted region and would */
1200 /* otherwise try a character beyond that region */
1201 if ((cursor
- p_limit
) * direction
<= len
)
1202 break; /* a small overrun is genuine */
1203 cursor
-= infinity
; /* large overrun = hit */
1204 i
= dirlen
- direction
;
1207 while ((i
-= direction
) + direction
!= 0)
1208 if (pat
[i
] != trt
[*(cursor
-= direction
)])
1213 while ((i
-= direction
) + direction
!= 0)
1214 if (pat
[i
] != *(cursor
-= direction
))
1217 cursor
+= dirlen
- i
- direction
; /* fix cursor */
1218 if (i
+ direction
== 0)
1220 cursor
-= direction
;
1222 set_search_regs (pos
+ cursor
- p2
+ ((direction
> 0)
1226 if ((n
-= direction
) != 0)
1227 cursor
+= dirlen
; /* to resume search */
1229 return ((direction
> 0)
1230 ? search_regs
.end
[0] : search_regs
.start
[0]);
1233 cursor
+= stride_for_teases
; /* <sigh> we lose - */
1238 /* Now we'll pick up a clump that has to be done the hard */
1239 /* way because it covers a discontinuity */
1241 limit
= ((direction
> 0)
1242 ? BUFFER_CEILING_OF (pos
- dirlen
+ 1)
1243 : BUFFER_FLOOR_OF (pos
- dirlen
- 1));
1244 limit
= ((direction
> 0)
1245 ? min (limit
+ len
, lim
- 1)
1246 : max (limit
- len
, lim
));
1247 /* LIMIT is now the last value POS can have
1248 and still be valid for a possible match. */
1251 /* This loop can be coded for space rather than */
1252 /* speed because it will usually run only once. */
1253 /* (the reach is at most len + 21, and typically */
1254 /* does not exceed len) */
1255 while ((limit
- pos
) * direction
>= 0)
1256 pos
+= BM_tab
[FETCH_CHAR(pos
)];
1257 /* now run the same tests to distinguish going off the */
1258 /* end, a match or a phony match. */
1259 if ((pos
- limit
) * direction
<= len
)
1260 break; /* ran off the end */
1261 /* Found what might be a match.
1262 Set POS back to last (first if reverse) char pos. */
1264 i
= dirlen
- direction
;
1265 while ((i
-= direction
) + direction
!= 0)
1268 if (pat
[i
] != (((int) trt
)
1269 ? trt
[FETCH_CHAR(pos
)]
1270 : FETCH_CHAR (pos
)))
1273 /* Above loop has moved POS part or all the way
1274 back to the first char pos (last char pos if reverse).
1275 Set it once again at the last (first if reverse) char. */
1276 pos
+= dirlen
- i
- direction
;
1277 if (i
+ direction
== 0)
1281 set_search_regs (pos
+ ((direction
> 0) ? 1 - len
: 0),
1284 if ((n
-= direction
) != 0)
1285 pos
+= dirlen
; /* to resume search */
1287 return ((direction
> 0)
1288 ? search_regs
.end
[0] : search_regs
.start
[0]);
1291 pos
+= stride_for_teases
;
1294 /* We have done one clump. Can we continue? */
1295 if ((lim
- pos
) * direction
< 0)
1296 return ((0 - n
) * direction
);
1302 /* Record beginning BEG and end BEG + LEN
1303 for a match just found in the current buffer. */
1306 set_search_regs (beg
, len
)
1309 /* Make sure we have registers in which to store
1310 the match position. */
1311 if (search_regs
.num_regs
== 0)
1313 regoff_t
*starts
, *ends
;
1315 starts
= (regoff_t
*) xmalloc (2 * sizeof (regoff_t
));
1316 ends
= (regoff_t
*) xmalloc (2 * sizeof (regoff_t
));
1317 search_regs
.num_regs
= 2;
1320 search_regs
.start
[0] = beg
;
1321 search_regs
.end
[0] = beg
+ len
;
1322 XSETBUFFER (last_thing_searched
, current_buffer
);
1325 /* Given a string of words separated by word delimiters,
1326 compute a regexp that matches those exact words
1327 separated by arbitrary punctuation. */
1333 register unsigned char *p
, *o
;
1334 register int i
, len
, punct_count
= 0, word_count
= 0;
1337 CHECK_STRING (string
, 0);
1338 p
= XSTRING (string
)->data
;
1339 len
= XSTRING (string
)->size
;
1341 for (i
= 0; i
< len
; i
++)
1342 if (SYNTAX (p
[i
]) != Sword
)
1345 if (i
> 0 && SYNTAX (p
[i
-1]) == Sword
) word_count
++;
1347 if (SYNTAX (p
[len
-1]) == Sword
) word_count
++;
1348 if (!word_count
) return build_string ("");
1350 val
= make_string (p
, len
- punct_count
+ 5 * (word_count
- 1) + 4);
1352 o
= XSTRING (val
)->data
;
1356 for (i
= 0; i
< len
; i
++)
1357 if (SYNTAX (p
[i
]) == Sword
)
1359 else if (i
> 0 && SYNTAX (p
[i
-1]) == Sword
&& --word_count
)
1374 DEFUN ("search-backward", Fsearch_backward
, Ssearch_backward
, 1, 4,
1375 "sSearch backward: ",
1376 "Search backward from point for STRING.\n\
1377 Set point to the beginning of the occurrence found, and return point.\n\
1378 An optional second argument bounds the search; it is a buffer position.\n\
1379 The match found must not extend before that position.\n\
1380 Optional third argument, if t, means if fail just return nil (no error).\n\
1381 If not nil and not t, position at limit of search and return nil.\n\
1382 Optional fourth argument is repeat count--search for successive occurrences.\n\
1383 See also the functions `match-beginning', `match-end' and `replace-match'.")
1384 (string
, bound
, noerror
, count
)
1385 Lisp_Object string
, bound
, noerror
, count
;
1387 return search_command (string
, bound
, noerror
, count
, -1, 0, 0);
1390 DEFUN ("search-forward", Fsearch_forward
, Ssearch_forward
, 1, 4, "sSearch: ",
1391 "Search forward from point for STRING.\n\
1392 Set point to the end of the occurrence found, and return point.\n\
1393 An optional second argument bounds the search; it is a buffer position.\n\
1394 The match found must not extend after that position. nil is equivalent\n\
1396 Optional third argument, if t, means if fail just return nil (no error).\n\
1397 If not nil and not t, move to limit of search and return nil.\n\
1398 Optional fourth argument is repeat count--search for successive occurrences.\n\
1399 See also the functions `match-beginning', `match-end' and `replace-match'.")
1400 (string
, bound
, noerror
, count
)
1401 Lisp_Object string
, bound
, noerror
, count
;
1403 return search_command (string
, bound
, noerror
, count
, 1, 0, 0);
1406 DEFUN ("word-search-backward", Fword_search_backward
, Sword_search_backward
, 1, 4,
1407 "sWord search backward: ",
1408 "Search backward from point for STRING, ignoring differences in punctuation.\n\
1409 Set point to the beginning of the occurrence found, and return point.\n\
1410 An optional second argument bounds the search; it is a buffer position.\n\
1411 The match found must not extend before that position.\n\
1412 Optional third argument, if t, means if fail just return nil (no error).\n\
1413 If not nil and not t, move to limit of search and return nil.\n\
1414 Optional fourth argument is repeat count--search for successive occurrences.")
1415 (string
, bound
, noerror
, count
)
1416 Lisp_Object string
, bound
, noerror
, count
;
1418 return search_command (wordify (string
), bound
, noerror
, count
, -1, 1, 0);
1421 DEFUN ("word-search-forward", Fword_search_forward
, Sword_search_forward
, 1, 4,
1423 "Search forward from point for STRING, ignoring differences in punctuation.\n\
1424 Set point to the end of the occurrence found, and return point.\n\
1425 An optional second argument bounds the search; it is a buffer position.\n\
1426 The match found must not extend after that position.\n\
1427 Optional third argument, if t, means if fail just return nil (no error).\n\
1428 If not nil and not t, move to limit of search and return nil.\n\
1429 Optional fourth argument is repeat count--search for successive occurrences.")
1430 (string
, bound
, noerror
, count
)
1431 Lisp_Object string
, bound
, noerror
, count
;
1433 return search_command (wordify (string
), bound
, noerror
, count
, 1, 1, 0);
1436 DEFUN ("re-search-backward", Fre_search_backward
, Sre_search_backward
, 1, 4,
1437 "sRE search backward: ",
1438 "Search backward from point for match for regular expression REGEXP.\n\
1439 Set point to the beginning of the match, and return point.\n\
1440 The match found is the one starting last in the buffer\n\
1441 and yet ending before the origin of the search.\n\
1442 An optional second argument bounds the search; it is a buffer position.\n\
1443 The match found must start at or after that position.\n\
1444 Optional third argument, if t, means if fail just return nil (no error).\n\
1445 If not nil and not t, move to limit of search and return nil.\n\
1446 Optional fourth argument is repeat count--search for successive occurrences.\n\
1447 See also the functions `match-beginning', `match-end' and `replace-match'.")
1448 (regexp
, bound
, noerror
, count
)
1449 Lisp_Object regexp
, bound
, noerror
, count
;
1451 return search_command (regexp
, bound
, noerror
, count
, -1, 1, 0);
1454 DEFUN ("re-search-forward", Fre_search_forward
, Sre_search_forward
, 1, 4,
1456 "Search forward from point for regular expression REGEXP.\n\
1457 Set point to the end of the occurrence found, and return point.\n\
1458 An optional second argument bounds the search; it is a buffer position.\n\
1459 The match found must not extend after that position.\n\
1460 Optional third argument, if t, means if fail just return nil (no error).\n\
1461 If not nil and not t, move to limit of search and return nil.\n\
1462 Optional fourth argument is repeat count--search for successive occurrences.\n\
1463 See also the functions `match-beginning', `match-end' and `replace-match'.")
1464 (regexp
, bound
, noerror
, count
)
1465 Lisp_Object regexp
, bound
, noerror
, count
;
1467 return search_command (regexp
, bound
, noerror
, count
, 1, 1, 0);
1470 DEFUN ("posix-search-backward", Fposix_search_backward
, Sposix_search_backward
, 1, 4,
1471 "sPosix search backward: ",
1472 "Search backward from point for match for regular expression REGEXP.\n\
1473 Find the longest match in accord with Posix regular expression rules.\n\
1474 Set point to the beginning of the match, and return point.\n\
1475 The match found is the one starting last in the buffer\n\
1476 and yet ending before the origin of the search.\n\
1477 An optional second argument bounds the search; it is a buffer position.\n\
1478 The match found must start at or after that position.\n\
1479 Optional third argument, if t, means if fail just return nil (no error).\n\
1480 If not nil and not t, move to limit of search and return nil.\n\
1481 Optional fourth argument is repeat count--search for successive occurrences.\n\
1482 See also the functions `match-beginning', `match-end' and `replace-match'.")
1483 (regexp
, bound
, noerror
, count
)
1484 Lisp_Object regexp
, bound
, noerror
, count
;
1486 return search_command (regexp
, bound
, noerror
, count
, -1, 1, 1);
1489 DEFUN ("posix-search-forward", Fposix_search_forward
, Sposix_search_forward
, 1, 4,
1491 "Search forward from point for regular expression REGEXP.\n\
1492 Find the longest match in accord with Posix regular expression rules.\n\
1493 Set point to the end of the occurrence found, and return point.\n\
1494 An optional second argument bounds the search; it is a buffer position.\n\
1495 The match found must not extend after that position.\n\
1496 Optional third argument, if t, means if fail just return nil (no error).\n\
1497 If not nil and not t, move to limit of search and return nil.\n\
1498 Optional fourth argument is repeat count--search for successive occurrences.\n\
1499 See also the functions `match-beginning', `match-end' and `replace-match'.")
1500 (regexp
, bound
, noerror
, count
)
1501 Lisp_Object regexp
, bound
, noerror
, count
;
1503 return search_command (regexp
, bound
, noerror
, count
, 1, 1, 1);
1506 DEFUN ("replace-match", Freplace_match
, Sreplace_match
, 1, 4, 0,
1507 "Replace text matched by last search with NEWTEXT.\n\
1508 If second arg FIXEDCASE is non-nil, do not alter case of replacement text.\n\
1509 Otherwise maybe capitalize the whole text, or maybe just word initials,\n\
1510 based on the replaced text.\n\
1511 If the replaced text has only capital letters\n\
1512 and has at least one multiletter word, convert NEWTEXT to all caps.\n\
1513 If the replaced text has at least one word starting with a capital letter,\n\
1514 then capitalize each word in NEWTEXT.\n\n\
1515 If third arg LITERAL is non-nil, insert NEWTEXT literally.\n\
1516 Otherwise treat `\\' as special:\n\
1517 `\\&' in NEWTEXT means substitute original matched text.\n\
1518 `\\N' means substitute what matched the Nth `\\(...\\)'.\n\
1519 If Nth parens didn't match, substitute nothing.\n\
1520 `\\\\' means insert one `\\'.\n\
1521 FIXEDCASE and LITERAL are optional arguments.\n\
1522 Leaves point at end of replacement text.\n\
1524 The optional fourth argument STRING can be a string to modify.\n\
1525 In that case, this function creates and returns a new string\n\
1526 which is made by replacing the part of STRING that was matched.")
1527 (newtext
, fixedcase
, literal
, string
)
1528 Lisp_Object newtext
, fixedcase
, literal
, string
;
1530 enum { nochange
, all_caps
, cap_initial
} case_action
;
1531 register int pos
, last
;
1532 int some_multiletter_word
;
1535 int some_nonuppercase_initial
;
1536 register int c
, prevc
;
1539 CHECK_STRING (newtext
, 0);
1541 if (! NILP (string
))
1542 CHECK_STRING (string
, 4);
1544 case_action
= nochange
; /* We tried an initialization */
1545 /* but some C compilers blew it */
1547 if (search_regs
.num_regs
<= 0)
1548 error ("replace-match called before any match found");
1552 if (search_regs
.start
[0] < BEGV
1553 || search_regs
.start
[0] > search_regs
.end
[0]
1554 || search_regs
.end
[0] > ZV
)
1555 args_out_of_range (make_number (search_regs
.start
[0]),
1556 make_number (search_regs
.end
[0]));
1560 if (search_regs
.start
[0] < 0
1561 || search_regs
.start
[0] > search_regs
.end
[0]
1562 || search_regs
.end
[0] > XSTRING (string
)->size
)
1563 args_out_of_range (make_number (search_regs
.start
[0]),
1564 make_number (search_regs
.end
[0]));
1567 if (NILP (fixedcase
))
1569 /* Decide how to casify by examining the matched text. */
1571 last
= search_regs
.end
[0];
1573 case_action
= all_caps
;
1575 /* some_multiletter_word is set nonzero if any original word
1576 is more than one letter long. */
1577 some_multiletter_word
= 0;
1579 some_nonuppercase_initial
= 0;
1582 for (pos
= search_regs
.start
[0]; pos
< last
; pos
++)
1585 c
= FETCH_CHAR (pos
);
1587 c
= XSTRING (string
)->data
[pos
];
1591 /* Cannot be all caps if any original char is lower case */
1594 if (SYNTAX (prevc
) != Sword
)
1595 some_nonuppercase_initial
= 1;
1597 some_multiletter_word
= 1;
1599 else if (!NOCASEP (c
))
1602 if (SYNTAX (prevc
) != Sword
)
1605 some_multiletter_word
= 1;
1609 /* If the initial is a caseless word constituent,
1610 treat that like a lowercase initial. */
1611 if (SYNTAX (prevc
) != Sword
)
1612 some_nonuppercase_initial
= 1;
1618 /* Convert to all caps if the old text is all caps
1619 and has at least one multiletter word. */
1620 if (! some_lowercase
&& some_multiletter_word
)
1621 case_action
= all_caps
;
1622 /* Capitalize each word, if the old text has all capitalized words. */
1623 else if (!some_nonuppercase_initial
&& some_multiletter_word
)
1624 case_action
= cap_initial
;
1625 else if (!some_nonuppercase_initial
&& some_uppercase
)
1626 /* Should x -> yz, operating on X, give Yz or YZ?
1627 We'll assume the latter. */
1628 case_action
= all_caps
;
1630 case_action
= nochange
;
1633 /* Do replacement in a string. */
1636 Lisp_Object before
, after
;
1638 before
= Fsubstring (string
, make_number (0),
1639 make_number (search_regs
.start
[0]));
1640 after
= Fsubstring (string
, make_number (search_regs
.end
[0]), Qnil
);
1642 /* Do case substitution into NEWTEXT if desired. */
1646 /* We build up the substituted string in ACCUM. */
1652 for (pos
= 0; pos
< XSTRING (newtext
)->size
; pos
++)
1657 c
= XSTRING (newtext
)->data
[pos
];
1660 c
= XSTRING (newtext
)->data
[++pos
];
1663 substart
= search_regs
.start
[0];
1664 subend
= search_regs
.end
[0];
1666 else if (c
>= '1' && c
<= '9' && c
<= search_regs
.num_regs
+ '0')
1668 if (search_regs
.start
[c
- '0'] >= 1)
1670 substart
= search_regs
.start
[c
- '0'];
1671 subend
= search_regs
.end
[c
- '0'];
1677 if (pos
- 1 != lastpos
+ 1)
1678 middle
= Fsubstring (newtext
, lastpos
+ 1, pos
- 1);
1681 accum
= concat3 (accum
, middle
,
1682 Fsubstring (string
, make_number (substart
),
1683 make_number (subend
)));
1688 if (pos
!= lastpos
+ 1)
1689 middle
= Fsubstring (newtext
, lastpos
+ 1, pos
);
1693 newtext
= concat2 (accum
, middle
);
1696 if (case_action
== all_caps
)
1697 newtext
= Fupcase (newtext
);
1698 else if (case_action
== cap_initial
)
1699 newtext
= upcase_initials (newtext
);
1701 return concat3 (before
, newtext
, after
);
1704 /* We insert the replacement text before the old text, and then
1705 delete the original text. This means that markers at the
1706 beginning or end of the original will float to the corresponding
1707 position in the replacement. */
1708 SET_PT (search_regs
.start
[0]);
1709 if (!NILP (literal
))
1710 Finsert_and_inherit (1, &newtext
);
1713 struct gcpro gcpro1
;
1716 for (pos
= 0; pos
< XSTRING (newtext
)->size
; pos
++)
1718 int offset
= point
- search_regs
.start
[0];
1720 c
= XSTRING (newtext
)->data
[pos
];
1723 c
= XSTRING (newtext
)->data
[++pos
];
1725 Finsert_buffer_substring
1726 (Fcurrent_buffer (),
1727 make_number (search_regs
.start
[0] + offset
),
1728 make_number (search_regs
.end
[0] + offset
));
1729 else if (c
>= '1' && c
<= '9' && c
<= search_regs
.num_regs
+ '0')
1731 if (search_regs
.start
[c
- '0'] >= 1)
1732 Finsert_buffer_substring
1733 (Fcurrent_buffer (),
1734 make_number (search_regs
.start
[c
- '0'] + offset
),
1735 make_number (search_regs
.end
[c
- '0'] + offset
));
1746 inslen
= point
- (search_regs
.start
[0]);
1747 del_range (search_regs
.start
[0] + inslen
, search_regs
.end
[0] + inslen
);
1749 if (case_action
== all_caps
)
1750 Fupcase_region (make_number (point
- inslen
), make_number (point
));
1751 else if (case_action
== cap_initial
)
1752 upcase_initials_region (make_number (point
- inslen
), make_number (point
));
1757 match_limit (num
, beginningp
)
1763 CHECK_NUMBER (num
, 0);
1765 if (n
< 0 || n
>= search_regs
.num_regs
)
1766 args_out_of_range (num
, make_number (search_regs
.num_regs
));
1767 if (search_regs
.num_regs
<= 0
1768 || search_regs
.start
[n
] < 0)
1770 return (make_number ((beginningp
) ? search_regs
.start
[n
]
1771 : search_regs
.end
[n
]));
1774 DEFUN ("match-beginning", Fmatch_beginning
, Smatch_beginning
, 1, 1, 0,
1775 "Return position of start of text matched by last search.\n\
1776 NUM specifies which parenthesized expression in the last regexp.\n\
1777 Value is nil if NUMth pair didn't match, or there were less than NUM pairs.\n\
1778 Zero means the entire text matched by the whole regexp or whole string.")
1782 return match_limit (num
, 1);
1785 DEFUN ("match-end", Fmatch_end
, Smatch_end
, 1, 1, 0,
1786 "Return position of end of text matched by last search.\n\
1787 ARG, a number, specifies which parenthesized expression in the last regexp.\n\
1788 Value is nil if ARGth pair didn't match, or there were less than ARG pairs.\n\
1789 Zero means the entire text matched by the whole regexp or whole string.")
1793 return match_limit (num
, 0);
1796 DEFUN ("match-data", Fmatch_data
, Smatch_data
, 0, 0, 0,
1797 "Return a list containing all info on what the last search matched.\n\
1798 Element 2N is `(match-beginning N)'; element 2N + 1 is `(match-end N)'.\n\
1799 All the elements are markers or nil (nil if the Nth pair didn't match)\n\
1800 if the last match was on a buffer; integers or nil if a string was matched.\n\
1801 Use `store-match-data' to reinstate the data in this list.")
1807 if (NILP (last_thing_searched
))
1808 error ("match-data called before any match found");
1810 data
= (Lisp_Object
*) alloca ((2 * search_regs
.num_regs
)
1811 * sizeof (Lisp_Object
));
1814 for (i
= 0; i
< search_regs
.num_regs
; i
++)
1816 int start
= search_regs
.start
[i
];
1819 if (EQ (last_thing_searched
, Qt
))
1821 XSETFASTINT (data
[2 * i
], start
);
1822 XSETFASTINT (data
[2 * i
+ 1], search_regs
.end
[i
]);
1824 else if (BUFFERP (last_thing_searched
))
1826 data
[2 * i
] = Fmake_marker ();
1827 Fset_marker (data
[2 * i
],
1828 make_number (start
),
1829 last_thing_searched
);
1830 data
[2 * i
+ 1] = Fmake_marker ();
1831 Fset_marker (data
[2 * i
+ 1],
1832 make_number (search_regs
.end
[i
]),
1833 last_thing_searched
);
1836 /* last_thing_searched must always be Qt, a buffer, or Qnil. */
1842 data
[2 * i
] = data
[2 * i
+ 1] = Qnil
;
1844 return Flist (2 * len
+ 2, data
);
1848 DEFUN ("store-match-data", Fstore_match_data
, Sstore_match_data
, 1, 1, 0,
1849 "Set internal data on last search match from elements of LIST.\n\
1850 LIST should have been created by calling `match-data' previously.")
1852 register Lisp_Object list
;
1855 register Lisp_Object marker
;
1857 if (running_asynch_code
)
1858 save_search_regs ();
1860 if (!CONSP (list
) && !NILP (list
))
1861 list
= wrong_type_argument (Qconsp
, list
);
1863 /* Unless we find a marker with a buffer in LIST, assume that this
1864 match data came from a string. */
1865 last_thing_searched
= Qt
;
1867 /* Allocate registers if they don't already exist. */
1869 int length
= XFASTINT (Flength (list
)) / 2;
1871 if (length
> search_regs
.num_regs
)
1873 if (search_regs
.num_regs
== 0)
1876 = (regoff_t
*) xmalloc (length
* sizeof (regoff_t
));
1878 = (regoff_t
*) xmalloc (length
* sizeof (regoff_t
));
1883 = (regoff_t
*) xrealloc (search_regs
.start
,
1884 length
* sizeof (regoff_t
));
1886 = (regoff_t
*) xrealloc (search_regs
.end
,
1887 length
* sizeof (regoff_t
));
1890 search_regs
.num_regs
= length
;
1894 for (i
= 0; i
< search_regs
.num_regs
; i
++)
1896 marker
= Fcar (list
);
1899 search_regs
.start
[i
] = -1;
1904 if (MARKERP (marker
))
1906 if (XMARKER (marker
)->buffer
== 0)
1907 XSETFASTINT (marker
, 0);
1909 XSETBUFFER (last_thing_searched
, XMARKER (marker
)->buffer
);
1912 CHECK_NUMBER_COERCE_MARKER (marker
, 0);
1913 search_regs
.start
[i
] = XINT (marker
);
1916 marker
= Fcar (list
);
1917 if (MARKERP (marker
) && XMARKER (marker
)->buffer
== 0)
1918 XSETFASTINT (marker
, 0);
1920 CHECK_NUMBER_COERCE_MARKER (marker
, 0);
1921 search_regs
.end
[i
] = XINT (marker
);
1929 /* If non-zero the match data have been saved in saved_search_regs
1930 during the execution of a sentinel or filter. */
1931 static int search_regs_saved
= 0;
1932 static struct re_registers saved_search_regs
;
1934 /* Called from Flooking_at, Fstring_match, search_buffer, Fstore_match_data
1935 if asynchronous code (filter or sentinel) is running. */
1939 if (!search_regs_saved
)
1941 saved_search_regs
.num_regs
= search_regs
.num_regs
;
1942 saved_search_regs
.start
= search_regs
.start
;
1943 saved_search_regs
.end
= search_regs
.end
;
1944 search_regs
.num_regs
= 0;
1946 search_regs_saved
= 1;
1950 /* Called upon exit from filters and sentinels. */
1952 restore_match_data ()
1954 if (search_regs_saved
)
1956 if (search_regs
.num_regs
> 0)
1958 xfree (search_regs
.start
);
1959 xfree (search_regs
.end
);
1961 search_regs
.num_regs
= saved_search_regs
.num_regs
;
1962 search_regs
.start
= saved_search_regs
.start
;
1963 search_regs
.end
= saved_search_regs
.end
;
1965 search_regs_saved
= 0;
1969 /* Quote a string to inactivate reg-expr chars */
1971 DEFUN ("regexp-quote", Fregexp_quote
, Sregexp_quote
, 1, 1, 0,
1972 "Return a regexp string which matches exactly STRING and nothing else.")
1976 register unsigned char *in
, *out
, *end
;
1977 register unsigned char *temp
;
1979 CHECK_STRING (str
, 0);
1981 temp
= (unsigned char *) alloca (XSTRING (str
)->size
* 2);
1983 /* Now copy the data into the new string, inserting escapes. */
1985 in
= XSTRING (str
)->data
;
1986 end
= in
+ XSTRING (str
)->size
;
1989 for (; in
!= end
; in
++)
1991 if (*in
== '[' || *in
== ']'
1992 || *in
== '*' || *in
== '.' || *in
== '\\'
1993 || *in
== '?' || *in
== '+'
1994 || *in
== '^' || *in
== '$')
1999 return make_string (temp
, out
- temp
);
2006 for (i
= 0; i
< REGEXP_CACHE_SIZE
; ++i
)
2008 searchbufs
[i
].buf
.allocated
= 100;
2009 searchbufs
[i
].buf
.buffer
= (unsigned char *) malloc (100);
2010 searchbufs
[i
].buf
.fastmap
= searchbufs
[i
].fastmap
;
2011 searchbufs
[i
].regexp
= Qnil
;
2012 staticpro (&searchbufs
[i
].regexp
);
2013 searchbufs
[i
].next
= (i
== REGEXP_CACHE_SIZE
-1 ? 0 : &searchbufs
[i
+1]);
2015 searchbuf_head
= &searchbufs
[0];
2017 Qsearch_failed
= intern ("search-failed");
2018 staticpro (&Qsearch_failed
);
2019 Qinvalid_regexp
= intern ("invalid-regexp");
2020 staticpro (&Qinvalid_regexp
);
2022 Fput (Qsearch_failed
, Qerror_conditions
,
2023 Fcons (Qsearch_failed
, Fcons (Qerror
, Qnil
)));
2024 Fput (Qsearch_failed
, Qerror_message
,
2025 build_string ("Search failed"));
2027 Fput (Qinvalid_regexp
, Qerror_conditions
,
2028 Fcons (Qinvalid_regexp
, Fcons (Qerror
, Qnil
)));
2029 Fput (Qinvalid_regexp
, Qerror_message
,
2030 build_string ("Invalid regexp"));
2032 last_thing_searched
= Qnil
;
2033 staticpro (&last_thing_searched
);
2035 defsubr (&Slooking_at
);
2036 defsubr (&Sposix_looking_at
);
2037 defsubr (&Sstring_match
);
2038 defsubr (&Sposix_string_match
);
2039 defsubr (&Sskip_chars_forward
);
2040 defsubr (&Sskip_chars_backward
);
2041 defsubr (&Sskip_syntax_forward
);
2042 defsubr (&Sskip_syntax_backward
);
2043 defsubr (&Ssearch_forward
);
2044 defsubr (&Ssearch_backward
);
2045 defsubr (&Sword_search_forward
);
2046 defsubr (&Sword_search_backward
);
2047 defsubr (&Sre_search_forward
);
2048 defsubr (&Sre_search_backward
);
2049 defsubr (&Sposix_search_forward
);
2050 defsubr (&Sposix_search_backward
);
2051 defsubr (&Sreplace_match
);
2052 defsubr (&Smatch_beginning
);
2053 defsubr (&Smatch_end
);
2054 defsubr (&Smatch_data
);
2055 defsubr (&Sstore_match_data
);
2056 defsubr (&Sregexp_quote
);