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, 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 ();
81 static void save_search_regs ();
83 static int search_buffer ();
88 error ("Stack overflow in regexp matcher");
97 /* Compile a regexp and signal a Lisp error if anything goes wrong.
98 PATTERN is the pattern to compile.
99 CP is the place to put the result.
100 TRANSLATE is a translation table for ignoring case, or NULL for none.
101 REGP is the structure that says where to store the "register"
102 values that will result from matching this pattern.
103 If it is 0, we should compile the pattern not to record any
104 subexpression bounds.
105 POSIX is nonzero if we want full backtracking (POSIX style)
106 for this pattern. 0 means backtrack only enough to get a valid match. */
109 compile_pattern_1 (cp
, pattern
, translate
, regp
, posix
)
110 struct regexp_cache
*cp
;
113 struct re_registers
*regp
;
120 cp
->buf
.translate
= translate
;
123 old
= re_set_syntax (RE_SYNTAX_EMACS
124 | (posix
? 0 : RE_NO_POSIX_BACKTRACKING
));
125 val
= (CONST
char *) re_compile_pattern ((char *) XSTRING (pattern
)->data
,
126 XSTRING (pattern
)->size
, &cp
->buf
);
130 Fsignal (Qinvalid_regexp
, Fcons (build_string (val
), Qnil
));
132 cp
->regexp
= Fcopy_sequence (pattern
);
135 /* Compile a regexp if necessary, but first check to see if there's one in
137 PATTERN is the pattern to compile.
138 TRANSLATE is a translation table for ignoring case, or NULL for none.
139 REGP is the structure that says where to store the "register"
140 values that will result from matching this pattern.
141 If it is 0, we should compile the pattern not to record any
142 subexpression bounds.
143 POSIX is nonzero if we want full backtracking (POSIX style)
144 for this pattern. 0 means backtrack only enough to get a valid match. */
146 struct re_pattern_buffer
*
147 compile_pattern (pattern
, regp
, translate
, posix
)
149 struct re_registers
*regp
;
153 struct regexp_cache
*cp
, **cpp
;
155 for (cpp
= &searchbuf_head
; ; cpp
= &cp
->next
)
158 if (!NILP (Fstring_equal (cp
->regexp
, pattern
))
159 && cp
->buf
.translate
== translate
160 && cp
->posix
== posix
)
163 /* If we're at the end of the cache, compile into the last cell. */
166 compile_pattern_1 (cp
, pattern
, translate
, regp
, posix
);
171 /* When we get here, cp (aka *cpp) contains the compiled pattern,
172 either because we found it in the cache or because we just compiled it.
173 Move it to the front of the queue to mark it as most recently used. */
175 cp
->next
= searchbuf_head
;
178 /* Advise the searching functions about the space we have allocated
179 for register data. */
181 re_set_registers (&cp
->buf
, regp
, regp
->num_regs
, regp
->start
, regp
->end
);
186 /* Error condition used for failing searches */
187 Lisp_Object Qsearch_failed
;
193 Fsignal (Qsearch_failed
, Fcons (arg
, Qnil
));
198 looking_at_1 (string
, posix
)
203 unsigned char *p1
, *p2
;
206 struct re_pattern_buffer
*bufp
;
208 if (running_asynch_code
)
211 CHECK_STRING (string
, 0);
212 bufp
= compile_pattern (string
, &search_regs
,
213 (!NILP (current_buffer
->case_fold_search
)
214 ? DOWNCASE_TABLE
: 0),
218 QUIT
; /* Do a pending quit right away, to avoid paradoxical behavior */
220 /* Get pointers and sizes of the two strings
221 that make up the visible portion of the buffer. */
239 i
= re_match_2 (bufp
, (char *) p1
, s1
, (char *) p2
, s2
,
240 point
- BEGV
, &search_regs
,
245 val
= (0 <= i
? Qt
: Qnil
);
246 for (i
= 0; i
< search_regs
.num_regs
; i
++)
247 if (search_regs
.start
[i
] >= 0)
249 search_regs
.start
[i
] += BEGV
;
250 search_regs
.end
[i
] += BEGV
;
252 XSETBUFFER (last_thing_searched
, current_buffer
);
257 DEFUN ("looking-at", Flooking_at
, Slooking_at
, 1, 1, 0,
258 "Return t if text after point matches regular expression REGEXP.\n\
259 This function modifies the match data that `match-beginning',\n\
260 `match-end' and `match-data' access; save and restore the match\n\
261 data if you want to preserve them.")
265 return looking_at_1 (regexp
, 0);
268 DEFUN ("posix-looking-at", Fposix_looking_at
, Sposix_looking_at
, 1, 1, 0,
269 "Return t if text after point matches regular expression REGEXP.\n\
270 Find the longest match, in accord with Posix regular expression rules.\n\
271 This function modifies the match data that `match-beginning',\n\
272 `match-end' and `match-data' access; save and restore the match\n\
273 data if you want to preserve them.")
277 return looking_at_1 (regexp
, 1);
281 string_match_1 (regexp
, string
, start
, posix
)
282 Lisp_Object regexp
, string
, start
;
287 struct re_pattern_buffer
*bufp
;
289 if (running_asynch_code
)
292 CHECK_STRING (regexp
, 0);
293 CHECK_STRING (string
, 1);
299 int len
= XSTRING (string
)->size
;
301 CHECK_NUMBER (start
, 2);
303 if (s
< 0 && -s
<= len
)
305 else if (0 > s
|| s
> len
)
306 args_out_of_range (string
, start
);
309 bufp
= compile_pattern (regexp
, &search_regs
,
310 (!NILP (current_buffer
->case_fold_search
)
311 ? DOWNCASE_TABLE
: 0),
314 val
= re_search (bufp
, (char *) XSTRING (string
)->data
,
315 XSTRING (string
)->size
, s
, XSTRING (string
)->size
- s
,
318 last_thing_searched
= Qt
;
321 if (val
< 0) return Qnil
;
322 return make_number (val
);
325 DEFUN ("string-match", Fstring_match
, Sstring_match
, 2, 3, 0,
326 "Return index of start of first match for REGEXP in STRING, or nil.\n\
327 If third arg START is non-nil, start search at that index in STRING.\n\
328 For index of first char beyond the match, do (match-end 0).\n\
329 `match-end' and `match-beginning' also give indices of substrings\n\
330 matched by parenthesis constructs in the pattern.")
331 (regexp
, string
, start
)
332 Lisp_Object regexp
, string
, start
;
334 return string_match_1 (regexp
, string
, start
, 0);
337 DEFUN ("posix-string-match", Fposix_string_match
, Sposix_string_match
, 2, 3, 0,
338 "Return index of start of first match for REGEXP in STRING, or nil.\n\
339 Find the longest match, in accord with Posix regular expression rules.\n\
340 If third arg START is non-nil, start search at that index in STRING.\n\
341 For index of first char beyond the match, do (match-end 0).\n\
342 `match-end' and `match-beginning' also give indices of substrings\n\
343 matched by parenthesis constructs in the pattern.")
344 (regexp
, string
, start
)
345 Lisp_Object regexp
, string
, start
;
347 return string_match_1 (regexp
, string
, start
, 1);
350 /* Match REGEXP against STRING, searching all of STRING,
351 and return the index of the match, or negative on failure.
352 This does not clobber the match data. */
355 fast_string_match (regexp
, string
)
356 Lisp_Object regexp
, string
;
359 struct re_pattern_buffer
*bufp
;
361 bufp
= compile_pattern (regexp
, 0, 0, 0);
363 val
= re_search (bufp
, (char *) XSTRING (string
)->data
,
364 XSTRING (string
)->size
, 0, XSTRING (string
)->size
,
376 return ((a
> b
) ? a
: b
);
383 return ((a
< b
) ? a
: b
);
387 /* The newline cache: remembering which sections of text have no newlines. */
389 /* If the user has requested newline caching, make sure it's on.
390 Otherwise, make sure it's off.
391 This is our cheezy way of associating an action with the change of
392 state of a buffer-local variable. */
394 newline_cache_on_off (buf
)
397 if (NILP (buf
->cache_long_line_scans
))
399 /* It should be off. */
400 if (buf
->newline_cache
)
402 free_region_cache (buf
->newline_cache
);
403 buf
->newline_cache
= 0;
408 /* It should be on. */
409 if (buf
->newline_cache
== 0)
410 buf
->newline_cache
= new_region_cache ();
415 /* Search for COUNT instances of the character TARGET between START and END.
417 If COUNT is positive, search forwards; END must be >= START.
418 If COUNT is negative, search backwards for the -COUNTth instance;
419 END must be <= START.
420 If COUNT is zero, do anything you please; run rogue, for all I care.
422 If END is zero, use BEGV or ZV instead, as appropriate for the
423 direction indicated by COUNT.
425 If we find COUNT instances, set *SHORTAGE to zero, and return the
426 position after the COUNTth match. Note that for reverse motion
427 this is not the same as the usual convention for Emacs motion commands.
429 If we don't find COUNT instances before reaching END, set *SHORTAGE
430 to the number of TARGETs left unfound, and return END.
432 If ALLOW_QUIT is non-zero, set immediate_quit. That's good to do
433 except when inside redisplay. */
435 scan_buffer (target
, start
, end
, count
, shortage
, allow_quit
)
442 struct region_cache
*newline_cache
;
453 if (! end
) end
= BEGV
;
456 newline_cache_on_off (current_buffer
);
457 newline_cache
= current_buffer
->newline_cache
;
462 immediate_quit
= allow_quit
;
467 /* Our innermost scanning loop is very simple; it doesn't know
468 about gaps, buffer ends, or the newline cache. ceiling is
469 the position of the last character before the next such
470 obstacle --- the last character the dumb search loop should
472 register int ceiling
= end
- 1;
474 /* If we're looking for a newline, consult the newline cache
475 to see where we can avoid some scanning. */
476 if (target
== '\n' && newline_cache
)
480 while (region_cache_forward
481 (current_buffer
, newline_cache
, start
, &next_change
))
483 immediate_quit
= allow_quit
;
485 /* start should never be after end. */
489 /* Now the text after start is an unknown region, and
490 next_change is the position of the next known region. */
491 ceiling
= min (next_change
- 1, ceiling
);
494 /* The dumb loop can only scan text stored in contiguous
495 bytes. BUFFER_CEILING_OF returns the last character
496 position that is contiguous, so the ceiling is the
497 position after that. */
498 ceiling
= min (BUFFER_CEILING_OF (start
), ceiling
);
501 /* The termination address of the dumb loop. */
502 register unsigned char *ceiling_addr
= &FETCH_CHAR (ceiling
) + 1;
503 register unsigned char *cursor
= &FETCH_CHAR (start
);
504 unsigned char *base
= cursor
;
506 while (cursor
< ceiling_addr
)
508 unsigned char *scan_start
= cursor
;
511 while (*cursor
!= target
&& ++cursor
< ceiling_addr
)
514 /* If we're looking for newlines, cache the fact that
515 the region from start to cursor is free of them. */
516 if (target
== '\n' && newline_cache
)
517 know_region_cache (current_buffer
, newline_cache
,
518 start
+ scan_start
- base
,
519 start
+ cursor
- base
);
521 /* Did we find the target character? */
522 if (cursor
< ceiling_addr
)
527 return (start
+ cursor
- base
+ 1);
533 start
+= cursor
- base
;
539 /* The last character to check before the next obstacle. */
540 register int ceiling
= end
;
542 /* Consult the newline cache, if appropriate. */
543 if (target
== '\n' && newline_cache
)
547 while (region_cache_backward
548 (current_buffer
, newline_cache
, start
, &next_change
))
550 immediate_quit
= allow_quit
;
552 /* Start should never be at or before end. */
556 /* Now the text before start is an unknown region, and
557 next_change is the position of the next known region. */
558 ceiling
= max (next_change
, ceiling
);
561 /* Stop scanning before the gap. */
562 ceiling
= max (BUFFER_FLOOR_OF (start
- 1), ceiling
);
565 /* The termination address of the dumb loop. */
566 register unsigned char *ceiling_addr
= &FETCH_CHAR (ceiling
);
567 register unsigned char *cursor
= &FETCH_CHAR (start
- 1);
568 unsigned char *base
= cursor
;
570 while (cursor
>= ceiling_addr
)
572 unsigned char *scan_start
= cursor
;
574 while (*cursor
!= target
&& --cursor
>= ceiling_addr
)
577 /* If we're looking for newlines, cache the fact that
578 the region from after the cursor to start is free of them. */
579 if (target
== '\n' && newline_cache
)
580 know_region_cache (current_buffer
, newline_cache
,
581 start
+ cursor
- base
,
582 start
+ scan_start
- base
);
584 /* Did we find the target character? */
585 if (cursor
>= ceiling_addr
)
590 return (start
+ cursor
- base
);
596 start
+= cursor
- base
;
602 *shortage
= count
* direction
;
607 find_next_newline_no_quit (from
, cnt
)
608 register int from
, cnt
;
610 return scan_buffer ('\n', from
, 0, cnt
, (int *) 0, 0);
614 find_next_newline (from
, cnt
)
615 register int from
, cnt
;
617 return scan_buffer ('\n', from
, 0, cnt
, (int *) 0, 1);
621 /* Like find_next_newline, but returns position before the newline,
622 not after, and only search up to TO. This isn't just
623 find_next_newline (...)-1, because you might hit TO. */
625 find_before_next_newline (from
, to
, cnt
)
629 int pos
= scan_buffer ('\n', from
, to
, cnt
, &shortage
, 1);
637 Lisp_Object
skip_chars ();
639 DEFUN ("skip-chars-forward", Fskip_chars_forward
, Sskip_chars_forward
, 1, 2, 0,
640 "Move point forward, stopping before a char not in STRING, or at pos LIM.\n\
641 STRING is like the inside of a `[...]' in a regular expression\n\
642 except that `]' is never special and `\\' quotes `^', `-' or `\\'.\n\
643 Thus, with arg \"a-zA-Z\", this skips letters stopping before first nonletter.\n\
644 With arg \"^a-zA-Z\", skips nonletters stopping before first letter.\n\
645 Returns the distance traveled, either zero or positive.")
647 Lisp_Object string
, lim
;
649 return skip_chars (1, 0, string
, lim
);
652 DEFUN ("skip-chars-backward", Fskip_chars_backward
, Sskip_chars_backward
, 1, 2, 0,
653 "Move point backward, stopping after a char not in STRING, or at pos LIM.\n\
654 See `skip-chars-forward' for details.\n\
655 Returns the distance traveled, either zero or negative.")
657 Lisp_Object string
, lim
;
659 return skip_chars (0, 0, string
, lim
);
662 DEFUN ("skip-syntax-forward", Fskip_syntax_forward
, Sskip_syntax_forward
, 1, 2, 0,
663 "Move point forward across chars in specified syntax classes.\n\
664 SYNTAX is a string of syntax code characters.\n\
665 Stop before a char whose syntax is not in SYNTAX, or at position LIM.\n\
666 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
667 This function returns the distance traveled, either zero or positive.")
669 Lisp_Object syntax
, lim
;
671 return skip_chars (1, 1, syntax
, lim
);
674 DEFUN ("skip-syntax-backward", Fskip_syntax_backward
, Sskip_syntax_backward
, 1, 2, 0,
675 "Move point backward across chars in specified syntax classes.\n\
676 SYNTAX is a string of syntax code characters.\n\
677 Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.\n\
678 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
679 This function returns the distance traveled, either zero or negative.")
681 Lisp_Object syntax
, lim
;
683 return skip_chars (0, 1, syntax
, lim
);
687 skip_chars (forwardp
, syntaxp
, string
, lim
)
688 int forwardp
, syntaxp
;
689 Lisp_Object string
, lim
;
691 register unsigned char *p
, *pend
;
692 register unsigned char c
;
693 unsigned char fastmap
[0400];
697 CHECK_STRING (string
, 0);
700 XSETINT (lim
, forwardp
? ZV
: BEGV
);
702 CHECK_NUMBER_COERCE_MARKER (lim
, 1);
704 /* In any case, don't allow scan outside bounds of buffer. */
705 /* jla turned this off, for no known reason.
706 bfox turned the ZV part on, and rms turned the
707 BEGV part back on. */
709 XSETFASTINT (lim
, ZV
);
710 if (XINT (lim
) < BEGV
)
711 XSETFASTINT (lim
, BEGV
);
713 p
= XSTRING (string
)->data
;
714 pend
= p
+ XSTRING (string
)->size
;
715 bzero (fastmap
, sizeof fastmap
);
717 if (p
!= pend
&& *p
== '^')
722 /* Find the characters specified and set their elements of fastmap.
723 If syntaxp, each character counts as itself.
724 Otherwise, handle backslashes and ranges specially */
735 if (p
== pend
) break;
738 if (p
!= pend
&& *p
== '-')
741 if (p
== pend
) break;
754 if (syntaxp
&& fastmap
['-'] != 0)
757 /* If ^ was the first character, complement the fastmap. */
760 for (i
= 0; i
< sizeof fastmap
; i
++)
764 int start_point
= point
;
772 while (point
< XINT (lim
)
773 && fastmap
[(unsigned char) syntax_code_spec
[(int) SYNTAX (FETCH_CHAR (point
))]])
778 while (point
> XINT (lim
)
779 && fastmap
[(unsigned char) syntax_code_spec
[(int) SYNTAX (FETCH_CHAR (point
- 1))]])
787 while (point
< XINT (lim
) && fastmap
[FETCH_CHAR (point
)])
792 while (point
> XINT (lim
) && fastmap
[FETCH_CHAR (point
- 1)])
798 return make_number (point
- start_point
);
802 /* Subroutines of Lisp buffer search functions. */
805 search_command (string
, bound
, noerror
, count
, direction
, RE
, posix
)
806 Lisp_Object string
, bound
, noerror
, count
;
817 CHECK_NUMBER (count
, 3);
821 CHECK_STRING (string
, 0);
823 lim
= n
> 0 ? ZV
: BEGV
;
826 CHECK_NUMBER_COERCE_MARKER (bound
, 1);
828 if (n
> 0 ? lim
< point
: lim
> point
)
829 error ("Invalid search bound (wrong side of point)");
836 np
= search_buffer (string
, point
, lim
, n
, RE
,
837 (!NILP (current_buffer
->case_fold_search
)
838 ? XSTRING (current_buffer
->case_canon_table
)->data
: 0),
839 (!NILP (current_buffer
->case_fold_search
)
840 ? XSTRING (current_buffer
->case_eqv_table
)->data
: 0),
845 return signal_failure (string
);
846 if (!EQ (noerror
, Qt
))
848 if (lim
< BEGV
|| lim
> ZV
)
852 #if 0 /* This would be clean, but maybe programs depend on
853 a value of nil here. */
861 if (np
< BEGV
|| np
> ZV
)
866 return make_number (np
);
870 trivial_regexp_p (regexp
)
873 int len
= XSTRING (regexp
)->size
;
874 unsigned char *s
= XSTRING (regexp
)->data
;
880 case '.': case '*': case '+': case '?': case '[': case '^': case '$':
887 case '|': case '(': case ')': case '`': case '\'': case 'b':
888 case 'B': case '<': case '>': case 'w': case 'W': case 's':
890 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 ((EMACS_INT
) (p_limit
+ infinity
) > (EMACS_INT
) p_limit
)
1180 while ((EMACS_INT
) cursor
<= (EMACS_INT
) p_limit
)
1181 cursor
+= BM_tab
[*cursor
];
1183 while ((unsigned EMACS_INT
) cursor
<= (unsigned EMACS_INT
) p_limit
)
1184 cursor
+= BM_tab
[*cursor
];
1188 if ((EMACS_INT
) (p_limit
+ infinity
) < (EMACS_INT
) p_limit
)
1189 while ((EMACS_INT
) cursor
>= (EMACS_INT
) p_limit
)
1190 cursor
+= BM_tab
[*cursor
];
1192 while ((unsigned EMACS_INT
) cursor
>= (unsigned EMACS_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
] != (trt
!= 0
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 search_regs
.start
= (regoff_t
*) xmalloc (2 * sizeof (regoff_t
));
1314 search_regs
.end
= (regoff_t
*) xmalloc (2 * sizeof (regoff_t
));
1315 search_regs
.num_regs
= 2;
1318 search_regs
.start
[0] = beg
;
1319 search_regs
.end
[0] = beg
+ len
;
1320 XSETBUFFER (last_thing_searched
, current_buffer
);
1323 /* Given a string of words separated by word delimiters,
1324 compute a regexp that matches those exact words
1325 separated by arbitrary punctuation. */
1331 register unsigned char *p
, *o
;
1332 register int i
, len
, punct_count
= 0, word_count
= 0;
1335 CHECK_STRING (string
, 0);
1336 p
= XSTRING (string
)->data
;
1337 len
= XSTRING (string
)->size
;
1339 for (i
= 0; i
< len
; i
++)
1340 if (SYNTAX (p
[i
]) != Sword
)
1343 if (i
> 0 && SYNTAX (p
[i
-1]) == Sword
) word_count
++;
1345 if (SYNTAX (p
[len
-1]) == Sword
) word_count
++;
1346 if (!word_count
) return build_string ("");
1348 val
= make_string (p
, len
- punct_count
+ 5 * (word_count
- 1) + 4);
1350 o
= XSTRING (val
)->data
;
1354 for (i
= 0; i
< len
; i
++)
1355 if (SYNTAX (p
[i
]) == Sword
)
1357 else if (i
> 0 && SYNTAX (p
[i
-1]) == Sword
&& --word_count
)
1372 DEFUN ("search-backward", Fsearch_backward
, Ssearch_backward
, 1, 4,
1373 "sSearch backward: ",
1374 "Search backward from point for STRING.\n\
1375 Set point to the beginning of the occurrence found, and return point.\n\
1376 An optional second argument bounds the search; it is a buffer position.\n\
1377 The match found must not extend before that position.\n\
1378 Optional third argument, if t, means if fail just return nil (no error).\n\
1379 If not nil and not t, position at limit of search and return nil.\n\
1380 Optional fourth argument is repeat count--search for successive occurrences.\n\
1381 See also the functions `match-beginning', `match-end' and `replace-match'.")
1382 (string
, bound
, noerror
, count
)
1383 Lisp_Object string
, bound
, noerror
, count
;
1385 return search_command (string
, bound
, noerror
, count
, -1, 0, 0);
1388 DEFUN ("search-forward", Fsearch_forward
, Ssearch_forward
, 1, 4, "sSearch: ",
1389 "Search forward from point for STRING.\n\
1390 Set point to the end of the occurrence found, and return point.\n\
1391 An optional second argument bounds the search; it is a buffer position.\n\
1392 The match found must not extend after that position. nil is equivalent\n\
1394 Optional third argument, if t, means if fail just return nil (no error).\n\
1395 If not nil and not t, move to limit of search and return nil.\n\
1396 Optional fourth argument is repeat count--search for successive occurrences.\n\
1397 See also the functions `match-beginning', `match-end' and `replace-match'.")
1398 (string
, bound
, noerror
, count
)
1399 Lisp_Object string
, bound
, noerror
, count
;
1401 return search_command (string
, bound
, noerror
, count
, 1, 0, 0);
1404 DEFUN ("word-search-backward", Fword_search_backward
, Sword_search_backward
, 1, 4,
1405 "sWord search backward: ",
1406 "Search backward from point for STRING, ignoring differences in punctuation.\n\
1407 Set point to the beginning of the occurrence found, and return point.\n\
1408 An optional second argument bounds the search; it is a buffer position.\n\
1409 The match found must not extend before that position.\n\
1410 Optional third argument, if t, means if fail just return nil (no error).\n\
1411 If not nil and not t, move to limit of search and return nil.\n\
1412 Optional fourth argument is repeat count--search for successive occurrences.")
1413 (string
, bound
, noerror
, count
)
1414 Lisp_Object string
, bound
, noerror
, count
;
1416 return search_command (wordify (string
), bound
, noerror
, count
, -1, 1, 0);
1419 DEFUN ("word-search-forward", Fword_search_forward
, Sword_search_forward
, 1, 4,
1421 "Search forward from point for STRING, ignoring differences in punctuation.\n\
1422 Set point to the end of the occurrence found, and return point.\n\
1423 An optional second argument bounds the search; it is a buffer position.\n\
1424 The match found must not extend after that position.\n\
1425 Optional third argument, if t, means if fail just return nil (no error).\n\
1426 If not nil and not t, move to limit of search and return nil.\n\
1427 Optional fourth argument is repeat count--search for successive occurrences.")
1428 (string
, bound
, noerror
, count
)
1429 Lisp_Object string
, bound
, noerror
, count
;
1431 return search_command (wordify (string
), bound
, noerror
, count
, 1, 1, 0);
1434 DEFUN ("re-search-backward", Fre_search_backward
, Sre_search_backward
, 1, 4,
1435 "sRE search backward: ",
1436 "Search backward from point for match for regular expression REGEXP.\n\
1437 Set point to the beginning of the match, and return point.\n\
1438 The match found is the one starting last in the buffer\n\
1439 and yet ending before the origin of the search.\n\
1440 An optional second argument bounds the search; it is a buffer position.\n\
1441 The match found must start at or after that position.\n\
1442 Optional third argument, if t, means if fail just return nil (no error).\n\
1443 If not nil and not t, move to limit of search and return nil.\n\
1444 Optional fourth argument is repeat count--search for successive occurrences.\n\
1445 See also the functions `match-beginning', `match-end' and `replace-match'.")
1446 (regexp
, bound
, noerror
, count
)
1447 Lisp_Object regexp
, bound
, noerror
, count
;
1449 return search_command (regexp
, bound
, noerror
, count
, -1, 1, 0);
1452 DEFUN ("re-search-forward", Fre_search_forward
, Sre_search_forward
, 1, 4,
1454 "Search forward from point for regular expression REGEXP.\n\
1455 Set point to the end of the occurrence found, and return point.\n\
1456 An optional second argument bounds the search; it is a buffer position.\n\
1457 The match found must not extend after that position.\n\
1458 Optional third argument, if t, means if fail just return nil (no error).\n\
1459 If not nil and not t, move to limit of search and return nil.\n\
1460 Optional fourth argument is repeat count--search for successive occurrences.\n\
1461 See also the functions `match-beginning', `match-end' and `replace-match'.")
1462 (regexp
, bound
, noerror
, count
)
1463 Lisp_Object regexp
, bound
, noerror
, count
;
1465 return search_command (regexp
, bound
, noerror
, count
, 1, 1, 0);
1468 DEFUN ("posix-search-backward", Fposix_search_backward
, Sposix_search_backward
, 1, 4,
1469 "sPosix search backward: ",
1470 "Search backward from point for match for regular expression REGEXP.\n\
1471 Find the longest match in accord with Posix regular expression rules.\n\
1472 Set point to the beginning of the match, and return point.\n\
1473 The match found is the one starting last in the buffer\n\
1474 and yet ending before the origin of the search.\n\
1475 An optional second argument bounds the search; it is a buffer position.\n\
1476 The match found must start at or after that position.\n\
1477 Optional third argument, if t, means if fail just return nil (no error).\n\
1478 If not nil and not t, move to limit of search and return nil.\n\
1479 Optional fourth argument is repeat count--search for successive occurrences.\n\
1480 See also the functions `match-beginning', `match-end' and `replace-match'.")
1481 (regexp
, bound
, noerror
, count
)
1482 Lisp_Object regexp
, bound
, noerror
, count
;
1484 return search_command (regexp
, bound
, noerror
, count
, -1, 1, 1);
1487 DEFUN ("posix-search-forward", Fposix_search_forward
, Sposix_search_forward
, 1, 4,
1489 "Search forward from point for regular expression REGEXP.\n\
1490 Find the longest match in accord with Posix regular expression rules.\n\
1491 Set point to the end of the occurrence found, and return point.\n\
1492 An optional second argument bounds the search; it is a buffer position.\n\
1493 The match found must not extend after that position.\n\
1494 Optional third argument, if t, means if fail just return nil (no error).\n\
1495 If not nil and not t, move to limit of search and return nil.\n\
1496 Optional fourth argument is repeat count--search for successive occurrences.\n\
1497 See also the functions `match-beginning', `match-end' and `replace-match'.")
1498 (regexp
, bound
, noerror
, count
)
1499 Lisp_Object regexp
, bound
, noerror
, count
;
1501 return search_command (regexp
, bound
, noerror
, count
, 1, 1, 1);
1504 DEFUN ("replace-match", Freplace_match
, Sreplace_match
, 1, 4, 0,
1505 "Replace text matched by last search with NEWTEXT.\n\
1506 If second arg FIXEDCASE is non-nil, do not alter case of replacement text.\n\
1507 Otherwise maybe capitalize the whole text, or maybe just word initials,\n\
1508 based on the replaced text.\n\
1509 If the replaced text has only capital letters\n\
1510 and has at least one multiletter word, convert NEWTEXT to all caps.\n\
1511 If the replaced text has at least one word starting with a capital letter,\n\
1512 then capitalize each word in NEWTEXT.\n\n\
1513 If third arg LITERAL is non-nil, insert NEWTEXT literally.\n\
1514 Otherwise treat `\\' as special:\n\
1515 `\\&' in NEWTEXT means substitute original matched text.\n\
1516 `\\N' means substitute what matched the Nth `\\(...\\)'.\n\
1517 If Nth parens didn't match, substitute nothing.\n\
1518 `\\\\' means insert one `\\'.\n\
1519 FIXEDCASE and LITERAL are optional arguments.\n\
1520 Leaves point at end of replacement text.\n\
1522 The optional fourth argument STRING can be a string to modify.\n\
1523 In that case, this function creates and returns a new string\n\
1524 which is made by replacing the part of STRING that was matched.")
1525 (newtext
, fixedcase
, literal
, string
)
1526 Lisp_Object newtext
, fixedcase
, literal
, string
;
1528 enum { nochange
, all_caps
, cap_initial
} case_action
;
1529 register int pos
, last
;
1530 int some_multiletter_word
;
1533 int some_nonuppercase_initial
;
1534 register int c
, prevc
;
1537 CHECK_STRING (newtext
, 0);
1539 if (! NILP (string
))
1540 CHECK_STRING (string
, 4);
1542 case_action
= nochange
; /* We tried an initialization */
1543 /* but some C compilers blew it */
1545 if (search_regs
.num_regs
<= 0)
1546 error ("replace-match called before any match found");
1550 if (search_regs
.start
[0] < BEGV
1551 || search_regs
.start
[0] > search_regs
.end
[0]
1552 || search_regs
.end
[0] > ZV
)
1553 args_out_of_range (make_number (search_regs
.start
[0]),
1554 make_number (search_regs
.end
[0]));
1558 if (search_regs
.start
[0] < 0
1559 || search_regs
.start
[0] > search_regs
.end
[0]
1560 || search_regs
.end
[0] > XSTRING (string
)->size
)
1561 args_out_of_range (make_number (search_regs
.start
[0]),
1562 make_number (search_regs
.end
[0]));
1565 if (NILP (fixedcase
))
1567 /* Decide how to casify by examining the matched text. */
1569 last
= search_regs
.end
[0];
1571 case_action
= all_caps
;
1573 /* some_multiletter_word is set nonzero if any original word
1574 is more than one letter long. */
1575 some_multiletter_word
= 0;
1577 some_nonuppercase_initial
= 0;
1580 for (pos
= search_regs
.start
[0]; pos
< last
; pos
++)
1583 c
= FETCH_CHAR (pos
);
1585 c
= XSTRING (string
)->data
[pos
];
1589 /* Cannot be all caps if any original char is lower case */
1592 if (SYNTAX (prevc
) != Sword
)
1593 some_nonuppercase_initial
= 1;
1595 some_multiletter_word
= 1;
1597 else if (!NOCASEP (c
))
1600 if (SYNTAX (prevc
) != Sword
)
1603 some_multiletter_word
= 1;
1607 /* If the initial is a caseless word constituent,
1608 treat that like a lowercase initial. */
1609 if (SYNTAX (prevc
) != Sword
)
1610 some_nonuppercase_initial
= 1;
1616 /* Convert to all caps if the old text is all caps
1617 and has at least one multiletter word. */
1618 if (! some_lowercase
&& some_multiletter_word
)
1619 case_action
= all_caps
;
1620 /* Capitalize each word, if the old text has all capitalized words. */
1621 else if (!some_nonuppercase_initial
&& some_multiletter_word
)
1622 case_action
= cap_initial
;
1623 else if (!some_nonuppercase_initial
&& some_uppercase
)
1624 /* Should x -> yz, operating on X, give Yz or YZ?
1625 We'll assume the latter. */
1626 case_action
= all_caps
;
1628 case_action
= nochange
;
1631 /* Do replacement in a string. */
1634 Lisp_Object before
, after
;
1636 before
= Fsubstring (string
, make_number (0),
1637 make_number (search_regs
.start
[0]));
1638 after
= Fsubstring (string
, make_number (search_regs
.end
[0]), Qnil
);
1640 /* Do case substitution into NEWTEXT if desired. */
1644 /* We build up the substituted string in ACCUM. */
1650 for (pos
= 0; pos
< XSTRING (newtext
)->size
; pos
++)
1654 int delbackslash
= 0;
1656 c
= XSTRING (newtext
)->data
[pos
];
1659 c
= XSTRING (newtext
)->data
[++pos
];
1662 substart
= search_regs
.start
[0];
1663 subend
= search_regs
.end
[0];
1665 else if (c
>= '1' && c
<= '9' && c
<= search_regs
.num_regs
+ '0')
1667 if (search_regs
.start
[c
- '0'] >= 0)
1669 substart
= search_regs
.start
[c
- '0'];
1670 subend
= search_regs
.end
[c
- '0'];
1678 if (pos
- 1 != lastpos
+ 1)
1679 middle
= Fsubstring (newtext
,
1680 make_number (lastpos
+ 1),
1681 make_number (pos
- 1));
1684 accum
= concat3 (accum
, middle
,
1685 Fsubstring (string
, make_number (substart
),
1686 make_number (subend
)));
1689 else if (delbackslash
)
1691 middle
= Fsubstring (newtext
, make_number (lastpos
+ 1),
1693 accum
= concat2 (accum
, middle
);
1698 if (pos
!= lastpos
+ 1)
1699 middle
= Fsubstring (newtext
, make_number (lastpos
+ 1),
1704 newtext
= concat2 (accum
, middle
);
1707 if (case_action
== all_caps
)
1708 newtext
= Fupcase (newtext
);
1709 else if (case_action
== cap_initial
)
1710 newtext
= Fupcase_initials (newtext
);
1712 return concat3 (before
, newtext
, after
);
1715 /* We insert the replacement text before the old text, and then
1716 delete the original text. This means that markers at the
1717 beginning or end of the original will float to the corresponding
1718 position in the replacement. */
1719 SET_PT (search_regs
.start
[0]);
1720 if (!NILP (literal
))
1721 Finsert_and_inherit (1, &newtext
);
1724 struct gcpro gcpro1
;
1727 for (pos
= 0; pos
< XSTRING (newtext
)->size
; pos
++)
1729 int offset
= point
- search_regs
.start
[0];
1731 c
= XSTRING (newtext
)->data
[pos
];
1734 c
= XSTRING (newtext
)->data
[++pos
];
1736 Finsert_buffer_substring
1737 (Fcurrent_buffer (),
1738 make_number (search_regs
.start
[0] + offset
),
1739 make_number (search_regs
.end
[0] + offset
));
1740 else if (c
>= '1' && c
<= '9' && c
<= search_regs
.num_regs
+ '0')
1742 if (search_regs
.start
[c
- '0'] >= 1)
1743 Finsert_buffer_substring
1744 (Fcurrent_buffer (),
1745 make_number (search_regs
.start
[c
- '0'] + offset
),
1746 make_number (search_regs
.end
[c
- '0'] + offset
));
1757 inslen
= point
- (search_regs
.start
[0]);
1758 del_range (search_regs
.start
[0] + inslen
, search_regs
.end
[0] + inslen
);
1760 if (case_action
== all_caps
)
1761 Fupcase_region (make_number (point
- inslen
), make_number (point
));
1762 else if (case_action
== cap_initial
)
1763 Fupcase_initials_region (make_number (point
- inslen
), make_number (point
));
1768 match_limit (num
, beginningp
)
1774 CHECK_NUMBER (num
, 0);
1776 if (n
< 0 || n
>= search_regs
.num_regs
)
1777 args_out_of_range (num
, make_number (search_regs
.num_regs
));
1778 if (search_regs
.num_regs
<= 0
1779 || search_regs
.start
[n
] < 0)
1781 return (make_number ((beginningp
) ? search_regs
.start
[n
]
1782 : search_regs
.end
[n
]));
1785 DEFUN ("match-beginning", Fmatch_beginning
, Smatch_beginning
, 1, 1, 0,
1786 "Return position of start of text matched by last search.\n\
1787 NUM specifies which parenthesized expression in the last regexp.\n\
1788 Value is nil if NUMth pair didn't match, or there were less than NUM pairs.\n\
1789 Zero means the entire text matched by the whole regexp or whole string.")
1793 return match_limit (num
, 1);
1796 DEFUN ("match-end", Fmatch_end
, Smatch_end
, 1, 1, 0,
1797 "Return position of end of text matched by last search.\n\
1798 ARG, a number, specifies which parenthesized expression in the last regexp.\n\
1799 Value is nil if ARGth pair didn't match, or there were less than ARG pairs.\n\
1800 Zero means the entire text matched by the whole regexp or whole string.")
1804 return match_limit (num
, 0);
1807 DEFUN ("match-data", Fmatch_data
, Smatch_data
, 0, 0, 0,
1808 "Return a list containing all info on what the last search matched.\n\
1809 Element 2N is `(match-beginning N)'; element 2N + 1 is `(match-end N)'.\n\
1810 All the elements are markers or nil (nil if the Nth pair didn't match)\n\
1811 if the last match was on a buffer; integers or nil if a string was matched.\n\
1812 Use `store-match-data' to reinstate the data in this list.")
1818 if (NILP (last_thing_searched
))
1819 error ("match-data called before any match found");
1821 data
= (Lisp_Object
*) alloca ((2 * search_regs
.num_regs
)
1822 * sizeof (Lisp_Object
));
1825 for (i
= 0; i
< search_regs
.num_regs
; i
++)
1827 int start
= search_regs
.start
[i
];
1830 if (EQ (last_thing_searched
, Qt
))
1832 XSETFASTINT (data
[2 * i
], start
);
1833 XSETFASTINT (data
[2 * i
+ 1], search_regs
.end
[i
]);
1835 else if (BUFFERP (last_thing_searched
))
1837 data
[2 * i
] = Fmake_marker ();
1838 Fset_marker (data
[2 * i
],
1839 make_number (start
),
1840 last_thing_searched
);
1841 data
[2 * i
+ 1] = Fmake_marker ();
1842 Fset_marker (data
[2 * i
+ 1],
1843 make_number (search_regs
.end
[i
]),
1844 last_thing_searched
);
1847 /* last_thing_searched must always be Qt, a buffer, or Qnil. */
1853 data
[2 * i
] = data
[2 * i
+ 1] = Qnil
;
1855 return Flist (2 * len
+ 2, data
);
1859 DEFUN ("store-match-data", Fstore_match_data
, Sstore_match_data
, 1, 1, 0,
1860 "Set internal data on last search match from elements of LIST.\n\
1861 LIST should have been created by calling `match-data' previously.")
1863 register Lisp_Object list
;
1866 register Lisp_Object marker
;
1868 if (running_asynch_code
)
1869 save_search_regs ();
1871 if (!CONSP (list
) && !NILP (list
))
1872 list
= wrong_type_argument (Qconsp
, list
);
1874 /* Unless we find a marker with a buffer in LIST, assume that this
1875 match data came from a string. */
1876 last_thing_searched
= Qt
;
1878 /* Allocate registers if they don't already exist. */
1880 int length
= XFASTINT (Flength (list
)) / 2;
1882 if (length
> search_regs
.num_regs
)
1884 if (search_regs
.num_regs
== 0)
1887 = (regoff_t
*) xmalloc (length
* sizeof (regoff_t
));
1889 = (regoff_t
*) xmalloc (length
* sizeof (regoff_t
));
1894 = (regoff_t
*) xrealloc (search_regs
.start
,
1895 length
* sizeof (regoff_t
));
1897 = (regoff_t
*) xrealloc (search_regs
.end
,
1898 length
* sizeof (regoff_t
));
1901 search_regs
.num_regs
= length
;
1905 for (i
= 0; i
< search_regs
.num_regs
; i
++)
1907 marker
= Fcar (list
);
1910 search_regs
.start
[i
] = -1;
1915 if (MARKERP (marker
))
1917 if (XMARKER (marker
)->buffer
== 0)
1918 XSETFASTINT (marker
, 0);
1920 XSETBUFFER (last_thing_searched
, XMARKER (marker
)->buffer
);
1923 CHECK_NUMBER_COERCE_MARKER (marker
, 0);
1924 search_regs
.start
[i
] = XINT (marker
);
1927 marker
= Fcar (list
);
1928 if (MARKERP (marker
) && XMARKER (marker
)->buffer
== 0)
1929 XSETFASTINT (marker
, 0);
1931 CHECK_NUMBER_COERCE_MARKER (marker
, 0);
1932 search_regs
.end
[i
] = XINT (marker
);
1940 /* If non-zero the match data have been saved in saved_search_regs
1941 during the execution of a sentinel or filter. */
1942 static int search_regs_saved
;
1943 static struct re_registers saved_search_regs
;
1945 /* Called from Flooking_at, Fstring_match, search_buffer, Fstore_match_data
1946 if asynchronous code (filter or sentinel) is running. */
1950 if (!search_regs_saved
)
1952 saved_search_regs
.num_regs
= search_regs
.num_regs
;
1953 saved_search_regs
.start
= search_regs
.start
;
1954 saved_search_regs
.end
= search_regs
.end
;
1955 search_regs
.num_regs
= 0;
1956 search_regs
.start
= 0;
1957 search_regs
.end
= 0;
1959 search_regs_saved
= 1;
1963 /* Called upon exit from filters and sentinels. */
1965 restore_match_data ()
1967 if (search_regs_saved
)
1969 if (search_regs
.num_regs
> 0)
1971 xfree (search_regs
.start
);
1972 xfree (search_regs
.end
);
1974 search_regs
.num_regs
= saved_search_regs
.num_regs
;
1975 search_regs
.start
= saved_search_regs
.start
;
1976 search_regs
.end
= saved_search_regs
.end
;
1978 search_regs_saved
= 0;
1982 /* Quote a string to inactivate reg-expr chars */
1984 DEFUN ("regexp-quote", Fregexp_quote
, Sregexp_quote
, 1, 1, 0,
1985 "Return a regexp string which matches exactly STRING and nothing else.")
1989 register unsigned char *in
, *out
, *end
;
1990 register unsigned char *temp
;
1992 CHECK_STRING (str
, 0);
1994 temp
= (unsigned char *) alloca (XSTRING (str
)->size
* 2);
1996 /* Now copy the data into the new string, inserting escapes. */
1998 in
= XSTRING (str
)->data
;
1999 end
= in
+ XSTRING (str
)->size
;
2002 for (; in
!= end
; in
++)
2004 if (*in
== '[' || *in
== ']'
2005 || *in
== '*' || *in
== '.' || *in
== '\\'
2006 || *in
== '?' || *in
== '+'
2007 || *in
== '^' || *in
== '$')
2012 return make_string (temp
, out
- temp
);
2019 for (i
= 0; i
< REGEXP_CACHE_SIZE
; ++i
)
2021 searchbufs
[i
].buf
.allocated
= 100;
2022 searchbufs
[i
].buf
.buffer
= (unsigned char *) malloc (100);
2023 searchbufs
[i
].buf
.fastmap
= searchbufs
[i
].fastmap
;
2024 searchbufs
[i
].regexp
= Qnil
;
2025 staticpro (&searchbufs
[i
].regexp
);
2026 searchbufs
[i
].next
= (i
== REGEXP_CACHE_SIZE
-1 ? 0 : &searchbufs
[i
+1]);
2028 searchbuf_head
= &searchbufs
[0];
2030 Qsearch_failed
= intern ("search-failed");
2031 staticpro (&Qsearch_failed
);
2032 Qinvalid_regexp
= intern ("invalid-regexp");
2033 staticpro (&Qinvalid_regexp
);
2035 Fput (Qsearch_failed
, Qerror_conditions
,
2036 Fcons (Qsearch_failed
, Fcons (Qerror
, Qnil
)));
2037 Fput (Qsearch_failed
, Qerror_message
,
2038 build_string ("Search failed"));
2040 Fput (Qinvalid_regexp
, Qerror_conditions
,
2041 Fcons (Qinvalid_regexp
, Fcons (Qerror
, Qnil
)));
2042 Fput (Qinvalid_regexp
, Qerror_message
,
2043 build_string ("Invalid regexp"));
2045 last_thing_searched
= Qnil
;
2046 staticpro (&last_thing_searched
);
2048 defsubr (&Slooking_at
);
2049 defsubr (&Sposix_looking_at
);
2050 defsubr (&Sstring_match
);
2051 defsubr (&Sposix_string_match
);
2052 defsubr (&Sskip_chars_forward
);
2053 defsubr (&Sskip_chars_backward
);
2054 defsubr (&Sskip_syntax_forward
);
2055 defsubr (&Sskip_syntax_backward
);
2056 defsubr (&Ssearch_forward
);
2057 defsubr (&Ssearch_backward
);
2058 defsubr (&Sword_search_forward
);
2059 defsubr (&Sword_search_backward
);
2060 defsubr (&Sre_search_forward
);
2061 defsubr (&Sre_search_backward
);
2062 defsubr (&Sposix_search_forward
);
2063 defsubr (&Sposix_search_backward
);
2064 defsubr (&Sreplace_match
);
2065 defsubr (&Smatch_beginning
);
2066 defsubr (&Smatch_end
);
2067 defsubr (&Smatch_data
);
2068 defsubr (&Sstore_match_data
);
2069 defsubr (&Sregexp_quote
);