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 2, 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, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
26 #include "region-cache.h"
28 #include "blockinput.h"
30 #include <sys/types.h>
33 #define REGEXP_CACHE_SIZE 20
35 /* If the regexp is non-nil, then the buffer contains the compiled form
36 of that regexp, suitable for searching. */
39 struct regexp_cache
*next
;
41 struct re_pattern_buffer buf
;
43 /* Nonzero means regexp was compiled to do full POSIX backtracking. */
47 /* The instances of that struct. */
48 struct regexp_cache searchbufs
[REGEXP_CACHE_SIZE
];
50 /* The head of the linked list; points to the most recently used buffer. */
51 struct regexp_cache
*searchbuf_head
;
54 /* Every call to re_match, etc., must pass &search_regs as the regs
55 argument unless you can show it is unnecessary (i.e., if re_match
56 is certainly going to be called again before region-around-match
59 Since the registers are now dynamically allocated, we need to make
60 sure not to refer to the Nth register before checking that it has
61 been allocated by checking search_regs.num_regs.
63 The regex code keeps track of whether it has allocated the search
64 buffer using bits in the re_pattern_buffer. This means that whenever
65 you compile a new pattern, it completely forgets whether it has
66 allocated any registers, and will allocate new registers the next
67 time you call a searching or matching function. Therefore, we need
68 to call re_set_registers after compiling a new pattern or after
69 setting the match registers, so that the regex functions will be
70 able to free or re-allocate it properly. */
71 static struct re_registers search_regs
;
73 /* The buffer in which the last search was performed, or
74 Qt if the last search was done in a string;
75 Qnil if no searching has been done yet. */
76 static Lisp_Object last_thing_searched
;
78 /* error condition signaled when regexp compile_pattern fails */
80 Lisp_Object Qinvalid_regexp
;
82 static void set_search_regs ();
83 static void save_search_regs ();
85 static int search_buffer ();
90 error ("Stack overflow in regexp matcher");
99 /* Compile a regexp and signal a Lisp error if anything goes wrong.
100 PATTERN is the pattern to compile.
101 CP is the place to put the result.
102 TRANSLATE is a translation table for ignoring case, or NULL for none.
103 REGP is the structure that says where to store the "register"
104 values that will result from matching this pattern.
105 If it is 0, we should compile the pattern not to record any
106 subexpression bounds.
107 POSIX is nonzero if we want full backtracking (POSIX style)
108 for this pattern. 0 means backtrack only enough to get a valid match. */
111 compile_pattern_1 (cp
, pattern
, translate
, regp
, posix
)
112 struct regexp_cache
*cp
;
114 Lisp_Object
*translate
;
115 struct re_registers
*regp
;
122 cp
->buf
.translate
= translate
;
125 old
= re_set_syntax (RE_SYNTAX_EMACS
126 | (posix
? 0 : RE_NO_POSIX_BACKTRACKING
));
127 val
= (CONST
char *) re_compile_pattern ((char *) XSTRING (pattern
)->data
,
128 XSTRING (pattern
)->size
, &cp
->buf
);
132 Fsignal (Qinvalid_regexp
, Fcons (build_string (val
), Qnil
));
134 cp
->regexp
= Fcopy_sequence (pattern
);
137 /* Compile a regexp if necessary, but first check to see if there's one in
139 PATTERN is the pattern to compile.
140 TRANSLATE is a translation table for ignoring case, or NULL for none.
141 REGP is the structure that says where to store the "register"
142 values that will result from matching this pattern.
143 If it is 0, we should compile the pattern not to record any
144 subexpression bounds.
145 POSIX is nonzero if we want full backtracking (POSIX style)
146 for this pattern. 0 means backtrack only enough to get a valid match. */
148 struct re_pattern_buffer
*
149 compile_pattern (pattern
, regp
, translate
, posix
)
151 struct re_registers
*regp
;
152 Lisp_Object
*translate
;
155 struct regexp_cache
*cp
, **cpp
;
157 for (cpp
= &searchbuf_head
; ; cpp
= &cp
->next
)
160 if (XSTRING (cp
->regexp
)->size
== XSTRING (pattern
)->size
161 && !NILP (Fstring_equal (cp
->regexp
, pattern
))
162 && cp
->buf
.translate
== translate
163 && cp
->posix
== posix
)
166 /* If we're at the end of the cache, compile into the last cell. */
169 compile_pattern_1 (cp
, pattern
, translate
, regp
, posix
);
174 /* When we get here, cp (aka *cpp) contains the compiled pattern,
175 either because we found it in the cache or because we just compiled it.
176 Move it to the front of the queue to mark it as most recently used. */
178 cp
->next
= searchbuf_head
;
181 /* Advise the searching functions about the space we have allocated
182 for register data. */
184 re_set_registers (&cp
->buf
, regp
, regp
->num_regs
, regp
->start
, regp
->end
);
189 /* Error condition used for failing searches */
190 Lisp_Object Qsearch_failed
;
196 Fsignal (Qsearch_failed
, Fcons (arg
, Qnil
));
201 looking_at_1 (string
, posix
)
206 unsigned char *p1
, *p2
;
209 struct re_pattern_buffer
*bufp
;
211 if (running_asynch_code
)
214 CHECK_STRING (string
, 0);
215 bufp
= compile_pattern (string
, &search_regs
,
216 (!NILP (current_buffer
->case_fold_search
)
217 ? DOWNCASE_TABLE
: 0),
221 QUIT
; /* Do a pending quit right away, to avoid paradoxical behavior */
223 /* Get pointers and sizes of the two strings
224 that make up the visible portion of the buffer. */
242 i
= re_match_2 (bufp
, (char *) p1
, s1
, (char *) p2
, s2
,
243 PT
- BEGV
, &search_regs
,
248 val
= (0 <= i
? Qt
: Qnil
);
249 for (i
= 0; i
< search_regs
.num_regs
; i
++)
250 if (search_regs
.start
[i
] >= 0)
252 search_regs
.start
[i
] += BEGV
;
253 search_regs
.end
[i
] += BEGV
;
255 XSETBUFFER (last_thing_searched
, current_buffer
);
260 DEFUN ("looking-at", Flooking_at
, Slooking_at
, 1, 1, 0,
261 "Return t if text after point matches regular expression REGEXP.\n\
262 This function modifies the match data that `match-beginning',\n\
263 `match-end' and `match-data' access; save and restore the match\n\
264 data if you want to preserve them.")
268 return looking_at_1 (regexp
, 0);
271 DEFUN ("posix-looking-at", Fposix_looking_at
, Sposix_looking_at
, 1, 1, 0,
272 "Return t if text after point matches regular expression REGEXP.\n\
273 Find the longest match, in accord with Posix regular expression rules.\n\
274 This function modifies the match data that `match-beginning',\n\
275 `match-end' and `match-data' access; save and restore the match\n\
276 data if you want to preserve them.")
280 return looking_at_1 (regexp
, 1);
284 string_match_1 (regexp
, string
, start
, posix
)
285 Lisp_Object regexp
, string
, start
;
290 struct re_pattern_buffer
*bufp
;
292 if (running_asynch_code
)
295 CHECK_STRING (regexp
, 0);
296 CHECK_STRING (string
, 1);
302 int len
= XSTRING (string
)->size
;
304 CHECK_NUMBER (start
, 2);
306 if (s
< 0 && -s
<= len
)
308 else if (0 > s
|| s
> len
)
309 args_out_of_range (string
, start
);
312 bufp
= compile_pattern (regexp
, &search_regs
,
313 (!NILP (current_buffer
->case_fold_search
)
314 ? DOWNCASE_TABLE
: 0),
317 val
= re_search (bufp
, (char *) XSTRING (string
)->data
,
318 XSTRING (string
)->size
, s
, XSTRING (string
)->size
- s
,
321 last_thing_searched
= Qt
;
324 if (val
< 0) return Qnil
;
325 return make_number (val
);
328 DEFUN ("string-match", Fstring_match
, Sstring_match
, 2, 3, 0,
329 "Return index of start of first match for REGEXP in STRING, or nil.\n\
330 If third arg START is non-nil, start search at that index in STRING.\n\
331 For index of first char beyond the match, do (match-end 0).\n\
332 `match-end' and `match-beginning' also give indices of substrings\n\
333 matched by parenthesis constructs in the pattern.")
334 (regexp
, string
, start
)
335 Lisp_Object regexp
, string
, start
;
337 return string_match_1 (regexp
, string
, start
, 0);
340 DEFUN ("posix-string-match", Fposix_string_match
, Sposix_string_match
, 2, 3, 0,
341 "Return index of start of first match for REGEXP in STRING, or nil.\n\
342 Find the longest match, in accord with Posix regular expression rules.\n\
343 If third arg START is non-nil, start search at that index in STRING.\n\
344 For index of first char beyond the match, do (match-end 0).\n\
345 `match-end' and `match-beginning' also give indices of substrings\n\
346 matched by parenthesis constructs in the pattern.")
347 (regexp
, string
, start
)
348 Lisp_Object regexp
, string
, start
;
350 return string_match_1 (regexp
, string
, start
, 1);
353 /* Match REGEXP against STRING, searching all of STRING,
354 and return the index of the match, or negative on failure.
355 This does not clobber the match data. */
358 fast_string_match (regexp
, string
)
359 Lisp_Object regexp
, string
;
362 struct re_pattern_buffer
*bufp
;
364 bufp
= compile_pattern (regexp
, 0, 0, 0);
366 val
= re_search (bufp
, (char *) XSTRING (string
)->data
,
367 XSTRING (string
)->size
, 0, XSTRING (string
)->size
,
379 return ((a
> b
) ? a
: b
);
386 return ((a
< b
) ? a
: b
);
390 /* The newline cache: remembering which sections of text have no newlines. */
392 /* If the user has requested newline caching, make sure it's on.
393 Otherwise, make sure it's off.
394 This is our cheezy way of associating an action with the change of
395 state of a buffer-local variable. */
397 newline_cache_on_off (buf
)
400 if (NILP (buf
->cache_long_line_scans
))
402 /* It should be off. */
403 if (buf
->newline_cache
)
405 free_region_cache (buf
->newline_cache
);
406 buf
->newline_cache
= 0;
411 /* It should be on. */
412 if (buf
->newline_cache
== 0)
413 buf
->newline_cache
= new_region_cache ();
418 /* Search for COUNT instances of the character TARGET between START and END.
420 If COUNT is positive, search forwards; END must be >= START.
421 If COUNT is negative, search backwards for the -COUNTth instance;
422 END must be <= START.
423 If COUNT is zero, do anything you please; run rogue, for all I care.
425 If END is zero, use BEGV or ZV instead, as appropriate for the
426 direction indicated by COUNT.
428 If we find COUNT instances, set *SHORTAGE to zero, and return the
429 position after the COUNTth match. Note that for reverse motion
430 this is not the same as the usual convention for Emacs motion commands.
432 If we don't find COUNT instances before reaching END, set *SHORTAGE
433 to the number of TARGETs left unfound, and return END.
435 If ALLOW_QUIT is non-zero, set immediate_quit. That's good to do
436 except when inside redisplay. */
438 scan_buffer (target
, start
, end
, count
, shortage
, allow_quit
)
445 struct region_cache
*newline_cache
;
456 if (! end
) end
= BEGV
;
459 newline_cache_on_off (current_buffer
);
460 newline_cache
= current_buffer
->newline_cache
;
465 immediate_quit
= allow_quit
;
470 /* Our innermost scanning loop is very simple; it doesn't know
471 about gaps, buffer ends, or the newline cache. ceiling is
472 the position of the last character before the next such
473 obstacle --- the last character the dumb search loop should
475 register int ceiling
= end
- 1;
477 /* If we're looking for a newline, consult the newline cache
478 to see where we can avoid some scanning. */
479 if (target
== '\n' && newline_cache
)
483 while (region_cache_forward
484 (current_buffer
, newline_cache
, start
, &next_change
))
486 immediate_quit
= allow_quit
;
488 /* start should never be after end. */
492 /* Now the text after start is an unknown region, and
493 next_change is the position of the next known region. */
494 ceiling
= min (next_change
- 1, ceiling
);
497 /* The dumb loop can only scan text stored in contiguous
498 bytes. BUFFER_CEILING_OF returns the last character
499 position that is contiguous, so the ceiling is the
500 position after that. */
501 ceiling
= min (BUFFER_CEILING_OF (start
), ceiling
);
504 /* The termination address of the dumb loop. */
505 register unsigned char *ceiling_addr
= &FETCH_CHAR (ceiling
) + 1;
506 register unsigned char *cursor
= &FETCH_CHAR (start
);
507 unsigned char *base
= cursor
;
509 while (cursor
< ceiling_addr
)
511 unsigned char *scan_start
= cursor
;
514 while (*cursor
!= target
&& ++cursor
< ceiling_addr
)
517 /* If we're looking for newlines, cache the fact that
518 the region from start to cursor is free of them. */
519 if (target
== '\n' && newline_cache
)
520 know_region_cache (current_buffer
, newline_cache
,
521 start
+ scan_start
- base
,
522 start
+ cursor
- base
);
524 /* Did we find the target character? */
525 if (cursor
< ceiling_addr
)
530 return (start
+ cursor
- base
+ 1);
536 start
+= cursor
- base
;
542 /* The last character to check before the next obstacle. */
543 register int ceiling
= end
;
545 /* Consult the newline cache, if appropriate. */
546 if (target
== '\n' && newline_cache
)
550 while (region_cache_backward
551 (current_buffer
, newline_cache
, start
, &next_change
))
553 immediate_quit
= allow_quit
;
555 /* Start should never be at or before end. */
559 /* Now the text before start is an unknown region, and
560 next_change is the position of the next known region. */
561 ceiling
= max (next_change
, ceiling
);
564 /* Stop scanning before the gap. */
565 ceiling
= max (BUFFER_FLOOR_OF (start
- 1), ceiling
);
568 /* The termination address of the dumb loop. */
569 register unsigned char *ceiling_addr
= &FETCH_CHAR (ceiling
);
570 register unsigned char *cursor
= &FETCH_CHAR (start
- 1);
571 unsigned char *base
= cursor
;
573 while (cursor
>= ceiling_addr
)
575 unsigned char *scan_start
= cursor
;
577 while (*cursor
!= target
&& --cursor
>= ceiling_addr
)
580 /* If we're looking for newlines, cache the fact that
581 the region from after the cursor to start is free of them. */
582 if (target
== '\n' && newline_cache
)
583 know_region_cache (current_buffer
, newline_cache
,
584 start
+ cursor
- base
,
585 start
+ scan_start
- base
);
587 /* Did we find the target character? */
588 if (cursor
>= ceiling_addr
)
593 return (start
+ cursor
- base
);
599 start
+= cursor
- base
;
605 *shortage
= count
* direction
;
610 find_next_newline_no_quit (from
, cnt
)
611 register int from
, cnt
;
613 return scan_buffer ('\n', from
, 0, cnt
, (int *) 0, 0);
617 find_next_newline (from
, cnt
)
618 register int from
, cnt
;
620 return scan_buffer ('\n', from
, 0, cnt
, (int *) 0, 1);
624 /* Like find_next_newline, but returns position before the newline,
625 not after, and only search up to TO. This isn't just
626 find_next_newline (...)-1, because you might hit TO. */
628 find_before_next_newline (from
, to
, cnt
)
632 int pos
= scan_buffer ('\n', from
, to
, cnt
, &shortage
, 1);
640 Lisp_Object
skip_chars ();
642 DEFUN ("skip-chars-forward", Fskip_chars_forward
, Sskip_chars_forward
, 1, 2, 0,
643 "Move point forward, stopping before a char not in STRING, or at pos LIM.\n\
644 STRING is like the inside of a `[...]' in a regular expression\n\
645 except that `]' is never special and `\\' quotes `^', `-' or `\\'.\n\
646 Thus, with arg \"a-zA-Z\", this skips letters stopping before first nonletter.\n\
647 With arg \"^a-zA-Z\", skips nonletters stopping before first letter.\n\
648 Returns the distance traveled, either zero or positive.")
650 Lisp_Object string
, lim
;
652 return skip_chars (1, 0, string
, lim
);
655 DEFUN ("skip-chars-backward", Fskip_chars_backward
, Sskip_chars_backward
, 1, 2, 0,
656 "Move point backward, stopping after a char not in STRING, or at pos LIM.\n\
657 See `skip-chars-forward' for details.\n\
658 Returns the distance traveled, either zero or negative.")
660 Lisp_Object string
, lim
;
662 return skip_chars (0, 0, string
, lim
);
665 DEFUN ("skip-syntax-forward", Fskip_syntax_forward
, Sskip_syntax_forward
, 1, 2, 0,
666 "Move point forward across chars in specified syntax classes.\n\
667 SYNTAX is a string of syntax code characters.\n\
668 Stop before a char whose syntax is not in SYNTAX, or at position LIM.\n\
669 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
670 This function returns the distance traveled, either zero or positive.")
672 Lisp_Object syntax
, lim
;
674 return skip_chars (1, 1, syntax
, lim
);
677 DEFUN ("skip-syntax-backward", Fskip_syntax_backward
, Sskip_syntax_backward
, 1, 2, 0,
678 "Move point backward across chars in specified syntax classes.\n\
679 SYNTAX is a string of syntax code characters.\n\
680 Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.\n\
681 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
682 This function returns the distance traveled, either zero or negative.")
684 Lisp_Object syntax
, lim
;
686 return skip_chars (0, 1, syntax
, lim
);
690 skip_chars (forwardp
, syntaxp
, string
, lim
)
691 int forwardp
, syntaxp
;
692 Lisp_Object string
, lim
;
694 register unsigned char *p
, *pend
;
695 register unsigned char c
;
696 unsigned char fastmap
[0400];
700 CHECK_STRING (string
, 0);
703 XSETINT (lim
, forwardp
? ZV
: BEGV
);
705 CHECK_NUMBER_COERCE_MARKER (lim
, 1);
707 /* In any case, don't allow scan outside bounds of buffer. */
708 /* jla turned this off, for no known reason.
709 bfox turned the ZV part on, and rms turned the
710 BEGV part back on. */
712 XSETFASTINT (lim
, ZV
);
713 if (XINT (lim
) < BEGV
)
714 XSETFASTINT (lim
, BEGV
);
716 p
= XSTRING (string
)->data
;
717 pend
= p
+ XSTRING (string
)->size
;
718 bzero (fastmap
, sizeof fastmap
);
720 if (p
!= pend
&& *p
== '^')
725 /* Find the characters specified and set their elements of fastmap.
726 If syntaxp, each character counts as itself.
727 Otherwise, handle backslashes and ranges specially */
733 fastmap
[syntax_spec_code
[c
]] = 1;
738 if (p
== pend
) break;
741 if (p
!= pend
&& *p
== '-')
744 if (p
== pend
) break;
757 /* If ^ was the first character, complement the fastmap. */
760 for (i
= 0; i
< sizeof fastmap
; i
++)
764 int start_point
= PT
;
772 while (pos
< XINT (lim
)
773 && fastmap
[(int) SYNTAX (FETCH_CHAR (pos
))])
778 while (pos
> XINT (lim
)
779 && fastmap
[(int) SYNTAX (FETCH_CHAR (pos
- 1))])
787 while (pos
< XINT (lim
) && fastmap
[FETCH_CHAR (pos
)])
792 while (pos
> XINT (lim
) && fastmap
[FETCH_CHAR (pos
- 1)])
799 return make_number (PT
- 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
< PT
: lim
> PT
)
830 error ("Invalid search bound (wrong side of point)");
837 np
= search_buffer (string
, PT
, lim
, n
, RE
,
838 (!NILP (current_buffer
->case_fold_search
)
839 ? XCHAR_TABLE (current_buffer
->case_canon_table
)->contents
841 (!NILP (current_buffer
->case_fold_search
)
842 ? XCHAR_TABLE (current_buffer
->case_eqv_table
)->contents
848 return signal_failure (string
);
849 if (!EQ (noerror
, Qt
))
851 if (lim
< BEGV
|| lim
> ZV
)
855 #if 0 /* This would be clean, but maybe programs depend on
856 a value of nil here. */
864 if (np
< BEGV
|| np
> ZV
)
869 return make_number (np
);
873 trivial_regexp_p (regexp
)
876 int len
= XSTRING (regexp
)->size
;
877 unsigned char *s
= XSTRING (regexp
)->data
;
883 case '.': case '*': case '+': case '?': case '[': case '^': case '$':
890 case '|': case '(': case ')': case '`': case '\'': case 'b':
891 case 'B': case '<': case '>': case 'w': case 'W': case 's':
893 case '1': case '2': case '3': case '4': case '5':
894 case '6': case '7': case '8': case '9':
902 /* Search for the n'th occurrence of STRING in the current buffer,
903 starting at position POS and stopping at position LIM,
904 treating STRING as a literal string if RE is false or as
905 a regular expression if RE is true.
907 If N is positive, searching is forward and LIM must be greater than POS.
908 If N is negative, searching is backward and LIM must be less than POS.
910 Returns -x if only N-x occurrences found (x > 0),
911 or else the position at the beginning of the Nth occurrence
912 (if searching backward) or the end (if searching forward).
914 POSIX is nonzero if we want full backtracking (POSIX style)
915 for this pattern. 0 means backtrack only enough to get a valid match. */
918 search_buffer (string
, pos
, lim
, n
, RE
, trt
, inverse_trt
, posix
)
925 Lisp_Object
*inverse_trt
;
928 int len
= XSTRING (string
)->size
;
929 unsigned char *base_pat
= XSTRING (string
)->data
;
930 register int *BM_tab
;
932 register int direction
= ((n
> 0) ? 1 : -1);
934 int infinity
, limit
, k
, stride_for_teases
;
935 register unsigned char *pat
, *cursor
, *p_limit
;
937 unsigned char *p1
, *p2
;
940 if (running_asynch_code
)
943 /* Null string is found at starting position. */
946 set_search_regs (pos
, 0);
950 /* Searching 0 times means don't move. */
954 if (RE
&& !trivial_regexp_p (string
))
956 struct re_pattern_buffer
*bufp
;
958 bufp
= compile_pattern (string
, &search_regs
, trt
, posix
);
960 immediate_quit
= 1; /* Quit immediately if user types ^G,
961 because letting this function finish
962 can take too long. */
963 QUIT
; /* Do a pending quit right away,
964 to avoid paradoxical behavior */
965 /* Get pointers and sizes of the two strings
966 that make up the visible portion of the buffer. */
986 val
= re_search_2 (bufp
, (char *) p1
, s1
, (char *) p2
, s2
,
987 pos
- BEGV
, lim
- pos
, &search_regs
,
988 /* Don't allow match past current point */
997 for (i
= 0; i
< search_regs
.num_regs
; i
++)
998 if (search_regs
.start
[i
] >= 0)
1000 search_regs
.start
[i
] += j
;
1001 search_regs
.end
[i
] += j
;
1003 XSETBUFFER (last_thing_searched
, current_buffer
);
1004 /* Set pos to the new position. */
1005 pos
= search_regs
.start
[0];
1017 val
= re_search_2 (bufp
, (char *) p1
, s1
, (char *) p2
, s2
,
1018 pos
- BEGV
, lim
- pos
, &search_regs
,
1022 matcher_overflow ();
1027 for (i
= 0; i
< search_regs
.num_regs
; i
++)
1028 if (search_regs
.start
[i
] >= 0)
1030 search_regs
.start
[i
] += j
;
1031 search_regs
.end
[i
] += j
;
1033 XSETBUFFER (last_thing_searched
, current_buffer
);
1034 pos
= search_regs
.end
[0];
1046 else /* non-RE case */
1049 int BM_tab_space
[0400];
1050 BM_tab
= &BM_tab_space
[0];
1052 BM_tab
= (int *) alloca (0400 * sizeof (int));
1055 unsigned char *patbuf
= (unsigned char *) alloca (len
);
1059 /* If we got here and the RE flag is set, it's because we're
1060 dealing with a regexp known to be trivial, so the backslash
1061 just quotes the next character. */
1062 if (RE
&& *base_pat
== '\\')
1067 *pat
++ = (trt
? trt
[*base_pat
++] : *base_pat
++);
1070 pat
= base_pat
= patbuf
;
1072 /* The general approach is that we are going to maintain that we know */
1073 /* the first (closest to the present position, in whatever direction */
1074 /* we're searching) character that could possibly be the last */
1075 /* (furthest from present position) character of a valid match. We */
1076 /* advance the state of our knowledge by looking at that character */
1077 /* and seeing whether it indeed matches the last character of the */
1078 /* pattern. If it does, we take a closer look. If it does not, we */
1079 /* move our pointer (to putative last characters) as far as is */
1080 /* logically possible. This amount of movement, which I call a */
1081 /* stride, will be the length of the pattern if the actual character */
1082 /* appears nowhere in the pattern, otherwise it will be the distance */
1083 /* from the last occurrence of that character to the end of the */
1085 /* As a coding trick, an enormous stride is coded into the table for */
1086 /* characters that match the last character. This allows use of only */
1087 /* a single test, a test for having gone past the end of the */
1088 /* permissible match region, to test for both possible matches (when */
1089 /* the stride goes past the end immediately) and failure to */
1090 /* match (where you get nudged past the end one stride at a time). */
1092 /* Here we make a "mickey mouse" BM table. The stride of the search */
1093 /* is determined only by the last character of the putative match. */
1094 /* If that character does not match, we will stride the proper */
1095 /* distance to propose a match that superimposes it on the last */
1096 /* instance of a character that matches it (per trt), or misses */
1097 /* it entirely if there is none. */
1099 dirlen
= len
* direction
;
1100 infinity
= dirlen
- (lim
+ pos
+ len
+ len
) * direction
;
1102 pat
= (base_pat
+= len
- 1);
1103 BM_tab_base
= BM_tab
;
1105 j
= dirlen
; /* to get it in a register */
1106 /* A character that does not appear in the pattern induces a */
1107 /* stride equal to the pattern length. */
1108 while (BM_tab_base
!= BM_tab
)
1116 while (i
!= infinity
)
1118 j
= pat
[i
]; i
+= direction
;
1119 if (i
== dirlen
) i
= infinity
;
1124 stride_for_teases
= BM_tab
[j
];
1125 BM_tab
[j
] = dirlen
- i
;
1126 /* A translation table is accompanied by its inverse -- see */
1127 /* comment following downcase_table for details */
1128 while ((j
= (unsigned char) inverse_trt
[j
]) != k
)
1129 BM_tab
[j
] = dirlen
- i
;
1134 stride_for_teases
= BM_tab
[j
];
1135 BM_tab
[j
] = dirlen
- i
;
1137 /* stride_for_teases tells how much to stride if we get a */
1138 /* match on the far character but are subsequently */
1139 /* disappointed, by recording what the stride would have been */
1140 /* for that character if the last character had been */
1143 infinity
= dirlen
- infinity
;
1144 pos
+= dirlen
- ((direction
> 0) ? direction
: 0);
1145 /* loop invariant - pos points at where last char (first char if reverse)
1146 of pattern would align in a possible match. */
1149 /* It's been reported that some (broken) compiler thinks that
1150 Boolean expressions in an arithmetic context are unsigned.
1151 Using an explicit ?1:0 prevents this. */
1152 if ((lim
- pos
- ((direction
> 0) ? 1 : 0)) * direction
< 0)
1153 return (n
* (0 - direction
));
1154 /* First we do the part we can by pointers (maybe nothing) */
1157 limit
= pos
- dirlen
+ direction
;
1158 limit
= ((direction
> 0)
1159 ? BUFFER_CEILING_OF (limit
)
1160 : BUFFER_FLOOR_OF (limit
));
1161 /* LIMIT is now the last (not beyond-last!) value
1162 POS can take on without hitting edge of buffer or the gap. */
1163 limit
= ((direction
> 0)
1164 ? min (lim
- 1, min (limit
, pos
+ 20000))
1165 : max (lim
, max (limit
, pos
- 20000)));
1166 if ((limit
- pos
) * direction
> 20)
1168 p_limit
= &FETCH_CHAR (limit
);
1169 p2
= (cursor
= &FETCH_CHAR (pos
));
1170 /* In this loop, pos + cursor - p2 is the surrogate for pos */
1171 while (1) /* use one cursor setting as long as i can */
1173 if (direction
> 0) /* worth duplicating */
1175 /* Use signed comparison if appropriate
1176 to make cursor+infinity sure to be > p_limit.
1177 Assuming that the buffer lies in a range of addresses
1178 that are all "positive" (as ints) or all "negative",
1179 either kind of comparison will work as long
1180 as we don't step by infinity. So pick the kind
1181 that works when we do step by infinity. */
1182 if ((EMACS_INT
) (p_limit
+ infinity
) > (EMACS_INT
) p_limit
)
1183 while ((EMACS_INT
) cursor
<= (EMACS_INT
) p_limit
)
1184 cursor
+= BM_tab
[*cursor
];
1186 while ((EMACS_UINT
) cursor
<= (EMACS_UINT
) p_limit
)
1187 cursor
+= BM_tab
[*cursor
];
1191 if ((EMACS_INT
) (p_limit
+ infinity
) < (EMACS_INT
) p_limit
)
1192 while ((EMACS_INT
) cursor
>= (EMACS_INT
) p_limit
)
1193 cursor
+= BM_tab
[*cursor
];
1195 while ((EMACS_UINT
) cursor
>= (EMACS_UINT
) p_limit
)
1196 cursor
+= BM_tab
[*cursor
];
1198 /* If you are here, cursor is beyond the end of the searched region. */
1199 /* This can happen if you match on the far character of the pattern, */
1200 /* because the "stride" of that character is infinity, a number able */
1201 /* to throw you well beyond the end of the search. It can also */
1202 /* happen if you fail to match within the permitted region and would */
1203 /* otherwise try a character beyond that region */
1204 if ((cursor
- p_limit
) * direction
<= len
)
1205 break; /* a small overrun is genuine */
1206 cursor
-= infinity
; /* large overrun = hit */
1207 i
= dirlen
- direction
;
1210 while ((i
-= direction
) + direction
!= 0)
1211 if (pat
[i
] != trt
[*(cursor
-= direction
)])
1216 while ((i
-= direction
) + direction
!= 0)
1217 if (pat
[i
] != *(cursor
-= direction
))
1220 cursor
+= dirlen
- i
- direction
; /* fix cursor */
1221 if (i
+ direction
== 0)
1223 cursor
-= direction
;
1225 set_search_regs (pos
+ cursor
- p2
+ ((direction
> 0)
1229 if ((n
-= direction
) != 0)
1230 cursor
+= dirlen
; /* to resume search */
1232 return ((direction
> 0)
1233 ? search_regs
.end
[0] : search_regs
.start
[0]);
1236 cursor
+= stride_for_teases
; /* <sigh> we lose - */
1241 /* Now we'll pick up a clump that has to be done the hard */
1242 /* way because it covers a discontinuity */
1244 limit
= ((direction
> 0)
1245 ? BUFFER_CEILING_OF (pos
- dirlen
+ 1)
1246 : BUFFER_FLOOR_OF (pos
- dirlen
- 1));
1247 limit
= ((direction
> 0)
1248 ? min (limit
+ len
, lim
- 1)
1249 : max (limit
- len
, lim
));
1250 /* LIMIT is now the last value POS can have
1251 and still be valid for a possible match. */
1254 /* This loop can be coded for space rather than */
1255 /* speed because it will usually run only once. */
1256 /* (the reach is at most len + 21, and typically */
1257 /* does not exceed len) */
1258 while ((limit
- pos
) * direction
>= 0)
1259 pos
+= BM_tab
[FETCH_CHAR(pos
)];
1260 /* now run the same tests to distinguish going off the */
1261 /* end, a match or a phony match. */
1262 if ((pos
- limit
) * direction
<= len
)
1263 break; /* ran off the end */
1264 /* Found what might be a match.
1265 Set POS back to last (first if reverse) char pos. */
1267 i
= dirlen
- direction
;
1268 while ((i
-= direction
) + direction
!= 0)
1271 if (pat
[i
] != (trt
!= 0
1272 ? trt
[FETCH_CHAR(pos
)]
1273 : FETCH_CHAR (pos
)))
1276 /* Above loop has moved POS part or all the way
1277 back to the first char pos (last char pos if reverse).
1278 Set it once again at the last (first if reverse) char. */
1279 pos
+= dirlen
- i
- direction
;
1280 if (i
+ direction
== 0)
1284 set_search_regs (pos
+ ((direction
> 0) ? 1 - len
: 0),
1287 if ((n
-= direction
) != 0)
1288 pos
+= dirlen
; /* to resume search */
1290 return ((direction
> 0)
1291 ? search_regs
.end
[0] : search_regs
.start
[0]);
1294 pos
+= stride_for_teases
;
1297 /* We have done one clump. Can we continue? */
1298 if ((lim
- pos
) * direction
< 0)
1299 return ((0 - n
) * direction
);
1305 /* Record beginning BEG and end BEG + LEN
1306 for a match just found in the current buffer. */
1309 set_search_regs (beg
, len
)
1312 /* Make sure we have registers in which to store
1313 the match position. */
1314 if (search_regs
.num_regs
== 0)
1316 search_regs
.start
= (regoff_t
*) xmalloc (2 * sizeof (regoff_t
));
1317 search_regs
.end
= (regoff_t
*) xmalloc (2 * sizeof (regoff_t
));
1318 search_regs
.num_regs
= 2;
1321 search_regs
.start
[0] = beg
;
1322 search_regs
.end
[0] = beg
+ len
;
1323 XSETBUFFER (last_thing_searched
, current_buffer
);
1326 /* Given a string of words separated by word delimiters,
1327 compute a regexp that matches those exact words
1328 separated by arbitrary punctuation. */
1334 register unsigned char *p
, *o
;
1335 register int i
, len
, punct_count
= 0, word_count
= 0;
1338 CHECK_STRING (string
, 0);
1339 p
= XSTRING (string
)->data
;
1340 len
= XSTRING (string
)->size
;
1342 for (i
= 0; i
< len
; i
++)
1343 if (SYNTAX (p
[i
]) != Sword
)
1346 if (i
> 0 && SYNTAX (p
[i
-1]) == Sword
) word_count
++;
1348 if (SYNTAX (p
[len
-1]) == Sword
) word_count
++;
1349 if (!word_count
) return build_string ("");
1351 val
= make_string (p
, len
- punct_count
+ 5 * (word_count
- 1) + 4);
1353 o
= XSTRING (val
)->data
;
1357 for (i
= 0; i
< len
; i
++)
1358 if (SYNTAX (p
[i
]) == Sword
)
1360 else if (i
> 0 && SYNTAX (p
[i
-1]) == Sword
&& --word_count
)
1375 DEFUN ("search-backward", Fsearch_backward
, Ssearch_backward
, 1, 4,
1376 "sSearch backward: ",
1377 "Search backward from point for STRING.\n\
1378 Set point to the beginning of the occurrence found, and return point.\n\
1379 An optional second argument bounds the search; it is a buffer position.\n\
1380 The match found must not extend before that position.\n\
1381 Optional third argument, if t, means if fail just return nil (no error).\n\
1382 If not nil and not t, position at limit of search and return nil.\n\
1383 Optional fourth argument is repeat count--search for successive occurrences.\n\
1384 See also the functions `match-beginning', `match-end' and `replace-match'.")
1385 (string
, bound
, noerror
, count
)
1386 Lisp_Object string
, bound
, noerror
, count
;
1388 return search_command (string
, bound
, noerror
, count
, -1, 0, 0);
1391 DEFUN ("search-forward", Fsearch_forward
, Ssearch_forward
, 1, 4, "sSearch: ",
1392 "Search forward from point for STRING.\n\
1393 Set point to the end of the occurrence found, and return point.\n\
1394 An optional second argument bounds the search; it is a buffer position.\n\
1395 The match found must not extend after that position. nil is equivalent\n\
1397 Optional third argument, if t, means if fail just return nil (no error).\n\
1398 If not nil and not t, move to limit of search and return nil.\n\
1399 Optional fourth argument is repeat count--search for successive occurrences.\n\
1400 See also the functions `match-beginning', `match-end' and `replace-match'.")
1401 (string
, bound
, noerror
, count
)
1402 Lisp_Object string
, bound
, noerror
, count
;
1404 return search_command (string
, bound
, noerror
, count
, 1, 0, 0);
1407 DEFUN ("word-search-backward", Fword_search_backward
, Sword_search_backward
, 1, 4,
1408 "sWord search backward: ",
1409 "Search backward from point for STRING, ignoring differences in punctuation.\n\
1410 Set point to the beginning of the occurrence found, and return point.\n\
1411 An optional second argument bounds the search; it is a buffer position.\n\
1412 The match found must not extend before that position.\n\
1413 Optional third argument, if t, means if fail just return nil (no error).\n\
1414 If not nil and not t, move to limit of search and return nil.\n\
1415 Optional fourth argument is repeat count--search for successive occurrences.")
1416 (string
, bound
, noerror
, count
)
1417 Lisp_Object string
, bound
, noerror
, count
;
1419 return search_command (wordify (string
), bound
, noerror
, count
, -1, 1, 0);
1422 DEFUN ("word-search-forward", Fword_search_forward
, Sword_search_forward
, 1, 4,
1424 "Search forward from point for STRING, ignoring differences in punctuation.\n\
1425 Set point to the end of the occurrence found, and return point.\n\
1426 An optional second argument bounds the search; it is a buffer position.\n\
1427 The match found must not extend after that position.\n\
1428 Optional third argument, if t, means if fail just return nil (no error).\n\
1429 If not nil and not t, move to limit of search and return nil.\n\
1430 Optional fourth argument is repeat count--search for successive occurrences.")
1431 (string
, bound
, noerror
, count
)
1432 Lisp_Object string
, bound
, noerror
, count
;
1434 return search_command (wordify (string
), bound
, noerror
, count
, 1, 1, 0);
1437 DEFUN ("re-search-backward", Fre_search_backward
, Sre_search_backward
, 1, 4,
1438 "sRE search backward: ",
1439 "Search backward from point for match for regular expression REGEXP.\n\
1440 Set point to the beginning of the match, and return point.\n\
1441 The match found is the one starting last in the buffer\n\
1442 and yet ending before the origin of the search.\n\
1443 An optional second argument bounds the search; it is a buffer position.\n\
1444 The match found must start at or after that position.\n\
1445 Optional third argument, if t, means if fail just return nil (no error).\n\
1446 If not nil and not t, move to limit of search and return nil.\n\
1447 Optional fourth argument is repeat count--search for successive occurrences.\n\
1448 See also the functions `match-beginning', `match-end' and `replace-match'.")
1449 (regexp
, bound
, noerror
, count
)
1450 Lisp_Object regexp
, bound
, noerror
, count
;
1452 return search_command (regexp
, bound
, noerror
, count
, -1, 1, 0);
1455 DEFUN ("re-search-forward", Fre_search_forward
, Sre_search_forward
, 1, 4,
1457 "Search forward from point for regular expression REGEXP.\n\
1458 Set point to the end of the occurrence found, and return point.\n\
1459 An optional second argument bounds the search; it is a buffer position.\n\
1460 The match found must not extend after that position.\n\
1461 Optional third argument, if t, means if fail just return nil (no error).\n\
1462 If not nil and not t, move to limit of search and return nil.\n\
1463 Optional fourth argument is repeat count--search for successive occurrences.\n\
1464 See also the functions `match-beginning', `match-end' and `replace-match'.")
1465 (regexp
, bound
, noerror
, count
)
1466 Lisp_Object regexp
, bound
, noerror
, count
;
1468 return search_command (regexp
, bound
, noerror
, count
, 1, 1, 0);
1471 DEFUN ("posix-search-backward", Fposix_search_backward
, Sposix_search_backward
, 1, 4,
1472 "sPosix search backward: ",
1473 "Search backward from point for match for regular expression REGEXP.\n\
1474 Find the longest match in accord with Posix regular expression rules.\n\
1475 Set point to the beginning of the match, and return point.\n\
1476 The match found is the one starting last in the buffer\n\
1477 and yet ending before the origin of the search.\n\
1478 An optional second argument bounds the search; it is a buffer position.\n\
1479 The match found must start at or after that position.\n\
1480 Optional third argument, if t, means if fail just return nil (no error).\n\
1481 If not nil and not t, move to limit of search and return nil.\n\
1482 Optional fourth argument is repeat count--search for successive occurrences.\n\
1483 See also the functions `match-beginning', `match-end' and `replace-match'.")
1484 (regexp
, bound
, noerror
, count
)
1485 Lisp_Object regexp
, bound
, noerror
, count
;
1487 return search_command (regexp
, bound
, noerror
, count
, -1, 1, 1);
1490 DEFUN ("posix-search-forward", Fposix_search_forward
, Sposix_search_forward
, 1, 4,
1492 "Search forward from point for regular expression REGEXP.\n\
1493 Find the longest match in accord with Posix regular expression rules.\n\
1494 Set point to the end of the occurrence found, and return point.\n\
1495 An optional second argument bounds the search; it is a buffer position.\n\
1496 The match found must not extend after that position.\n\
1497 Optional third argument, if t, means if fail just return nil (no error).\n\
1498 If not nil and not t, move to limit of search and return nil.\n\
1499 Optional fourth argument is repeat count--search for successive occurrences.\n\
1500 See also the functions `match-beginning', `match-end' and `replace-match'.")
1501 (regexp
, bound
, noerror
, count
)
1502 Lisp_Object regexp
, bound
, noerror
, count
;
1504 return search_command (regexp
, bound
, noerror
, count
, 1, 1, 1);
1507 DEFUN ("replace-match", Freplace_match
, Sreplace_match
, 1, 5, 0,
1508 "Replace text matched by last search with NEWTEXT.\n\
1509 If second arg FIXEDCASE is non-nil, do not alter case of replacement text.\n\
1510 Otherwise maybe capitalize the whole text, or maybe just word initials,\n\
1511 based on the replaced text.\n\
1512 If the replaced text has only capital letters\n\
1513 and has at least one multiletter word, convert NEWTEXT to all caps.\n\
1514 If the replaced text has at least one word starting with a capital letter,\n\
1515 then capitalize each word in NEWTEXT.\n\n\
1516 If third arg LITERAL is non-nil, insert NEWTEXT literally.\n\
1517 Otherwise treat `\\' as special:\n\
1518 `\\&' in NEWTEXT means substitute original matched text.\n\
1519 `\\N' means substitute what matched the Nth `\\(...\\)'.\n\
1520 If Nth parens didn't match, substitute nothing.\n\
1521 `\\\\' means insert one `\\'.\n\
1522 FIXEDCASE and LITERAL are optional arguments.\n\
1523 Leaves point at end of replacement text.\n\
1525 The optional fourth argument STRING can be a string to modify.\n\
1526 In that case, this function creates and returns a new string\n\
1527 which is made by replacing the part of STRING that was matched.\n\
1529 The optional fifth argument SUBEXP specifies a subexpression of the match.\n\
1530 It says to replace just that subexpression instead of the whole match.\n\
1531 This is useful only after a regular expression search or match\n\
1532 since only regular expressions have distinguished subexpressions.")
1533 (newtext
, fixedcase
, literal
, string
, subexp
)
1534 Lisp_Object newtext
, fixedcase
, literal
, string
, subexp
;
1536 enum { nochange
, all_caps
, cap_initial
} case_action
;
1537 register int pos
, last
;
1538 int some_multiletter_word
;
1541 int some_nonuppercase_initial
;
1542 register int c
, prevc
;
1546 CHECK_STRING (newtext
, 0);
1548 if (! NILP (string
))
1549 CHECK_STRING (string
, 4);
1551 case_action
= nochange
; /* We tried an initialization */
1552 /* but some C compilers blew it */
1554 if (search_regs
.num_regs
<= 0)
1555 error ("replace-match called before any match found");
1561 CHECK_NUMBER (subexp
, 3);
1562 sub
= XINT (subexp
);
1563 if (sub
< 0 || sub
>= search_regs
.num_regs
)
1564 args_out_of_range (subexp
, make_number (search_regs
.num_regs
));
1569 if (search_regs
.start
[sub
] < BEGV
1570 || search_regs
.start
[sub
] > search_regs
.end
[sub
]
1571 || search_regs
.end
[sub
] > ZV
)
1572 args_out_of_range (make_number (search_regs
.start
[sub
]),
1573 make_number (search_regs
.end
[sub
]));
1577 if (search_regs
.start
[sub
] < 0
1578 || search_regs
.start
[sub
] > search_regs
.end
[sub
]
1579 || search_regs
.end
[sub
] > XSTRING (string
)->size
)
1580 args_out_of_range (make_number (search_regs
.start
[sub
]),
1581 make_number (search_regs
.end
[sub
]));
1584 if (NILP (fixedcase
))
1586 /* Decide how to casify by examining the matched text. */
1588 last
= search_regs
.end
[sub
];
1590 case_action
= all_caps
;
1592 /* some_multiletter_word is set nonzero if any original word
1593 is more than one letter long. */
1594 some_multiletter_word
= 0;
1596 some_nonuppercase_initial
= 0;
1599 for (pos
= search_regs
.start
[sub
]; pos
< last
; pos
++)
1602 c
= FETCH_CHAR (pos
);
1604 c
= XSTRING (string
)->data
[pos
];
1608 /* Cannot be all caps if any original char is lower case */
1611 if (SYNTAX (prevc
) != Sword
)
1612 some_nonuppercase_initial
= 1;
1614 some_multiletter_word
= 1;
1616 else if (!NOCASEP (c
))
1619 if (SYNTAX (prevc
) != Sword
)
1622 some_multiletter_word
= 1;
1626 /* If the initial is a caseless word constituent,
1627 treat that like a lowercase initial. */
1628 if (SYNTAX (prevc
) != Sword
)
1629 some_nonuppercase_initial
= 1;
1635 /* Convert to all caps if the old text is all caps
1636 and has at least one multiletter word. */
1637 if (! some_lowercase
&& some_multiletter_word
)
1638 case_action
= all_caps
;
1639 /* Capitalize each word, if the old text has all capitalized words. */
1640 else if (!some_nonuppercase_initial
&& some_multiletter_word
)
1641 case_action
= cap_initial
;
1642 else if (!some_nonuppercase_initial
&& some_uppercase
)
1643 /* Should x -> yz, operating on X, give Yz or YZ?
1644 We'll assume the latter. */
1645 case_action
= all_caps
;
1647 case_action
= nochange
;
1650 /* Do replacement in a string. */
1653 Lisp_Object before
, after
;
1655 before
= Fsubstring (string
, make_number (0),
1656 make_number (search_regs
.start
[sub
]));
1657 after
= Fsubstring (string
, make_number (search_regs
.end
[sub
]), Qnil
);
1659 /* Do case substitution into NEWTEXT if desired. */
1663 /* We build up the substituted string in ACCUM. */
1669 for (pos
= 0; pos
< XSTRING (newtext
)->size
; pos
++)
1673 int delbackslash
= 0;
1675 c
= XSTRING (newtext
)->data
[pos
];
1678 c
= XSTRING (newtext
)->data
[++pos
];
1681 substart
= search_regs
.start
[sub
];
1682 subend
= search_regs
.end
[sub
];
1684 else if (c
>= '1' && c
<= '9' && c
<= search_regs
.num_regs
+ '0')
1686 if (search_regs
.start
[c
- '0'] >= 0)
1688 substart
= search_regs
.start
[c
- '0'];
1689 subend
= search_regs
.end
[c
- '0'];
1697 if (pos
- 1 != lastpos
+ 1)
1698 middle
= Fsubstring (newtext
,
1699 make_number (lastpos
+ 1),
1700 make_number (pos
- 1));
1703 accum
= concat3 (accum
, middle
,
1704 Fsubstring (string
, make_number (substart
),
1705 make_number (subend
)));
1708 else if (delbackslash
)
1710 middle
= Fsubstring (newtext
, make_number (lastpos
+ 1),
1712 accum
= concat2 (accum
, middle
);
1717 if (pos
!= lastpos
+ 1)
1718 middle
= Fsubstring (newtext
, make_number (lastpos
+ 1),
1723 newtext
= concat2 (accum
, middle
);
1726 if (case_action
== all_caps
)
1727 newtext
= Fupcase (newtext
);
1728 else if (case_action
== cap_initial
)
1729 newtext
= Fupcase_initials (newtext
);
1731 return concat3 (before
, newtext
, after
);
1734 /* We insert the replacement text before the old text, and then
1735 delete the original text. This means that markers at the
1736 beginning or end of the original will float to the corresponding
1737 position in the replacement. */
1738 SET_PT (search_regs
.start
[sub
]);
1739 if (!NILP (literal
))
1740 Finsert_and_inherit (1, &newtext
);
1743 struct gcpro gcpro1
;
1746 for (pos
= 0; pos
< XSTRING (newtext
)->size
; pos
++)
1748 int offset
= PT
- search_regs
.start
[sub
];
1750 c
= XSTRING (newtext
)->data
[pos
];
1753 c
= XSTRING (newtext
)->data
[++pos
];
1755 Finsert_buffer_substring
1756 (Fcurrent_buffer (),
1757 make_number (search_regs
.start
[sub
] + offset
),
1758 make_number (search_regs
.end
[sub
] + offset
));
1759 else if (c
>= '1' && c
<= '9' && c
<= search_regs
.num_regs
+ '0')
1761 if (search_regs
.start
[c
- '0'] >= 1)
1762 Finsert_buffer_substring
1763 (Fcurrent_buffer (),
1764 make_number (search_regs
.start
[c
- '0'] + offset
),
1765 make_number (search_regs
.end
[c
- '0'] + offset
));
1776 inslen
= PT
- (search_regs
.start
[sub
]);
1777 del_range (search_regs
.start
[sub
] + inslen
, search_regs
.end
[sub
] + inslen
);
1779 if (case_action
== all_caps
)
1780 Fupcase_region (make_number (PT
- inslen
), make_number (PT
));
1781 else if (case_action
== cap_initial
)
1782 Fupcase_initials_region (make_number (PT
- inslen
), make_number (PT
));
1787 match_limit (num
, beginningp
)
1793 CHECK_NUMBER (num
, 0);
1795 if (n
< 0 || n
>= search_regs
.num_regs
)
1796 args_out_of_range (num
, make_number (search_regs
.num_regs
));
1797 if (search_regs
.num_regs
<= 0
1798 || search_regs
.start
[n
] < 0)
1800 return (make_number ((beginningp
) ? search_regs
.start
[n
]
1801 : search_regs
.end
[n
]));
1804 DEFUN ("match-beginning", Fmatch_beginning
, Smatch_beginning
, 1, 1, 0,
1805 "Return position of start of text matched by last search.\n\
1806 SUBEXP, a number, specifies which parenthesized expression in the last\n\
1808 Value is nil if SUBEXPth pair didn't match, or there were less than\n\
1810 Zero means the entire text matched by the whole regexp or whole string.")
1814 return match_limit (subexp
, 1);
1817 DEFUN ("match-end", Fmatch_end
, Smatch_end
, 1, 1, 0,
1818 "Return position of end of text matched by last search.\n\
1819 SUBEXP, a number, specifies which parenthesized expression in the last\n\
1821 Value is nil if SUBEXPth pair didn't match, or there were less than\n\
1823 Zero means the entire text matched by the whole regexp or whole string.")
1827 return match_limit (subexp
, 0);
1830 DEFUN ("match-data", Fmatch_data
, Smatch_data
, 0, 2, 0,
1831 "Return a list containing all info on what the last search matched.\n\
1832 Element 2N is `(match-beginning N)'; element 2N + 1 is `(match-end N)'.\n\
1833 All the elements are markers or nil (nil if the Nth pair didn't match)\n\
1834 if the last match was on a buffer; integers or nil if a string was matched.\n\
1835 Use `store-match-data' to reinstate the data in this list.\n\
1837 If INTEGERS (the optional first argument) is non-nil, always use integers\n\
1838 \(rather than markers) to represent buffer positions.\n\
1839 If REUSE is a list, reuse it as part of the value. If REUSE is long enough\n\
1840 to hold all the values, and if INTEGERS is non-nil, no consing is done.")
1842 Lisp_Object integers
, reuse
;
1844 Lisp_Object tail
, prev
;
1848 if (NILP (last_thing_searched
))
1851 data
= (Lisp_Object
*) alloca ((2 * search_regs
.num_regs
)
1852 * sizeof (Lisp_Object
));
1855 for (i
= 0; i
< search_regs
.num_regs
; i
++)
1857 int start
= search_regs
.start
[i
];
1860 if (EQ (last_thing_searched
, Qt
)
1861 || ! NILP (integers
))
1863 XSETFASTINT (data
[2 * i
], start
);
1864 XSETFASTINT (data
[2 * i
+ 1], search_regs
.end
[i
]);
1866 else if (BUFFERP (last_thing_searched
))
1868 data
[2 * i
] = Fmake_marker ();
1869 Fset_marker (data
[2 * i
],
1870 make_number (start
),
1871 last_thing_searched
);
1872 data
[2 * i
+ 1] = Fmake_marker ();
1873 Fset_marker (data
[2 * i
+ 1],
1874 make_number (search_regs
.end
[i
]),
1875 last_thing_searched
);
1878 /* last_thing_searched must always be Qt, a buffer, or Qnil. */
1884 data
[2 * i
] = data
[2 * i
+ 1] = Qnil
;
1887 /* If REUSE is not usable, cons up the values and return them. */
1888 if (! CONSP (reuse
))
1889 return Flist (2 * len
+ 2, data
);
1891 /* If REUSE is a list, store as many value elements as will fit
1892 into the elements of REUSE. */
1893 for (i
= 0, tail
= reuse
; CONSP (tail
);
1894 i
++, tail
= XCONS (tail
)->cdr
)
1896 if (i
< 2 * len
+ 2)
1897 XCONS (tail
)->car
= data
[i
];
1899 XCONS (tail
)->car
= Qnil
;
1903 /* If we couldn't fit all value elements into REUSE,
1904 cons up the rest of them and add them to the end of REUSE. */
1905 if (i
< 2 * len
+ 2)
1906 XCONS (prev
)->cdr
= Flist (2 * len
+ 2 - i
, data
+ i
);
1912 DEFUN ("store-match-data", Fstore_match_data
, Sstore_match_data
, 1, 1, 0,
1913 "Set internal data on last search match from elements of LIST.\n\
1914 LIST should have been created by calling `match-data' previously.")
1916 register Lisp_Object list
;
1919 register Lisp_Object marker
;
1921 if (running_asynch_code
)
1922 save_search_regs ();
1924 if (!CONSP (list
) && !NILP (list
))
1925 list
= wrong_type_argument (Qconsp
, list
);
1927 /* Unless we find a marker with a buffer in LIST, assume that this
1928 match data came from a string. */
1929 last_thing_searched
= Qt
;
1931 /* Allocate registers if they don't already exist. */
1933 int length
= XFASTINT (Flength (list
)) / 2;
1935 if (length
> search_regs
.num_regs
)
1937 if (search_regs
.num_regs
== 0)
1940 = (regoff_t
*) xmalloc (length
* sizeof (regoff_t
));
1942 = (regoff_t
*) xmalloc (length
* sizeof (regoff_t
));
1947 = (regoff_t
*) xrealloc (search_regs
.start
,
1948 length
* sizeof (regoff_t
));
1950 = (regoff_t
*) xrealloc (search_regs
.end
,
1951 length
* sizeof (regoff_t
));
1954 search_regs
.num_regs
= length
;
1958 for (i
= 0; i
< search_regs
.num_regs
; i
++)
1960 marker
= Fcar (list
);
1963 search_regs
.start
[i
] = -1;
1968 if (MARKERP (marker
))
1970 if (XMARKER (marker
)->buffer
== 0)
1971 XSETFASTINT (marker
, 0);
1973 XSETBUFFER (last_thing_searched
, XMARKER (marker
)->buffer
);
1976 CHECK_NUMBER_COERCE_MARKER (marker
, 0);
1977 search_regs
.start
[i
] = XINT (marker
);
1980 marker
= Fcar (list
);
1981 if (MARKERP (marker
) && XMARKER (marker
)->buffer
== 0)
1982 XSETFASTINT (marker
, 0);
1984 CHECK_NUMBER_COERCE_MARKER (marker
, 0);
1985 search_regs
.end
[i
] = XINT (marker
);
1993 /* If non-zero the match data have been saved in saved_search_regs
1994 during the execution of a sentinel or filter. */
1995 static int search_regs_saved
;
1996 static struct re_registers saved_search_regs
;
1998 /* Called from Flooking_at, Fstring_match, search_buffer, Fstore_match_data
1999 if asynchronous code (filter or sentinel) is running. */
2003 if (!search_regs_saved
)
2005 saved_search_regs
.num_regs
= search_regs
.num_regs
;
2006 saved_search_regs
.start
= search_regs
.start
;
2007 saved_search_regs
.end
= search_regs
.end
;
2008 search_regs
.num_regs
= 0;
2009 search_regs
.start
= 0;
2010 search_regs
.end
= 0;
2012 search_regs_saved
= 1;
2016 /* Called upon exit from filters and sentinels. */
2018 restore_match_data ()
2020 if (search_regs_saved
)
2022 if (search_regs
.num_regs
> 0)
2024 xfree (search_regs
.start
);
2025 xfree (search_regs
.end
);
2027 search_regs
.num_regs
= saved_search_regs
.num_regs
;
2028 search_regs
.start
= saved_search_regs
.start
;
2029 search_regs
.end
= saved_search_regs
.end
;
2031 search_regs_saved
= 0;
2035 /* Quote a string to inactivate reg-expr chars */
2037 DEFUN ("regexp-quote", Fregexp_quote
, Sregexp_quote
, 1, 1, 0,
2038 "Return a regexp string which matches exactly STRING and nothing else.")
2042 register unsigned char *in
, *out
, *end
;
2043 register unsigned char *temp
;
2045 CHECK_STRING (string
, 0);
2047 temp
= (unsigned char *) alloca (XSTRING (string
)->size
* 2);
2049 /* Now copy the data into the new string, inserting escapes. */
2051 in
= XSTRING (string
)->data
;
2052 end
= in
+ XSTRING (string
)->size
;
2055 for (; in
!= end
; in
++)
2057 if (*in
== '[' || *in
== ']'
2058 || *in
== '*' || *in
== '.' || *in
== '\\'
2059 || *in
== '?' || *in
== '+'
2060 || *in
== '^' || *in
== '$')
2065 return make_string (temp
, out
- temp
);
2072 for (i
= 0; i
< REGEXP_CACHE_SIZE
; ++i
)
2074 searchbufs
[i
].buf
.allocated
= 100;
2075 searchbufs
[i
].buf
.buffer
= (unsigned char *) malloc (100);
2076 searchbufs
[i
].buf
.fastmap
= searchbufs
[i
].fastmap
;
2077 searchbufs
[i
].regexp
= Qnil
;
2078 staticpro (&searchbufs
[i
].regexp
);
2079 searchbufs
[i
].next
= (i
== REGEXP_CACHE_SIZE
-1 ? 0 : &searchbufs
[i
+1]);
2081 searchbuf_head
= &searchbufs
[0];
2083 Qsearch_failed
= intern ("search-failed");
2084 staticpro (&Qsearch_failed
);
2085 Qinvalid_regexp
= intern ("invalid-regexp");
2086 staticpro (&Qinvalid_regexp
);
2088 Fput (Qsearch_failed
, Qerror_conditions
,
2089 Fcons (Qsearch_failed
, Fcons (Qerror
, Qnil
)));
2090 Fput (Qsearch_failed
, Qerror_message
,
2091 build_string ("Search failed"));
2093 Fput (Qinvalid_regexp
, Qerror_conditions
,
2094 Fcons (Qinvalid_regexp
, Fcons (Qerror
, Qnil
)));
2095 Fput (Qinvalid_regexp
, Qerror_message
,
2096 build_string ("Invalid regexp"));
2098 last_thing_searched
= Qnil
;
2099 staticpro (&last_thing_searched
);
2101 defsubr (&Slooking_at
);
2102 defsubr (&Sposix_looking_at
);
2103 defsubr (&Sstring_match
);
2104 defsubr (&Sposix_string_match
);
2105 defsubr (&Sskip_chars_forward
);
2106 defsubr (&Sskip_chars_backward
);
2107 defsubr (&Sskip_syntax_forward
);
2108 defsubr (&Sskip_syntax_backward
);
2109 defsubr (&Ssearch_forward
);
2110 defsubr (&Ssearch_backward
);
2111 defsubr (&Sword_search_forward
);
2112 defsubr (&Sword_search_backward
);
2113 defsubr (&Sre_search_forward
);
2114 defsubr (&Sre_search_backward
);
2115 defsubr (&Sposix_search_forward
);
2116 defsubr (&Sposix_search_backward
);
2117 defsubr (&Sreplace_match
);
2118 defsubr (&Smatch_beginning
);
2119 defsubr (&Smatch_end
);
2120 defsubr (&Smatch_data
);
2121 defsubr (&Sstore_match_data
);
2122 defsubr (&Sregexp_quote
);