Mercurial > emacs
annotate src/search.c @ 17085:4dafa5431293
Change coding system name koi8 to koi8-r.
Remove prefix "coding-system-" from coding system symbol names.
author | Kenichi Handa <handa@m17n.org> |
---|---|
date | Wed, 26 Feb 1997 12:27:06 +0000 |
parents | b14c67f044a6 |
children | 82769113e12f |
rev | line source |
---|---|
603 | 1 /* String search routines for GNU Emacs. |
7307 | 2 Copyright (C) 1985, 1986, 1987, 1993, 1994 Free Software Foundation, Inc. |
603 | 3 |
4 This file is part of GNU Emacs. | |
5 | |
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 | |
12244 | 8 the Free Software Foundation; either version 2, or (at your option) |
603 | 9 any later version. |
10 | |
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. | |
15 | |
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 | |
14186
ee40177f6c68
Update FSF's address in the preamble.
Erik Naggum <erik@naggum.no>
parents:
14086
diff
changeset
|
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
ee40177f6c68
Update FSF's address in the preamble.
Erik Naggum <erik@naggum.no>
parents:
14086
diff
changeset
|
19 Boston, MA 02111-1307, USA. */ |
603 | 20 |
21 | |
4696
1fc792473491
Include <config.h> instead of "config.h".
Roland McGrath <roland@gnu.org>
parents:
4635
diff
changeset
|
22 #include <config.h> |
603 | 23 #include "lisp.h" |
24 #include "syntax.h" | |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
25 #include "category.h" |
603 | 26 #include "buffer.h" |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
27 #include "charset.h" |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
28 #include "region-cache.h" |
603 | 29 #include "commands.h" |
2439
b6c62e4abf59
Put interrupt input blocking in a separate file from xterm.h.
Jim Blandy <jimb@redhat.com>
parents:
2393
diff
changeset
|
30 #include "blockinput.h" |
621 | 31 |
603 | 32 #include <sys/types.h> |
33 #include "regex.h" | |
34 | |
16275
a4bcfdc9bb66
(REGEXP_CACHE_SIZE): Increase to 20.
Richard M. Stallman <rms@gnu.org>
parents:
16152
diff
changeset
|
35 #define REGEXP_CACHE_SIZE 20 |
603 | 36 |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
37 /* If the regexp is non-nil, then the buffer contains the compiled form |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
38 of that regexp, suitable for searching. */ |
16275
a4bcfdc9bb66
(REGEXP_CACHE_SIZE): Increase to 20.
Richard M. Stallman <rms@gnu.org>
parents:
16152
diff
changeset
|
39 struct regexp_cache |
a4bcfdc9bb66
(REGEXP_CACHE_SIZE): Increase to 20.
Richard M. Stallman <rms@gnu.org>
parents:
16152
diff
changeset
|
40 { |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
41 struct regexp_cache *next; |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
42 Lisp_Object regexp; |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
43 struct re_pattern_buffer buf; |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
44 char fastmap[0400]; |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
45 /* Nonzero means regexp was compiled to do full POSIX backtracking. */ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
46 char posix; |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
47 }; |
603 | 48 |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
49 /* The instances of that struct. */ |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
50 struct regexp_cache searchbufs[REGEXP_CACHE_SIZE]; |
603 | 51 |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
52 /* The head of the linked list; points to the most recently used buffer. */ |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
53 struct regexp_cache *searchbuf_head; |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
54 |
603 | 55 |
621 | 56 /* Every call to re_match, etc., must pass &search_regs as the regs |
57 argument unless you can show it is unnecessary (i.e., if re_match | |
58 is certainly going to be called again before region-around-match | |
59 can be called). | |
60 | |
61 Since the registers are now dynamically allocated, we need to make | |
62 sure not to refer to the Nth register before checking that it has | |
708 | 63 been allocated by checking search_regs.num_regs. |
603 | 64 |
708 | 65 The regex code keeps track of whether it has allocated the search |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
66 buffer using bits in the re_pattern_buffer. This means that whenever |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
67 you compile a new pattern, it completely forgets whether it has |
708 | 68 allocated any registers, and will allocate new registers the next |
69 time you call a searching or matching function. Therefore, we need | |
70 to call re_set_registers after compiling a new pattern or after | |
71 setting the match registers, so that the regex functions will be | |
72 able to free or re-allocate it properly. */ | |
603 | 73 static struct re_registers search_regs; |
74 | |
727 | 75 /* The buffer in which the last search was performed, or |
76 Qt if the last search was done in a string; | |
77 Qnil if no searching has been done yet. */ | |
78 static Lisp_Object last_thing_searched; | |
603 | 79 |
14036 | 80 /* error condition signaled when regexp compile_pattern fails */ |
603 | 81 |
82 Lisp_Object Qinvalid_regexp; | |
83 | |
5556
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
84 static void set_search_regs (); |
10055
cb713218845a
(save_search_regs): Add declaration.
Richard M. Stallman <rms@gnu.org>
parents:
10032
diff
changeset
|
85 static void save_search_regs (); |
5556
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
86 |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
87 static int search_buffer (); |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
88 |
603 | 89 static void |
90 matcher_overflow () | |
91 { | |
92 error ("Stack overflow in regexp matcher"); | |
93 } | |
94 | |
95 #ifdef __STDC__ | |
96 #define CONST const | |
97 #else | |
98 #define CONST | |
99 #endif | |
100 | |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
101 /* Compile a regexp and signal a Lisp error if anything goes wrong. |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
102 PATTERN is the pattern to compile. |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
103 CP is the place to put the result. |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
104 TRANSLATE is a translation table for ignoring case, or NULL for none. |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
105 REGP is the structure that says where to store the "register" |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
106 values that will result from matching this pattern. |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
107 If it is 0, we should compile the pattern not to record any |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
108 subexpression bounds. |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
109 POSIX is nonzero if we want full backtracking (POSIX style) |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
110 for this pattern. 0 means backtrack only enough to get a valid match. |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
111 MULTIBYTE is nonzero if we want to handle multibyte characters in |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
112 PATTERN. 0 means all multibyte characters are recognized just as |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
113 sequences of binary data. */ |
603 | 114 |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
115 static void |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
116 compile_pattern_1 (cp, pattern, translate, regp, posix, multibyte) |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
117 struct regexp_cache *cp; |
603 | 118 Lisp_Object pattern; |
13237
1aa239b8d03c
(compile_pattern_1, compile_pattern, search_buffer):
Richard M. Stallman <rms@gnu.org>
parents:
12807
diff
changeset
|
119 Lisp_Object *translate; |
708 | 120 struct re_registers *regp; |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
121 int posix; |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
122 int multibyte; |
603 | 123 { |
124 CONST char *val; | |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
125 reg_syntax_t old; |
603 | 126 |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
127 cp->regexp = Qnil; |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
128 cp->buf.translate = translate; |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
129 cp->posix = posix; |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
130 cp->buf.multibyte = multibyte; |
2439
b6c62e4abf59
Put interrupt input blocking in a separate file from xterm.h.
Jim Blandy <jimb@redhat.com>
parents:
2393
diff
changeset
|
131 BLOCK_INPUT; |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
132 old = re_set_syntax (RE_SYNTAX_EMACS |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
133 | (posix ? 0 : RE_NO_POSIX_BACKTRACKING)); |
4635
ad4add779dac
(compile_pattern): Cast result of re_compile_pattern.
Richard M. Stallman <rms@gnu.org>
parents:
4299
diff
changeset
|
134 val = (CONST char *) re_compile_pattern ((char *) XSTRING (pattern)->data, |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
135 XSTRING (pattern)->size, &cp->buf); |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
136 re_set_syntax (old); |
2439
b6c62e4abf59
Put interrupt input blocking in a separate file from xterm.h.
Jim Blandy <jimb@redhat.com>
parents:
2393
diff
changeset
|
137 UNBLOCK_INPUT; |
603 | 138 if (val) |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
139 Fsignal (Qinvalid_regexp, Fcons (build_string (val), Qnil)); |
708 | 140 |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
141 cp->regexp = Fcopy_sequence (pattern); |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
142 } |
708 | 143 |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
144 /* Compile a regexp if necessary, but first check to see if there's one in |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
145 the cache. |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
146 PATTERN is the pattern to compile. |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
147 TRANSLATE is a translation table for ignoring case, or NULL for none. |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
148 REGP is the structure that says where to store the "register" |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
149 values that will result from matching this pattern. |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
150 If it is 0, we should compile the pattern not to record any |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
151 subexpression bounds. |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
152 POSIX is nonzero if we want full backtracking (POSIX style) |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
153 for this pattern. 0 means backtrack only enough to get a valid match. */ |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
154 |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
155 struct re_pattern_buffer * |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
156 compile_pattern (pattern, regp, translate, posix) |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
157 Lisp_Object pattern; |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
158 struct re_registers *regp; |
13237
1aa239b8d03c
(compile_pattern_1, compile_pattern, search_buffer):
Richard M. Stallman <rms@gnu.org>
parents:
12807
diff
changeset
|
159 Lisp_Object *translate; |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
160 int posix; |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
161 { |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
162 struct regexp_cache *cp, **cpp; |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
163 /* Should we check it here, or add an argument `multibyte' to this |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
164 function? */ |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
165 int multibyte = !NILP (current_buffer->enable_multibyte_characters); |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
166 |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
167 for (cpp = &searchbuf_head; ; cpp = &cp->next) |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
168 { |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
169 cp = *cpp; |
16275
a4bcfdc9bb66
(REGEXP_CACHE_SIZE): Increase to 20.
Richard M. Stallman <rms@gnu.org>
parents:
16152
diff
changeset
|
170 if (XSTRING (cp->regexp)->size == XSTRING (pattern)->size |
a4bcfdc9bb66
(REGEXP_CACHE_SIZE): Increase to 20.
Richard M. Stallman <rms@gnu.org>
parents:
16152
diff
changeset
|
171 && !NILP (Fstring_equal (cp->regexp, pattern)) |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
172 && cp->buf.translate == translate |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
173 && cp->posix == posix |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
174 && cp->buf.multibyte == multibyte) |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
175 break; |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
176 |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
177 /* If we're at the end of the cache, compile into the last cell. */ |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
178 if (cp->next == 0) |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
179 { |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
180 compile_pattern_1 (cp, pattern, translate, regp, posix, multibyte); |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
181 break; |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
182 } |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
183 } |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
184 |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
185 /* When we get here, cp (aka *cpp) contains the compiled pattern, |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
186 either because we found it in the cache or because we just compiled it. |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
187 Move it to the front of the queue to mark it as most recently used. */ |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
188 *cpp = cp->next; |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
189 cp->next = searchbuf_head; |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
190 searchbuf_head = cp; |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
191 |
10141
afe81fd385eb
(compile_pattern): Call re_set_registers here.
Richard M. Stallman <rms@gnu.org>
parents:
10128
diff
changeset
|
192 /* Advise the searching functions about the space we have allocated |
afe81fd385eb
(compile_pattern): Call re_set_registers here.
Richard M. Stallman <rms@gnu.org>
parents:
10128
diff
changeset
|
193 for register data. */ |
afe81fd385eb
(compile_pattern): Call re_set_registers here.
Richard M. Stallman <rms@gnu.org>
parents:
10128
diff
changeset
|
194 if (regp) |
afe81fd385eb
(compile_pattern): Call re_set_registers here.
Richard M. Stallman <rms@gnu.org>
parents:
10128
diff
changeset
|
195 re_set_registers (&cp->buf, regp, regp->num_regs, regp->start, regp->end); |
afe81fd385eb
(compile_pattern): Call re_set_registers here.
Richard M. Stallman <rms@gnu.org>
parents:
10128
diff
changeset
|
196 |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
197 return &cp->buf; |
603 | 198 } |
199 | |
200 /* Error condition used for failing searches */ | |
201 Lisp_Object Qsearch_failed; | |
202 | |
203 Lisp_Object | |
204 signal_failure (arg) | |
205 Lisp_Object arg; | |
206 { | |
207 Fsignal (Qsearch_failed, Fcons (arg, Qnil)); | |
208 return Qnil; | |
209 } | |
210 | |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
211 static Lisp_Object |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
212 looking_at_1 (string, posix) |
603 | 213 Lisp_Object string; |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
214 int posix; |
603 | 215 { |
216 Lisp_Object val; | |
217 unsigned char *p1, *p2; | |
218 int s1, s2; | |
219 register int i; | |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
220 struct re_pattern_buffer *bufp; |
603 | 221 |
10032
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
222 if (running_asynch_code) |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
223 save_search_regs (); |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
224 |
603 | 225 CHECK_STRING (string, 0); |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
226 bufp = compile_pattern (string, &search_regs, |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
227 (!NILP (current_buffer->case_fold_search) |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
228 ? DOWNCASE_TABLE : 0), |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
229 posix); |
603 | 230 |
231 immediate_quit = 1; | |
232 QUIT; /* Do a pending quit right away, to avoid paradoxical behavior */ | |
233 | |
234 /* Get pointers and sizes of the two strings | |
235 that make up the visible portion of the buffer. */ | |
236 | |
237 p1 = BEGV_ADDR; | |
238 s1 = GPT - BEGV; | |
239 p2 = GAP_END_ADDR; | |
240 s2 = ZV - GPT; | |
241 if (s1 < 0) | |
242 { | |
243 p2 = p1; | |
244 s2 = ZV - BEGV; | |
245 s1 = 0; | |
246 } | |
247 if (s2 < 0) | |
248 { | |
249 s1 = ZV - BEGV; | |
250 s2 = 0; | |
251 } | |
252 | |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
253 i = re_match_2 (bufp, (char *) p1, s1, (char *) p2, s2, |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15667
diff
changeset
|
254 PT - BEGV, &search_regs, |
603 | 255 ZV - BEGV); |
256 if (i == -2) | |
257 matcher_overflow (); | |
258 | |
259 val = (0 <= i ? Qt : Qnil); | |
621 | 260 for (i = 0; i < search_regs.num_regs; i++) |
603 | 261 if (search_regs.start[i] >= 0) |
262 { | |
263 search_regs.start[i] += BEGV; | |
264 search_regs.end[i] += BEGV; | |
265 } | |
9278
f2138d548313
(Flooking_at, skip_chars, search_buffer, set_search_regs, Fstore_match_data):
Karl Heuer <kwzh@gnu.org>
parents:
9113
diff
changeset
|
266 XSETBUFFER (last_thing_searched, current_buffer); |
603 | 267 immediate_quit = 0; |
268 return val; | |
269 } | |
270 | |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
271 DEFUN ("looking-at", Flooking_at, Slooking_at, 1, 1, 0, |
11213
d0811ba886f8
(Flooking_at, Fposix_looking_at): Change arg name.
Richard M. Stallman <rms@gnu.org>
parents:
10250
diff
changeset
|
272 "Return t if text after point matches regular expression REGEXP.\n\ |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
273 This function modifies the match data that `match-beginning',\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
274 `match-end' and `match-data' access; save and restore the match\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
275 data if you want to preserve them.") |
11213
d0811ba886f8
(Flooking_at, Fposix_looking_at): Change arg name.
Richard M. Stallman <rms@gnu.org>
parents:
10250
diff
changeset
|
276 (regexp) |
d0811ba886f8
(Flooking_at, Fposix_looking_at): Change arg name.
Richard M. Stallman <rms@gnu.org>
parents:
10250
diff
changeset
|
277 Lisp_Object regexp; |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
278 { |
11213
d0811ba886f8
(Flooking_at, Fposix_looking_at): Change arg name.
Richard M. Stallman <rms@gnu.org>
parents:
10250
diff
changeset
|
279 return looking_at_1 (regexp, 0); |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
280 } |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
281 |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
282 DEFUN ("posix-looking-at", Fposix_looking_at, Sposix_looking_at, 1, 1, 0, |
11213
d0811ba886f8
(Flooking_at, Fposix_looking_at): Change arg name.
Richard M. Stallman <rms@gnu.org>
parents:
10250
diff
changeset
|
283 "Return t if text after point matches regular expression REGEXP.\n\ |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
284 Find the longest match, in accord with Posix regular expression rules.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
285 This function modifies the match data that `match-beginning',\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
286 `match-end' and `match-data' access; save and restore the match\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
287 data if you want to preserve them.") |
11213
d0811ba886f8
(Flooking_at, Fposix_looking_at): Change arg name.
Richard M. Stallman <rms@gnu.org>
parents:
10250
diff
changeset
|
288 (regexp) |
d0811ba886f8
(Flooking_at, Fposix_looking_at): Change arg name.
Richard M. Stallman <rms@gnu.org>
parents:
10250
diff
changeset
|
289 Lisp_Object regexp; |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
290 { |
11213
d0811ba886f8
(Flooking_at, Fposix_looking_at): Change arg name.
Richard M. Stallman <rms@gnu.org>
parents:
10250
diff
changeset
|
291 return looking_at_1 (regexp, 1); |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
292 } |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
293 |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
294 static Lisp_Object |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
295 string_match_1 (regexp, string, start, posix) |
603 | 296 Lisp_Object regexp, string, start; |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
297 int posix; |
603 | 298 { |
299 int val; | |
300 int s; | |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
301 struct re_pattern_buffer *bufp; |
603 | 302 |
10032
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
303 if (running_asynch_code) |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
304 save_search_regs (); |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
305 |
603 | 306 CHECK_STRING (regexp, 0); |
307 CHECK_STRING (string, 1); | |
308 | |
309 if (NILP (start)) | |
310 s = 0; | |
311 else | |
312 { | |
313 int len = XSTRING (string)->size; | |
314 | |
315 CHECK_NUMBER (start, 2); | |
316 s = XINT (start); | |
317 if (s < 0 && -s <= len) | |
8584
4f0a475b1fa9
(Fstring_match): Fix sign error.
Karl Heuer <kwzh@gnu.org>
parents:
8526
diff
changeset
|
318 s = len + s; |
603 | 319 else if (0 > s || s > len) |
320 args_out_of_range (string, start); | |
321 } | |
322 | |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
323 bufp = compile_pattern (regexp, &search_regs, |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
324 (!NILP (current_buffer->case_fold_search) |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
325 ? DOWNCASE_TABLE : 0), |
13295
bc92156aa523
(string_match_1): Pass the POSIX arg to compile_pattern.
Richard M. Stallman <rms@gnu.org>
parents:
13237
diff
changeset
|
326 posix); |
603 | 327 immediate_quit = 1; |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
328 val = re_search (bufp, (char *) XSTRING (string)->data, |
603 | 329 XSTRING (string)->size, s, XSTRING (string)->size - s, |
330 &search_regs); | |
331 immediate_quit = 0; | |
727 | 332 last_thing_searched = Qt; |
603 | 333 if (val == -2) |
334 matcher_overflow (); | |
335 if (val < 0) return Qnil; | |
336 return make_number (val); | |
337 } | |
842 | 338 |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
339 DEFUN ("string-match", Fstring_match, Sstring_match, 2, 3, 0, |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
340 "Return index of start of first match for REGEXP in STRING, or nil.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
341 If third arg START is non-nil, start search at that index in STRING.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
342 For index of first char beyond the match, do (match-end 0).\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
343 `match-end' and `match-beginning' also give indices of substrings\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
344 matched by parenthesis constructs in the pattern.") |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
345 (regexp, string, start) |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
346 Lisp_Object regexp, string, start; |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
347 { |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
348 return string_match_1 (regexp, string, start, 0); |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
349 } |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
350 |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
351 DEFUN ("posix-string-match", Fposix_string_match, Sposix_string_match, 2, 3, 0, |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
352 "Return index of start of first match for REGEXP in STRING, or nil.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
353 Find the longest match, in accord with Posix regular expression rules.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
354 If third arg START is non-nil, start search at that index in STRING.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
355 For index of first char beyond the match, do (match-end 0).\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
356 `match-end' and `match-beginning' also give indices of substrings\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
357 matched by parenthesis constructs in the pattern.") |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
358 (regexp, string, start) |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
359 Lisp_Object regexp, string, start; |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
360 { |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
361 return string_match_1 (regexp, string, start, 1); |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
362 } |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
363 |
842 | 364 /* Match REGEXP against STRING, searching all of STRING, |
365 and return the index of the match, or negative on failure. | |
366 This does not clobber the match data. */ | |
367 | |
368 int | |
369 fast_string_match (regexp, string) | |
370 Lisp_Object regexp, string; | |
371 { | |
372 int val; | |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
373 struct re_pattern_buffer *bufp; |
842 | 374 |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
375 bufp = compile_pattern (regexp, 0, 0, 0); |
842 | 376 immediate_quit = 1; |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
377 val = re_search (bufp, (char *) XSTRING (string)->data, |
842 | 378 XSTRING (string)->size, 0, XSTRING (string)->size, |
379 0); | |
380 immediate_quit = 0; | |
381 return val; | |
382 } | |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
383 |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
384 /* Match REGEXP against STRING, searching all of STRING ignoring case, |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
385 and return the index of the match, or negative on failure. |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
386 This does not clobber the match data. */ |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
387 |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
388 extern Lisp_Object Vascii_downcase_table; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
389 |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
390 int |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
391 fast_string_match_ignore_case (regexp, string) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
392 Lisp_Object regexp; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
393 char *string; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
394 { |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
395 int val; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
396 struct re_pattern_buffer *bufp; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
397 int len = strlen (string); |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
398 |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
399 bufp = compile_pattern (regexp, 0, |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
400 XCHAR_TABLE (Vascii_downcase_table)->contents, 0); |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
401 immediate_quit = 1; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
402 val = re_search (bufp, string, len, 0, len, 0); |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
403 immediate_quit = 0; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
404 return val; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
405 } |
603 | 406 |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
407 /* max and min. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
408 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
409 static int |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
410 max (a, b) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
411 int a, b; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
412 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
413 return ((a > b) ? a : b); |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
414 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
415 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
416 static int |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
417 min (a, b) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
418 int a, b; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
419 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
420 return ((a < b) ? a : b); |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
421 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
422 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
423 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
424 /* The newline cache: remembering which sections of text have no newlines. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
425 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
426 /* If the user has requested newline caching, make sure it's on. |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
427 Otherwise, make sure it's off. |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
428 This is our cheezy way of associating an action with the change of |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
429 state of a buffer-local variable. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
430 static void |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
431 newline_cache_on_off (buf) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
432 struct buffer *buf; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
433 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
434 if (NILP (buf->cache_long_line_scans)) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
435 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
436 /* It should be off. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
437 if (buf->newline_cache) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
438 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
439 free_region_cache (buf->newline_cache); |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
440 buf->newline_cache = 0; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
441 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
442 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
443 else |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
444 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
445 /* It should be on. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
446 if (buf->newline_cache == 0) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
447 buf->newline_cache = new_region_cache (); |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
448 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
449 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
450 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
451 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
452 /* Search for COUNT instances of the character TARGET between START and END. |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
453 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
454 If COUNT is positive, search forwards; END must be >= START. |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
455 If COUNT is negative, search backwards for the -COUNTth instance; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
456 END must be <= START. |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
457 If COUNT is zero, do anything you please; run rogue, for all I care. |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
458 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
459 If END is zero, use BEGV or ZV instead, as appropriate for the |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
460 direction indicated by COUNT. |
648 | 461 |
462 If we find COUNT instances, set *SHORTAGE to zero, and return the | |
1413 | 463 position after the COUNTth match. Note that for reverse motion |
464 this is not the same as the usual convention for Emacs motion commands. | |
648 | 465 |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
466 If we don't find COUNT instances before reaching END, set *SHORTAGE |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
467 to the number of TARGETs left unfound, and return END. |
648 | 468 |
5756
a54c236b43c6
(scan_buffer): New arg ALLOW_QUIT.
Richard M. Stallman <rms@gnu.org>
parents:
5556
diff
changeset
|
469 If ALLOW_QUIT is non-zero, set immediate_quit. That's good to do |
a54c236b43c6
(scan_buffer): New arg ALLOW_QUIT.
Richard M. Stallman <rms@gnu.org>
parents:
5556
diff
changeset
|
470 except when inside redisplay. */ |
a54c236b43c6
(scan_buffer): New arg ALLOW_QUIT.
Richard M. Stallman <rms@gnu.org>
parents:
5556
diff
changeset
|
471 |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
472 scan_buffer (target, start, end, count, shortage, allow_quit) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
473 register int target; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
474 int start, end; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
475 int count; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
476 int *shortage; |
5756
a54c236b43c6
(scan_buffer): New arg ALLOW_QUIT.
Richard M. Stallman <rms@gnu.org>
parents:
5556
diff
changeset
|
477 int allow_quit; |
603 | 478 { |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
479 struct region_cache *newline_cache; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
480 int direction; |
648 | 481 |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
482 if (count > 0) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
483 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
484 direction = 1; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
485 if (! end) end = ZV; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
486 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
487 else |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
488 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
489 direction = -1; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
490 if (! end) end = BEGV; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
491 } |
648 | 492 |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
493 newline_cache_on_off (current_buffer); |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
494 newline_cache = current_buffer->newline_cache; |
603 | 495 |
496 if (shortage != 0) | |
497 *shortage = 0; | |
498 | |
5756
a54c236b43c6
(scan_buffer): New arg ALLOW_QUIT.
Richard M. Stallman <rms@gnu.org>
parents:
5556
diff
changeset
|
499 immediate_quit = allow_quit; |
603 | 500 |
648 | 501 if (count > 0) |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
502 while (start != end) |
603 | 503 { |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
504 /* Our innermost scanning loop is very simple; it doesn't know |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
505 about gaps, buffer ends, or the newline cache. ceiling is |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
506 the position of the last character before the next such |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
507 obstacle --- the last character the dumb search loop should |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
508 examine. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
509 register int ceiling = end - 1; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
510 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
511 /* If we're looking for a newline, consult the newline cache |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
512 to see where we can avoid some scanning. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
513 if (target == '\n' && newline_cache) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
514 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
515 int next_change; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
516 immediate_quit = 0; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
517 while (region_cache_forward |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
518 (current_buffer, newline_cache, start, &next_change)) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
519 start = next_change; |
9452
76f75b9091f1
(scan_buffer): After temporarily turning immediate_quit off, turn it
Jim Blandy <jimb@redhat.com>
parents:
9410
diff
changeset
|
520 immediate_quit = allow_quit; |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
521 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
522 /* start should never be after end. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
523 if (start >= end) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
524 start = end - 1; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
525 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
526 /* Now the text after start is an unknown region, and |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
527 next_change is the position of the next known region. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
528 ceiling = min (next_change - 1, ceiling); |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
529 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
530 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
531 /* The dumb loop can only scan text stored in contiguous |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
532 bytes. BUFFER_CEILING_OF returns the last character |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
533 position that is contiguous, so the ceiling is the |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
534 position after that. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
535 ceiling = min (BUFFER_CEILING_OF (start), ceiling); |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
536 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
537 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
538 /* The termination address of the dumb loop. */ |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
539 register unsigned char *ceiling_addr = POS_ADDR (ceiling) + 1; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
540 register unsigned char *cursor = POS_ADDR (start); |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
541 unsigned char *base = cursor; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
542 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
543 while (cursor < ceiling_addr) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
544 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
545 unsigned char *scan_start = cursor; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
546 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
547 /* The dumb loop. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
548 while (*cursor != target && ++cursor < ceiling_addr) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
549 ; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
550 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
551 /* If we're looking for newlines, cache the fact that |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
552 the region from start to cursor is free of them. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
553 if (target == '\n' && newline_cache) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
554 know_region_cache (current_buffer, newline_cache, |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
555 start + scan_start - base, |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
556 start + cursor - base); |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
557 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
558 /* Did we find the target character? */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
559 if (cursor < ceiling_addr) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
560 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
561 if (--count == 0) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
562 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
563 immediate_quit = 0; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
564 return (start + cursor - base + 1); |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
565 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
566 cursor++; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
567 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
568 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
569 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
570 start += cursor - base; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
571 } |
603 | 572 } |
573 else | |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
574 while (start > end) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
575 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
576 /* The last character to check before the next obstacle. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
577 register int ceiling = end; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
578 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
579 /* Consult the newline cache, if appropriate. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
580 if (target == '\n' && newline_cache) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
581 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
582 int next_change; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
583 immediate_quit = 0; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
584 while (region_cache_backward |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
585 (current_buffer, newline_cache, start, &next_change)) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
586 start = next_change; |
9452
76f75b9091f1
(scan_buffer): After temporarily turning immediate_quit off, turn it
Jim Blandy <jimb@redhat.com>
parents:
9410
diff
changeset
|
587 immediate_quit = allow_quit; |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
588 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
589 /* Start should never be at or before end. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
590 if (start <= end) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
591 start = end + 1; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
592 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
593 /* Now the text before start is an unknown region, and |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
594 next_change is the position of the next known region. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
595 ceiling = max (next_change, ceiling); |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
596 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
597 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
598 /* Stop scanning before the gap. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
599 ceiling = max (BUFFER_FLOOR_OF (start - 1), ceiling); |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
600 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
601 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
602 /* The termination address of the dumb loop. */ |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
603 register unsigned char *ceiling_addr = POS_ADDR (ceiling); |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
604 register unsigned char *cursor = POS_ADDR (start - 1); |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
605 unsigned char *base = cursor; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
606 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
607 while (cursor >= ceiling_addr) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
608 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
609 unsigned char *scan_start = cursor; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
610 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
611 while (*cursor != target && --cursor >= ceiling_addr) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
612 ; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
613 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
614 /* If we're looking for newlines, cache the fact that |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
615 the region from after the cursor to start is free of them. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
616 if (target == '\n' && newline_cache) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
617 know_region_cache (current_buffer, newline_cache, |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
618 start + cursor - base, |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
619 start + scan_start - base); |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
620 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
621 /* Did we find the target character? */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
622 if (cursor >= ceiling_addr) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
623 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
624 if (++count >= 0) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
625 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
626 immediate_quit = 0; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
627 return (start + cursor - base); |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
628 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
629 cursor--; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
630 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
631 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
632 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
633 start += cursor - base; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
634 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
635 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
636 |
603 | 637 immediate_quit = 0; |
638 if (shortage != 0) | |
648 | 639 *shortage = count * direction; |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
640 return start; |
603 | 641 } |
642 | |
643 int | |
7891
7d8e0f338e4a
(find_next_newline_no_quit): New function.
Richard M. Stallman <rms@gnu.org>
parents:
7856
diff
changeset
|
644 find_next_newline_no_quit (from, cnt) |
7d8e0f338e4a
(find_next_newline_no_quit): New function.
Richard M. Stallman <rms@gnu.org>
parents:
7856
diff
changeset
|
645 register int from, cnt; |
7d8e0f338e4a
(find_next_newline_no_quit): New function.
Richard M. Stallman <rms@gnu.org>
parents:
7856
diff
changeset
|
646 { |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
647 return scan_buffer ('\n', from, 0, cnt, (int *) 0, 0); |
7891
7d8e0f338e4a
(find_next_newline_no_quit): New function.
Richard M. Stallman <rms@gnu.org>
parents:
7856
diff
changeset
|
648 } |
7d8e0f338e4a
(find_next_newline_no_quit): New function.
Richard M. Stallman <rms@gnu.org>
parents:
7856
diff
changeset
|
649 |
7d8e0f338e4a
(find_next_newline_no_quit): New function.
Richard M. Stallman <rms@gnu.org>
parents:
7856
diff
changeset
|
650 int |
603 | 651 find_next_newline (from, cnt) |
652 register int from, cnt; | |
653 { | |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
654 return scan_buffer ('\n', from, 0, cnt, (int *) 0, 1); |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
655 } |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
656 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
657 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
658 /* Like find_next_newline, but returns position before the newline, |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
659 not after, and only search up to TO. This isn't just |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
660 find_next_newline (...)-1, because you might hit TO. */ |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
661 int |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
662 find_before_next_newline (from, to, cnt) |
9452
76f75b9091f1
(scan_buffer): After temporarily turning immediate_quit off, turn it
Jim Blandy <jimb@redhat.com>
parents:
9410
diff
changeset
|
663 int from, to, cnt; |
9410
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
664 { |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
665 int shortage; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
666 int pos = scan_buffer ('\n', from, to, cnt, &shortage, 1); |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
667 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
668 if (shortage == 0) |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
669 pos--; |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
670 |
8598c3d6f2f0
* search.c: #include "region-cache.h".
Jim Blandy <jimb@redhat.com>
parents:
9319
diff
changeset
|
671 return pos; |
603 | 672 } |
673 | |
1684
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
674 Lisp_Object skip_chars (); |
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
675 |
603 | 676 DEFUN ("skip-chars-forward", Fskip_chars_forward, Sskip_chars_forward, 1, 2, 0, |
4954
dc4d4f874b5c
(Fskip_chars_backward, Fskip_chars_forward): Doc fix.
Richard M. Stallman <rms@gnu.org>
parents:
4951
diff
changeset
|
677 "Move point forward, stopping before a char not in STRING, or at pos LIM.\n\ |
dc4d4f874b5c
(Fskip_chars_backward, Fskip_chars_forward): Doc fix.
Richard M. Stallman <rms@gnu.org>
parents:
4951
diff
changeset
|
678 STRING is like the inside of a `[...]' in a regular expression\n\ |
603 | 679 except that `]' is never special and `\\' quotes `^', `-' or `\\'.\n\ |
680 Thus, with arg \"a-zA-Z\", this skips letters stopping before first nonletter.\n\ | |
1684
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
681 With arg \"^a-zA-Z\", skips nonletters stopping before first letter.\n\ |
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
682 Returns the distance traveled, either zero or positive.") |
603 | 683 (string, lim) |
684 Lisp_Object string, lim; | |
685 { | |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
686 return skip_chars (1, 0, string, lim); |
603 | 687 } |
688 | |
689 DEFUN ("skip-chars-backward", Fskip_chars_backward, Sskip_chars_backward, 1, 2, 0, | |
4954
dc4d4f874b5c
(Fskip_chars_backward, Fskip_chars_forward): Doc fix.
Richard M. Stallman <rms@gnu.org>
parents:
4951
diff
changeset
|
690 "Move point backward, stopping after a char not in STRING, or at pos LIM.\n\ |
1684
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
691 See `skip-chars-forward' for details.\n\ |
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
692 Returns the distance traveled, either zero or negative.") |
603 | 693 (string, lim) |
694 Lisp_Object string, lim; | |
695 { | |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
696 return skip_chars (0, 0, string, lim); |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
697 } |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
698 |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
699 DEFUN ("skip-syntax-forward", Fskip_syntax_forward, Sskip_syntax_forward, 1, 2, 0, |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
700 "Move point forward across chars in specified syntax classes.\n\ |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
701 SYNTAX is a string of syntax code characters.\n\ |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
702 Stop before a char whose syntax is not in SYNTAX, or at position LIM.\n\ |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
703 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\ |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
704 This function returns the distance traveled, either zero or positive.") |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
705 (syntax, lim) |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
706 Lisp_Object syntax, lim; |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
707 { |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
708 return skip_chars (1, 1, syntax, lim); |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
709 } |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
710 |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
711 DEFUN ("skip-syntax-backward", Fskip_syntax_backward, Sskip_syntax_backward, 1, 2, 0, |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
712 "Move point backward across chars in specified syntax classes.\n\ |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
713 SYNTAX is a string of syntax code characters.\n\ |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
714 Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.\n\ |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
715 If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\ |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
716 This function returns the distance traveled, either zero or negative.") |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
717 (syntax, lim) |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
718 Lisp_Object syntax, lim; |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
719 { |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
720 return skip_chars (0, 1, syntax, lim); |
603 | 721 } |
722 | |
1684
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
723 Lisp_Object |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
724 skip_chars (forwardp, syntaxp, string, lim) |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
725 int forwardp, syntaxp; |
603 | 726 Lisp_Object string, lim; |
727 { | |
728 register unsigned char *p, *pend; | |
729 register unsigned char c; | |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
730 register int ch; |
603 | 731 unsigned char fastmap[0400]; |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
732 /* If SYNTAXP is 0, STRING may contain multi-byte form of characters |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
733 of which codes don't fit in FASTMAP. In that case, we set the |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
734 first byte of multibyte form (i.e. base leading-code) in FASTMAP |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
735 and set the actual ranges of characters in CHAR_RANGES. In the |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
736 form "X-Y" of STRING, both X and Y must belong to the same |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
737 character set because a range striding across character sets is |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
738 meaningless. */ |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
739 int *char_ranges |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
740 = (int *) alloca (XSTRING (string)->size * (sizeof (int)) * 2); |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
741 int n_char_ranges = 0; |
603 | 742 int negate = 0; |
743 register int i; | |
744 | |
745 CHECK_STRING (string, 0); | |
746 | |
747 if (NILP (lim)) | |
9278
f2138d548313
(Flooking_at, skip_chars, search_buffer, set_search_regs, Fstore_match_data):
Karl Heuer <kwzh@gnu.org>
parents:
9113
diff
changeset
|
748 XSETINT (lim, forwardp ? ZV : BEGV); |
603 | 749 else |
750 CHECK_NUMBER_COERCE_MARKER (lim, 1); | |
751 | |
4831
66a523672100
(skip_chars): Reinstate check for end of buffer, ignoring cryptic
Brian Fox <bfox@gnu.org>
parents:
4713
diff
changeset
|
752 /* In any case, don't allow scan outside bounds of buffer. */ |
4951
be690aaa7194
(skip_chars): Finish reenabling checks for buffer bounds.
Richard M. Stallman <rms@gnu.org>
parents:
4882
diff
changeset
|
753 /* jla turned this off, for no known reason. |
be690aaa7194
(skip_chars): Finish reenabling checks for buffer bounds.
Richard M. Stallman <rms@gnu.org>
parents:
4882
diff
changeset
|
754 bfox turned the ZV part on, and rms turned the |
be690aaa7194
(skip_chars): Finish reenabling checks for buffer bounds.
Richard M. Stallman <rms@gnu.org>
parents:
4882
diff
changeset
|
755 BEGV part back on. */ |
be690aaa7194
(skip_chars): Finish reenabling checks for buffer bounds.
Richard M. Stallman <rms@gnu.org>
parents:
4882
diff
changeset
|
756 if (XINT (lim) > ZV) |
9319
7969182b6cc6
(skip_chars, Fmatch_data, Fstore_match_data): Don't use XFASTINT as an lvalue.
Karl Heuer <kwzh@gnu.org>
parents:
9278
diff
changeset
|
757 XSETFASTINT (lim, ZV); |
4951
be690aaa7194
(skip_chars): Finish reenabling checks for buffer bounds.
Richard M. Stallman <rms@gnu.org>
parents:
4882
diff
changeset
|
758 if (XINT (lim) < BEGV) |
9319
7969182b6cc6
(skip_chars, Fmatch_data, Fstore_match_data): Don't use XFASTINT as an lvalue.
Karl Heuer <kwzh@gnu.org>
parents:
9278
diff
changeset
|
759 XSETFASTINT (lim, BEGV); |
603 | 760 |
761 p = XSTRING (string)->data; | |
762 pend = p + XSTRING (string)->size; | |
763 bzero (fastmap, sizeof fastmap); | |
764 | |
765 if (p != pend && *p == '^') | |
766 { | |
767 negate = 1; p++; | |
768 } | |
769 | |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
770 /* Find the characters specified and set their elements of fastmap. |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
771 If syntaxp, each character counts as itself. |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
772 Otherwise, handle backslashes and ranges specially. */ |
603 | 773 |
774 while (p != pend) | |
775 { | |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
776 c = *p; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
777 ch = STRING_CHAR (p, pend - p); |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
778 p += BYTES_BY_CHAR_HEAD (*p); |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
779 if (syntaxp) |
16880
40ea37a6dc40
(skip_chars): Optimize by not calling SET_PT in the loop.
Richard M. Stallman <rms@gnu.org>
parents:
16731
diff
changeset
|
780 fastmap[syntax_spec_code[c]] = 1; |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
781 else |
603 | 782 { |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
783 if (c == '\\') |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
784 { |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
785 if (p == pend) break; |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
786 c = *p++; |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
787 } |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
788 if (p != pend && *p == '-') |
603 | 789 { |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
790 unsigned int ch2; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
791 |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
792 p++; |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
793 if (p == pend) break; |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
794 if (SINGLE_BYTE_CHAR_P (ch)) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
795 while (c <= *p) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
796 { |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
797 fastmap[c] = 1; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
798 c++; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
799 } |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
800 else |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
801 { |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
802 fastmap[c] = 1; /* C is the base leading-code. */ |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
803 ch2 = STRING_CHAR (p, pend - p); |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
804 if (ch <= ch2) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
805 char_ranges[n_char_ranges++] = ch, |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
806 char_ranges[n_char_ranges++] = ch2; |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
807 } |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
808 p += BYTES_BY_CHAR_HEAD (*p); |
603 | 809 } |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
810 else |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
811 { |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
812 fastmap[c] = 1; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
813 if (!SINGLE_BYTE_CHAR_P (ch)) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
814 char_ranges[n_char_ranges++] = ch, |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
815 char_ranges[n_char_ranges++] = ch; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
816 } |
603 | 817 } |
818 } | |
819 | |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
820 /* If ^ was the first character, complement the fastmap. In |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
821 addition, as all multibyte characters have possibility of |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
822 matching, set all entries for base leading codes, which is |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
823 harmless even if SYNTAXP is 1. */ |
603 | 824 |
825 if (negate) | |
826 for (i = 0; i < sizeof fastmap; i++) | |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
827 { |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
828 if (!BASE_LEADING_CODE_P (i)) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
829 fastmap[i] ^= 1; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
830 else |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
831 fastmap[i] = 1; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
832 } |
603 | 833 |
1684
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
834 { |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15667
diff
changeset
|
835 int start_point = PT; |
16880
40ea37a6dc40
(skip_chars): Optimize by not calling SET_PT in the loop.
Richard M. Stallman <rms@gnu.org>
parents:
16731
diff
changeset
|
836 int pos = PT; |
1684
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
837 |
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
838 immediate_quit = 1; |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
839 if (syntaxp) |
1684
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
840 { |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
841 if (forwardp) |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
842 { |
16880
40ea37a6dc40
(skip_chars): Optimize by not calling SET_PT in the loop.
Richard M. Stallman <rms@gnu.org>
parents:
16731
diff
changeset
|
843 while (pos < XINT (lim) |
40ea37a6dc40
(skip_chars): Optimize by not calling SET_PT in the loop.
Richard M. Stallman <rms@gnu.org>
parents:
16731
diff
changeset
|
844 && fastmap[(int) SYNTAX (FETCH_CHAR (pos))]) |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
845 INC_POS (pos); |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
846 } |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
847 else |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
848 { |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
849 while (pos > XINT (lim)) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
850 { |
17072 | 851 int savepos = pos; |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
852 DEC_POS (pos); |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
853 if (!fastmap[(int) SYNTAX (FETCH_CHAR (pos))]) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
854 { |
17072 | 855 pos = savepos; |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
856 break; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
857 } |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
858 } |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
859 } |
1684
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
860 } |
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
861 else |
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
862 { |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
863 if (forwardp) |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
864 { |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
865 while (pos < XINT (lim) && fastmap[(c = FETCH_BYTE (pos))]) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
866 { |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
867 if (!BASE_LEADING_CODE_P (c)) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
868 pos++; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
869 else if (n_char_ranges) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
870 { |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
871 /* We much check CHAR_RANGES for a multibyte |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
872 character. */ |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
873 ch = FETCH_MULTIBYTE_CHAR (pos); |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
874 for (i = 0; i < n_char_ranges; i += 2) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
875 if ((ch >= char_ranges[i] && ch <= char_ranges[i + 1])) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
876 break; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
877 if (!(negate ^ (i < n_char_ranges))) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
878 break; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
879 |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
880 INC_POS (pos); |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
881 } |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
882 else |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
883 { |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
884 if (!negate) break; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
885 INC_POS (pos); |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
886 } |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
887 } |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
888 } |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
889 else |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
890 { |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
891 while (pos > XINT (lim)) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
892 { |
17072 | 893 int savepos = pos; |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
894 DEC_POS (pos); |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
895 if (fastmap[(c = FETCH_BYTE (pos))]) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
896 { |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
897 if (!BASE_LEADING_CODE_P (c)) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
898 ; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
899 else if (n_char_ranges) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
900 { |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
901 /* We much check CHAR_RANGES for a multibyte |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
902 character. */ |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
903 ch = FETCH_MULTIBYTE_CHAR (pos); |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
904 for (i = 0; i < n_char_ranges; i += 2) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
905 if (ch >= char_ranges[i] && ch <= char_ranges[i + 1]) |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
906 break; |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
907 if (!(negate ^ (i < n_char_ranges))) |
17072 | 908 { |
909 pos = savepos; | |
910 break; | |
911 } | |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
912 } |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
913 else |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
914 if (!negate) |
17072 | 915 { |
916 pos = savepos; | |
917 break; | |
918 } | |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
919 } |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
920 else |
17072 | 921 { |
922 pos = savepos; | |
923 break; | |
924 } | |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
925 } |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
926 } |
1684
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
927 } |
16880
40ea37a6dc40
(skip_chars): Optimize by not calling SET_PT in the loop.
Richard M. Stallman <rms@gnu.org>
parents:
16731
diff
changeset
|
928 SET_PT (pos); |
1684
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
929 immediate_quit = 0; |
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
930 |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15667
diff
changeset
|
931 return make_number (PT - start_point); |
1684
f4d848dea8ff
* search.c (Fskip_chars_forward, Fskip_chars_backward): Return the
Jim Blandy <jimb@redhat.com>
parents:
1523
diff
changeset
|
932 } |
603 | 933 } |
934 | |
935 /* Subroutines of Lisp buffer search functions. */ | |
936 | |
937 static Lisp_Object | |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
938 search_command (string, bound, noerror, count, direction, RE, posix) |
603 | 939 Lisp_Object string, bound, noerror, count; |
940 int direction; | |
941 int RE; | |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
942 int posix; |
603 | 943 { |
944 register int np; | |
945 int lim; | |
946 int n = direction; | |
947 | |
948 if (!NILP (count)) | |
949 { | |
950 CHECK_NUMBER (count, 3); | |
951 n *= XINT (count); | |
952 } | |
953 | |
954 CHECK_STRING (string, 0); | |
955 if (NILP (bound)) | |
956 lim = n > 0 ? ZV : BEGV; | |
957 else | |
958 { | |
959 CHECK_NUMBER_COERCE_MARKER (bound, 1); | |
960 lim = XINT (bound); | |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15667
diff
changeset
|
961 if (n > 0 ? lim < PT : lim > PT) |
603 | 962 error ("Invalid search bound (wrong side of point)"); |
963 if (lim > ZV) | |
964 lim = ZV; | |
965 if (lim < BEGV) | |
966 lim = BEGV; | |
967 } | |
968 | |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15667
diff
changeset
|
969 np = search_buffer (string, PT, lim, n, RE, |
603 | 970 (!NILP (current_buffer->case_fold_search) |
13237
1aa239b8d03c
(compile_pattern_1, compile_pattern, search_buffer):
Richard M. Stallman <rms@gnu.org>
parents:
12807
diff
changeset
|
971 ? XCHAR_TABLE (current_buffer->case_canon_table)->contents |
1aa239b8d03c
(compile_pattern_1, compile_pattern, search_buffer):
Richard M. Stallman <rms@gnu.org>
parents:
12807
diff
changeset
|
972 : 0), |
603 | 973 (!NILP (current_buffer->case_fold_search) |
13237
1aa239b8d03c
(compile_pattern_1, compile_pattern, search_buffer):
Richard M. Stallman <rms@gnu.org>
parents:
12807
diff
changeset
|
974 ? XCHAR_TABLE (current_buffer->case_eqv_table)->contents |
1aa239b8d03c
(compile_pattern_1, compile_pattern, search_buffer):
Richard M. Stallman <rms@gnu.org>
parents:
12807
diff
changeset
|
975 : 0), |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
976 posix); |
603 | 977 if (np <= 0) |
978 { | |
979 if (NILP (noerror)) | |
980 return signal_failure (string); | |
981 if (!EQ (noerror, Qt)) | |
982 { | |
983 if (lim < BEGV || lim > ZV) | |
984 abort (); | |
1878
1c26d0049d4f
(search_command): #if 0 previous change.
Richard M. Stallman <rms@gnu.org>
parents:
1877
diff
changeset
|
985 SET_PT (lim); |
1c26d0049d4f
(search_command): #if 0 previous change.
Richard M. Stallman <rms@gnu.org>
parents:
1877
diff
changeset
|
986 return Qnil; |
1c26d0049d4f
(search_command): #if 0 previous change.
Richard M. Stallman <rms@gnu.org>
parents:
1877
diff
changeset
|
987 #if 0 /* This would be clean, but maybe programs depend on |
1c26d0049d4f
(search_command): #if 0 previous change.
Richard M. Stallman <rms@gnu.org>
parents:
1877
diff
changeset
|
988 a value of nil here. */ |
1877
7786f61ec635
(search_command): When moving to LIM on failure, return LIM.
Richard M. Stallman <rms@gnu.org>
parents:
1684
diff
changeset
|
989 np = lim; |
1878
1c26d0049d4f
(search_command): #if 0 previous change.
Richard M. Stallman <rms@gnu.org>
parents:
1877
diff
changeset
|
990 #endif |
603 | 991 } |
1877
7786f61ec635
(search_command): When moving to LIM on failure, return LIM.
Richard M. Stallman <rms@gnu.org>
parents:
1684
diff
changeset
|
992 else |
7786f61ec635
(search_command): When moving to LIM on failure, return LIM.
Richard M. Stallman <rms@gnu.org>
parents:
1684
diff
changeset
|
993 return Qnil; |
603 | 994 } |
995 | |
996 if (np < BEGV || np > ZV) | |
997 abort (); | |
998 | |
999 SET_PT (np); | |
1000 | |
1001 return make_number (np); | |
1002 } | |
1003 | |
8950
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1004 static int |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1005 trivial_regexp_p (regexp) |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1006 Lisp_Object regexp; |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1007 { |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1008 int len = XSTRING (regexp)->size; |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1009 unsigned char *s = XSTRING (regexp)->data; |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1010 unsigned char c; |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1011 while (--len >= 0) |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1012 { |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1013 switch (*s++) |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1014 { |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1015 case '.': case '*': case '+': case '?': case '[': case '^': case '$': |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1016 return 0; |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1017 case '\\': |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1018 if (--len < 0) |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1019 return 0; |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1020 switch (*s++) |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1021 { |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1022 case '|': case '(': case ')': case '`': case '\'': case 'b': |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1023 case 'B': case '<': case '>': case 'w': case 'W': case 's': |
12069
505dc29a68cf
(trivial_regexp_p): = is special after \.
Karl Heuer <kwzh@gnu.org>
parents:
11678
diff
changeset
|
1024 case 'S': case '=': |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
1025 case 'c': case 'C': /* for categoryspec and notcategoryspec */ |
12069
505dc29a68cf
(trivial_regexp_p): = is special after \.
Karl Heuer <kwzh@gnu.org>
parents:
11678
diff
changeset
|
1026 case '1': case '2': case '3': case '4': case '5': |
8950
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1027 case '6': case '7': case '8': case '9': |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1028 return 0; |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1029 } |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1030 } |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1031 } |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1032 return 1; |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1033 } |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1034 |
5556
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1035 /* Search for the n'th occurrence of STRING in the current buffer, |
603 | 1036 starting at position POS and stopping at position LIM, |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1037 treating STRING as a literal string if RE is false or as |
603 | 1038 a regular expression if RE is true. |
1039 | |
1040 If N is positive, searching is forward and LIM must be greater than POS. | |
1041 If N is negative, searching is backward and LIM must be less than POS. | |
1042 | |
1043 Returns -x if only N-x occurrences found (x > 0), | |
1044 or else the position at the beginning of the Nth occurrence | |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1045 (if searching backward) or the end (if searching forward). |
603 | 1046 |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1047 POSIX is nonzero if we want full backtracking (POSIX style) |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1048 for this pattern. 0 means backtrack only enough to get a valid match. */ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1049 |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1050 static int |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1051 search_buffer (string, pos, lim, n, RE, trt, inverse_trt, posix) |
603 | 1052 Lisp_Object string; |
1053 int pos; | |
1054 int lim; | |
1055 int n; | |
1056 int RE; | |
13237
1aa239b8d03c
(compile_pattern_1, compile_pattern, search_buffer):
Richard M. Stallman <rms@gnu.org>
parents:
12807
diff
changeset
|
1057 Lisp_Object *trt; |
1aa239b8d03c
(compile_pattern_1, compile_pattern, search_buffer):
Richard M. Stallman <rms@gnu.org>
parents:
12807
diff
changeset
|
1058 Lisp_Object *inverse_trt; |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1059 int posix; |
603 | 1060 { |
1061 int len = XSTRING (string)->size; | |
1062 unsigned char *base_pat = XSTRING (string)->data; | |
1063 register int *BM_tab; | |
1064 int *BM_tab_base; | |
1065 register int direction = ((n > 0) ? 1 : -1); | |
1066 register int dirlen; | |
1067 int infinity, limit, k, stride_for_teases; | |
1068 register unsigned char *pat, *cursor, *p_limit; | |
1069 register int i, j; | |
1070 unsigned char *p1, *p2; | |
1071 int s1, s2; | |
1072 | |
10032
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
1073 if (running_asynch_code) |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
1074 save_search_regs (); |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
1075 |
603 | 1076 /* Null string is found at starting position. */ |
4299
7a2e1d7362c5
(search_buffer): If n is 0, just return POS.
Richard M. Stallman <rms@gnu.org>
parents:
3615
diff
changeset
|
1077 if (len == 0) |
5556
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1078 { |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1079 set_search_regs (pos, 0); |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1080 return pos; |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1081 } |
4299
7a2e1d7362c5
(search_buffer): If n is 0, just return POS.
Richard M. Stallman <rms@gnu.org>
parents:
3615
diff
changeset
|
1082 |
7a2e1d7362c5
(search_buffer): If n is 0, just return POS.
Richard M. Stallman <rms@gnu.org>
parents:
3615
diff
changeset
|
1083 /* Searching 0 times means don't move. */ |
7a2e1d7362c5
(search_buffer): If n is 0, just return POS.
Richard M. Stallman <rms@gnu.org>
parents:
3615
diff
changeset
|
1084 if (n == 0) |
603 | 1085 return pos; |
1086 | |
8950
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1087 if (RE && !trivial_regexp_p (string)) |
603 | 1088 { |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
1089 struct re_pattern_buffer *bufp; |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
1090 |
13237
1aa239b8d03c
(compile_pattern_1, compile_pattern, search_buffer):
Richard M. Stallman <rms@gnu.org>
parents:
12807
diff
changeset
|
1091 bufp = compile_pattern (string, &search_regs, trt, posix); |
603 | 1092 |
1093 immediate_quit = 1; /* Quit immediately if user types ^G, | |
1094 because letting this function finish | |
1095 can take too long. */ | |
1096 QUIT; /* Do a pending quit right away, | |
1097 to avoid paradoxical behavior */ | |
1098 /* Get pointers and sizes of the two strings | |
1099 that make up the visible portion of the buffer. */ | |
1100 | |
1101 p1 = BEGV_ADDR; | |
1102 s1 = GPT - BEGV; | |
1103 p2 = GAP_END_ADDR; | |
1104 s2 = ZV - GPT; | |
1105 if (s1 < 0) | |
1106 { | |
1107 p2 = p1; | |
1108 s2 = ZV - BEGV; | |
1109 s1 = 0; | |
1110 } | |
1111 if (s2 < 0) | |
1112 { | |
1113 s1 = ZV - BEGV; | |
1114 s2 = 0; | |
1115 } | |
1116 while (n < 0) | |
1117 { | |
2475
052bbdf1b817
(search_buffer): Fix typo in previous change.
Richard M. Stallman <rms@gnu.org>
parents:
2439
diff
changeset
|
1118 int val; |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
1119 val = re_search_2 (bufp, (char *) p1, s1, (char *) p2, s2, |
2475
052bbdf1b817
(search_buffer): Fix typo in previous change.
Richard M. Stallman <rms@gnu.org>
parents:
2439
diff
changeset
|
1120 pos - BEGV, lim - pos, &search_regs, |
052bbdf1b817
(search_buffer): Fix typo in previous change.
Richard M. Stallman <rms@gnu.org>
parents:
2439
diff
changeset
|
1121 /* Don't allow match past current point */ |
052bbdf1b817
(search_buffer): Fix typo in previous change.
Richard M. Stallman <rms@gnu.org>
parents:
2439
diff
changeset
|
1122 pos - BEGV); |
603 | 1123 if (val == -2) |
8950
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1124 { |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1125 matcher_overflow (); |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1126 } |
603 | 1127 if (val >= 0) |
1128 { | |
1129 j = BEGV; | |
621 | 1130 for (i = 0; i < search_regs.num_regs; i++) |
603 | 1131 if (search_regs.start[i] >= 0) |
1132 { | |
1133 search_regs.start[i] += j; | |
1134 search_regs.end[i] += j; | |
1135 } | |
9278
f2138d548313
(Flooking_at, skip_chars, search_buffer, set_search_regs, Fstore_match_data):
Karl Heuer <kwzh@gnu.org>
parents:
9113
diff
changeset
|
1136 XSETBUFFER (last_thing_searched, current_buffer); |
603 | 1137 /* Set pos to the new position. */ |
1138 pos = search_regs.start[0]; | |
1139 } | |
1140 else | |
1141 { | |
1142 immediate_quit = 0; | |
1143 return (n); | |
1144 } | |
1145 n++; | |
1146 } | |
1147 while (n > 0) | |
1148 { | |
2475
052bbdf1b817
(search_buffer): Fix typo in previous change.
Richard M. Stallman <rms@gnu.org>
parents:
2439
diff
changeset
|
1149 int val; |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
1150 val = re_search_2 (bufp, (char *) p1, s1, (char *) p2, s2, |
2475
052bbdf1b817
(search_buffer): Fix typo in previous change.
Richard M. Stallman <rms@gnu.org>
parents:
2439
diff
changeset
|
1151 pos - BEGV, lim - pos, &search_regs, |
052bbdf1b817
(search_buffer): Fix typo in previous change.
Richard M. Stallman <rms@gnu.org>
parents:
2439
diff
changeset
|
1152 lim - BEGV); |
603 | 1153 if (val == -2) |
8950
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1154 { |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1155 matcher_overflow (); |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1156 } |
603 | 1157 if (val >= 0) |
1158 { | |
1159 j = BEGV; | |
621 | 1160 for (i = 0; i < search_regs.num_regs; i++) |
603 | 1161 if (search_regs.start[i] >= 0) |
1162 { | |
1163 search_regs.start[i] += j; | |
1164 search_regs.end[i] += j; | |
1165 } | |
9278
f2138d548313
(Flooking_at, skip_chars, search_buffer, set_search_regs, Fstore_match_data):
Karl Heuer <kwzh@gnu.org>
parents:
9113
diff
changeset
|
1166 XSETBUFFER (last_thing_searched, current_buffer); |
603 | 1167 pos = search_regs.end[0]; |
1168 } | |
1169 else | |
1170 { | |
1171 immediate_quit = 0; | |
1172 return (0 - n); | |
1173 } | |
1174 n--; | |
1175 } | |
1176 immediate_quit = 0; | |
1177 return (pos); | |
1178 } | |
1179 else /* non-RE case */ | |
1180 { | |
1181 #ifdef C_ALLOCA | |
1182 int BM_tab_space[0400]; | |
1183 BM_tab = &BM_tab_space[0]; | |
1184 #else | |
1185 BM_tab = (int *) alloca (0400 * sizeof (int)); | |
1186 #endif | |
8950
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1187 { |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1188 unsigned char *patbuf = (unsigned char *) alloca (len); |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1189 pat = patbuf; |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1190 while (--len >= 0) |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1191 { |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1192 /* If we got here and the RE flag is set, it's because we're |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1193 dealing with a regexp known to be trivial, so the backslash |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1194 just quotes the next character. */ |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1195 if (RE && *base_pat == '\\') |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1196 { |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1197 len--; |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1198 base_pat++; |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1199 } |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1200 *pat++ = (trt ? trt[*base_pat++] : *base_pat++); |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1201 } |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1202 len = pat - patbuf; |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1203 pat = base_pat = patbuf; |
68ad2f08d735
(trivial_regexp_p): New function.
Karl Heuer <kwzh@gnu.org>
parents:
8584
diff
changeset
|
1204 } |
603 | 1205 /* The general approach is that we are going to maintain that we know */ |
1206 /* the first (closest to the present position, in whatever direction */ | |
1207 /* we're searching) character that could possibly be the last */ | |
1208 /* (furthest from present position) character of a valid match. We */ | |
1209 /* advance the state of our knowledge by looking at that character */ | |
1210 /* and seeing whether it indeed matches the last character of the */ | |
1211 /* pattern. If it does, we take a closer look. If it does not, we */ | |
1212 /* move our pointer (to putative last characters) as far as is */ | |
1213 /* logically possible. This amount of movement, which I call a */ | |
1214 /* stride, will be the length of the pattern if the actual character */ | |
1215 /* appears nowhere in the pattern, otherwise it will be the distance */ | |
1216 /* from the last occurrence of that character to the end of the */ | |
1217 /* pattern. */ | |
1218 /* As a coding trick, an enormous stride is coded into the table for */ | |
1219 /* characters that match the last character. This allows use of only */ | |
1220 /* a single test, a test for having gone past the end of the */ | |
1221 /* permissible match region, to test for both possible matches (when */ | |
1222 /* the stride goes past the end immediately) and failure to */ | |
1223 /* match (where you get nudged past the end one stride at a time). */ | |
1224 | |
1225 /* Here we make a "mickey mouse" BM table. The stride of the search */ | |
1226 /* is determined only by the last character of the putative match. */ | |
1227 /* If that character does not match, we will stride the proper */ | |
1228 /* distance to propose a match that superimposes it on the last */ | |
1229 /* instance of a character that matches it (per trt), or misses */ | |
1230 /* it entirely if there is none. */ | |
1231 | |
1232 dirlen = len * direction; | |
1233 infinity = dirlen - (lim + pos + len + len) * direction; | |
1234 if (direction < 0) | |
1235 pat = (base_pat += len - 1); | |
1236 BM_tab_base = BM_tab; | |
1237 BM_tab += 0400; | |
1238 j = dirlen; /* to get it in a register */ | |
1239 /* A character that does not appear in the pattern induces a */ | |
1240 /* stride equal to the pattern length. */ | |
1241 while (BM_tab_base != BM_tab) | |
1242 { | |
1243 *--BM_tab = j; | |
1244 *--BM_tab = j; | |
1245 *--BM_tab = j; | |
1246 *--BM_tab = j; | |
1247 } | |
1248 i = 0; | |
1249 while (i != infinity) | |
1250 { | |
1251 j = pat[i]; i += direction; | |
1252 if (i == dirlen) i = infinity; | |
11262
6386347256f0
(search_buffer): Avoid casting trt to int.
Richard M. Stallman <rms@gnu.org>
parents:
11213
diff
changeset
|
1253 if (trt != 0) |
603 | 1254 { |
1255 k = (j = trt[j]); | |
1256 if (i == infinity) | |
1257 stride_for_teases = BM_tab[j]; | |
1258 BM_tab[j] = dirlen - i; | |
1259 /* A translation table is accompanied by its inverse -- see */ | |
1260 /* comment following downcase_table for details */ | |
13237
1aa239b8d03c
(compile_pattern_1, compile_pattern, search_buffer):
Richard M. Stallman <rms@gnu.org>
parents:
12807
diff
changeset
|
1261 while ((j = (unsigned char) inverse_trt[j]) != k) |
603 | 1262 BM_tab[j] = dirlen - i; |
1263 } | |
1264 else | |
1265 { | |
1266 if (i == infinity) | |
1267 stride_for_teases = BM_tab[j]; | |
1268 BM_tab[j] = dirlen - i; | |
1269 } | |
1270 /* stride_for_teases tells how much to stride if we get a */ | |
1271 /* match on the far character but are subsequently */ | |
1272 /* disappointed, by recording what the stride would have been */ | |
1273 /* for that character if the last character had been */ | |
1274 /* different. */ | |
1275 } | |
1276 infinity = dirlen - infinity; | |
1277 pos += dirlen - ((direction > 0) ? direction : 0); | |
1278 /* loop invariant - pos points at where last char (first char if reverse) | |
1279 of pattern would align in a possible match. */ | |
1280 while (n != 0) | |
1281 { | |
6343
372613d5970b
(search_buffer): Avoid boolean/integer mixing that confuses some compilers.
Karl Heuer <kwzh@gnu.org>
parents:
6297
diff
changeset
|
1282 /* It's been reported that some (broken) compiler thinks that |
372613d5970b
(search_buffer): Avoid boolean/integer mixing that confuses some compilers.
Karl Heuer <kwzh@gnu.org>
parents:
6297
diff
changeset
|
1283 Boolean expressions in an arithmetic context are unsigned. |
372613d5970b
(search_buffer): Avoid boolean/integer mixing that confuses some compilers.
Karl Heuer <kwzh@gnu.org>
parents:
6297
diff
changeset
|
1284 Using an explicit ?1:0 prevents this. */ |
372613d5970b
(search_buffer): Avoid boolean/integer mixing that confuses some compilers.
Karl Heuer <kwzh@gnu.org>
parents:
6297
diff
changeset
|
1285 if ((lim - pos - ((direction > 0) ? 1 : 0)) * direction < 0) |
603 | 1286 return (n * (0 - direction)); |
1287 /* First we do the part we can by pointers (maybe nothing) */ | |
1288 QUIT; | |
1289 pat = base_pat; | |
1290 limit = pos - dirlen + direction; | |
1291 limit = ((direction > 0) | |
1292 ? BUFFER_CEILING_OF (limit) | |
1293 : BUFFER_FLOOR_OF (limit)); | |
1294 /* LIMIT is now the last (not beyond-last!) value | |
1295 POS can take on without hitting edge of buffer or the gap. */ | |
1296 limit = ((direction > 0) | |
1297 ? min (lim - 1, min (limit, pos + 20000)) | |
1298 : max (lim, max (limit, pos - 20000))); | |
1299 if ((limit - pos) * direction > 20) | |
1300 { | |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
1301 p_limit = POS_ADDR (limit); |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
1302 p2 = (cursor = POS_ADDR (pos)); |
603 | 1303 /* In this loop, pos + cursor - p2 is the surrogate for pos */ |
1304 while (1) /* use one cursor setting as long as i can */ | |
1305 { | |
1306 if (direction > 0) /* worth duplicating */ | |
1307 { | |
1308 /* Use signed comparison if appropriate | |
1309 to make cursor+infinity sure to be > p_limit. | |
1310 Assuming that the buffer lies in a range of addresses | |
1311 that are all "positive" (as ints) or all "negative", | |
1312 either kind of comparison will work as long | |
1313 as we don't step by infinity. So pick the kind | |
1314 that works when we do step by infinity. */ | |
11262
6386347256f0
(search_buffer): Avoid casting trt to int.
Richard M. Stallman <rms@gnu.org>
parents:
11213
diff
changeset
|
1315 if ((EMACS_INT) (p_limit + infinity) > (EMACS_INT) p_limit) |
11678
c0e33cdebfab
(search_buffer): Cast p_limit to EMACS_INT not int.
Richard M. Stallman <rms@gnu.org>
parents:
11262
diff
changeset
|
1316 while ((EMACS_INT) cursor <= (EMACS_INT) p_limit) |
603 | 1317 cursor += BM_tab[*cursor]; |
1318 else | |
16152
cc2b553290aa
(search_buffer): Use EMACS_UINT.
Richard M. Stallman <rms@gnu.org>
parents:
16039
diff
changeset
|
1319 while ((EMACS_UINT) cursor <= (EMACS_UINT) p_limit) |
603 | 1320 cursor += BM_tab[*cursor]; |
1321 } | |
1322 else | |
1323 { | |
11262
6386347256f0
(search_buffer): Avoid casting trt to int.
Richard M. Stallman <rms@gnu.org>
parents:
11213
diff
changeset
|
1324 if ((EMACS_INT) (p_limit + infinity) < (EMACS_INT) p_limit) |
6386347256f0
(search_buffer): Avoid casting trt to int.
Richard M. Stallman <rms@gnu.org>
parents:
11213
diff
changeset
|
1325 while ((EMACS_INT) cursor >= (EMACS_INT) p_limit) |
603 | 1326 cursor += BM_tab[*cursor]; |
1327 else | |
16152
cc2b553290aa
(search_buffer): Use EMACS_UINT.
Richard M. Stallman <rms@gnu.org>
parents:
16039
diff
changeset
|
1328 while ((EMACS_UINT) cursor >= (EMACS_UINT) p_limit) |
603 | 1329 cursor += BM_tab[*cursor]; |
1330 } | |
1331 /* If you are here, cursor is beyond the end of the searched region. */ | |
1332 /* This can happen if you match on the far character of the pattern, */ | |
1333 /* because the "stride" of that character is infinity, a number able */ | |
1334 /* to throw you well beyond the end of the search. It can also */ | |
1335 /* happen if you fail to match within the permitted region and would */ | |
1336 /* otherwise try a character beyond that region */ | |
1337 if ((cursor - p_limit) * direction <= len) | |
1338 break; /* a small overrun is genuine */ | |
1339 cursor -= infinity; /* large overrun = hit */ | |
1340 i = dirlen - direction; | |
11262
6386347256f0
(search_buffer): Avoid casting trt to int.
Richard M. Stallman <rms@gnu.org>
parents:
11213
diff
changeset
|
1341 if (trt != 0) |
603 | 1342 { |
1343 while ((i -= direction) + direction != 0) | |
1344 if (pat[i] != trt[*(cursor -= direction)]) | |
1345 break; | |
1346 } | |
1347 else | |
1348 { | |
1349 while ((i -= direction) + direction != 0) | |
1350 if (pat[i] != *(cursor -= direction)) | |
1351 break; | |
1352 } | |
1353 cursor += dirlen - i - direction; /* fix cursor */ | |
1354 if (i + direction == 0) | |
1355 { | |
1356 cursor -= direction; | |
708 | 1357 |
5556
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1358 set_search_regs (pos + cursor - p2 + ((direction > 0) |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1359 ? 1 - len : 0), |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1360 len); |
708 | 1361 |
603 | 1362 if ((n -= direction) != 0) |
1363 cursor += dirlen; /* to resume search */ | |
1364 else | |
1365 return ((direction > 0) | |
1366 ? search_regs.end[0] : search_regs.start[0]); | |
1367 } | |
1368 else | |
1369 cursor += stride_for_teases; /* <sigh> we lose - */ | |
1370 } | |
1371 pos += cursor - p2; | |
1372 } | |
1373 else | |
1374 /* Now we'll pick up a clump that has to be done the hard */ | |
1375 /* way because it covers a discontinuity */ | |
1376 { | |
1377 limit = ((direction > 0) | |
1378 ? BUFFER_CEILING_OF (pos - dirlen + 1) | |
1379 : BUFFER_FLOOR_OF (pos - dirlen - 1)); | |
1380 limit = ((direction > 0) | |
1381 ? min (limit + len, lim - 1) | |
1382 : max (limit - len, lim)); | |
1383 /* LIMIT is now the last value POS can have | |
1384 and still be valid for a possible match. */ | |
1385 while (1) | |
1386 { | |
1387 /* This loop can be coded for space rather than */ | |
1388 /* speed because it will usually run only once. */ | |
1389 /* (the reach is at most len + 21, and typically */ | |
1390 /* does not exceed len) */ | |
1391 while ((limit - pos) * direction >= 0) | |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
1392 pos += BM_tab[FETCH_BYTE (pos)]; |
603 | 1393 /* now run the same tests to distinguish going off the */ |
3591
507f64624555
Apply typo patches from Paul Eggert.
Jim Blandy <jimb@redhat.com>
parents:
2961
diff
changeset
|
1394 /* end, a match or a phony match. */ |
603 | 1395 if ((pos - limit) * direction <= len) |
1396 break; /* ran off the end */ | |
1397 /* Found what might be a match. | |
1398 Set POS back to last (first if reverse) char pos. */ | |
1399 pos -= infinity; | |
1400 i = dirlen - direction; | |
1401 while ((i -= direction) + direction != 0) | |
1402 { | |
1403 pos -= direction; | |
11262
6386347256f0
(search_buffer): Avoid casting trt to int.
Richard M. Stallman <rms@gnu.org>
parents:
11213
diff
changeset
|
1404 if (pat[i] != (trt != 0 |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
1405 ? trt[FETCH_BYTE (pos)] |
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
1406 : FETCH_BYTE (pos))) |
603 | 1407 break; |
1408 } | |
1409 /* Above loop has moved POS part or all the way | |
1410 back to the first char pos (last char pos if reverse). | |
1411 Set it once again at the last (first if reverse) char. */ | |
1412 pos += dirlen - i- direction; | |
1413 if (i + direction == 0) | |
1414 { | |
1415 pos -= direction; | |
708 | 1416 |
5556
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1417 set_search_regs (pos + ((direction > 0) ? 1 - len : 0), |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1418 len); |
708 | 1419 |
603 | 1420 if ((n -= direction) != 0) |
1421 pos += dirlen; /* to resume search */ | |
1422 else | |
1423 return ((direction > 0) | |
1424 ? search_regs.end[0] : search_regs.start[0]); | |
1425 } | |
1426 else | |
1427 pos += stride_for_teases; | |
1428 } | |
1429 } | |
1430 /* We have done one clump. Can we continue? */ | |
1431 if ((lim - pos) * direction < 0) | |
1432 return ((0 - n) * direction); | |
1433 } | |
1434 return pos; | |
1435 } | |
1436 } | |
5556
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1437 |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1438 /* Record beginning BEG and end BEG + LEN |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1439 for a match just found in the current buffer. */ |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1440 |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1441 static void |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1442 set_search_regs (beg, len) |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1443 int beg, len; |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1444 { |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1445 /* Make sure we have registers in which to store |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1446 the match position. */ |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1447 if (search_regs.num_regs == 0) |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1448 { |
10250
422c3b96efda
(set_search_regs): Really set search_regs.start and .end.
Richard M. Stallman <rms@gnu.org>
parents:
10141
diff
changeset
|
1449 search_regs.start = (regoff_t *) xmalloc (2 * sizeof (regoff_t)); |
422c3b96efda
(set_search_regs): Really set search_regs.start and .end.
Richard M. Stallman <rms@gnu.org>
parents:
10141
diff
changeset
|
1450 search_regs.end = (regoff_t *) xmalloc (2 * sizeof (regoff_t)); |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
1451 search_regs.num_regs = 2; |
5556
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1452 } |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1453 |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1454 search_regs.start[0] = beg; |
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1455 search_regs.end[0] = beg + len; |
9278
f2138d548313
(Flooking_at, skip_chars, search_buffer, set_search_regs, Fstore_match_data):
Karl Heuer <kwzh@gnu.org>
parents:
9113
diff
changeset
|
1456 XSETBUFFER (last_thing_searched, current_buffer); |
5556
14161cfec24a
(set_search_regs): New subroutine.
Richard M. Stallman <rms@gnu.org>
parents:
4954
diff
changeset
|
1457 } |
603 | 1458 |
1459 /* Given a string of words separated by word delimiters, | |
1460 compute a regexp that matches those exact words | |
1461 separated by arbitrary punctuation. */ | |
1462 | |
1463 static Lisp_Object | |
1464 wordify (string) | |
1465 Lisp_Object string; | |
1466 { | |
1467 register unsigned char *p, *o; | |
1468 register int i, len, punct_count = 0, word_count = 0; | |
1469 Lisp_Object val; | |
1470 | |
1471 CHECK_STRING (string, 0); | |
1472 p = XSTRING (string)->data; | |
1473 len = XSTRING (string)->size; | |
1474 | |
1475 for (i = 0; i < len; i++) | |
1476 if (SYNTAX (p[i]) != Sword) | |
1477 { | |
1478 punct_count++; | |
1479 if (i > 0 && SYNTAX (p[i-1]) == Sword) word_count++; | |
1480 } | |
1481 if (SYNTAX (p[len-1]) == Sword) word_count++; | |
1482 if (!word_count) return build_string (""); | |
1483 | |
1484 val = make_string (p, len - punct_count + 5 * (word_count - 1) + 4); | |
1485 | |
1486 o = XSTRING (val)->data; | |
1487 *o++ = '\\'; | |
1488 *o++ = 'b'; | |
1489 | |
1490 for (i = 0; i < len; i++) | |
1491 if (SYNTAX (p[i]) == Sword) | |
1492 *o++ = p[i]; | |
1493 else if (i > 0 && SYNTAX (p[i-1]) == Sword && --word_count) | |
1494 { | |
1495 *o++ = '\\'; | |
1496 *o++ = 'W'; | |
1497 *o++ = '\\'; | |
1498 *o++ = 'W'; | |
1499 *o++ = '*'; | |
1500 } | |
1501 | |
1502 *o++ = '\\'; | |
1503 *o++ = 'b'; | |
1504 | |
1505 return val; | |
1506 } | |
1507 | |
1508 DEFUN ("search-backward", Fsearch_backward, Ssearch_backward, 1, 4, | |
1509 "sSearch backward: ", | |
1510 "Search backward from point for STRING.\n\ | |
1511 Set point to the beginning of the occurrence found, and return point.\n\ | |
1512 An optional second argument bounds the search; it is a buffer position.\n\ | |
1513 The match found must not extend before that position.\n\ | |
1514 Optional third argument, if t, means if fail just return nil (no error).\n\ | |
1515 If not nil and not t, position at limit of search and return nil.\n\ | |
1516 Optional fourth argument is repeat count--search for successive occurrences.\n\ | |
1517 See also the functions `match-beginning', `match-end' and `replace-match'.") | |
1518 (string, bound, noerror, count) | |
1519 Lisp_Object string, bound, noerror, count; | |
1520 { | |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1521 return search_command (string, bound, noerror, count, -1, 0, 0); |
603 | 1522 } |
1523 | |
1524 DEFUN ("search-forward", Fsearch_forward, Ssearch_forward, 1, 4, "sSearch: ", | |
1525 "Search forward from point for STRING.\n\ | |
1526 Set point to the end of the occurrence found, and return point.\n\ | |
1527 An optional second argument bounds the search; it is a buffer position.\n\ | |
1528 The match found must not extend after that position. nil is equivalent\n\ | |
1529 to (point-max).\n\ | |
1530 Optional third argument, if t, means if fail just return nil (no error).\n\ | |
1531 If not nil and not t, move to limit of search and return nil.\n\ | |
1532 Optional fourth argument is repeat count--search for successive occurrences.\n\ | |
1533 See also the functions `match-beginning', `match-end' and `replace-match'.") | |
1534 (string, bound, noerror, count) | |
1535 Lisp_Object string, bound, noerror, count; | |
1536 { | |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1537 return search_command (string, bound, noerror, count, 1, 0, 0); |
603 | 1538 } |
1539 | |
1540 DEFUN ("word-search-backward", Fword_search_backward, Sword_search_backward, 1, 4, | |
1541 "sWord search backward: ", | |
1542 "Search backward from point for STRING, ignoring differences in punctuation.\n\ | |
1543 Set point to the beginning of the occurrence found, and return point.\n\ | |
1544 An optional second argument bounds the search; it is a buffer position.\n\ | |
1545 The match found must not extend before that position.\n\ | |
1546 Optional third argument, if t, means if fail just return nil (no error).\n\ | |
1547 If not nil and not t, move to limit of search and return nil.\n\ | |
1548 Optional fourth argument is repeat count--search for successive occurrences.") | |
1549 (string, bound, noerror, count) | |
1550 Lisp_Object string, bound, noerror, count; | |
1551 { | |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1552 return search_command (wordify (string), bound, noerror, count, -1, 1, 0); |
603 | 1553 } |
1554 | |
1555 DEFUN ("word-search-forward", Fword_search_forward, Sword_search_forward, 1, 4, | |
1556 "sWord search: ", | |
1557 "Search forward from point for STRING, ignoring differences in punctuation.\n\ | |
1558 Set point to the end of the occurrence found, and return point.\n\ | |
1559 An optional second argument bounds the search; it is a buffer position.\n\ | |
1560 The match found must not extend after that position.\n\ | |
1561 Optional third argument, if t, means if fail just return nil (no error).\n\ | |
1562 If not nil and not t, move to limit of search and return nil.\n\ | |
1563 Optional fourth argument is repeat count--search for successive occurrences.") | |
1564 (string, bound, noerror, count) | |
1565 Lisp_Object string, bound, noerror, count; | |
1566 { | |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1567 return search_command (wordify (string), bound, noerror, count, 1, 1, 0); |
603 | 1568 } |
1569 | |
1570 DEFUN ("re-search-backward", Fre_search_backward, Sre_search_backward, 1, 4, | |
1571 "sRE search backward: ", | |
1572 "Search backward from point for match for regular expression REGEXP.\n\ | |
1573 Set point to the beginning of the match, and return point.\n\ | |
1574 The match found is the one starting last in the buffer\n\ | |
6297
b44907fd0ff0
(Fre_search_forward, Fre_search_backward): Doc fix.
Karl Heuer <kwzh@gnu.org>
parents:
6196
diff
changeset
|
1575 and yet ending before the origin of the search.\n\ |
603 | 1576 An optional second argument bounds the search; it is a buffer position.\n\ |
1577 The match found must start at or after that position.\n\ | |
1578 Optional third argument, if t, means if fail just return nil (no error).\n\ | |
1579 If not nil and not t, move to limit of search and return nil.\n\ | |
1580 Optional fourth argument is repeat count--search for successive occurrences.\n\ | |
1581 See also the functions `match-beginning', `match-end' and `replace-match'.") | |
6297
b44907fd0ff0
(Fre_search_forward, Fre_search_backward): Doc fix.
Karl Heuer <kwzh@gnu.org>
parents:
6196
diff
changeset
|
1582 (regexp, bound, noerror, count) |
b44907fd0ff0
(Fre_search_forward, Fre_search_backward): Doc fix.
Karl Heuer <kwzh@gnu.org>
parents:
6196
diff
changeset
|
1583 Lisp_Object regexp, bound, noerror, count; |
603 | 1584 { |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1585 return search_command (regexp, bound, noerror, count, -1, 1, 0); |
603 | 1586 } |
1587 | |
1588 DEFUN ("re-search-forward", Fre_search_forward, Sre_search_forward, 1, 4, | |
1589 "sRE search: ", | |
1590 "Search forward from point for regular expression REGEXP.\n\ | |
1591 Set point to the end of the occurrence found, and return point.\n\ | |
1592 An optional second argument bounds the search; it is a buffer position.\n\ | |
1593 The match found must not extend after that position.\n\ | |
1594 Optional third argument, if t, means if fail just return nil (no error).\n\ | |
1595 If not nil and not t, move to limit of search and return nil.\n\ | |
1596 Optional fourth argument is repeat count--search for successive occurrences.\n\ | |
1597 See also the functions `match-beginning', `match-end' and `replace-match'.") | |
6297
b44907fd0ff0
(Fre_search_forward, Fre_search_backward): Doc fix.
Karl Heuer <kwzh@gnu.org>
parents:
6196
diff
changeset
|
1598 (regexp, bound, noerror, count) |
b44907fd0ff0
(Fre_search_forward, Fre_search_backward): Doc fix.
Karl Heuer <kwzh@gnu.org>
parents:
6196
diff
changeset
|
1599 Lisp_Object regexp, bound, noerror, count; |
603 | 1600 { |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1601 return search_command (regexp, bound, noerror, count, 1, 1, 0); |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1602 } |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1603 |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1604 DEFUN ("posix-search-backward", Fposix_search_backward, Sposix_search_backward, 1, 4, |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1605 "sPosix search backward: ", |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1606 "Search backward from point for match for regular expression REGEXP.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1607 Find the longest match in accord with Posix regular expression rules.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1608 Set point to the beginning of the match, and return point.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1609 The match found is the one starting last in the buffer\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1610 and yet ending before the origin of the search.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1611 An optional second argument bounds the search; it is a buffer position.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1612 The match found must start at or after that position.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1613 Optional third argument, if t, means if fail just return nil (no error).\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1614 If not nil and not t, move to limit of search and return nil.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1615 Optional fourth argument is repeat count--search for successive occurrences.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1616 See also the functions `match-beginning', `match-end' and `replace-match'.") |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1617 (regexp, bound, noerror, count) |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1618 Lisp_Object regexp, bound, noerror, count; |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1619 { |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1620 return search_command (regexp, bound, noerror, count, -1, 1, 1); |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1621 } |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1622 |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1623 DEFUN ("posix-search-forward", Fposix_search_forward, Sposix_search_forward, 1, 4, |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1624 "sPosix search: ", |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1625 "Search forward from point for regular expression REGEXP.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1626 Find the longest match in accord with Posix regular expression rules.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1627 Set point to the end of the occurrence found, and return point.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1628 An optional second argument bounds the search; it is a buffer position.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1629 The match found must not extend after that position.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1630 Optional third argument, if t, means if fail just return nil (no error).\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1631 If not nil and not t, move to limit of search and return nil.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1632 Optional fourth argument is repeat count--search for successive occurrences.\n\ |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1633 See also the functions `match-beginning', `match-end' and `replace-match'.") |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1634 (regexp, bound, noerror, count) |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1635 Lisp_Object regexp, bound, noerror, count; |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1636 { |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
1637 return search_command (regexp, bound, noerror, count, 1, 1, 1); |
603 | 1638 } |
1639 | |
12807
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1640 DEFUN ("replace-match", Freplace_match, Sreplace_match, 1, 5, 0, |
603 | 1641 "Replace text matched by last search with NEWTEXT.\n\ |
1642 If second arg FIXEDCASE is non-nil, do not alter case of replacement text.\n\ | |
6543
33032ee16c7c
(Freplace_match): Doc fix.
Richard M. Stallman <rms@gnu.org>
parents:
6343
diff
changeset
|
1643 Otherwise maybe capitalize the whole text, or maybe just word initials,\n\ |
33032ee16c7c
(Freplace_match): Doc fix.
Richard M. Stallman <rms@gnu.org>
parents:
6343
diff
changeset
|
1644 based on the replaced text.\n\ |
33032ee16c7c
(Freplace_match): Doc fix.
Richard M. Stallman <rms@gnu.org>
parents:
6343
diff
changeset
|
1645 If the replaced text has only capital letters\n\ |
33032ee16c7c
(Freplace_match): Doc fix.
Richard M. Stallman <rms@gnu.org>
parents:
6343
diff
changeset
|
1646 and has at least one multiletter word, convert NEWTEXT to all caps.\n\ |
33032ee16c7c
(Freplace_match): Doc fix.
Richard M. Stallman <rms@gnu.org>
parents:
6343
diff
changeset
|
1647 If the replaced text has at least one word starting with a capital letter,\n\ |
33032ee16c7c
(Freplace_match): Doc fix.
Richard M. Stallman <rms@gnu.org>
parents:
6343
diff
changeset
|
1648 then capitalize each word in NEWTEXT.\n\n\ |
603 | 1649 If third arg LITERAL is non-nil, insert NEWTEXT literally.\n\ |
1650 Otherwise treat `\\' as special:\n\ | |
1651 `\\&' in NEWTEXT means substitute original matched text.\n\ | |
1652 `\\N' means substitute what matched the Nth `\\(...\\)'.\n\ | |
1653 If Nth parens didn't match, substitute nothing.\n\ | |
1654 `\\\\' means insert one `\\'.\n\ | |
708 | 1655 FIXEDCASE and LITERAL are optional arguments.\n\ |
9029
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1656 Leaves point at end of replacement text.\n\ |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1657 \n\ |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1658 The optional fourth argument STRING can be a string to modify.\n\ |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1659 In that case, this function creates and returns a new string\n\ |
12807
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1660 which is made by replacing the part of STRING that was matched.\n\ |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1661 \n\ |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1662 The optional fifth argument SUBEXP specifies a subexpression of the match.\n\ |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1663 It says to replace just that subexpression instead of the whole match.\n\ |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1664 This is useful only after a regular expression search or match\n\ |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1665 since only regular expressions have distinguished subexpressions.") |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1666 (newtext, fixedcase, literal, string, subexp) |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1667 Lisp_Object newtext, fixedcase, literal, string, subexp; |
603 | 1668 { |
1669 enum { nochange, all_caps, cap_initial } case_action; | |
1670 register int pos, last; | |
1671 int some_multiletter_word; | |
2393
a35d2c5cbb3b
(Freplace_match): Clean up criterion about converting case.
Richard M. Stallman <rms@gnu.org>
parents:
1926
diff
changeset
|
1672 int some_lowercase; |
7674
947d24fefd9e
(Freplace_match): Improve capitalization heuristics.
Karl Heuer <kwzh@gnu.org>
parents:
7673
diff
changeset
|
1673 int some_uppercase; |
8526
2b7b23059f1b
(Freplace_match): Treat caseless initial like a lowercase initial.
Richard M. Stallman <rms@gnu.org>
parents:
7891
diff
changeset
|
1674 int some_nonuppercase_initial; |
603 | 1675 register int c, prevc; |
1676 int inslen; | |
12807
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1677 int sub; |
603 | 1678 |
4882
8c09f87f5087
(Freplace_match): Fix argument names to match doc string.
Brian Fox <bfox@gnu.org>
parents:
4832
diff
changeset
|
1679 CHECK_STRING (newtext, 0); |
603 | 1680 |
9029
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1681 if (! NILP (string)) |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1682 CHECK_STRING (string, 4); |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1683 |
603 | 1684 case_action = nochange; /* We tried an initialization */ |
1685 /* but some C compilers blew it */ | |
621 | 1686 |
1687 if (search_regs.num_regs <= 0) | |
1688 error ("replace-match called before any match found"); | |
1689 | |
12807
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1690 if (NILP (subexp)) |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1691 sub = 0; |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1692 else |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1693 { |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1694 CHECK_NUMBER (subexp, 3); |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1695 sub = XINT (subexp); |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1696 if (sub < 0 || sub >= search_regs.num_regs) |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1697 args_out_of_range (subexp, make_number (search_regs.num_regs)); |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1698 } |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1699 |
9029
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1700 if (NILP (string)) |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1701 { |
12807
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1702 if (search_regs.start[sub] < BEGV |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1703 || search_regs.start[sub] > search_regs.end[sub] |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1704 || search_regs.end[sub] > ZV) |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1705 args_out_of_range (make_number (search_regs.start[sub]), |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1706 make_number (search_regs.end[sub])); |
9029
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1707 } |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1708 else |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1709 { |
12807
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1710 if (search_regs.start[sub] < 0 |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1711 || search_regs.start[sub] > search_regs.end[sub] |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1712 || search_regs.end[sub] > XSTRING (string)->size) |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1713 args_out_of_range (make_number (search_regs.start[sub]), |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1714 make_number (search_regs.end[sub])); |
9029
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1715 } |
603 | 1716 |
1717 if (NILP (fixedcase)) | |
1718 { | |
1719 /* Decide how to casify by examining the matched text. */ | |
1720 | |
12807
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1721 last = search_regs.end[sub]; |
603 | 1722 prevc = '\n'; |
1723 case_action = all_caps; | |
1724 | |
1725 /* some_multiletter_word is set nonzero if any original word | |
1726 is more than one letter long. */ | |
1727 some_multiletter_word = 0; | |
2393
a35d2c5cbb3b
(Freplace_match): Clean up criterion about converting case.
Richard M. Stallman <rms@gnu.org>
parents:
1926
diff
changeset
|
1728 some_lowercase = 0; |
8526
2b7b23059f1b
(Freplace_match): Treat caseless initial like a lowercase initial.
Richard M. Stallman <rms@gnu.org>
parents:
7891
diff
changeset
|
1729 some_nonuppercase_initial = 0; |
7674
947d24fefd9e
(Freplace_match): Improve capitalization heuristics.
Karl Heuer <kwzh@gnu.org>
parents:
7673
diff
changeset
|
1730 some_uppercase = 0; |
603 | 1731 |
12807
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1732 for (pos = search_regs.start[sub]; pos < last; pos++) |
603 | 1733 { |
9029
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1734 if (NILP (string)) |
17053
df904355f033
Include category.h and charset.h.
Karl Heuer <kwzh@gnu.org>
parents:
16880
diff
changeset
|
1735 c = FETCH_BYTE (pos); |
9029
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1736 else |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1737 c = XSTRING (string)->data[pos]; |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1738 |
603 | 1739 if (LOWERCASEP (c)) |
1740 { | |
1741 /* Cannot be all caps if any original char is lower case */ | |
1742 | |
2393
a35d2c5cbb3b
(Freplace_match): Clean up criterion about converting case.
Richard M. Stallman <rms@gnu.org>
parents:
1926
diff
changeset
|
1743 some_lowercase = 1; |
603 | 1744 if (SYNTAX (prevc) != Sword) |
8526
2b7b23059f1b
(Freplace_match): Treat caseless initial like a lowercase initial.
Richard M. Stallman <rms@gnu.org>
parents:
7891
diff
changeset
|
1745 some_nonuppercase_initial = 1; |
603 | 1746 else |
1747 some_multiletter_word = 1; | |
1748 } | |
1749 else if (!NOCASEP (c)) | |
1750 { | |
7674
947d24fefd9e
(Freplace_match): Improve capitalization heuristics.
Karl Heuer <kwzh@gnu.org>
parents:
7673
diff
changeset
|
1751 some_uppercase = 1; |
2393
a35d2c5cbb3b
(Freplace_match): Clean up criterion about converting case.
Richard M. Stallman <rms@gnu.org>
parents:
1926
diff
changeset
|
1752 if (SYNTAX (prevc) != Sword) |
6679
490b7e2db978
(Freplace_match): Don't capitalize unless all matched words are capitalized.
Karl Heuer <kwzh@gnu.org>
parents:
6543
diff
changeset
|
1753 ; |
2393
a35d2c5cbb3b
(Freplace_match): Clean up criterion about converting case.
Richard M. Stallman <rms@gnu.org>
parents:
1926
diff
changeset
|
1754 else |
603 | 1755 some_multiletter_word = 1; |
1756 } | |
8526
2b7b23059f1b
(Freplace_match): Treat caseless initial like a lowercase initial.
Richard M. Stallman <rms@gnu.org>
parents:
7891
diff
changeset
|
1757 else |
2b7b23059f1b
(Freplace_match): Treat caseless initial like a lowercase initial.
Richard M. Stallman <rms@gnu.org>
parents:
7891
diff
changeset
|
1758 { |
2b7b23059f1b
(Freplace_match): Treat caseless initial like a lowercase initial.
Richard M. Stallman <rms@gnu.org>
parents:
7891
diff
changeset
|
1759 /* If the initial is a caseless word constituent, |
2b7b23059f1b
(Freplace_match): Treat caseless initial like a lowercase initial.
Richard M. Stallman <rms@gnu.org>
parents:
7891
diff
changeset
|
1760 treat that like a lowercase initial. */ |
2b7b23059f1b
(Freplace_match): Treat caseless initial like a lowercase initial.
Richard M. Stallman <rms@gnu.org>
parents:
7891
diff
changeset
|
1761 if (SYNTAX (prevc) != Sword) |
2b7b23059f1b
(Freplace_match): Treat caseless initial like a lowercase initial.
Richard M. Stallman <rms@gnu.org>
parents:
7891
diff
changeset
|
1762 some_nonuppercase_initial = 1; |
2b7b23059f1b
(Freplace_match): Treat caseless initial like a lowercase initial.
Richard M. Stallman <rms@gnu.org>
parents:
7891
diff
changeset
|
1763 } |
603 | 1764 |
1765 prevc = c; | |
1766 } | |
1767 | |
2393
a35d2c5cbb3b
(Freplace_match): Clean up criterion about converting case.
Richard M. Stallman <rms@gnu.org>
parents:
1926
diff
changeset
|
1768 /* Convert to all caps if the old text is all caps |
a35d2c5cbb3b
(Freplace_match): Clean up criterion about converting case.
Richard M. Stallman <rms@gnu.org>
parents:
1926
diff
changeset
|
1769 and has at least one multiletter word. */ |
a35d2c5cbb3b
(Freplace_match): Clean up criterion about converting case.
Richard M. Stallman <rms@gnu.org>
parents:
1926
diff
changeset
|
1770 if (! some_lowercase && some_multiletter_word) |
a35d2c5cbb3b
(Freplace_match): Clean up criterion about converting case.
Richard M. Stallman <rms@gnu.org>
parents:
1926
diff
changeset
|
1771 case_action = all_caps; |
6679
490b7e2db978
(Freplace_match): Don't capitalize unless all matched words are capitalized.
Karl Heuer <kwzh@gnu.org>
parents:
6543
diff
changeset
|
1772 /* Capitalize each word, if the old text has all capitalized words. */ |
8526
2b7b23059f1b
(Freplace_match): Treat caseless initial like a lowercase initial.
Richard M. Stallman <rms@gnu.org>
parents:
7891
diff
changeset
|
1773 else if (!some_nonuppercase_initial && some_multiletter_word) |
603 | 1774 case_action = cap_initial; |
8526
2b7b23059f1b
(Freplace_match): Treat caseless initial like a lowercase initial.
Richard M. Stallman <rms@gnu.org>
parents:
7891
diff
changeset
|
1775 else if (!some_nonuppercase_initial && some_uppercase) |
7674
947d24fefd9e
(Freplace_match): Improve capitalization heuristics.
Karl Heuer <kwzh@gnu.org>
parents:
7673
diff
changeset
|
1776 /* Should x -> yz, operating on X, give Yz or YZ? |
947d24fefd9e
(Freplace_match): Improve capitalization heuristics.
Karl Heuer <kwzh@gnu.org>
parents:
7673
diff
changeset
|
1777 We'll assume the latter. */ |
947d24fefd9e
(Freplace_match): Improve capitalization heuristics.
Karl Heuer <kwzh@gnu.org>
parents:
7673
diff
changeset
|
1778 case_action = all_caps; |
2393
a35d2c5cbb3b
(Freplace_match): Clean up criterion about converting case.
Richard M. Stallman <rms@gnu.org>
parents:
1926
diff
changeset
|
1779 else |
a35d2c5cbb3b
(Freplace_match): Clean up criterion about converting case.
Richard M. Stallman <rms@gnu.org>
parents:
1926
diff
changeset
|
1780 case_action = nochange; |
603 | 1781 } |
1782 | |
9029
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1783 /* Do replacement in a string. */ |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1784 if (!NILP (string)) |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1785 { |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1786 Lisp_Object before, after; |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1787 |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1788 before = Fsubstring (string, make_number (0), |
12807
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1789 make_number (search_regs.start[sub])); |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1790 after = Fsubstring (string, make_number (search_regs.end[sub]), Qnil); |
9029
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1791 |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1792 /* Do case substitution into NEWTEXT if desired. */ |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1793 if (NILP (literal)) |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1794 { |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1795 int lastpos = -1; |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1796 /* We build up the substituted string in ACCUM. */ |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1797 Lisp_Object accum; |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1798 Lisp_Object middle; |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1799 |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1800 accum = Qnil; |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1801 |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1802 for (pos = 0; pos < XSTRING (newtext)->size; pos++) |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1803 { |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1804 int substart = -1; |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1805 int subend; |
12148
a1c38b9b0f73
(Freplace_match): Do the right thing with backslash.
Karl Heuer <kwzh@gnu.org>
parents:
12147
diff
changeset
|
1806 int delbackslash = 0; |
9029
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1807 |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1808 c = XSTRING (newtext)->data[pos]; |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1809 if (c == '\\') |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1810 { |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1811 c = XSTRING (newtext)->data[++pos]; |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1812 if (c == '&') |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1813 { |
12807
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1814 substart = search_regs.start[sub]; |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1815 subend = search_regs.end[sub]; |
9029
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1816 } |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1817 else if (c >= '1' && c <= '9' && c <= search_regs.num_regs + '0') |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1818 { |
12147
9200a0e153d3
(Freplace_match): Fix check for valid reg in string replace.
Karl Heuer <kwzh@gnu.org>
parents:
12092
diff
changeset
|
1819 if (search_regs.start[c - '0'] >= 0) |
9029
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1820 { |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1821 substart = search_regs.start[c - '0']; |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1822 subend = search_regs.end[c - '0']; |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1823 } |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1824 } |
12148
a1c38b9b0f73
(Freplace_match): Do the right thing with backslash.
Karl Heuer <kwzh@gnu.org>
parents:
12147
diff
changeset
|
1825 else if (c == '\\') |
a1c38b9b0f73
(Freplace_match): Do the right thing with backslash.
Karl Heuer <kwzh@gnu.org>
parents:
12147
diff
changeset
|
1826 delbackslash = 1; |
9029
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1827 } |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1828 if (substart >= 0) |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1829 { |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1830 if (pos - 1 != lastpos + 1) |
12148
a1c38b9b0f73
(Freplace_match): Do the right thing with backslash.
Karl Heuer <kwzh@gnu.org>
parents:
12147
diff
changeset
|
1831 middle = Fsubstring (newtext, |
a1c38b9b0f73
(Freplace_match): Do the right thing with backslash.
Karl Heuer <kwzh@gnu.org>
parents:
12147
diff
changeset
|
1832 make_number (lastpos + 1), |
a1c38b9b0f73
(Freplace_match): Do the right thing with backslash.
Karl Heuer <kwzh@gnu.org>
parents:
12147
diff
changeset
|
1833 make_number (pos - 1)); |
9029
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1834 else |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1835 middle = Qnil; |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1836 accum = concat3 (accum, middle, |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1837 Fsubstring (string, make_number (substart), |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1838 make_number (subend))); |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1839 lastpos = pos; |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1840 } |
12148
a1c38b9b0f73
(Freplace_match): Do the right thing with backslash.
Karl Heuer <kwzh@gnu.org>
parents:
12147
diff
changeset
|
1841 else if (delbackslash) |
a1c38b9b0f73
(Freplace_match): Do the right thing with backslash.
Karl Heuer <kwzh@gnu.org>
parents:
12147
diff
changeset
|
1842 { |
a1c38b9b0f73
(Freplace_match): Do the right thing with backslash.
Karl Heuer <kwzh@gnu.org>
parents:
12147
diff
changeset
|
1843 middle = Fsubstring (newtext, make_number (lastpos + 1), |
a1c38b9b0f73
(Freplace_match): Do the right thing with backslash.
Karl Heuer <kwzh@gnu.org>
parents:
12147
diff
changeset
|
1844 make_number (pos)); |
a1c38b9b0f73
(Freplace_match): Do the right thing with backslash.
Karl Heuer <kwzh@gnu.org>
parents:
12147
diff
changeset
|
1845 accum = concat2 (accum, middle); |
a1c38b9b0f73
(Freplace_match): Do the right thing with backslash.
Karl Heuer <kwzh@gnu.org>
parents:
12147
diff
changeset
|
1846 lastpos = pos; |
a1c38b9b0f73
(Freplace_match): Do the right thing with backslash.
Karl Heuer <kwzh@gnu.org>
parents:
12147
diff
changeset
|
1847 } |
9029
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1848 } |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1849 |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1850 if (pos != lastpos + 1) |
12148
a1c38b9b0f73
(Freplace_match): Do the right thing with backslash.
Karl Heuer <kwzh@gnu.org>
parents:
12147
diff
changeset
|
1851 middle = Fsubstring (newtext, make_number (lastpos + 1), |
a1c38b9b0f73
(Freplace_match): Do the right thing with backslash.
Karl Heuer <kwzh@gnu.org>
parents:
12147
diff
changeset
|
1852 make_number (pos)); |
9029
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1853 else |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1854 middle = Qnil; |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1855 |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1856 newtext = concat2 (accum, middle); |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1857 } |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1858 |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1859 if (case_action == all_caps) |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1860 newtext = Fupcase (newtext); |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1861 else if (case_action == cap_initial) |
12092
b932b2ed40f5
(Freplace_match): Calls to upcase_initials and upcase_initials_region changed
Karl Heuer <kwzh@gnu.org>
parents:
12069
diff
changeset
|
1862 newtext = Fupcase_initials (newtext); |
9029
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1863 |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1864 return concat3 (before, newtext, after); |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1865 } |
f0d89b62dd27
(Freplace_match): New 4th arg OBJECT can specify string to replace in.
Richard M. Stallman <rms@gnu.org>
parents:
8950
diff
changeset
|
1866 |
2655
594a33ffed85
* search.c (Freplace_match): Arrange for markers sitting at the
Jim Blandy <jimb@redhat.com>
parents:
2475
diff
changeset
|
1867 /* We insert the replacement text before the old text, and then |
594a33ffed85
* search.c (Freplace_match): Arrange for markers sitting at the
Jim Blandy <jimb@redhat.com>
parents:
2475
diff
changeset
|
1868 delete the original text. This means that markers at the |
594a33ffed85
* search.c (Freplace_match): Arrange for markers sitting at the
Jim Blandy <jimb@redhat.com>
parents:
2475
diff
changeset
|
1869 beginning or end of the original will float to the corresponding |
594a33ffed85
* search.c (Freplace_match): Arrange for markers sitting at the
Jim Blandy <jimb@redhat.com>
parents:
2475
diff
changeset
|
1870 position in the replacement. */ |
12807
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1871 SET_PT (search_regs.start[sub]); |
603 | 1872 if (!NILP (literal)) |
4882
8c09f87f5087
(Freplace_match): Fix argument names to match doc string.
Brian Fox <bfox@gnu.org>
parents:
4832
diff
changeset
|
1873 Finsert_and_inherit (1, &newtext); |
603 | 1874 else |
1875 { | |
1876 struct gcpro gcpro1; | |
4882
8c09f87f5087
(Freplace_match): Fix argument names to match doc string.
Brian Fox <bfox@gnu.org>
parents:
4832
diff
changeset
|
1877 GCPRO1 (newtext); |
603 | 1878 |
4882
8c09f87f5087
(Freplace_match): Fix argument names to match doc string.
Brian Fox <bfox@gnu.org>
parents:
4832
diff
changeset
|
1879 for (pos = 0; pos < XSTRING (newtext)->size; pos++) |
603 | 1880 { |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15667
diff
changeset
|
1881 int offset = PT - search_regs.start[sub]; |
2655
594a33ffed85
* search.c (Freplace_match): Arrange for markers sitting at the
Jim Blandy <jimb@redhat.com>
parents:
2475
diff
changeset
|
1882 |
4882
8c09f87f5087
(Freplace_match): Fix argument names to match doc string.
Brian Fox <bfox@gnu.org>
parents:
4832
diff
changeset
|
1883 c = XSTRING (newtext)->data[pos]; |
603 | 1884 if (c == '\\') |
1885 { | |
4882
8c09f87f5087
(Freplace_match): Fix argument names to match doc string.
Brian Fox <bfox@gnu.org>
parents:
4832
diff
changeset
|
1886 c = XSTRING (newtext)->data[++pos]; |
603 | 1887 if (c == '&') |
2655
594a33ffed85
* search.c (Freplace_match): Arrange for markers sitting at the
Jim Blandy <jimb@redhat.com>
parents:
2475
diff
changeset
|
1888 Finsert_buffer_substring |
594a33ffed85
* search.c (Freplace_match): Arrange for markers sitting at the
Jim Blandy <jimb@redhat.com>
parents:
2475
diff
changeset
|
1889 (Fcurrent_buffer (), |
12807
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1890 make_number (search_regs.start[sub] + offset), |
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1891 make_number (search_regs.end[sub] + offset)); |
7856
9687141f6264
(Freplace_match): Be sure not to treat non-digit like digit.
Richard M. Stallman <rms@gnu.org>
parents:
7674
diff
changeset
|
1892 else if (c >= '1' && c <= '9' && c <= search_regs.num_regs + '0') |
603 | 1893 { |
1894 if (search_regs.start[c - '0'] >= 1) | |
2655
594a33ffed85
* search.c (Freplace_match): Arrange for markers sitting at the
Jim Blandy <jimb@redhat.com>
parents:
2475
diff
changeset
|
1895 Finsert_buffer_substring |
594a33ffed85
* search.c (Freplace_match): Arrange for markers sitting at the
Jim Blandy <jimb@redhat.com>
parents:
2475
diff
changeset
|
1896 (Fcurrent_buffer (), |
594a33ffed85
* search.c (Freplace_match): Arrange for markers sitting at the
Jim Blandy <jimb@redhat.com>
parents:
2475
diff
changeset
|
1897 make_number (search_regs.start[c - '0'] + offset), |
594a33ffed85
* search.c (Freplace_match): Arrange for markers sitting at the
Jim Blandy <jimb@redhat.com>
parents:
2475
diff
changeset
|
1898 make_number (search_regs.end[c - '0'] + offset)); |
603 | 1899 } |
1900 else | |
1901 insert_char (c); | |
1902 } | |
1903 else | |
1904 insert_char (c); | |
1905 } | |
1906 UNGCPRO; | |
1907 } | |
1908 | |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15667
diff
changeset
|
1909 inslen = PT - (search_regs.start[sub]); |
12807
34d269b30df1
(Freplace_match): New arg SUBEXP.
Richard M. Stallman <rms@gnu.org>
parents:
12244
diff
changeset
|
1910 del_range (search_regs.start[sub] + inslen, search_regs.end[sub] + inslen); |
603 | 1911 |
1912 if (case_action == all_caps) | |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15667
diff
changeset
|
1913 Fupcase_region (make_number (PT - inslen), make_number (PT)); |
603 | 1914 else if (case_action == cap_initial) |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15667
diff
changeset
|
1915 Fupcase_initials_region (make_number (PT - inslen), make_number (PT)); |
603 | 1916 return Qnil; |
1917 } | |
1918 | |
1919 static Lisp_Object | |
1920 match_limit (num, beginningp) | |
1921 Lisp_Object num; | |
1922 int beginningp; | |
1923 { | |
1924 register int n; | |
1925 | |
1926 CHECK_NUMBER (num, 0); | |
1927 n = XINT (num); | |
621 | 1928 if (n < 0 || n >= search_regs.num_regs) |
1929 args_out_of_range (num, make_number (search_regs.num_regs)); | |
1930 if (search_regs.num_regs <= 0 | |
1931 || search_regs.start[n] < 0) | |
603 | 1932 return Qnil; |
1933 return (make_number ((beginningp) ? search_regs.start[n] | |
1934 : search_regs.end[n])); | |
1935 } | |
1936 | |
1937 DEFUN ("match-beginning", Fmatch_beginning, Smatch_beginning, 1, 1, 0, | |
1938 "Return position of start of text matched by last search.\n\ | |
14086
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
1939 SUBEXP, a number, specifies which parenthesized expression in the last\n\ |
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
1940 regexp.\n\ |
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
1941 Value is nil if SUBEXPth pair didn't match, or there were less than\n\ |
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
1942 SUBEXP pairs.\n\ |
603 | 1943 Zero means the entire text matched by the whole regexp or whole string.") |
14086
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
1944 (subexp) |
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
1945 Lisp_Object subexp; |
603 | 1946 { |
14086
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
1947 return match_limit (subexp, 1); |
603 | 1948 } |
1949 | |
1950 DEFUN ("match-end", Fmatch_end, Smatch_end, 1, 1, 0, | |
1951 "Return position of end of text matched by last search.\n\ | |
14086
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
1952 SUBEXP, a number, specifies which parenthesized expression in the last\n\ |
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
1953 regexp.\n\ |
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
1954 Value is nil if SUBEXPth pair didn't match, or there were less than\n\ |
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
1955 SUBEXP pairs.\n\ |
603 | 1956 Zero means the entire text matched by the whole regexp or whole string.") |
14086
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
1957 (subexp) |
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
1958 Lisp_Object subexp; |
603 | 1959 { |
14086
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
1960 return match_limit (subexp, 0); |
603 | 1961 } |
1962 | |
16724
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
1963 DEFUN ("match-data", Fmatch_data, Smatch_data, 0, 2, 0, |
603 | 1964 "Return a list containing all info on what the last search matched.\n\ |
1965 Element 2N is `(match-beginning N)'; element 2N + 1 is `(match-end N)'.\n\ | |
1966 All the elements are markers or nil (nil if the Nth pair didn't match)\n\ | |
1967 if the last match was on a buffer; integers or nil if a string was matched.\n\ | |
16724
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
1968 Use `store-match-data' to reinstate the data in this list.\n\ |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
1969 \n\ |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
1970 If INTEGERS (the optional first argument) is non-nil, always use integers\n\ |
16731
039ef6e74d3a
(Fmatch_data): Doc fix.
Richard M. Stallman <rms@gnu.org>
parents:
16724
diff
changeset
|
1971 \(rather than markers) to represent buffer positions.\n\ |
16724
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
1972 If REUSE is a list, reuse it as part of the value. If REUSE is long enough\n\ |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
1973 to hold all the values, and if INTEGERS is non-nil, no consing is done.") |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
1974 (integers, reuse) |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
1975 Lisp_Object integers, reuse; |
603 | 1976 { |
16724
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
1977 Lisp_Object tail, prev; |
621 | 1978 Lisp_Object *data; |
603 | 1979 int i, len; |
1980 | |
727 | 1981 if (NILP (last_thing_searched)) |
15667
9531c03134b6
(Fmatch_data): If no matching done yet, return Qnil.
Karl Heuer <kwzh@gnu.org>
parents:
14186
diff
changeset
|
1982 return Qnil; |
727 | 1983 |
621 | 1984 data = (Lisp_Object *) alloca ((2 * search_regs.num_regs) |
1985 * sizeof (Lisp_Object)); | |
1986 | |
603 | 1987 len = -1; |
621 | 1988 for (i = 0; i < search_regs.num_regs; i++) |
603 | 1989 { |
1990 int start = search_regs.start[i]; | |
1991 if (start >= 0) | |
1992 { | |
16724
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
1993 if (EQ (last_thing_searched, Qt) |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
1994 || ! NILP (integers)) |
603 | 1995 { |
9319
7969182b6cc6
(skip_chars, Fmatch_data, Fstore_match_data): Don't use XFASTINT as an lvalue.
Karl Heuer <kwzh@gnu.org>
parents:
9278
diff
changeset
|
1996 XSETFASTINT (data[2 * i], start); |
7969182b6cc6
(skip_chars, Fmatch_data, Fstore_match_data): Don't use XFASTINT as an lvalue.
Karl Heuer <kwzh@gnu.org>
parents:
9278
diff
changeset
|
1997 XSETFASTINT (data[2 * i + 1], search_regs.end[i]); |
603 | 1998 } |
9113
766b6288e0f2
(Fmatch_data, Fstore_match_data): Use type test macros.
Karl Heuer <kwzh@gnu.org>
parents:
9029
diff
changeset
|
1999 else if (BUFFERP (last_thing_searched)) |
603 | 2000 { |
2001 data[2 * i] = Fmake_marker (); | |
727 | 2002 Fset_marker (data[2 * i], |
2003 make_number (start), | |
2004 last_thing_searched); | |
603 | 2005 data[2 * i + 1] = Fmake_marker (); |
2006 Fset_marker (data[2 * i + 1], | |
727 | 2007 make_number (search_regs.end[i]), |
2008 last_thing_searched); | |
603 | 2009 } |
727 | 2010 else |
2011 /* last_thing_searched must always be Qt, a buffer, or Qnil. */ | |
2012 abort (); | |
2013 | |
603 | 2014 len = i; |
2015 } | |
2016 else | |
2017 data[2 * i] = data [2 * i + 1] = Qnil; | |
2018 } | |
16724
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2019 |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2020 /* If REUSE is not usable, cons up the values and return them. */ |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2021 if (! CONSP (reuse)) |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2022 return Flist (2 * len + 2, data); |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2023 |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2024 /* If REUSE is a list, store as many value elements as will fit |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2025 into the elements of REUSE. */ |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2026 for (i = 0, tail = reuse; CONSP (tail); |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2027 i++, tail = XCONS (tail)->cdr) |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2028 { |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2029 if (i < 2 * len + 2) |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2030 XCONS (tail)->car = data[i]; |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2031 else |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2032 XCONS (tail)->car = Qnil; |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2033 prev = tail; |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2034 } |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2035 |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2036 /* If we couldn't fit all value elements into REUSE, |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2037 cons up the rest of them and add them to the end of REUSE. */ |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2038 if (i < 2 * len + 2) |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2039 XCONS (prev)->cdr = Flist (2 * len + 2 - i, data + i); |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2040 |
4b1fb372a4fe
(Fmatch_data): New args INTEGERS and REUSE.
Richard M. Stallman <rms@gnu.org>
parents:
16275
diff
changeset
|
2041 return reuse; |
603 | 2042 } |
2043 | |
2044 | |
2045 DEFUN ("store-match-data", Fstore_match_data, Sstore_match_data, 1, 1, 0, | |
2046 "Set internal data on last search match from elements of LIST.\n\ | |
2047 LIST should have been created by calling `match-data' previously.") | |
2048 (list) | |
2049 register Lisp_Object list; | |
2050 { | |
2051 register int i; | |
2052 register Lisp_Object marker; | |
2053 | |
10032
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2054 if (running_asynch_code) |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2055 save_search_regs (); |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2056 |
603 | 2057 if (!CONSP (list) && !NILP (list)) |
1926
952f2a18f83d
* callint.c (Fcall_interactively): Pass the correct number of
Jim Blandy <jimb@redhat.com>
parents:
1896
diff
changeset
|
2058 list = wrong_type_argument (Qconsp, list); |
603 | 2059 |
727 | 2060 /* Unless we find a marker with a buffer in LIST, assume that this |
2061 match data came from a string. */ | |
2062 last_thing_searched = Qt; | |
2063 | |
621 | 2064 /* Allocate registers if they don't already exist. */ |
2065 { | |
1523
bd61aaa7828b
* search.c (Fstore_match_data): Don't assume Flength returns an
Jim Blandy <jimb@redhat.com>
parents:
1413
diff
changeset
|
2066 int length = XFASTINT (Flength (list)) / 2; |
621 | 2067 |
2068 if (length > search_regs.num_regs) | |
2069 { | |
708 | 2070 if (search_regs.num_regs == 0) |
2071 { | |
2072 search_regs.start | |
2073 = (regoff_t *) xmalloc (length * sizeof (regoff_t)); | |
2074 search_regs.end | |
2075 = (regoff_t *) xmalloc (length * sizeof (regoff_t)); | |
2076 } | |
621 | 2077 else |
708 | 2078 { |
2079 search_regs.start | |
2080 = (regoff_t *) xrealloc (search_regs.start, | |
2081 length * sizeof (regoff_t)); | |
2082 search_regs.end | |
2083 = (regoff_t *) xrealloc (search_regs.end, | |
2084 length * sizeof (regoff_t)); | |
2085 } | |
621 | 2086 |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
2087 search_regs.num_regs = length; |
621 | 2088 } |
2089 } | |
2090 | |
2091 for (i = 0; i < search_regs.num_regs; i++) | |
603 | 2092 { |
2093 marker = Fcar (list); | |
2094 if (NILP (marker)) | |
2095 { | |
2096 search_regs.start[i] = -1; | |
2097 list = Fcdr (list); | |
2098 } | |
2099 else | |
2100 { | |
9113
766b6288e0f2
(Fmatch_data, Fstore_match_data): Use type test macros.
Karl Heuer <kwzh@gnu.org>
parents:
9029
diff
changeset
|
2101 if (MARKERP (marker)) |
727 | 2102 { |
2103 if (XMARKER (marker)->buffer == 0) | |
9319
7969182b6cc6
(skip_chars, Fmatch_data, Fstore_match_data): Don't use XFASTINT as an lvalue.
Karl Heuer <kwzh@gnu.org>
parents:
9278
diff
changeset
|
2104 XSETFASTINT (marker, 0); |
727 | 2105 else |
9278
f2138d548313
(Flooking_at, skip_chars, search_buffer, set_search_regs, Fstore_match_data):
Karl Heuer <kwzh@gnu.org>
parents:
9113
diff
changeset
|
2106 XSETBUFFER (last_thing_searched, XMARKER (marker)->buffer); |
727 | 2107 } |
603 | 2108 |
2109 CHECK_NUMBER_COERCE_MARKER (marker, 0); | |
2110 search_regs.start[i] = XINT (marker); | |
2111 list = Fcdr (list); | |
2112 | |
2113 marker = Fcar (list); | |
9113
766b6288e0f2
(Fmatch_data, Fstore_match_data): Use type test macros.
Karl Heuer <kwzh@gnu.org>
parents:
9029
diff
changeset
|
2114 if (MARKERP (marker) && XMARKER (marker)->buffer == 0) |
9319
7969182b6cc6
(skip_chars, Fmatch_data, Fstore_match_data): Don't use XFASTINT as an lvalue.
Karl Heuer <kwzh@gnu.org>
parents:
9278
diff
changeset
|
2115 XSETFASTINT (marker, 0); |
603 | 2116 |
2117 CHECK_NUMBER_COERCE_MARKER (marker, 0); | |
2118 search_regs.end[i] = XINT (marker); | |
2119 } | |
2120 list = Fcdr (list); | |
2121 } | |
2122 | |
2123 return Qnil; | |
2124 } | |
2125 | |
10032
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2126 /* If non-zero the match data have been saved in saved_search_regs |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2127 during the execution of a sentinel or filter. */ |
10128
59ccd063e016
(search_regs_saved): Delete initializer.
Richard M. Stallman <rms@gnu.org>
parents:
10055
diff
changeset
|
2128 static int search_regs_saved; |
10032
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2129 static struct re_registers saved_search_regs; |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2130 |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2131 /* Called from Flooking_at, Fstring_match, search_buffer, Fstore_match_data |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2132 if asynchronous code (filter or sentinel) is running. */ |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2133 static void |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2134 save_search_regs () |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2135 { |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2136 if (!search_regs_saved) |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2137 { |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2138 saved_search_regs.num_regs = search_regs.num_regs; |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2139 saved_search_regs.start = search_regs.start; |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2140 saved_search_regs.end = search_regs.end; |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2141 search_regs.num_regs = 0; |
10250
422c3b96efda
(set_search_regs): Really set search_regs.start and .end.
Richard M. Stallman <rms@gnu.org>
parents:
10141
diff
changeset
|
2142 search_regs.start = 0; |
422c3b96efda
(set_search_regs): Really set search_regs.start and .end.
Richard M. Stallman <rms@gnu.org>
parents:
10141
diff
changeset
|
2143 search_regs.end = 0; |
10032
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2144 |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2145 search_regs_saved = 1; |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2146 } |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2147 } |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2148 |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2149 /* Called upon exit from filters and sentinels. */ |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2150 void |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2151 restore_match_data () |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2152 { |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2153 if (search_regs_saved) |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2154 { |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2155 if (search_regs.num_regs > 0) |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2156 { |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2157 xfree (search_regs.start); |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2158 xfree (search_regs.end); |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2159 } |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2160 search_regs.num_regs = saved_search_regs.num_regs; |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2161 search_regs.start = saved_search_regs.start; |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2162 search_regs.end = saved_search_regs.end; |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2163 |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2164 search_regs_saved = 0; |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2165 } |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2166 } |
f689803caa92
Added code for automatically saving and restoring the match data
Francesco Potortì <pot@gnu.org>
parents:
10020
diff
changeset
|
2167 |
603 | 2168 /* Quote a string to inactivate reg-expr chars */ |
2169 | |
2170 DEFUN ("regexp-quote", Fregexp_quote, Sregexp_quote, 1, 1, 0, | |
2171 "Return a regexp string which matches exactly STRING and nothing else.") | |
14086
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
2172 (string) |
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
2173 Lisp_Object string; |
603 | 2174 { |
2175 register unsigned char *in, *out, *end; | |
2176 register unsigned char *temp; | |
2177 | |
14086
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
2178 CHECK_STRING (string, 0); |
603 | 2179 |
14086
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
2180 temp = (unsigned char *) alloca (XSTRING (string)->size * 2); |
603 | 2181 |
2182 /* Now copy the data into the new string, inserting escapes. */ | |
2183 | |
14086
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
2184 in = XSTRING (string)->data; |
a410808fda15
(Fmatch_end, Fregexp_quote): Harmonize arguments with documentation.
Erik Naggum <erik@naggum.no>
parents:
14036
diff
changeset
|
2185 end = in + XSTRING (string)->size; |
603 | 2186 out = temp; |
2187 | |
2188 for (; in != end; in++) | |
2189 { | |
2190 if (*in == '[' || *in == ']' | |
2191 || *in == '*' || *in == '.' || *in == '\\' | |
2192 || *in == '?' || *in == '+' | |
2193 || *in == '^' || *in == '$') | |
2194 *out++ = '\\'; | |
2195 *out++ = *in; | |
2196 } | |
2197 | |
2198 return make_string (temp, out - temp); | |
2199 } | |
2200 | |
2201 syms_of_search () | |
2202 { | |
2203 register int i; | |
2204 | |
9605
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
2205 for (i = 0; i < REGEXP_CACHE_SIZE; ++i) |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
2206 { |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
2207 searchbufs[i].buf.allocated = 100; |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
2208 searchbufs[i].buf.buffer = (unsigned char *) malloc (100); |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
2209 searchbufs[i].buf.fastmap = searchbufs[i].fastmap; |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
2210 searchbufs[i].regexp = Qnil; |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
2211 staticpro (&searchbufs[i].regexp); |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
2212 searchbufs[i].next = (i == REGEXP_CACHE_SIZE-1 ? 0 : &searchbufs[i+1]); |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
2213 } |
cf97e75d8e02
(searchbufs): New variable, replaces searchbuf and last_regexp and
Karl Heuer <kwzh@gnu.org>
parents:
9452
diff
changeset
|
2214 searchbuf_head = &searchbufs[0]; |
603 | 2215 |
2216 Qsearch_failed = intern ("search-failed"); | |
2217 staticpro (&Qsearch_failed); | |
2218 Qinvalid_regexp = intern ("invalid-regexp"); | |
2219 staticpro (&Qinvalid_regexp); | |
2220 | |
2221 Fput (Qsearch_failed, Qerror_conditions, | |
2222 Fcons (Qsearch_failed, Fcons (Qerror, Qnil))); | |
2223 Fput (Qsearch_failed, Qerror_message, | |
2224 build_string ("Search failed")); | |
2225 | |
2226 Fput (Qinvalid_regexp, Qerror_conditions, | |
2227 Fcons (Qinvalid_regexp, Fcons (Qerror, Qnil))); | |
2228 Fput (Qinvalid_regexp, Qerror_message, | |
2229 build_string ("Invalid regexp")); | |
2230 | |
727 | 2231 last_thing_searched = Qnil; |
2232 staticpro (&last_thing_searched); | |
2233 | |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
2234 defsubr (&Slooking_at); |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
2235 defsubr (&Sposix_looking_at); |
603 | 2236 defsubr (&Sstring_match); |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
2237 defsubr (&Sposix_string_match); |
603 | 2238 defsubr (&Sskip_chars_forward); |
2239 defsubr (&Sskip_chars_backward); | |
1896
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
2240 defsubr (&Sskip_syntax_forward); |
10895ac08bc6
(Fskip_syntax_backward): New function.
Richard M. Stallman <rms@gnu.org>
parents:
1878
diff
changeset
|
2241 defsubr (&Sskip_syntax_backward); |
603 | 2242 defsubr (&Ssearch_forward); |
2243 defsubr (&Ssearch_backward); | |
2244 defsubr (&Sword_search_forward); | |
2245 defsubr (&Sword_search_backward); | |
2246 defsubr (&Sre_search_forward); | |
2247 defsubr (&Sre_search_backward); | |
10020
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
2248 defsubr (&Sposix_search_forward); |
c41ce96785a8
(struct regexp_cache): New field `posix'.
Richard M. Stallman <rms@gnu.org>
parents:
9605
diff
changeset
|
2249 defsubr (&Sposix_search_backward); |
603 | 2250 defsubr (&Sreplace_match); |
2251 defsubr (&Smatch_beginning); | |
2252 defsubr (&Smatch_end); | |
2253 defsubr (&Smatch_data); | |
2254 defsubr (&Sstore_match_data); | |
2255 defsubr (&Sregexp_quote); | |
2256 } |