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