1 /* String search routines for GNU Emacs.
2 Copyright (C) 1985, 86,87,93,94,97,98, 1999 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. */
27 #include "character.h"
28 #include "region-cache.h"
30 #include "blockinput.h"
31 #include "intervals.h"
33 #include <sys/types.h>
36 #define REGEXP_CACHE_SIZE 20
38 /* If the regexp is non-nil, then the buffer contains the compiled form
39 of that regexp, suitable for searching. */
42 struct regexp_cache
*next
;
44 struct re_pattern_buffer buf
;
46 /* Nonzero means regexp was compiled to do full POSIX backtracking. */
50 /* The instances of that struct. */
51 struct regexp_cache searchbufs
[REGEXP_CACHE_SIZE
];
53 /* The head of the linked list; points to the most recently used buffer. */
54 struct regexp_cache
*searchbuf_head
;
57 /* Every call to re_match, etc., must pass &search_regs as the regs
58 argument unless you can show it is unnecessary (i.e., if re_match
59 is certainly going to be called again before region-around-match
62 Since the registers are now dynamically allocated, we need to make
63 sure not to refer to the Nth register before checking that it has
64 been allocated by checking search_regs.num_regs.
66 The regex code keeps track of whether it has allocated the search
67 buffer using bits in the re_pattern_buffer. This means that whenever
68 you compile a new pattern, it completely forgets whether it has
69 allocated any registers, and will allocate new registers the next
70 time you call a searching or matching function. Therefore, we need
71 to call re_set_registers after compiling a new pattern or after
72 setting the match registers, so that the regex functions will be
73 able to free or re-allocate it properly. */
74 static struct re_registers search_regs
;
76 /* The buffer in which the last search was performed, or
77 Qt if the last search was done in a string;
78 Qnil if no searching has been done yet. */
79 static Lisp_Object last_thing_searched
;
81 /* error condition signaled when regexp compile_pattern fails */
83 Lisp_Object Qinvalid_regexp
;
85 static void set_search_regs ();
86 static void save_search_regs ();
87 static int simple_search ();
88 static int boyer_moore ();
89 static int search_buffer ();
94 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 nil 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.
107 MULTIBYTE is nonzero iff a target of match is a multibyte buffer or
111 compile_pattern_1 (cp
, pattern
, translate
, regp
, posix
, multibyte
)
112 struct regexp_cache
*cp
;
114 Lisp_Object translate
;
115 struct re_registers
*regp
;
123 cp
->buf
.translate
= (! NILP (translate
) ? translate
: make_number (0));
125 cp
->buf
.multibyte
= STRING_MULTIBYTE (pattern
);
126 cp
->buf
.target_multibyte
= multibyte
;
128 old
= re_set_syntax (RE_SYNTAX_EMACS
129 | (posix
? 0 : RE_NO_POSIX_BACKTRACKING
));
130 val
= (char *) re_compile_pattern ((char *) SDATA (pattern
),
131 SBYTES (pattern
), &cp
->buf
);
135 Fsignal (Qinvalid_regexp
, Fcons (build_string (val
), Qnil
));
137 cp
->regexp
= Fcopy_sequence (pattern
);
140 /* Shrink each compiled regexp buffer in the cache
141 to the size actually used right now.
142 This is called from garbage collection. */
145 shrink_regexp_cache ()
147 struct regexp_cache
*cp
;
149 for (cp
= searchbuf_head
; cp
!= 0; cp
= cp
->next
)
151 cp
->buf
.allocated
= cp
->buf
.used
;
153 = (unsigned char *) xrealloc (cp
->buf
.buffer
, cp
->buf
.used
);
157 /* Compile a regexp if necessary, but first check to see if there's one in
159 PATTERN is the pattern to compile.
160 TRANSLATE is a translation table for ignoring case, or nil for none.
161 REGP is the structure that says where to store the "register"
162 values that will result from matching this pattern.
163 If it is 0, we should compile the pattern not to record any
164 subexpression bounds.
165 POSIX is nonzero if we want full backtracking (POSIX style)
166 for this pattern. 0 means backtrack only enough to get a valid match. */
168 struct re_pattern_buffer
*
169 compile_pattern (pattern
, regp
, translate
, posix
, multibyte
)
171 struct re_registers
*regp
;
172 Lisp_Object translate
;
173 int posix
, multibyte
;
175 struct regexp_cache
*cp
, **cpp
;
177 for (cpp
= &searchbuf_head
; ; cpp
= &cp
->next
)
180 /* Entries are initialized to nil, and may be set to nil by
181 compile_pattern_1 if the pattern isn't valid. Don't apply
182 string accessors in those cases. However, compile_pattern_1
183 is only applied to the cache entry we pick here to reuse. So
184 nil should never appear before a non-nil entry. */
185 if (NILP (cp
->regexp
))
187 if (SCHARS (cp
->regexp
) == SCHARS (pattern
)
188 && STRING_MULTIBYTE (cp
->regexp
) == STRING_MULTIBYTE (pattern
)
189 && !NILP (Fstring_equal (cp
->regexp
, pattern
))
190 && EQ (cp
->buf
.translate
, (! NILP (translate
) ? translate
: make_number (0)))
191 && cp
->posix
== posix
192 && cp
->buf
.target_multibyte
== multibyte
)
195 /* If we're at the end of the cache, compile into the nil cell
196 we found, or the last (least recently used) cell with a
201 compile_pattern_1 (cp
, pattern
, translate
, regp
, posix
, multibyte
);
206 /* When we get here, cp (aka *cpp) contains the compiled pattern,
207 either because we found it in the cache or because we just compiled it.
208 Move it to the front of the queue to mark it as most recently used. */
210 cp
->next
= searchbuf_head
;
213 /* Advise the searching functions about the space we have allocated
214 for register data. */
216 re_set_registers (&cp
->buf
, regp
, regp
->num_regs
, regp
->start
, regp
->end
);
221 /* Error condition used for failing searches */
222 Lisp_Object Qsearch_failed
;
228 Fsignal (Qsearch_failed
, Fcons (arg
, Qnil
));
233 looking_at_1 (string
, posix
)
238 unsigned char *p1
, *p2
;
241 struct re_pattern_buffer
*bufp
;
243 if (running_asynch_code
)
246 CHECK_STRING (string
);
247 bufp
= compile_pattern (string
, &search_regs
,
248 (!NILP (current_buffer
->case_fold_search
)
249 ? DOWNCASE_TABLE
: Qnil
),
251 !NILP (current_buffer
->enable_multibyte_characters
));
254 QUIT
; /* Do a pending quit right away, to avoid paradoxical behavior */
256 /* Get pointers and sizes of the two strings
257 that make up the visible portion of the buffer. */
260 s1
= GPT_BYTE
- BEGV_BYTE
;
262 s2
= ZV_BYTE
- GPT_BYTE
;
266 s2
= ZV_BYTE
- BEGV_BYTE
;
271 s1
= ZV_BYTE
- BEGV_BYTE
;
275 re_match_object
= Qnil
;
277 i
= re_match_2 (bufp
, (char *) p1
, s1
, (char *) p2
, s2
,
278 PT_BYTE
- BEGV_BYTE
, &search_regs
,
279 ZV_BYTE
- BEGV_BYTE
);
285 val
= (0 <= i
? Qt
: Qnil
);
287 for (i
= 0; i
< search_regs
.num_regs
; i
++)
288 if (search_regs
.start
[i
] >= 0)
291 = BYTE_TO_CHAR (search_regs
.start
[i
] + BEGV_BYTE
);
293 = BYTE_TO_CHAR (search_regs
.end
[i
] + BEGV_BYTE
);
295 XSETBUFFER (last_thing_searched
, current_buffer
);
299 DEFUN ("looking-at", Flooking_at
, Slooking_at
, 1, 1, 0,
300 doc
: /* Return t if text after point matches regular expression REGEXP.
301 This function modifies the match data that `match-beginning',
302 `match-end' and `match-data' access; save and restore the match
303 data if you want to preserve them. */)
307 return looking_at_1 (regexp
, 0);
310 DEFUN ("posix-looking-at", Fposix_looking_at
, Sposix_looking_at
, 1, 1, 0,
311 doc
: /* Return t if text after point matches regular expression REGEXP.
312 Find the longest match, in accord with Posix regular expression rules.
313 This function modifies the match data that `match-beginning',
314 `match-end' and `match-data' access; save and restore the match
315 data if you want to preserve them. */)
319 return looking_at_1 (regexp
, 1);
323 string_match_1 (regexp
, string
, start
, posix
)
324 Lisp_Object regexp
, string
, start
;
328 struct re_pattern_buffer
*bufp
;
332 if (running_asynch_code
)
335 CHECK_STRING (regexp
);
336 CHECK_STRING (string
);
339 pos
= 0, pos_byte
= 0;
342 int len
= SCHARS (string
);
344 CHECK_NUMBER (start
);
346 if (pos
< 0 && -pos
<= len
)
348 else if (0 > pos
|| pos
> len
)
349 args_out_of_range (string
, start
);
350 pos_byte
= string_char_to_byte (string
, pos
);
353 bufp
= compile_pattern (regexp
, &search_regs
,
354 (!NILP (current_buffer
->case_fold_search
)
355 ? DOWNCASE_TABLE
: Qnil
),
357 STRING_MULTIBYTE (string
));
359 re_match_object
= string
;
361 val
= re_search (bufp
, (char *) SDATA (string
),
362 SBYTES (string
), pos_byte
,
363 SBYTES (string
) - pos_byte
,
366 last_thing_searched
= Qt
;
369 if (val
< 0) return Qnil
;
371 for (i
= 0; i
< search_regs
.num_regs
; i
++)
372 if (search_regs
.start
[i
] >= 0)
375 = string_byte_to_char (string
, search_regs
.start
[i
]);
377 = string_byte_to_char (string
, search_regs
.end
[i
]);
380 return make_number (string_byte_to_char (string
, val
));
383 DEFUN ("string-match", Fstring_match
, Sstring_match
, 2, 3, 0,
384 doc
: /* Return index of start of first match for REGEXP in STRING, or nil.
385 Case is ignored if `case-fold-search' is non-nil in the current buffer.
386 If third arg START is non-nil, start search at that index in STRING.
387 For index of first char beyond the match, do (match-end 0).
388 `match-end' and `match-beginning' also give indices of substrings
389 matched by parenthesis constructs in the pattern.
391 You can use the function `match-string' to extract the substrings
392 matched by the parenthesis constructions in REGEXP. */)
393 (regexp
, string
, start
)
394 Lisp_Object regexp
, string
, start
;
396 return string_match_1 (regexp
, string
, start
, 0);
399 DEFUN ("posix-string-match", Fposix_string_match
, Sposix_string_match
, 2, 3, 0,
400 doc
: /* Return index of start of first match for REGEXP in STRING, or nil.
401 Find the longest match, in accord with Posix regular expression rules.
402 Case is ignored if `case-fold-search' is non-nil in the current buffer.
403 If third arg START is non-nil, start search at that index in STRING.
404 For index of first char beyond the match, do (match-end 0).
405 `match-end' and `match-beginning' also give indices of substrings
406 matched by parenthesis constructs in the pattern. */)
407 (regexp
, string
, start
)
408 Lisp_Object regexp
, string
, start
;
410 return string_match_1 (regexp
, string
, start
, 1);
413 /* Match REGEXP against STRING, searching all of STRING,
414 and return the index of the match, or negative on failure.
415 This does not clobber the match data. */
418 fast_string_match (regexp
, string
)
419 Lisp_Object regexp
, string
;
422 struct re_pattern_buffer
*bufp
;
424 bufp
= compile_pattern (regexp
, 0, Qnil
,
425 0, STRING_MULTIBYTE (string
));
427 re_match_object
= string
;
429 val
= re_search (bufp
, (char *) SDATA (string
),
436 /* Match REGEXP against STRING, searching all of STRING ignoring case,
437 and return the index of the match, or negative on failure.
438 This does not clobber the match data.
439 We assume that STRING contains single-byte characters. */
441 extern Lisp_Object Vascii_downcase_table
;
444 fast_c_string_match_ignore_case (regexp
, string
)
449 struct re_pattern_buffer
*bufp
;
450 int len
= strlen (string
);
452 regexp
= string_make_unibyte (regexp
);
453 re_match_object
= Qt
;
454 bufp
= compile_pattern (regexp
, 0,
455 Vascii_downcase_table
, 0,
458 val
= re_search (bufp
, string
, len
, 0, len
, 0);
463 /* The newline cache: remembering which sections of text have no newlines. */
465 /* If the user has requested newline caching, make sure it's on.
466 Otherwise, make sure it's off.
467 This is our cheezy way of associating an action with the change of
468 state of a buffer-local variable. */
470 newline_cache_on_off (buf
)
473 if (NILP (buf
->cache_long_line_scans
))
475 /* It should be off. */
476 if (buf
->newline_cache
)
478 free_region_cache (buf
->newline_cache
);
479 buf
->newline_cache
= 0;
484 /* It should be on. */
485 if (buf
->newline_cache
== 0)
486 buf
->newline_cache
= new_region_cache ();
491 /* Search for COUNT instances of the character TARGET between START and END.
493 If COUNT is positive, search forwards; END must be >= START.
494 If COUNT is negative, search backwards for the -COUNTth instance;
495 END must be <= START.
496 If COUNT is zero, do anything you please; run rogue, for all I care.
498 If END is zero, use BEGV or ZV instead, as appropriate for the
499 direction indicated by COUNT.
501 If we find COUNT instances, set *SHORTAGE to zero, and return the
502 position after the COUNTth match. Note that for reverse motion
503 this is not the same as the usual convention for Emacs motion commands.
505 If we don't find COUNT instances before reaching END, set *SHORTAGE
506 to the number of TARGETs left unfound, and return END.
508 If ALLOW_QUIT is non-zero, set immediate_quit. That's good to do
509 except when inside redisplay. */
512 scan_buffer (target
, start
, end
, count
, shortage
, allow_quit
)
519 struct region_cache
*newline_cache
;
530 if (! end
) end
= BEGV
;
533 newline_cache_on_off (current_buffer
);
534 newline_cache
= current_buffer
->newline_cache
;
539 immediate_quit
= allow_quit
;
544 /* Our innermost scanning loop is very simple; it doesn't know
545 about gaps, buffer ends, or the newline cache. ceiling is
546 the position of the last character before the next such
547 obstacle --- the last character the dumb search loop should
549 int ceiling_byte
= CHAR_TO_BYTE (end
) - 1;
550 int start_byte
= CHAR_TO_BYTE (start
);
553 /* If we're looking for a newline, consult the newline cache
554 to see where we can avoid some scanning. */
555 if (target
== '\n' && newline_cache
)
559 while (region_cache_forward
560 (current_buffer
, newline_cache
, start_byte
, &next_change
))
561 start_byte
= next_change
;
562 immediate_quit
= allow_quit
;
564 /* START should never be after END. */
565 if (start_byte
> ceiling_byte
)
566 start_byte
= ceiling_byte
;
568 /* Now the text after start is an unknown region, and
569 next_change is the position of the next known region. */
570 ceiling_byte
= min (next_change
- 1, ceiling_byte
);
573 /* The dumb loop can only scan text stored in contiguous
574 bytes. BUFFER_CEILING_OF returns the last character
575 position that is contiguous, so the ceiling is the
576 position after that. */
577 tem
= BUFFER_CEILING_OF (start_byte
);
578 ceiling_byte
= min (tem
, ceiling_byte
);
581 /* The termination address of the dumb loop. */
582 register unsigned char *ceiling_addr
583 = BYTE_POS_ADDR (ceiling_byte
) + 1;
584 register unsigned char *cursor
585 = BYTE_POS_ADDR (start_byte
);
586 unsigned char *base
= cursor
;
588 while (cursor
< ceiling_addr
)
590 unsigned char *scan_start
= cursor
;
593 while (*cursor
!= target
&& ++cursor
< ceiling_addr
)
596 /* If we're looking for newlines, cache the fact that
597 the region from start to cursor is free of them. */
598 if (target
== '\n' && newline_cache
)
599 know_region_cache (current_buffer
, newline_cache
,
600 start_byte
+ scan_start
- base
,
601 start_byte
+ cursor
- base
);
603 /* Did we find the target character? */
604 if (cursor
< ceiling_addr
)
609 return BYTE_TO_CHAR (start_byte
+ cursor
- base
+ 1);
615 start
= BYTE_TO_CHAR (start_byte
+ cursor
- base
);
621 /* The last character to check before the next obstacle. */
622 int ceiling_byte
= CHAR_TO_BYTE (end
);
623 int start_byte
= CHAR_TO_BYTE (start
);
626 /* Consult the newline cache, if appropriate. */
627 if (target
== '\n' && newline_cache
)
631 while (region_cache_backward
632 (current_buffer
, newline_cache
, start_byte
, &next_change
))
633 start_byte
= next_change
;
634 immediate_quit
= allow_quit
;
636 /* Start should never be at or before end. */
637 if (start_byte
<= ceiling_byte
)
638 start_byte
= ceiling_byte
+ 1;
640 /* Now the text before start is an unknown region, and
641 next_change is the position of the next known region. */
642 ceiling_byte
= max (next_change
, ceiling_byte
);
645 /* Stop scanning before the gap. */
646 tem
= BUFFER_FLOOR_OF (start_byte
- 1);
647 ceiling_byte
= max (tem
, ceiling_byte
);
650 /* The termination address of the dumb loop. */
651 register unsigned char *ceiling_addr
= BYTE_POS_ADDR (ceiling_byte
);
652 register unsigned char *cursor
= BYTE_POS_ADDR (start_byte
- 1);
653 unsigned char *base
= cursor
;
655 while (cursor
>= ceiling_addr
)
657 unsigned char *scan_start
= cursor
;
659 while (*cursor
!= target
&& --cursor
>= ceiling_addr
)
662 /* If we're looking for newlines, cache the fact that
663 the region from after the cursor to start is free of them. */
664 if (target
== '\n' && newline_cache
)
665 know_region_cache (current_buffer
, newline_cache
,
666 start_byte
+ cursor
- base
,
667 start_byte
+ scan_start
- base
);
669 /* Did we find the target character? */
670 if (cursor
>= ceiling_addr
)
675 return BYTE_TO_CHAR (start_byte
+ cursor
- base
);
681 start
= BYTE_TO_CHAR (start_byte
+ cursor
- base
);
687 *shortage
= count
* direction
;
691 /* Search for COUNT instances of a line boundary, which means either a
692 newline or (if selective display enabled) a carriage return.
693 Start at START. If COUNT is negative, search backwards.
695 We report the resulting position by calling TEMP_SET_PT_BOTH.
697 If we find COUNT instances. we position after (always after,
698 even if scanning backwards) the COUNTth match, and return 0.
700 If we don't find COUNT instances before reaching the end of the
701 buffer (or the beginning, if scanning backwards), we return
702 the number of line boundaries left unfound, and position at
703 the limit we bumped up against.
705 If ALLOW_QUIT is non-zero, set immediate_quit. That's good to do
706 except in special cases. */
709 scan_newline (start
, start_byte
, limit
, limit_byte
, count
, allow_quit
)
710 int start
, start_byte
;
711 int limit
, limit_byte
;
715 int direction
= ((count
> 0) ? 1 : -1);
717 register unsigned char *cursor
;
720 register int ceiling
;
721 register unsigned char *ceiling_addr
;
723 int old_immediate_quit
= immediate_quit
;
725 /* The code that follows is like scan_buffer
726 but checks for either newline or carriage return. */
731 start_byte
= CHAR_TO_BYTE (start
);
735 while (start_byte
< limit_byte
)
737 ceiling
= BUFFER_CEILING_OF (start_byte
);
738 ceiling
= min (limit_byte
- 1, ceiling
);
739 ceiling_addr
= BYTE_POS_ADDR (ceiling
) + 1;
740 base
= (cursor
= BYTE_POS_ADDR (start_byte
));
743 while (*cursor
!= '\n' && ++cursor
!= ceiling_addr
)
746 if (cursor
!= ceiling_addr
)
750 immediate_quit
= old_immediate_quit
;
751 start_byte
= start_byte
+ cursor
- base
+ 1;
752 start
= BYTE_TO_CHAR (start_byte
);
753 TEMP_SET_PT_BOTH (start
, start_byte
);
757 if (++cursor
== ceiling_addr
)
763 start_byte
+= cursor
- base
;
768 while (start_byte
> limit_byte
)
770 ceiling
= BUFFER_FLOOR_OF (start_byte
- 1);
771 ceiling
= max (limit_byte
, ceiling
);
772 ceiling_addr
= BYTE_POS_ADDR (ceiling
) - 1;
773 base
= (cursor
= BYTE_POS_ADDR (start_byte
- 1) + 1);
776 while (--cursor
!= ceiling_addr
&& *cursor
!= '\n')
779 if (cursor
!= ceiling_addr
)
783 immediate_quit
= old_immediate_quit
;
784 /* Return the position AFTER the match we found. */
785 start_byte
= start_byte
+ cursor
- base
+ 1;
786 start
= BYTE_TO_CHAR (start_byte
);
787 TEMP_SET_PT_BOTH (start
, start_byte
);
794 /* Here we add 1 to compensate for the last decrement
795 of CURSOR, which took it past the valid range. */
796 start_byte
+= cursor
- base
+ 1;
800 TEMP_SET_PT_BOTH (limit
, limit_byte
);
801 immediate_quit
= old_immediate_quit
;
803 return count
* direction
;
807 find_next_newline_no_quit (from
, cnt
)
808 register int from
, cnt
;
810 return scan_buffer ('\n', from
, 0, cnt
, (int *) 0, 0);
813 /* Like find_next_newline, but returns position before the newline,
814 not after, and only search up to TO. This isn't just
815 find_next_newline (...)-1, because you might hit TO. */
818 find_before_next_newline (from
, to
, cnt
)
822 int pos
= scan_buffer ('\n', from
, to
, cnt
, &shortage
, 1);
830 /* Subroutines of Lisp buffer search functions. */
833 search_command (string
, bound
, noerror
, count
, direction
, RE
, posix
)
834 Lisp_Object string
, bound
, noerror
, count
;
845 CHECK_NUMBER (count
);
849 CHECK_STRING (string
);
853 lim
= ZV
, lim_byte
= ZV_BYTE
;
855 lim
= BEGV
, lim_byte
= BEGV_BYTE
;
859 CHECK_NUMBER_COERCE_MARKER (bound
);
861 if (n
> 0 ? lim
< PT
: lim
> PT
)
862 error ("Invalid search bound (wrong side of point)");
864 lim
= ZV
, lim_byte
= ZV_BYTE
;
866 lim
= BEGV
, lim_byte
= BEGV_BYTE
;
868 lim_byte
= CHAR_TO_BYTE (lim
);
871 np
= search_buffer (string
, PT
, PT_BYTE
, lim
, lim_byte
, n
, RE
,
872 (!NILP (current_buffer
->case_fold_search
)
873 ? current_buffer
->case_canon_table
875 (!NILP (current_buffer
->case_fold_search
)
876 ? current_buffer
->case_eqv_table
882 return signal_failure (string
);
883 if (!EQ (noerror
, Qt
))
885 if (lim
< BEGV
|| lim
> ZV
)
887 SET_PT_BOTH (lim
, lim_byte
);
889 #if 0 /* This would be clean, but maybe programs depend on
890 a value of nil here. */
898 if (np
< BEGV
|| np
> ZV
)
903 return make_number (np
);
906 /* Return 1 if REGEXP it matches just one constant string. */
909 trivial_regexp_p (regexp
)
912 int len
= SBYTES (regexp
);
913 unsigned char *s
= SDATA (regexp
);
918 case '.': case '*': case '+': case '?': case '[': case '^': case '$':
925 case '|': case '(': case ')': case '`': case '\'': case 'b':
926 case 'B': case '<': case '>': case 'w': case 'W': case 's':
927 case 'S': case '=': case '{': case '}': case '_':
928 case 'c': case 'C': /* for categoryspec and notcategoryspec */
929 case '1': case '2': case '3': case '4': case '5':
930 case '6': case '7': case '8': case '9':
938 /* Search for the n'th occurrence of STRING in the current buffer,
939 starting at position POS and stopping at position LIM,
940 treating STRING as a literal string if RE is false or as
941 a regular expression if RE is true.
943 If N is positive, searching is forward and LIM must be greater than POS.
944 If N is negative, searching is backward and LIM must be less than POS.
946 Returns -x if x occurrences remain to be found (x > 0),
947 or else the position at the beginning of the Nth occurrence
948 (if searching backward) or the end (if searching forward).
950 POSIX is nonzero if we want full backtracking (POSIX style)
951 for this pattern. 0 means backtrack only enough to get a valid match. */
953 #define TRANSLATE(out, trt, d) \
959 temp = Faref (trt, make_number (d)); \
960 if (INTEGERP (temp)) \
971 search_buffer (string
, pos
, pos_byte
, lim
, lim_byte
, n
,
972 RE
, trt
, inverse_trt
, posix
)
981 Lisp_Object inverse_trt
;
984 int len
= SCHARS (string
);
985 int len_byte
= SBYTES (string
);
988 if (running_asynch_code
)
991 /* Searching 0 times means don't move. */
992 /* Null string is found at starting position. */
993 if (len
== 0 || n
== 0)
995 set_search_regs (pos_byte
, 0);
999 if (RE
&& !trivial_regexp_p (string
))
1001 unsigned char *p1
, *p2
;
1003 struct re_pattern_buffer
*bufp
;
1005 bufp
= compile_pattern (string
, &search_regs
, trt
, posix
,
1006 !NILP (current_buffer
->enable_multibyte_characters
));
1008 immediate_quit
= 1; /* Quit immediately if user types ^G,
1009 because letting this function finish
1010 can take too long. */
1011 QUIT
; /* Do a pending quit right away,
1012 to avoid paradoxical behavior */
1013 /* Get pointers and sizes of the two strings
1014 that make up the visible portion of the buffer. */
1017 s1
= GPT_BYTE
- BEGV_BYTE
;
1019 s2
= ZV_BYTE
- GPT_BYTE
;
1023 s2
= ZV_BYTE
- BEGV_BYTE
;
1028 s1
= ZV_BYTE
- BEGV_BYTE
;
1031 re_match_object
= Qnil
;
1036 val
= re_search_2 (bufp
, (char *) p1
, s1
, (char *) p2
, s2
,
1037 pos_byte
- BEGV_BYTE
, lim_byte
- pos_byte
,
1039 /* Don't allow match past current point */
1040 pos_byte
- BEGV_BYTE
);
1043 matcher_overflow ();
1047 pos_byte
= search_regs
.start
[0] + BEGV_BYTE
;
1048 for (i
= 0; i
< search_regs
.num_regs
; i
++)
1049 if (search_regs
.start
[i
] >= 0)
1051 search_regs
.start
[i
]
1052 = BYTE_TO_CHAR (search_regs
.start
[i
] + BEGV_BYTE
);
1054 = BYTE_TO_CHAR (search_regs
.end
[i
] + BEGV_BYTE
);
1056 XSETBUFFER (last_thing_searched
, current_buffer
);
1057 /* Set pos to the new position. */
1058 pos
= search_regs
.start
[0];
1070 val
= re_search_2 (bufp
, (char *) p1
, s1
, (char *) p2
, s2
,
1071 pos_byte
- BEGV_BYTE
, lim_byte
- pos_byte
,
1073 lim_byte
- BEGV_BYTE
);
1076 matcher_overflow ();
1080 pos_byte
= search_regs
.end
[0] + BEGV_BYTE
;
1081 for (i
= 0; i
< search_regs
.num_regs
; i
++)
1082 if (search_regs
.start
[i
] >= 0)
1084 search_regs
.start
[i
]
1085 = BYTE_TO_CHAR (search_regs
.start
[i
] + BEGV_BYTE
);
1087 = BYTE_TO_CHAR (search_regs
.end
[i
] + BEGV_BYTE
);
1089 XSETBUFFER (last_thing_searched
, current_buffer
);
1090 pos
= search_regs
.end
[0];
1102 else /* non-RE case */
1104 unsigned char *raw_pattern
, *pat
;
1105 int raw_pattern_size
;
1106 int raw_pattern_size_byte
;
1107 unsigned char *patbuf
;
1108 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1109 unsigned char *base_pat
= SDATA (string
);
1110 /* High bits of char; 0 for ASCII characters, (CHAR & ~0x3F)
1111 otherwise. Characters of the same high bits have the same
1112 sequence of bytes but last. To do the BM search, all
1113 characters in STRING must have the same high bits (including
1114 their case translations). */
1115 int char_high_bits
= -1;
1116 int boyer_moore_ok
= 1;
1118 /* MULTIBYTE says whether the text to be searched is multibyte.
1119 We must convert PATTERN to match that, or we will not really
1120 find things right. */
1122 if (multibyte
== STRING_MULTIBYTE (string
))
1124 raw_pattern
= (unsigned char *) SDATA (string
);
1125 raw_pattern_size
= SCHARS (string
);
1126 raw_pattern_size_byte
= SBYTES (string
);
1130 raw_pattern_size
= SCHARS (string
);
1131 raw_pattern_size_byte
1132 = count_size_as_multibyte (SDATA (string
),
1134 raw_pattern
= (unsigned char *) alloca (raw_pattern_size_byte
+ 1);
1135 copy_text (SDATA (string
), raw_pattern
,
1136 SCHARS (string
), 0, 1);
1140 /* Converting multibyte to single-byte.
1142 ??? Perhaps this conversion should be done in a special way
1143 by subtracting nonascii-insert-offset from each non-ASCII char,
1144 so that only the multibyte chars which really correspond to
1145 the chosen single-byte character set can possibly match. */
1146 raw_pattern_size
= SCHARS (string
);
1147 raw_pattern_size_byte
= SCHARS (string
);
1148 raw_pattern
= (unsigned char *) alloca (raw_pattern_size
+ 1);
1149 copy_text (SDATA (string
), raw_pattern
,
1150 SBYTES (string
), 1, 0);
1153 /* Copy and optionally translate the pattern. */
1154 len
= raw_pattern_size
;
1155 len_byte
= raw_pattern_size_byte
;
1156 patbuf
= (unsigned char *) alloca (len
* MAX_MULTIBYTE_LENGTH
);
1158 base_pat
= raw_pattern
;
1163 int c
, translated
, inverse
;
1166 /* If we got here and the RE flag is set, it's because we're
1167 dealing with a regexp known to be trivial, so the backslash
1168 just quotes the next character. */
1169 if (RE
&& *base_pat
== '\\')
1176 c
= STRING_CHAR_AND_LENGTH (base_pat
, len_byte
, in_charlen
);
1178 /* Translate the character, if requested. */
1179 TRANSLATE (translated
, trt
, c
);
1180 TRANSLATE (inverse
, inverse_trt
, c
);
1182 /* Did this char actually get translated?
1183 Would any other char get translated into it? */
1184 if (translated
!= c
|| inverse
!= c
)
1186 /* Keep track of which character set row
1187 contains the characters that need translation. */
1188 int this_high_bit
= ASCII_CHAR_P (c
) ? 0 : (c
& ~0x3F);
1189 int c1
= inverse
!= c
? inverse
: translated
;
1190 int trt_high_bit
= ASCII_CHAR_P (c1
) ? 0 : (c1
& ~0x3F);
1192 if (this_high_bit
!= trt_high_bit
)
1194 else if (char_high_bits
== -1)
1195 char_high_bits
= this_high_bit
;
1196 else if (char_high_bits
!= this_high_bit
)
1197 /* If two different rows appear, needing translation,
1198 then we cannot use boyer_moore search. */
1202 /* Store this character into the translated pattern. */
1203 CHAR_STRING_ADVANCE (translated
, pat
);
1204 base_pat
+= in_charlen
;
1205 len_byte
-= in_charlen
;
1210 /* Unibyte buffer. */
1216 /* If we got here and the RE flag is set, it's because we're
1217 dealing with a regexp known to be trivial, so the backslash
1218 just quotes the next character. */
1219 if (RE
&& *base_pat
== '\\')
1225 TRANSLATE (translated
, trt
, c
);
1226 *pat
++ = translated
;
1230 len_byte
= pat
- patbuf
;
1231 len
= raw_pattern_size
;
1232 pat
= base_pat
= patbuf
;
1235 return boyer_moore (n
, pat
, len
, len_byte
, trt
, inverse_trt
,
1236 pos
, pos_byte
, lim
, lim_byte
,
1239 return simple_search (n
, pat
, len
, len_byte
, trt
,
1240 pos
, pos_byte
, lim
, lim_byte
);
1244 /* Do a simple string search N times for the string PAT,
1245 whose length is LEN/LEN_BYTE,
1246 from buffer position POS/POS_BYTE until LIM/LIM_BYTE.
1247 TRT is the translation table.
1249 Return the character position where the match is found.
1250 Otherwise, if M matches remained to be found, return -M.
1252 This kind of search works regardless of what is in PAT and
1253 regardless of what is in TRT. It is used in cases where
1254 boyer_moore cannot work. */
1257 simple_search (n
, pat
, len
, len_byte
, trt
, pos
, pos_byte
, lim
, lim_byte
)
1265 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
1266 int forward
= n
> 0;
1268 if (lim
> pos
&& multibyte
)
1273 /* Try matching at position POS. */
1275 int this_pos_byte
= pos_byte
;
1277 int this_len_byte
= len_byte
;
1278 unsigned char *p
= pat
;
1279 if (pos
+ len
> lim
)
1282 while (this_len
> 0)
1284 int charlen
, buf_charlen
;
1287 pat_ch
= STRING_CHAR_AND_LENGTH (p
, this_len_byte
, charlen
);
1288 buf_ch
= STRING_CHAR_AND_LENGTH (BYTE_POS_ADDR (this_pos_byte
),
1289 ZV_BYTE
- this_pos_byte
,
1291 TRANSLATE (buf_ch
, trt
, buf_ch
);
1293 if (buf_ch
!= pat_ch
)
1296 this_len_byte
-= charlen
;
1300 this_pos_byte
+= buf_charlen
;
1307 pos_byte
+= len_byte
;
1311 INC_BOTH (pos
, pos_byte
);
1321 /* Try matching at position POS. */
1324 unsigned char *p
= pat
;
1326 if (pos
+ len
> lim
)
1329 while (this_len
> 0)
1332 int buf_ch
= FETCH_BYTE (this_pos
);
1333 TRANSLATE (buf_ch
, trt
, buf_ch
);
1335 if (buf_ch
!= pat_ch
)
1353 /* Backwards search. */
1354 else if (lim
< pos
&& multibyte
)
1359 /* Try matching at position POS. */
1360 int this_pos
= pos
- len
;
1363 int this_len_byte
= len_byte
;
1364 unsigned char *p
= pat
;
1366 if (pos
- len
< lim
)
1368 this_pos_byte
= CHAR_TO_BYTE (this_pos
);
1370 while (this_len
> 0)
1372 int charlen
, buf_charlen
;
1375 pat_ch
= STRING_CHAR_AND_LENGTH (p
, this_len_byte
, charlen
);
1376 buf_ch
= STRING_CHAR_AND_LENGTH (BYTE_POS_ADDR (this_pos_byte
),
1377 ZV_BYTE
- this_pos_byte
,
1379 TRANSLATE (buf_ch
, trt
, buf_ch
);
1381 if (buf_ch
!= pat_ch
)
1384 this_len_byte
-= charlen
;
1387 this_pos_byte
+= buf_charlen
;
1394 pos_byte
-= len_byte
;
1398 DEC_BOTH (pos
, pos_byte
);
1408 /* Try matching at position POS. */
1409 int this_pos
= pos
- len
;
1411 unsigned char *p
= pat
;
1413 if (pos
- len
< lim
)
1416 while (this_len
> 0)
1419 int buf_ch
= FETCH_BYTE (this_pos
);
1420 TRANSLATE (buf_ch
, trt
, buf_ch
);
1422 if (buf_ch
!= pat_ch
)
1444 set_search_regs ((multibyte
? pos_byte
: pos
) - len_byte
, len_byte
);
1446 set_search_regs (multibyte
? pos_byte
: pos
, len_byte
);
1456 /* Do Boyer-Moore search N times for the string PAT,
1457 whose length is LEN/LEN_BYTE,
1458 from buffer position POS/POS_BYTE until LIM/LIM_BYTE.
1459 DIRECTION says which direction we search in.
1460 TRT and INVERSE_TRT are translation tables.
1462 This kind of search works if all the characters in PAT that have
1463 nontrivial translation are the same aside from the last byte. This
1464 makes it possible to translate just the last byte of a character,
1465 and do so after just a simple test of the context.
1467 If that criterion is not satisfied, do not call this function. */
1470 boyer_moore (n
, base_pat
, len
, len_byte
, trt
, inverse_trt
,
1471 pos
, pos_byte
, lim
, lim_byte
, char_high_bits
)
1473 unsigned char *base_pat
;
1476 Lisp_Object inverse_trt
;
1481 int direction
= ((n
> 0) ? 1 : -1);
1482 register int dirlen
;
1483 int infinity
, limit
, stride_for_teases
= 0;
1484 register int *BM_tab
;
1486 register unsigned char *cursor
, *p_limit
;
1488 unsigned char *pat
, *pat_end
;
1489 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
1491 unsigned char simple_translate
[0400];
1492 int translate_prev_byte
= 0;
1493 int translate_anteprev_byte
= 0;
1496 int BM_tab_space
[0400];
1497 BM_tab
= &BM_tab_space
[0];
1499 BM_tab
= (int *) alloca (0400 * sizeof (int));
1501 /* The general approach is that we are going to maintain that we know */
1502 /* the first (closest to the present position, in whatever direction */
1503 /* we're searching) character that could possibly be the last */
1504 /* (furthest from present position) character of a valid match. We */
1505 /* advance the state of our knowledge by looking at that character */
1506 /* and seeing whether it indeed matches the last character of the */
1507 /* pattern. If it does, we take a closer look. If it does not, we */
1508 /* move our pointer (to putative last characters) as far as is */
1509 /* logically possible. This amount of movement, which I call a */
1510 /* stride, will be the length of the pattern if the actual character */
1511 /* appears nowhere in the pattern, otherwise it will be the distance */
1512 /* from the last occurrence of that character to the end of the */
1514 /* As a coding trick, an enormous stride is coded into the table for */
1515 /* characters that match the last character. This allows use of only */
1516 /* a single test, a test for having gone past the end of the */
1517 /* permissible match region, to test for both possible matches (when */
1518 /* the stride goes past the end immediately) and failure to */
1519 /* match (where you get nudged past the end one stride at a time). */
1521 /* Here we make a "mickey mouse" BM table. The stride of the search */
1522 /* is determined only by the last character of the putative match. */
1523 /* If that character does not match, we will stride the proper */
1524 /* distance to propose a match that superimposes it on the last */
1525 /* instance of a character that matches it (per trt), or misses */
1526 /* it entirely if there is none. */
1528 dirlen
= len_byte
* direction
;
1529 infinity
= dirlen
- (lim_byte
+ pos_byte
+ len_byte
+ len_byte
) * direction
;
1531 /* Record position after the end of the pattern. */
1532 pat_end
= base_pat
+ len_byte
;
1533 /* BASE_PAT points to a character that we start scanning from.
1534 It is the first character in a forward search,
1535 the last character in a backward search. */
1537 base_pat
= pat_end
- 1;
1539 BM_tab_base
= BM_tab
;
1541 j
= dirlen
; /* to get it in a register */
1542 /* A character that does not appear in the pattern induces a */
1543 /* stride equal to the pattern length. */
1544 while (BM_tab_base
!= BM_tab
)
1552 /* We use this for translation, instead of TRT itself.
1553 We fill this in to handle the characters that actually
1554 occur in the pattern. Others don't matter anyway! */
1555 bzero (simple_translate
, sizeof simple_translate
);
1556 for (i
= 0; i
< 0400; i
++)
1557 simple_translate
[i
] = i
;
1560 while (i
!= infinity
)
1562 unsigned char *ptr
= base_pat
+ i
;
1570 int this_translated
= 1;
1573 /* Is *PTR the last byte of a character? */
1574 && (pat_end
- ptr
== 1 || CHAR_HEAD_P (ptr
[1])))
1576 unsigned char *charstart
= ptr
;
1577 while (! CHAR_HEAD_P (*charstart
))
1579 untranslated
= STRING_CHAR (charstart
, ptr
- charstart
+ 1);
1581 == (ASCII_CHAR_P (untranslated
) ? 0 : untranslated
& ~0x3F))
1583 TRANSLATE (ch
, trt
, untranslated
);
1584 if (! CHAR_HEAD_P (*ptr
))
1586 translate_prev_byte
= ptr
[-1];
1587 if (! CHAR_HEAD_P (translate_prev_byte
))
1588 translate_anteprev_byte
= ptr
[-2];
1593 this_translated
= 0;
1597 else if (!multibyte
)
1598 TRANSLATE (ch
, trt
, *ptr
);
1602 this_translated
= 0;
1607 j
= (ch
& 0x3F) | 0200;
1609 j
= (unsigned char) ch
;
1612 stride_for_teases
= BM_tab
[j
];
1614 BM_tab
[j
] = dirlen
- i
;
1615 /* A translation table is accompanied by its inverse -- see */
1616 /* comment following downcase_table for details */
1617 if (this_translated
)
1619 int starting_ch
= ch
;
1623 TRANSLATE (ch
, inverse_trt
, ch
);
1625 j
= (ch
& 0x3F) | 0200;
1627 j
= (unsigned char) ch
;
1629 /* For all the characters that map into CH,
1630 set up simple_translate to map the last byte
1632 simple_translate
[j
] = starting_j
;
1633 if (ch
== starting_ch
)
1635 BM_tab
[j
] = dirlen
- i
;
1644 stride_for_teases
= BM_tab
[j
];
1645 BM_tab
[j
] = dirlen
- i
;
1647 /* stride_for_teases tells how much to stride if we get a */
1648 /* match on the far character but are subsequently */
1649 /* disappointed, by recording what the stride would have been */
1650 /* for that character if the last character had been */
1653 infinity
= dirlen
- infinity
;
1654 pos_byte
+= dirlen
- ((direction
> 0) ? direction
: 0);
1655 /* loop invariant - POS_BYTE points at where last char (first
1656 char if reverse) of pattern would align in a possible match. */
1660 unsigned char *tail_end_ptr
;
1662 /* It's been reported that some (broken) compiler thinks that
1663 Boolean expressions in an arithmetic context are unsigned.
1664 Using an explicit ?1:0 prevents this. */
1665 if ((lim_byte
- pos_byte
- ((direction
> 0) ? 1 : 0)) * direction
1667 return (n
* (0 - direction
));
1668 /* First we do the part we can by pointers (maybe nothing) */
1671 limit
= pos_byte
- dirlen
+ direction
;
1674 limit
= BUFFER_CEILING_OF (limit
);
1675 /* LIMIT is now the last (not beyond-last!) value POS_BYTE
1676 can take on without hitting edge of buffer or the gap. */
1677 limit
= min (limit
, pos_byte
+ 20000);
1678 limit
= min (limit
, lim_byte
- 1);
1682 limit
= BUFFER_FLOOR_OF (limit
);
1683 /* LIMIT is now the last (not beyond-last!) value POS_BYTE
1684 can take on without hitting edge of buffer or the gap. */
1685 limit
= max (limit
, pos_byte
- 20000);
1686 limit
= max (limit
, lim_byte
);
1688 tail_end
= BUFFER_CEILING_OF (pos_byte
) + 1;
1689 tail_end_ptr
= BYTE_POS_ADDR (tail_end
);
1691 if ((limit
- pos_byte
) * direction
> 20)
1695 p_limit
= BYTE_POS_ADDR (limit
);
1696 p2
= (cursor
= BYTE_POS_ADDR (pos_byte
));
1697 /* In this loop, pos + cursor - p2 is the surrogate for pos */
1698 while (1) /* use one cursor setting as long as i can */
1700 if (direction
> 0) /* worth duplicating */
1702 /* Use signed comparison if appropriate
1703 to make cursor+infinity sure to be > p_limit.
1704 Assuming that the buffer lies in a range of addresses
1705 that are all "positive" (as ints) or all "negative",
1706 either kind of comparison will work as long
1707 as we don't step by infinity. So pick the kind
1708 that works when we do step by infinity. */
1709 if ((EMACS_INT
) (p_limit
+ infinity
) > (EMACS_INT
) p_limit
)
1710 while ((EMACS_INT
) cursor
<= (EMACS_INT
) p_limit
)
1711 cursor
+= BM_tab
[*cursor
];
1713 while ((EMACS_UINT
) cursor
<= (EMACS_UINT
) p_limit
)
1714 cursor
+= BM_tab
[*cursor
];
1718 if ((EMACS_INT
) (p_limit
+ infinity
) < (EMACS_INT
) p_limit
)
1719 while ((EMACS_INT
) cursor
>= (EMACS_INT
) p_limit
)
1720 cursor
+= BM_tab
[*cursor
];
1722 while ((EMACS_UINT
) cursor
>= (EMACS_UINT
) p_limit
)
1723 cursor
+= BM_tab
[*cursor
];
1725 /* If you are here, cursor is beyond the end of the searched region. */
1726 /* This can happen if you match on the far character of the pattern, */
1727 /* because the "stride" of that character is infinity, a number able */
1728 /* to throw you well beyond the end of the search. It can also */
1729 /* happen if you fail to match within the permitted region and would */
1730 /* otherwise try a character beyond that region */
1731 if ((cursor
- p_limit
) * direction
<= len_byte
)
1732 break; /* a small overrun is genuine */
1733 cursor
-= infinity
; /* large overrun = hit */
1734 i
= dirlen
- direction
;
1737 while ((i
-= direction
) + direction
!= 0)
1740 cursor
-= direction
;
1741 /* Translate only the last byte of a character. */
1743 || ((cursor
== tail_end_ptr
1744 || CHAR_HEAD_P (cursor
[1]))
1745 && (CHAR_HEAD_P (cursor
[0])
1746 || (translate_prev_byte
== cursor
[-1]
1747 && (CHAR_HEAD_P (translate_prev_byte
)
1748 || translate_anteprev_byte
== cursor
[-2])))))
1749 ch
= simple_translate
[*cursor
];
1758 while ((i
-= direction
) + direction
!= 0)
1760 cursor
-= direction
;
1761 if (pat
[i
] != *cursor
)
1765 cursor
+= dirlen
- i
- direction
; /* fix cursor */
1766 if (i
+ direction
== 0)
1770 cursor
-= direction
;
1772 position
= pos_byte
+ cursor
- p2
+ ((direction
> 0)
1773 ? 1 - len_byte
: 0);
1774 set_search_regs (position
, len_byte
);
1776 if ((n
-= direction
) != 0)
1777 cursor
+= dirlen
; /* to resume search */
1779 return ((direction
> 0)
1780 ? search_regs
.end
[0] : search_regs
.start
[0]);
1783 cursor
+= stride_for_teases
; /* <sigh> we lose - */
1785 pos_byte
+= cursor
- p2
;
1788 /* Now we'll pick up a clump that has to be done the hard */
1789 /* way because it covers a discontinuity */
1791 limit
= ((direction
> 0)
1792 ? BUFFER_CEILING_OF (pos_byte
- dirlen
+ 1)
1793 : BUFFER_FLOOR_OF (pos_byte
- dirlen
- 1));
1794 limit
= ((direction
> 0)
1795 ? min (limit
+ len_byte
, lim_byte
- 1)
1796 : max (limit
- len_byte
, lim_byte
));
1797 /* LIMIT is now the last value POS_BYTE can have
1798 and still be valid for a possible match. */
1801 /* This loop can be coded for space rather than */
1802 /* speed because it will usually run only once. */
1803 /* (the reach is at most len + 21, and typically */
1804 /* does not exceed len) */
1805 while ((limit
- pos_byte
) * direction
>= 0)
1806 pos_byte
+= BM_tab
[FETCH_BYTE (pos_byte
)];
1807 /* now run the same tests to distinguish going off the */
1808 /* end, a match or a phony match. */
1809 if ((pos_byte
- limit
) * direction
<= len_byte
)
1810 break; /* ran off the end */
1811 /* Found what might be a match.
1812 Set POS_BYTE back to last (first if reverse) pos. */
1813 pos_byte
-= infinity
;
1814 i
= dirlen
- direction
;
1815 while ((i
-= direction
) + direction
!= 0)
1819 pos_byte
-= direction
;
1820 ptr
= BYTE_POS_ADDR (pos_byte
);
1821 /* Translate only the last byte of a character. */
1823 || ((ptr
== tail_end_ptr
1824 || CHAR_HEAD_P (ptr
[1]))
1825 && (CHAR_HEAD_P (ptr
[0])
1826 || (translate_prev_byte
== ptr
[-1]
1827 && (CHAR_HEAD_P (translate_prev_byte
)
1828 || translate_anteprev_byte
== ptr
[-2])))))
1829 ch
= simple_translate
[*ptr
];
1835 /* Above loop has moved POS_BYTE part or all the way
1836 back to the first pos (last pos if reverse).
1837 Set it once again at the last (first if reverse) char. */
1838 pos_byte
+= dirlen
- i
- direction
;
1839 if (i
+ direction
== 0)
1842 pos_byte
-= direction
;
1844 position
= pos_byte
+ ((direction
> 0) ? 1 - len_byte
: 0);
1846 set_search_regs (position
, len_byte
);
1848 if ((n
-= direction
) != 0)
1849 pos_byte
+= dirlen
; /* to resume search */
1851 return ((direction
> 0)
1852 ? search_regs
.end
[0] : search_regs
.start
[0]);
1855 pos_byte
+= stride_for_teases
;
1858 /* We have done one clump. Can we continue? */
1859 if ((lim_byte
- pos_byte
) * direction
< 0)
1860 return ((0 - n
) * direction
);
1862 return BYTE_TO_CHAR (pos_byte
);
1865 /* Record beginning BEG_BYTE and end BEG_BYTE + NBYTES
1866 for the overall match just found in the current buffer.
1867 Also clear out the match data for registers 1 and up. */
1870 set_search_regs (beg_byte
, nbytes
)
1871 int beg_byte
, nbytes
;
1875 /* Make sure we have registers in which to store
1876 the match position. */
1877 if (search_regs
.num_regs
== 0)
1879 search_regs
.start
= (regoff_t
*) xmalloc (2 * sizeof (regoff_t
));
1880 search_regs
.end
= (regoff_t
*) xmalloc (2 * sizeof (regoff_t
));
1881 search_regs
.num_regs
= 2;
1884 /* Clear out the other registers. */
1885 for (i
= 1; i
< search_regs
.num_regs
; i
++)
1887 search_regs
.start
[i
] = -1;
1888 search_regs
.end
[i
] = -1;
1891 search_regs
.start
[0] = BYTE_TO_CHAR (beg_byte
);
1892 search_regs
.end
[0] = BYTE_TO_CHAR (beg_byte
+ nbytes
);
1893 XSETBUFFER (last_thing_searched
, current_buffer
);
1896 /* Given a string of words separated by word delimiters,
1897 compute a regexp that matches those exact words
1898 separated by arbitrary punctuation. */
1904 register unsigned char *p
, *o
;
1905 register int i
, i_byte
, len
, punct_count
= 0, word_count
= 0;
1910 CHECK_STRING (string
);
1912 len
= SCHARS (string
);
1914 for (i
= 0, i_byte
= 0; i
< len
; )
1918 FETCH_STRING_CHAR_AS_MULTIBYTE_ADVANCE (c
, string
, i
, i_byte
);
1920 if (SYNTAX (c
) != Sword
)
1923 if (i
> 0 && SYNTAX (prev_c
) == Sword
)
1930 if (SYNTAX (prev_c
) == Sword
)
1933 return empty_string
;
1935 adjust
= - punct_count
+ 5 * (word_count
- 1) + 4;
1936 if (STRING_MULTIBYTE (string
))
1937 val
= make_uninit_multibyte_string (len
+ adjust
,
1941 val
= make_uninit_string (len
+ adjust
);
1948 for (i
= 0, i_byte
= 0; i
< len
; )
1951 int i_byte_orig
= i_byte
;
1953 FETCH_STRING_CHAR_AS_MULTIBYTE_ADVANCE (c
, string
, i
, i_byte
);
1955 if (SYNTAX (c
) == Sword
)
1957 bcopy (SDATA (string
) + i_byte_orig
, o
,
1958 i_byte
- i_byte_orig
);
1959 o
+= i_byte
- i_byte_orig
;
1961 else if (i
> 0 && SYNTAX (prev_c
) == Sword
&& --word_count
)
1979 DEFUN ("search-backward", Fsearch_backward
, Ssearch_backward
, 1, 4,
1980 "MSearch backward: ",
1981 doc
: /* Search backward from point for STRING.
1982 Set point to the beginning of the occurrence found, and return point.
1983 An optional second argument bounds the search; it is a buffer position.
1984 The match found must not extend before that position.
1985 Optional third argument, if t, means if fail just return nil (no error).
1986 If not nil and not t, position at limit of search and return nil.
1987 Optional fourth argument is repeat count--search for successive occurrences.
1989 Search case-sensitivity is determined by the value of the variable
1990 `case-fold-search', which see.
1992 See also the functions `match-beginning', `match-end' and `replace-match'. */)
1993 (string
, bound
, noerror
, count
)
1994 Lisp_Object string
, bound
, noerror
, count
;
1996 return search_command (string
, bound
, noerror
, count
, -1, 0, 0);
1999 DEFUN ("search-forward", Fsearch_forward
, Ssearch_forward
, 1, 4, "MSearch: ",
2000 doc
: /* Search forward from point for STRING.
2001 Set point to the end of the occurrence found, and return point.
2002 An optional second argument bounds the search; it is a buffer position.
2003 The match found must not extend after that position. nil is equivalent
2005 Optional third argument, if t, means if fail just return nil (no error).
2006 If not nil and not t, move to limit of search and return nil.
2007 Optional fourth argument is repeat count--search for successive occurrences.
2009 Search case-sensitivity is determined by the value of the variable
2010 `case-fold-search', which see.
2012 See also the functions `match-beginning', `match-end' and `replace-match'. */)
2013 (string
, bound
, noerror
, count
)
2014 Lisp_Object string
, bound
, noerror
, count
;
2016 return search_command (string
, bound
, noerror
, count
, 1, 0, 0);
2019 DEFUN ("word-search-backward", Fword_search_backward
, Sword_search_backward
, 1, 4,
2020 "sWord search backward: ",
2021 doc
: /* Search backward from point for STRING, ignoring differences in punctuation.
2022 Set point to the beginning of the occurrence found, and return point.
2023 An optional second argument bounds the search; it is a buffer position.
2024 The match found must not extend before that position.
2025 Optional third argument, if t, means if fail just return nil (no error).
2026 If not nil and not t, move to limit of search and return nil.
2027 Optional fourth argument is repeat count--search for successive occurrences. */)
2028 (string
, bound
, noerror
, count
)
2029 Lisp_Object string
, bound
, noerror
, count
;
2031 return search_command (wordify (string
), bound
, noerror
, count
, -1, 1, 0);
2034 DEFUN ("word-search-forward", Fword_search_forward
, Sword_search_forward
, 1, 4,
2036 doc
: /* Search forward from point for STRING, ignoring differences in punctuation.
2037 Set point to the end of the occurrence found, and return point.
2038 An optional second argument bounds the search; it is a buffer position.
2039 The match found must not extend after that position.
2040 Optional third argument, if t, means if fail just return nil (no error).
2041 If not nil and not t, move to limit of search and return nil.
2042 Optional fourth argument is repeat count--search for successive occurrences. */)
2043 (string
, bound
, noerror
, count
)
2044 Lisp_Object string
, bound
, noerror
, count
;
2046 return search_command (wordify (string
), bound
, noerror
, count
, 1, 1, 0);
2049 DEFUN ("re-search-backward", Fre_search_backward
, Sre_search_backward
, 1, 4,
2050 "sRE search backward: ",
2051 doc
: /* Search backward from point for match for regular expression REGEXP.
2052 Set point to the beginning of the match, and return point.
2053 The match found is the one starting last in the buffer
2054 and yet ending before the origin of the search.
2055 An optional second argument bounds the search; it is a buffer position.
2056 The match found must start at or after that position.
2057 Optional third argument, if t, means if fail just return nil (no error).
2058 If not nil and not t, move to limit of search and return nil.
2059 Optional fourth argument is repeat count--search for successive occurrences.
2060 See also the functions `match-beginning', `match-end', `match-string',
2061 and `replace-match'. */)
2062 (regexp
, bound
, noerror
, count
)
2063 Lisp_Object regexp
, bound
, noerror
, count
;
2065 return search_command (regexp
, bound
, noerror
, count
, -1, 1, 0);
2068 DEFUN ("re-search-forward", Fre_search_forward
, Sre_search_forward
, 1, 4,
2070 doc
: /* Search forward from point for regular expression REGEXP.
2071 Set point to the end of the occurrence found, and return point.
2072 An optional second argument bounds the search; it is a buffer position.
2073 The match found must not extend after that position.
2074 Optional third argument, if t, means if fail just return nil (no error).
2075 If not nil and not t, move to limit of search and return nil.
2076 Optional fourth argument is repeat count--search for successive occurrences.
2077 See also the functions `match-beginning', `match-end', `match-string',
2078 and `replace-match'. */)
2079 (regexp
, bound
, noerror
, count
)
2080 Lisp_Object regexp
, bound
, noerror
, count
;
2082 return search_command (regexp
, bound
, noerror
, count
, 1, 1, 0);
2085 DEFUN ("posix-search-backward", Fposix_search_backward
, Sposix_search_backward
, 1, 4,
2086 "sPosix search backward: ",
2087 doc
: /* Search backward from point for match for regular expression REGEXP.
2088 Find the longest match in accord with Posix regular expression rules.
2089 Set point to the beginning of the match, and return point.
2090 The match found is the one starting last in the buffer
2091 and yet ending before the origin of the search.
2092 An optional second argument bounds the search; it is a buffer position.
2093 The match found must start at or after that position.
2094 Optional third argument, if t, means if fail just return nil (no error).
2095 If not nil and not t, move to limit of search and return nil.
2096 Optional fourth argument is repeat count--search for successive occurrences.
2097 See also the functions `match-beginning', `match-end', `match-string',
2098 and `replace-match'. */)
2099 (regexp
, bound
, noerror
, count
)
2100 Lisp_Object regexp
, bound
, noerror
, count
;
2102 return search_command (regexp
, bound
, noerror
, count
, -1, 1, 1);
2105 DEFUN ("posix-search-forward", Fposix_search_forward
, Sposix_search_forward
, 1, 4,
2107 doc
: /* Search forward from point for regular expression REGEXP.
2108 Find the longest match in accord with Posix regular expression rules.
2109 Set point to the end of the occurrence found, and return point.
2110 An optional second argument bounds the search; it is a buffer position.
2111 The match found must not extend after that position.
2112 Optional third argument, if t, means if fail just return nil (no error).
2113 If not nil and not t, move to limit of search and return nil.
2114 Optional fourth argument is repeat count--search for successive occurrences.
2115 See also the functions `match-beginning', `match-end', `match-string',
2116 and `replace-match'. */)
2117 (regexp
, bound
, noerror
, count
)
2118 Lisp_Object regexp
, bound
, noerror
, count
;
2120 return search_command (regexp
, bound
, noerror
, count
, 1, 1, 1);
2123 DEFUN ("replace-match", Freplace_match
, Sreplace_match
, 1, 5, 0,
2124 doc
: /* Replace text matched by last search with NEWTEXT.
2125 Leave point at the end of the replacement text.
2127 If second arg FIXEDCASE is non-nil, do not alter case of replacement text.
2128 Otherwise maybe capitalize the whole text, or maybe just word initials,
2129 based on the replaced text.
2130 If the replaced text has only capital letters
2131 and has at least one multiletter word, convert NEWTEXT to all caps.
2132 Otherwise if all words are capitalized in the replaced text,
2133 capitalize each word in NEWTEXT.
2135 If third arg LITERAL is non-nil, insert NEWTEXT literally.
2136 Otherwise treat `\\' as special:
2137 `\\&' in NEWTEXT means substitute original matched text.
2138 `\\N' means substitute what matched the Nth `\\(...\\)'.
2139 If Nth parens didn't match, substitute nothing.
2140 `\\\\' means insert one `\\'.
2141 Case conversion does not apply to these substitutions.
2143 FIXEDCASE and LITERAL are optional arguments.
2145 The optional fourth argument STRING can be a string to modify.
2146 This is meaningful when the previous match was done against STRING,
2147 using `string-match'. When used this way, `replace-match'
2148 creates and returns a new string made by copying STRING and replacing
2149 the part of STRING that was matched.
2151 The optional fifth argument SUBEXP specifies a subexpression;
2152 it says to replace just that subexpression with NEWTEXT,
2153 rather than replacing the entire matched text.
2154 This is, in a vague sense, the inverse of using `\\N' in NEWTEXT;
2155 `\\N' copies subexp N into NEWTEXT, but using N as SUBEXP puts
2156 NEWTEXT in place of subexp N.
2157 This is useful only after a regular expression search or match,
2158 since only regular expressions have distinguished subexpressions. */)
2159 (newtext
, fixedcase
, literal
, string
, subexp
)
2160 Lisp_Object newtext
, fixedcase
, literal
, string
, subexp
;
2162 enum { nochange
, all_caps
, cap_initial
} case_action
;
2163 register int pos
, pos_byte
;
2164 int some_multiletter_word
;
2167 int some_nonuppercase_initial
;
2168 register int c
, prevc
;
2170 int opoint
, newpoint
;
2172 CHECK_STRING (newtext
);
2174 if (! NILP (string
))
2175 CHECK_STRING (string
);
2177 case_action
= nochange
; /* We tried an initialization */
2178 /* but some C compilers blew it */
2180 if (search_regs
.num_regs
<= 0)
2181 error ("replace-match called before any match found");
2187 CHECK_NUMBER (subexp
);
2188 sub
= XINT (subexp
);
2189 if (sub
< 0 || sub
>= search_regs
.num_regs
)
2190 args_out_of_range (subexp
, make_number (search_regs
.num_regs
));
2195 if (search_regs
.start
[sub
] < BEGV
2196 || search_regs
.start
[sub
] > search_regs
.end
[sub
]
2197 || search_regs
.end
[sub
] > ZV
)
2198 args_out_of_range (make_number (search_regs
.start
[sub
]),
2199 make_number (search_regs
.end
[sub
]));
2203 if (search_regs
.start
[sub
] < 0
2204 || search_regs
.start
[sub
] > search_regs
.end
[sub
]
2205 || search_regs
.end
[sub
] > SCHARS (string
))
2206 args_out_of_range (make_number (search_regs
.start
[sub
]),
2207 make_number (search_regs
.end
[sub
]));
2210 if (NILP (fixedcase
))
2212 /* Decide how to casify by examining the matched text. */
2215 pos
= search_regs
.start
[sub
];
2216 last
= search_regs
.end
[sub
];
2219 pos_byte
= CHAR_TO_BYTE (pos
);
2221 pos_byte
= string_char_to_byte (string
, pos
);
2224 case_action
= all_caps
;
2226 /* some_multiletter_word is set nonzero if any original word
2227 is more than one letter long. */
2228 some_multiletter_word
= 0;
2230 some_nonuppercase_initial
= 0;
2237 c
= FETCH_CHAR_AS_MULTIBYTE (pos_byte
);
2238 INC_BOTH (pos
, pos_byte
);
2241 FETCH_STRING_CHAR_AS_MULTIBYTE_ADVANCE (c
, string
, pos
, pos_byte
);
2245 /* Cannot be all caps if any original char is lower case */
2248 if (SYNTAX (prevc
) != Sword
)
2249 some_nonuppercase_initial
= 1;
2251 some_multiletter_word
= 1;
2253 else if (!NOCASEP (c
))
2256 if (SYNTAX (prevc
) != Sword
)
2259 some_multiletter_word
= 1;
2263 /* If the initial is a caseless word constituent,
2264 treat that like a lowercase initial. */
2265 if (SYNTAX (prevc
) != Sword
)
2266 some_nonuppercase_initial
= 1;
2272 /* Convert to all caps if the old text is all caps
2273 and has at least one multiletter word. */
2274 if (! some_lowercase
&& some_multiletter_word
)
2275 case_action
= all_caps
;
2276 /* Capitalize each word, if the old text has all capitalized words. */
2277 else if (!some_nonuppercase_initial
&& some_multiletter_word
)
2278 case_action
= cap_initial
;
2279 else if (!some_nonuppercase_initial
&& some_uppercase
)
2280 /* Should x -> yz, operating on X, give Yz or YZ?
2281 We'll assume the latter. */
2282 case_action
= all_caps
;
2284 case_action
= nochange
;
2287 /* Do replacement in a string. */
2290 Lisp_Object before
, after
;
2292 before
= Fsubstring (string
, make_number (0),
2293 make_number (search_regs
.start
[sub
]));
2294 after
= Fsubstring (string
, make_number (search_regs
.end
[sub
]), Qnil
);
2296 /* Substitute parts of the match into NEWTEXT
2301 int lastpos_byte
= 0;
2302 /* We build up the substituted string in ACCUM. */
2305 int length
= SBYTES (newtext
);
2309 for (pos_byte
= 0, pos
= 0; pos_byte
< length
;)
2313 int delbackslash
= 0;
2315 FETCH_STRING_CHAR_ADVANCE (c
, newtext
, pos
, pos_byte
);
2319 FETCH_STRING_CHAR_ADVANCE (c
, newtext
, pos
, pos_byte
);
2323 substart
= search_regs
.start
[sub
];
2324 subend
= search_regs
.end
[sub
];
2326 else if (c
>= '1' && c
<= '9')
2328 if (search_regs
.start
[c
- '0'] >= 0
2329 && c
<= search_regs
.num_regs
+ '0')
2331 substart
= search_regs
.start
[c
- '0'];
2332 subend
= search_regs
.end
[c
- '0'];
2336 /* If that subexp did not match,
2337 replace \\N with nothing. */
2345 error ("Invalid use of `\\' in replacement text");
2349 if (pos
- 2 != lastpos
)
2350 middle
= substring_both (newtext
, lastpos
,
2352 pos
- 2, pos_byte
- 2);
2355 accum
= concat3 (accum
, middle
,
2357 make_number (substart
),
2358 make_number (subend
)));
2360 lastpos_byte
= pos_byte
;
2362 else if (delbackslash
)
2364 middle
= substring_both (newtext
, lastpos
,
2366 pos
- 1, pos_byte
- 1);
2368 accum
= concat2 (accum
, middle
);
2370 lastpos_byte
= pos_byte
;
2375 middle
= substring_both (newtext
, lastpos
,
2381 newtext
= concat2 (accum
, middle
);
2384 /* Do case substitution in NEWTEXT if desired. */
2385 if (case_action
== all_caps
)
2386 newtext
= Fupcase (newtext
);
2387 else if (case_action
== cap_initial
)
2388 newtext
= Fupcase_initials (newtext
);
2390 return concat3 (before
, newtext
, after
);
2393 /* Record point, then move (quietly) to the start of the match. */
2394 if (PT
>= search_regs
.end
[sub
])
2396 else if (PT
> search_regs
.start
[sub
])
2397 opoint
= search_regs
.end
[sub
] - ZV
;
2401 /* If we want non-literal replacement,
2402 perform substitution on the replacement string. */
2405 int length
= SBYTES (newtext
);
2406 unsigned char *substed
;
2407 int substed_alloc_size
, substed_len
;
2408 int buf_multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
2409 int str_multibyte
= STRING_MULTIBYTE (newtext
);
2410 Lisp_Object rev_tbl
;
2411 int really_changed
= 0;
2415 substed_alloc_size
= length
* 2 + 100;
2416 substed
= (unsigned char *) xmalloc (substed_alloc_size
+ 1);
2419 /* Go thru NEWTEXT, producing the actual text to insert in
2420 SUBSTED while adjusting multibyteness to that of the current
2423 for (pos_byte
= 0, pos
= 0; pos_byte
< length
;)
2425 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
2426 unsigned char *add_stuff
= NULL
;
2432 FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c
, newtext
, pos
, pos_byte
);
2434 c
= multibyte_char_to_unibyte (c
, rev_tbl
);
2438 /* Note that we don't have to increment POS. */
2439 c
= SREF (newtext
, pos_byte
++);
2441 c
= unibyte_char_to_multibyte (c
);
2444 /* Either set ADD_STUFF and ADD_LEN to the text to put in SUBSTED,
2445 or set IDX to a match index, which means put that part
2446 of the buffer text into SUBSTED. */
2454 FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c
, newtext
,
2456 if (!buf_multibyte
&& !ASCII_CHAR_P (c
))
2457 c
= multibyte_char_to_unibyte (c
, rev_tbl
);
2461 c
= SREF (newtext
, pos_byte
++);
2463 c
= unibyte_char_to_multibyte (c
);
2468 else if (c
>= '1' && c
<= '9' && c
<= search_regs
.num_regs
+ '0')
2470 if (search_regs
.start
[c
- '0'] >= 1)
2474 add_len
= 1, add_stuff
= "\\";
2478 error ("Invalid use of `\\' in replacement text");
2483 add_len
= CHAR_STRING (c
, str
);
2487 /* If we want to copy part of a previous match,
2488 set up ADD_STUFF and ADD_LEN to point to it. */
2491 int begbyte
= CHAR_TO_BYTE (search_regs
.start
[idx
]);
2492 add_len
= CHAR_TO_BYTE (search_regs
.end
[idx
]) - begbyte
;
2493 if (search_regs
.start
[idx
] < GPT
&& GPT
< search_regs
.end
[idx
])
2494 move_gap (search_regs
.start
[idx
]);
2495 add_stuff
= BYTE_POS_ADDR (begbyte
);
2498 /* Now the stuff we want to add to SUBSTED
2499 is invariably ADD_LEN bytes starting at ADD_STUFF. */
2501 /* Make sure SUBSTED is big enough. */
2502 if (substed_len
+ add_len
>= substed_alloc_size
)
2504 substed_alloc_size
= substed_len
+ add_len
+ 500;
2505 substed
= (unsigned char *) xrealloc (substed
,
2506 substed_alloc_size
+ 1);
2509 /* Now add to the end of SUBSTED. */
2512 bcopy (add_stuff
, substed
+ substed_len
, add_len
);
2513 substed_len
+= add_len
;
2521 int nchars
= multibyte_chars_in_text (substed
, substed_len
);
2523 newtext
= make_multibyte_string (substed
, nchars
, substed_len
);
2526 newtext
= make_unibyte_string (substed
, substed_len
);
2531 /* Replace the old text with the new in the cleanest possible way. */
2532 replace_range (search_regs
.start
[sub
], search_regs
.end
[sub
],
2534 newpoint
= search_regs
.start
[sub
] + SCHARS (newtext
);
2536 if (case_action
== all_caps
)
2537 Fupcase_region (make_number (search_regs
.start
[sub
]),
2538 make_number (newpoint
));
2539 else if (case_action
== cap_initial
)
2540 Fupcase_initials_region (make_number (search_regs
.start
[sub
]),
2541 make_number (newpoint
));
2543 /* Adjust search data for this change. */
2545 int oldend
= search_regs
.end
[sub
];
2546 int change
= newpoint
- search_regs
.end
[sub
];
2549 for (i
= 0; i
< search_regs
.num_regs
; i
++)
2551 if (search_regs
.start
[i
] > oldend
)
2552 search_regs
.start
[i
] += change
;
2553 if (search_regs
.end
[i
] > oldend
)
2554 search_regs
.end
[i
] += change
;
2558 /* Put point back where it was in the text. */
2560 TEMP_SET_PT (opoint
+ ZV
);
2562 TEMP_SET_PT (opoint
);
2564 /* Now move point "officially" to the start of the inserted replacement. */
2565 move_if_not_intangible (newpoint
);
2571 match_limit (num
, beginningp
)
2580 args_out_of_range (num
, 0);
2581 if (search_regs
.num_regs
<= 0)
2582 error ("No match data, because no search succeeded");
2583 if (n
>= search_regs
.num_regs
2584 || search_regs
.start
[n
] < 0)
2586 return (make_number ((beginningp
) ? search_regs
.start
[n
]
2587 : search_regs
.end
[n
]));
2590 DEFUN ("match-beginning", Fmatch_beginning
, Smatch_beginning
, 1, 1, 0,
2591 doc
: /* Return position of start of text matched by last search.
2592 SUBEXP, a number, specifies which parenthesized expression in the last
2594 Value is nil if SUBEXPth pair didn't match, or there were less than
2596 Zero means the entire text matched by the whole regexp or whole string. */)
2600 return match_limit (subexp
, 1);
2603 DEFUN ("match-end", Fmatch_end
, Smatch_end
, 1, 1, 0,
2604 doc
: /* Return position of end of text matched by last search.
2605 SUBEXP, a number, specifies which parenthesized expression in the last
2607 Value is nil if SUBEXPth pair didn't match, or there were less than
2609 Zero means the entire text matched by the whole regexp or whole string. */)
2613 return match_limit (subexp
, 0);
2616 DEFUN ("match-data", Fmatch_data
, Smatch_data
, 0, 2, 0,
2617 doc
: /* Return a list containing all info on what the last search matched.
2618 Element 2N is `(match-beginning N)'; element 2N + 1 is `(match-end N)'.
2619 All the elements are markers or nil (nil if the Nth pair didn't match)
2620 if the last match was on a buffer; integers or nil if a string was matched.
2621 Use `store-match-data' to reinstate the data in this list.
2623 If INTEGERS (the optional first argument) is non-nil, always use integers
2624 \(rather than markers) to represent buffer positions.
2625 If REUSE is a list, reuse it as part of the value. If REUSE is long enough
2626 to hold all the values, and if INTEGERS is non-nil, no consing is done.
2628 Return value is undefined if the last search failed. */)
2630 Lisp_Object integers
, reuse
;
2632 Lisp_Object tail
, prev
;
2636 if (NILP (last_thing_searched
))
2641 data
= (Lisp_Object
*) alloca ((2 * search_regs
.num_regs
)
2642 * sizeof (Lisp_Object
));
2645 for (i
= 0; i
< search_regs
.num_regs
; i
++)
2647 int start
= search_regs
.start
[i
];
2650 if (EQ (last_thing_searched
, Qt
)
2651 || ! NILP (integers
))
2653 XSETFASTINT (data
[2 * i
], start
);
2654 XSETFASTINT (data
[2 * i
+ 1], search_regs
.end
[i
]);
2656 else if (BUFFERP (last_thing_searched
))
2658 data
[2 * i
] = Fmake_marker ();
2659 Fset_marker (data
[2 * i
],
2660 make_number (start
),
2661 last_thing_searched
);
2662 data
[2 * i
+ 1] = Fmake_marker ();
2663 Fset_marker (data
[2 * i
+ 1],
2664 make_number (search_regs
.end
[i
]),
2665 last_thing_searched
);
2668 /* last_thing_searched must always be Qt, a buffer, or Qnil. */
2674 data
[2 * i
] = data
[2 * i
+ 1] = Qnil
;
2677 /* If REUSE is not usable, cons up the values and return them. */
2678 if (! CONSP (reuse
))
2679 return Flist (2 * len
+ 2, data
);
2681 /* If REUSE is a list, store as many value elements as will fit
2682 into the elements of REUSE. */
2683 for (i
= 0, tail
= reuse
; CONSP (tail
);
2684 i
++, tail
= XCDR (tail
))
2686 if (i
< 2 * len
+ 2)
2687 XSETCAR (tail
, data
[i
]);
2689 XSETCAR (tail
, Qnil
);
2693 /* If we couldn't fit all value elements into REUSE,
2694 cons up the rest of them and add them to the end of REUSE. */
2695 if (i
< 2 * len
+ 2)
2696 XSETCDR (prev
, Flist (2 * len
+ 2 - i
, data
+ i
));
2702 DEFUN ("set-match-data", Fset_match_data
, Sset_match_data
, 1, 1, 0,
2703 doc
: /* Set internal data on last search match from elements of LIST.
2704 LIST should have been created by calling `match-data' previously. */)
2706 register Lisp_Object list
;
2709 register Lisp_Object marker
;
2711 if (running_asynch_code
)
2712 save_search_regs ();
2714 if (!CONSP (list
) && !NILP (list
))
2715 list
= wrong_type_argument (Qconsp
, list
);
2717 /* Unless we find a marker with a buffer in LIST, assume that this
2718 match data came from a string. */
2719 last_thing_searched
= Qt
;
2721 /* Allocate registers if they don't already exist. */
2723 int length
= XFASTINT (Flength (list
)) / 2;
2725 if (length
> search_regs
.num_regs
)
2727 if (search_regs
.num_regs
== 0)
2730 = (regoff_t
*) xmalloc (length
* sizeof (regoff_t
));
2732 = (regoff_t
*) xmalloc (length
* sizeof (regoff_t
));
2737 = (regoff_t
*) xrealloc (search_regs
.start
,
2738 length
* sizeof (regoff_t
));
2740 = (regoff_t
*) xrealloc (search_regs
.end
,
2741 length
* sizeof (regoff_t
));
2744 for (i
= search_regs
.num_regs
; i
< length
; i
++)
2745 search_regs
.start
[i
] = -1;
2747 search_regs
.num_regs
= length
;
2751 for (i
= 0; i
< search_regs
.num_regs
; i
++)
2753 marker
= Fcar (list
);
2756 search_regs
.start
[i
] = -1;
2763 if (MARKERP (marker
))
2765 if (XMARKER (marker
)->buffer
== 0)
2766 XSETFASTINT (marker
, 0);
2768 XSETBUFFER (last_thing_searched
, XMARKER (marker
)->buffer
);
2771 CHECK_NUMBER_COERCE_MARKER (marker
);
2772 from
= XINT (marker
);
2775 marker
= Fcar (list
);
2776 if (MARKERP (marker
) && XMARKER (marker
)->buffer
== 0)
2777 XSETFASTINT (marker
, 0);
2779 CHECK_NUMBER_COERCE_MARKER (marker
);
2780 search_regs
.start
[i
] = from
;
2781 search_regs
.end
[i
] = XINT (marker
);
2789 /* If non-zero the match data have been saved in saved_search_regs
2790 during the execution of a sentinel or filter. */
2791 static int search_regs_saved
;
2792 static struct re_registers saved_search_regs
;
2794 /* Called from Flooking_at, Fstring_match, search_buffer, Fstore_match_data
2795 if asynchronous code (filter or sentinel) is running. */
2799 if (!search_regs_saved
)
2801 saved_search_regs
.num_regs
= search_regs
.num_regs
;
2802 saved_search_regs
.start
= search_regs
.start
;
2803 saved_search_regs
.end
= search_regs
.end
;
2804 search_regs
.num_regs
= 0;
2805 search_regs
.start
= 0;
2806 search_regs
.end
= 0;
2808 search_regs_saved
= 1;
2812 /* Called upon exit from filters and sentinels. */
2814 restore_match_data ()
2816 if (search_regs_saved
)
2818 if (search_regs
.num_regs
> 0)
2820 xfree (search_regs
.start
);
2821 xfree (search_regs
.end
);
2823 search_regs
.num_regs
= saved_search_regs
.num_regs
;
2824 search_regs
.start
= saved_search_regs
.start
;
2825 search_regs
.end
= saved_search_regs
.end
;
2827 search_regs_saved
= 0;
2831 /* Quote a string to inactivate reg-expr chars */
2833 DEFUN ("regexp-quote", Fregexp_quote
, Sregexp_quote
, 1, 1, 0,
2834 doc
: /* Return a regexp string which matches exactly STRING and nothing else. */)
2838 register unsigned char *in
, *out
, *end
;
2839 register unsigned char *temp
;
2840 int backslashes_added
= 0;
2842 CHECK_STRING (string
);
2844 temp
= (unsigned char *) alloca (SBYTES (string
) * 2);
2846 /* Now copy the data into the new string, inserting escapes. */
2848 in
= SDATA (string
);
2849 end
= in
+ SBYTES (string
);
2852 for (; in
!= end
; in
++)
2854 if (*in
== '[' || *in
== ']'
2855 || *in
== '*' || *in
== '.' || *in
== '\\'
2856 || *in
== '?' || *in
== '+'
2857 || *in
== '^' || *in
== '$')
2858 *out
++ = '\\', backslashes_added
++;
2862 return make_specified_string (temp
,
2863 SCHARS (string
) + backslashes_added
,
2865 STRING_MULTIBYTE (string
));
2873 for (i
= 0; i
< REGEXP_CACHE_SIZE
; ++i
)
2875 searchbufs
[i
].buf
.allocated
= 100;
2876 searchbufs
[i
].buf
.buffer
= (unsigned char *) xmalloc (100);
2877 searchbufs
[i
].buf
.fastmap
= searchbufs
[i
].fastmap
;
2878 searchbufs
[i
].regexp
= Qnil
;
2879 staticpro (&searchbufs
[i
].regexp
);
2880 searchbufs
[i
].next
= (i
== REGEXP_CACHE_SIZE
-1 ? 0 : &searchbufs
[i
+1]);
2882 searchbuf_head
= &searchbufs
[0];
2884 Qsearch_failed
= intern ("search-failed");
2885 staticpro (&Qsearch_failed
);
2886 Qinvalid_regexp
= intern ("invalid-regexp");
2887 staticpro (&Qinvalid_regexp
);
2889 Fput (Qsearch_failed
, Qerror_conditions
,
2890 Fcons (Qsearch_failed
, Fcons (Qerror
, Qnil
)));
2891 Fput (Qsearch_failed
, Qerror_message
,
2892 build_string ("Search failed"));
2894 Fput (Qinvalid_regexp
, Qerror_conditions
,
2895 Fcons (Qinvalid_regexp
, Fcons (Qerror
, Qnil
)));
2896 Fput (Qinvalid_regexp
, Qerror_message
,
2897 build_string ("Invalid regexp"));
2899 last_thing_searched
= Qnil
;
2900 staticpro (&last_thing_searched
);
2902 defsubr (&Slooking_at
);
2903 defsubr (&Sposix_looking_at
);
2904 defsubr (&Sstring_match
);
2905 defsubr (&Sposix_string_match
);
2906 defsubr (&Ssearch_forward
);
2907 defsubr (&Ssearch_backward
);
2908 defsubr (&Sword_search_forward
);
2909 defsubr (&Sword_search_backward
);
2910 defsubr (&Sre_search_forward
);
2911 defsubr (&Sre_search_backward
);
2912 defsubr (&Sposix_search_forward
);
2913 defsubr (&Sposix_search_backward
);
2914 defsubr (&Sreplace_match
);
2915 defsubr (&Smatch_beginning
);
2916 defsubr (&Smatch_end
);
2917 defsubr (&Smatch_data
);
2918 defsubr (&Sset_match_data
);
2919 defsubr (&Sregexp_quote
);
2922 /* arch-tag: a6059d79-0552-4f14-a2cb-d379a4e3c78f
2923 (do not change this comment) */