Mercurial > vim
annotate src/regexp.c @ 20843:1a9f8fe67cd7
Added tag v8.2.0973 for changeset bacc2ab118102345122ee9750ef10a76cab0996e
author | Bram Moolenaar <Bram@vim.org> |
---|---|
date | Sat, 13 Jun 2020 19:15:04 +0200 |
parents | 9064044fd4f6 |
children | 3af71cbcfdbe |
rev | line source |
---|---|
10042
4aead6a9b7a9
commit https://github.com/vim/vim/commit/edf3f97ae2af024708ebb4ac614227327033ca47
Christian Brabandt <cb@256bit.org>
parents:
9723
diff
changeset
|
1 /* vi:set ts=8 sts=4 sw=4 noet: |
7 | 2 * |
3 * Handling of regular expressions: vim_regcomp(), vim_regexec(), vim_regsub() | |
4 */ | |
5 | |
16395
a849fe2a4b21
patch 8.1.1202: always get regexp debugging logs when building with -DDEBUG
Bram Moolenaar <Bram@vim.org>
parents:
16054
diff
changeset
|
6 // By default: do not create debugging logs or files related to regular |
a849fe2a4b21
patch 8.1.1202: always get regexp debugging logs when building with -DDEBUG
Bram Moolenaar <Bram@vim.org>
parents:
16054
diff
changeset
|
7 // expressions, even when compiling with -DDEBUG. |
a849fe2a4b21
patch 8.1.1202: always get regexp debugging logs when building with -DDEBUG
Bram Moolenaar <Bram@vim.org>
parents:
16054
diff
changeset
|
8 // Uncomment the second line to get the regexp debugging. |
a849fe2a4b21
patch 8.1.1202: always get regexp debugging logs when building with -DDEBUG
Bram Moolenaar <Bram@vim.org>
parents:
16054
diff
changeset
|
9 #undef DEBUG |
a849fe2a4b21
patch 8.1.1202: always get regexp debugging logs when building with -DDEBUG
Bram Moolenaar <Bram@vim.org>
parents:
16054
diff
changeset
|
10 // #define DEBUG |
4444 | 11 |
7 | 12 #include "vim.h" |
13 | |
4444 | 14 #ifdef DEBUG |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
15 // show/save debugging data when BT engine is used |
4444 | 16 # define BT_REGEXP_DUMP |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
17 // save the debugging data to a file instead of displaying it |
4444 | 18 # define BT_REGEXP_LOG |
4460 | 19 # define BT_REGEXP_DEBUG_LOG |
20 # define BT_REGEXP_DEBUG_LOG_NAME "bt_regexp_debug.log" | |
4444 | 21 #endif |
7 | 22 |
23 /* | |
24 * Magic characters have a special meaning, they don't match literally. | |
25 * Magic characters are negative. This separates them from literal characters | |
26 * (possibly multi-byte). Only ASCII characters can be Magic. | |
27 */ | |
28 #define Magic(x) ((int)(x) - 256) | |
29 #define un_Magic(x) ((x) + 256) | |
30 #define is_Magic(x) ((x) < 0) | |
31 | |
32 static int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
33 no_Magic(int x) |
7 | 34 { |
35 if (is_Magic(x)) | |
36 return un_Magic(x); | |
37 return x; | |
38 } | |
39 | |
40 static int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
41 toggle_Magic(int x) |
7 | 42 { |
43 if (is_Magic(x)) | |
44 return un_Magic(x); | |
45 return Magic(x); | |
46 } | |
47 | |
48 /* | |
18019
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
49 * The first byte of the BT regexp internal "program" is actually this magic |
7 | 50 * number; the start node begins in the second byte. It's used to catch the |
51 * most severe mutilation of the program by the caller. | |
52 */ | |
53 | |
54 #define REGMAGIC 0234 | |
55 | |
56 /* | |
57 * Utility definitions. | |
58 */ | |
59 #define UCHARAT(p) ((int)*(char_u *)(p)) | |
60 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
61 // Used for an error (down from) vim_regcomp(): give the error message, set |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
62 // rc_did_emsg and return NULL |
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15339
diff
changeset
|
63 #define EMSG_RET_NULL(m) return (emsg((m)), rc_did_emsg = TRUE, (void *)NULL) |
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15339
diff
changeset
|
64 #define IEMSG_RET_NULL(m) return (iemsg((m)), rc_did_emsg = TRUE, (void *)NULL) |
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15339
diff
changeset
|
65 #define EMSG_RET_FAIL(m) return (emsg((m)), rc_did_emsg = TRUE, FAIL) |
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15339
diff
changeset
|
66 #define EMSG2_RET_NULL(m, c) return (semsg((const char *)(m), (c) ? "" : "\\"), rc_did_emsg = TRUE, (void *)NULL) |
15480
bd12ace1bab2
patch 8.1.0748: using sprintf() instead of semsg()
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
67 #define EMSG3_RET_NULL(m, c, a) return (semsg((const char *)(m), (c) ? "" : "\\", (a)), rc_did_emsg = TRUE, (void *)NULL) |
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15339
diff
changeset
|
68 #define EMSG2_RET_FAIL(m, c) return (semsg((const char *)(m), (c) ? "" : "\\"), rc_did_emsg = TRUE, FAIL) |
4444 | 69 #define EMSG_ONE_RET_NULL EMSG2_RET_NULL(_("E369: invalid item in %s%%[]"), reg_magic == MAGIC_ALL) |
7 | 70 |
10359
66f1b5bf3fa6
commit https://github.com/vim/vim/commit/95f096030ed1a8afea028f2ea295d6f6a70f466f
Christian Brabandt <cb@256bit.org>
parents:
10245
diff
changeset
|
71 |
7 | 72 #define MAX_LIMIT (32767L << 16L) |
73 | |
4444 | 74 static char_u e_missingbracket[] = N_("E769: Missing ] after %s["); |
11480
99ce30ac4226
patch 8.0.0623: error for invalid regexp is not very informative
Christian Brabandt <cb@256bit.org>
parents:
11269
diff
changeset
|
75 static char_u e_reverse_range[] = N_("E944: Reverse range in character class"); |
99ce30ac4226
patch 8.0.0623: error for invalid regexp is not very informative
Christian Brabandt <cb@256bit.org>
parents:
11269
diff
changeset
|
76 static char_u e_large_class[] = N_("E945: Range too large in character class"); |
4444 | 77 static char_u e_unmatchedpp[] = N_("E53: Unmatched %s%%("); |
78 static char_u e_unmatchedp[] = N_("E54: Unmatched %s("); | |
79 static char_u e_unmatchedpar[] = N_("E55: Unmatched %s)"); | |
4720
bd6bef0bd0fb
updated for version 7.3.1107
Bram Moolenaar <bram@vim.org>
parents:
4688
diff
changeset
|
80 #ifdef FEAT_SYN_HL |
4688
371cc0c44097
updated for version 7.3.1091
Bram Moolenaar <bram@vim.org>
parents:
4682
diff
changeset
|
81 static char_u e_z_not_allowed[] = N_("E66: \\z( not allowed here"); |
14161
7cac4646c552
patch 8.1.0098: segfault when pattern with z() is very slow
Christian Brabandt <cb@256bit.org>
parents:
13286
diff
changeset
|
82 static char_u e_z1_not_allowed[] = N_("E67: \\z1 - \\z9 not allowed here"); |
4720
bd6bef0bd0fb
updated for version 7.3.1107
Bram Moolenaar <bram@vim.org>
parents:
4688
diff
changeset
|
83 #endif |
4744
a62695305e03
updated for version 7.3.1119
Bram Moolenaar <bram@vim.org>
parents:
4732
diff
changeset
|
84 static char_u e_missing_sb[] = N_("E69: Missing ] after %s%%["); |
4760
532a9855bd30
updated for version 7.3.1127
Bram Moolenaar <bram@vim.org>
parents:
4746
diff
changeset
|
85 static char_u e_empty_sb[] = N_("E70: Empty %s%%[]"); |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
86 static char_u e_recursive[] = N_("E956: Cannot use pattern recursively"); |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
87 |
7 | 88 #define NOT_MULTI 0 |
89 #define MULTI_ONE 1 | |
90 #define MULTI_MULT 2 | |
18019
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
91 |
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
92 // return values for regmatch() |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
93 #define RA_FAIL 1 // something failed, abort |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
94 #define RA_CONT 2 // continue in inner loop |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
95 #define RA_BREAK 3 // break inner loop |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
96 #define RA_MATCH 4 // successful match |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
97 #define RA_NOMATCH 5 // didn't match |
18019
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
98 |
7 | 99 /* |
100 * Return NOT_MULTI if c is not a "multi" operator. | |
101 * Return MULTI_ONE if c is a single "multi" operator. | |
102 * Return MULTI_MULT if c is a multi "multi" operator. | |
103 */ | |
104 static int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
105 re_multi_type(int c) |
7 | 106 { |
107 if (c == Magic('@') || c == Magic('=') || c == Magic('?')) | |
108 return MULTI_ONE; | |
109 if (c == Magic('*') || c == Magic('+') || c == Magic('{')) | |
110 return MULTI_MULT; | |
111 return NOT_MULTI; | |
112 } | |
113 | |
359 | 114 static char_u *reg_prev_sub = NULL; |
115 | |
7 | 116 /* |
117 * REGEXP_INRANGE contains all characters which are always special in a [] | |
118 * range after '\'. | |
119 * REGEXP_ABBR contains all characters which act as abbreviations after '\'. | |
120 * These are: | |
121 * \n - New line (NL). | |
122 * \r - Carriage Return (CR). | |
123 * \t - Tab (TAB). | |
124 * \e - Escape (ESC). | |
125 * \b - Backspace (Ctrl_H). | |
24 | 126 * \d - Character code in decimal, eg \d123 |
127 * \o - Character code in octal, eg \o80 | |
128 * \x - Character code in hex, eg \x4a | |
129 * \u - Multibyte character code, eg \u20ac | |
130 * \U - Long multibyte character code, eg \U12345678 | |
7 | 131 */ |
132 static char_u REGEXP_INRANGE[] = "]^-n\\"; | |
24 | 133 static char_u REGEXP_ABBR[] = "nrtebdoxuU"; |
7 | 134 |
135 /* | |
136 * Translate '\x' to its control character, except "\n", which is Magic. | |
137 */ | |
138 static int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
139 backslash_trans(int c) |
7 | 140 { |
141 switch (c) | |
142 { | |
143 case 'r': return CAR; | |
144 case 't': return TAB; | |
145 case 'e': return ESC; | |
146 case 'b': return BS; | |
147 } | |
148 return c; | |
149 } | |
150 | |
151 /* | |
167 | 152 * Check for a character class name "[:name:]". "pp" points to the '['. |
7 | 153 * Returns one of the CLASS_ items. CLASS_NONE means that no item was |
154 * recognized. Otherwise "pp" is advanced to after the item. | |
155 */ | |
156 static int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
157 get_char_class(char_u **pp) |
7 | 158 { |
159 static const char *(class_names[]) = | |
160 { | |
161 "alnum:]", | |
162 #define CLASS_ALNUM 0 | |
163 "alpha:]", | |
164 #define CLASS_ALPHA 1 | |
165 "blank:]", | |
166 #define CLASS_BLANK 2 | |
167 "cntrl:]", | |
168 #define CLASS_CNTRL 3 | |
169 "digit:]", | |
170 #define CLASS_DIGIT 4 | |
171 "graph:]", | |
172 #define CLASS_GRAPH 5 | |
173 "lower:]", | |
174 #define CLASS_LOWER 6 | |
175 "print:]", | |
176 #define CLASS_PRINT 7 | |
177 "punct:]", | |
178 #define CLASS_PUNCT 8 | |
179 "space:]", | |
180 #define CLASS_SPACE 9 | |
181 "upper:]", | |
182 #define CLASS_UPPER 10 | |
183 "xdigit:]", | |
184 #define CLASS_XDIGIT 11 | |
185 "tab:]", | |
186 #define CLASS_TAB 12 | |
187 "return:]", | |
188 #define CLASS_RETURN 13 | |
189 "backspace:]", | |
190 #define CLASS_BACKSPACE 14 | |
191 "escape:]", | |
192 #define CLASS_ESCAPE 15 | |
15709
2e2f07561f4b
patch 8.1.0862: no verbose version of character classes
Bram Moolenaar <Bram@vim.org>
parents:
15603
diff
changeset
|
193 "ident:]", |
2e2f07561f4b
patch 8.1.0862: no verbose version of character classes
Bram Moolenaar <Bram@vim.org>
parents:
15603
diff
changeset
|
194 #define CLASS_IDENT 16 |
2e2f07561f4b
patch 8.1.0862: no verbose version of character classes
Bram Moolenaar <Bram@vim.org>
parents:
15603
diff
changeset
|
195 "keyword:]", |
2e2f07561f4b
patch 8.1.0862: no verbose version of character classes
Bram Moolenaar <Bram@vim.org>
parents:
15603
diff
changeset
|
196 #define CLASS_KEYWORD 17 |
2e2f07561f4b
patch 8.1.0862: no verbose version of character classes
Bram Moolenaar <Bram@vim.org>
parents:
15603
diff
changeset
|
197 "fname:]", |
2e2f07561f4b
patch 8.1.0862: no verbose version of character classes
Bram Moolenaar <Bram@vim.org>
parents:
15603
diff
changeset
|
198 #define CLASS_FNAME 18 |
7 | 199 }; |
200 #define CLASS_NONE 99 | |
201 int i; | |
202 | |
203 if ((*pp)[1] == ':') | |
204 { | |
1877 | 205 for (i = 0; i < (int)(sizeof(class_names) / sizeof(*class_names)); ++i) |
7 | 206 if (STRNCMP(*pp + 2, class_names[i], STRLEN(class_names[i])) == 0) |
207 { | |
208 *pp += STRLEN(class_names[i]) + 2; | |
209 return i; | |
210 } | |
211 } | |
212 return CLASS_NONE; | |
213 } | |
214 | |
215 /* | |
216 * Specific version of character class functions. | |
217 * Using a table to keep this fast. | |
218 */ | |
219 static short class_tab[256]; | |
220 | |
221 #define RI_DIGIT 0x01 | |
222 #define RI_HEX 0x02 | |
223 #define RI_OCTAL 0x04 | |
224 #define RI_WORD 0x08 | |
225 #define RI_HEAD 0x10 | |
226 #define RI_ALPHA 0x20 | |
227 #define RI_LOWER 0x40 | |
228 #define RI_UPPER 0x80 | |
229 #define RI_WHITE 0x100 | |
230 | |
231 static void | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
232 init_class_tab(void) |
7 | 233 { |
234 int i; | |
235 static int done = FALSE; | |
236 | |
237 if (done) | |
238 return; | |
239 | |
240 for (i = 0; i < 256; ++i) | |
241 { | |
242 if (i >= '0' && i <= '7') | |
243 class_tab[i] = RI_DIGIT + RI_HEX + RI_OCTAL + RI_WORD; | |
244 else if (i >= '8' && i <= '9') | |
245 class_tab[i] = RI_DIGIT + RI_HEX + RI_WORD; | |
246 else if (i >= 'a' && i <= 'f') | |
247 class_tab[i] = RI_HEX + RI_WORD + RI_HEAD + RI_ALPHA + RI_LOWER; | |
248 #ifdef EBCDIC | |
249 else if ((i >= 'g' && i <= 'i') || (i >= 'j' && i <= 'r') | |
250 || (i >= 's' && i <= 'z')) | |
251 #else | |
252 else if (i >= 'g' && i <= 'z') | |
253 #endif | |
254 class_tab[i] = RI_WORD + RI_HEAD + RI_ALPHA + RI_LOWER; | |
255 else if (i >= 'A' && i <= 'F') | |
256 class_tab[i] = RI_HEX + RI_WORD + RI_HEAD + RI_ALPHA + RI_UPPER; | |
257 #ifdef EBCDIC | |
258 else if ((i >= 'G' && i <= 'I') || ( i >= 'J' && i <= 'R') | |
259 || (i >= 'S' && i <= 'Z')) | |
260 #else | |
261 else if (i >= 'G' && i <= 'Z') | |
262 #endif | |
263 class_tab[i] = RI_WORD + RI_HEAD + RI_ALPHA + RI_UPPER; | |
264 else if (i == '_') | |
265 class_tab[i] = RI_WORD + RI_HEAD; | |
266 else | |
267 class_tab[i] = 0; | |
268 } | |
269 class_tab[' '] |= RI_WHITE; | |
270 class_tab['\t'] |= RI_WHITE; | |
271 done = TRUE; | |
272 } | |
273 | |
15603
639b8318472c
patch 8.1.0809: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
15555
diff
changeset
|
274 #define ri_digit(c) (c < 0x100 && (class_tab[c] & RI_DIGIT)) |
639b8318472c
patch 8.1.0809: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
15555
diff
changeset
|
275 #define ri_hex(c) (c < 0x100 && (class_tab[c] & RI_HEX)) |
639b8318472c
patch 8.1.0809: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
15555
diff
changeset
|
276 #define ri_octal(c) (c < 0x100 && (class_tab[c] & RI_OCTAL)) |
639b8318472c
patch 8.1.0809: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
15555
diff
changeset
|
277 #define ri_word(c) (c < 0x100 && (class_tab[c] & RI_WORD)) |
639b8318472c
patch 8.1.0809: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
15555
diff
changeset
|
278 #define ri_head(c) (c < 0x100 && (class_tab[c] & RI_HEAD)) |
639b8318472c
patch 8.1.0809: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
15555
diff
changeset
|
279 #define ri_alpha(c) (c < 0x100 && (class_tab[c] & RI_ALPHA)) |
639b8318472c
patch 8.1.0809: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
15555
diff
changeset
|
280 #define ri_lower(c) (c < 0x100 && (class_tab[c] & RI_LOWER)) |
639b8318472c
patch 8.1.0809: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
15555
diff
changeset
|
281 #define ri_upper(c) (c < 0x100 && (class_tab[c] & RI_UPPER)) |
639b8318472c
patch 8.1.0809: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
15555
diff
changeset
|
282 #define ri_white(c) (c < 0x100 && (class_tab[c] & RI_WHITE)) |
7 | 283 |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
284 // flags for regflags |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
285 #define RF_ICASE 1 // ignore case |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
286 #define RF_NOICASE 2 // don't ignore case |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
287 #define RF_HASNL 4 // can match a NL |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
288 #define RF_ICOMBINE 8 // ignore combining characters |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
289 #define RF_LOOKBH 16 // uses "\@<=" or "\@<!" |
7 | 290 |
291 /* | |
292 * Global work variables for vim_regcomp(). | |
293 */ | |
294 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
295 static char_u *regparse; // Input-scan pointer. |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
296 static int regnpar; // () count. |
7 | 297 #ifdef FEAT_SYN_HL |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
298 static int regnzpar; // \z() count. |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
299 static int re_has_z; // \z item detected |
7 | 300 #endif |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
301 static unsigned regflags; // RF_ flags for prog |
7 | 302 #if defined(FEAT_SYN_HL) || defined(PROTO) |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
303 static int had_eol; // TRUE when EOL found by vim_regcomp() |
7 | 304 #endif |
305 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
306 static int reg_magic; // magicness of the pattern: |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
307 #define MAGIC_NONE 1 // "\V" very unmagic |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
308 #define MAGIC_OFF 2 // "\M" or 'magic' off |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
309 #define MAGIC_ON 3 // "\m" or 'magic' |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
310 #define MAGIC_ALL 4 // "\v" very magic |
7 | 311 |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
312 static int reg_string; // matching with a string instead of a buffer |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
313 // line |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
314 static int reg_strict; // "[abc" is illegal |
7 | 315 |
316 /* | |
317 * META contains all characters that may be magic, except '^' and '$'. | |
318 */ | |
319 | |
320 #ifdef EBCDIC | |
321 static char_u META[] = "%&()*+.123456789<=>?@ACDFHIKLMOPSUVWX[_acdfhiklmnopsuvwxz{|~"; | |
322 #else | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
323 // META[] is used often enough to justify turning it into a table. |
7 | 324 static char_u META_flags[] = { |
325 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
326 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
327 // % & ( ) * + . |
7 | 328 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
329 // 1 2 3 4 5 6 7 8 9 < = > ? |
7 | 330 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
331 // @ A C D F H I K L M O |
7 | 332 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
333 // P S U V W X Z [ _ |
7 | 334 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
335 // a c d f h i k l m n o |
7 | 336 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
337 // p s u v w x z { | ~ |
7 | 338 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1 |
339 }; | |
340 #endif | |
341 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
342 static int curchr; // currently parsed character |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
343 // Previous character. Note: prevchr is sometimes -1 when we are not at the |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
344 // start, eg in /[ ^I]^ the pattern was never found even if it existed, |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
345 // because ^ was taken to be magic -- webb |
4444 | 346 static int prevchr; |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
347 static int prevprevchr; // previous-previous character |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
348 static int nextchr; // used for ungetchr() |
7 | 349 |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
350 // arguments for reg() |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
351 #define REG_NOPAREN 0 // toplevel reg() |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
352 #define REG_PAREN 1 // \(\) |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
353 #define REG_ZPAREN 2 // \z(\) |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
354 #define REG_NPAREN 3 // \%(\) |
7 | 355 |
4679
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
356 typedef struct |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
357 { |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
358 char_u *regparse; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
359 int prevchr_len; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
360 int curchr; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
361 int prevchr; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
362 int prevprevchr; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
363 int nextchr; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
364 int at_start; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
365 int prev_at_start; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
366 int regnpar; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
367 } parse_state_T; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
368 |
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7009
diff
changeset
|
369 static void initchr(char_u *); |
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7009
diff
changeset
|
370 static int getchr(void); |
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7009
diff
changeset
|
371 static void skipchr_keepstart(void); |
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7009
diff
changeset
|
372 static int peekchr(void); |
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7009
diff
changeset
|
373 static void skipchr(void); |
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7009
diff
changeset
|
374 static void ungetchr(void); |
12752
09c856605191
patch 8.0.1254: undefined left shift in gethexchrs()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
375 static long gethexchrs(int maxinputlen); |
09c856605191
patch 8.0.1254: undefined left shift in gethexchrs()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
376 static long getoctchrs(void); |
09c856605191
patch 8.0.1254: undefined left shift in gethexchrs()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
377 static long getdecchrs(void); |
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7009
diff
changeset
|
378 static int coll_get_char(void); |
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7009
diff
changeset
|
379 static int prog_magic_wrong(void); |
18019
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
380 static int cstrncmp(char_u *s1, char_u *s2, int *n); |
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
381 static char_u *cstrchr(char_u *, int); |
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
382 static int re_mult_next(char *what); |
15709
2e2f07561f4b
patch 8.1.0862: no verbose version of character classes
Bram Moolenaar <Bram@vim.org>
parents:
15603
diff
changeset
|
383 static int reg_iswordc(int); |
7 | 384 |
4444 | 385 static regengine_T bt_regengine; |
386 static regengine_T nfa_regengine; | |
387 | |
7 | 388 /* |
389 * Return TRUE if compiled regular expression "prog" can match a line break. | |
390 */ | |
391 int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
392 re_multiline(regprog_T *prog) |
7 | 393 { |
394 return (prog->regflags & RF_HASNL); | |
395 } | |
396 | |
397 /* | |
167 | 398 * Check for an equivalence class name "[=a=]". "pp" points to the '['. |
399 * Returns a character representing the class. Zero means that no item was | |
400 * recognized. Otherwise "pp" is advanced to after the item. | |
401 */ | |
402 static int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
403 get_equi_class(char_u **pp) |
167 | 404 { |
405 int c; | |
406 int l = 1; | |
407 char_u *p = *pp; | |
408 | |
15854
4ac1c185b0b8
patch 8.1.0934: invalid memory access in search pattern
Bram Moolenaar <Bram@vim.org>
parents:
15792
diff
changeset
|
409 if (p[1] == '=' && p[2] != NUL) |
167 | 410 { |
411 if (has_mbyte) | |
474 | 412 l = (*mb_ptr2len)(p + 2); |
167 | 413 if (p[l + 2] == '=' && p[l + 3] == ']') |
414 { | |
415 if (has_mbyte) | |
416 c = mb_ptr2char(p + 2); | |
417 else | |
418 c = p[2]; | |
419 *pp += l + 4; | |
420 return c; | |
421 } | |
422 } | |
423 return 0; | |
424 } | |
425 | |
2247
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
426 #ifdef EBCDIC |
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
427 /* |
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
428 * Table for equivalence class "c". (IBM-1047) |
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
429 */ |
17789
0f7ae8010787
patch 8.1.1891: functions used in one file are global
Bram Moolenaar <Bram@vim.org>
parents:
17659
diff
changeset
|
430 static char *EQUIVAL_CLASS_C[16] = { |
2247
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
431 "A\x62\x63\x64\x65\x66\x67", |
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
432 "C\x68", |
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
433 "E\x71\x72\x73\x74", |
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
434 "I\x75\x76\x77\x78", |
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
435 "N\x69", |
8825
318eaa6fa973
commit https://github.com/vim/vim/commit/22e421549d54147d003f6444de007cb1d73f1d27
Christian Brabandt <cb@256bit.org>
parents:
8212
diff
changeset
|
436 "O\xEB\xEC\xED\xEE\xEF\x80", |
2247
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
437 "U\xFB\xFC\xFD\xFE", |
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
438 "Y\xBA", |
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
439 "a\x42\x43\x44\x45\x46\x47", |
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
440 "c\x48", |
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
441 "e\x51\x52\x53\x54", |
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
442 "i\x55\x56\x57\x58", |
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
443 "n\x49", |
8825
318eaa6fa973
commit https://github.com/vim/vim/commit/22e421549d54147d003f6444de007cb1d73f1d27
Christian Brabandt <cb@256bit.org>
parents:
8212
diff
changeset
|
444 "o\xCB\xCC\xCD\xCE\xCF\x70", |
2247
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
445 "u\xDB\xDC\xDD\xDE", |
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
446 "y\x8D\xDF", |
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
447 }; |
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
448 #endif |
c40cd9aad546
Add patch to improve support of z/OS (OS/390). (Ralf Schandl)
Bram Moolenaar <bram@vim.org>
parents:
2173
diff
changeset
|
449 |
167 | 450 /* |
451 * Check for a collating element "[.a.]". "pp" points to the '['. | |
452 * Returns a character. Zero means that no item was recognized. Otherwise | |
453 * "pp" is advanced to after the item. | |
454 * Currently only single characters are recognized! | |
455 */ | |
456 static int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
457 get_coll_element(char_u **pp) |
167 | 458 { |
459 int c; | |
460 int l = 1; | |
461 char_u *p = *pp; | |
462 | |
15860
9cd9bf2897de
patch 8.1.0937: invalid memory access in search pattern
Bram Moolenaar <Bram@vim.org>
parents:
15856
diff
changeset
|
463 if (p[0] != NUL && p[1] == '.' && p[2] != NUL) |
167 | 464 { |
465 if (has_mbyte) | |
474 | 466 l = (*mb_ptr2len)(p + 2); |
167 | 467 if (p[l + 2] == '.' && p[l + 3] == ']') |
468 { | |
469 if (has_mbyte) | |
470 c = mb_ptr2char(p + 2); | |
471 else | |
472 c = p[2]; | |
473 *pp += l + 4; | |
474 return c; | |
475 } | |
476 } | |
477 return 0; | |
478 } | |
479 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
480 static int reg_cpo_lit; // 'cpoptions' contains 'l' flag |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
481 static int reg_cpo_bsl; // 'cpoptions' contains '\' flag |
4744
a62695305e03
updated for version 7.3.1119
Bram Moolenaar <bram@vim.org>
parents:
4732
diff
changeset
|
482 |
a62695305e03
updated for version 7.3.1119
Bram Moolenaar <bram@vim.org>
parents:
4732
diff
changeset
|
483 static void |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
484 get_cpo_flags(void) |
4744
a62695305e03
updated for version 7.3.1119
Bram Moolenaar <bram@vim.org>
parents:
4732
diff
changeset
|
485 { |
a62695305e03
updated for version 7.3.1119
Bram Moolenaar <bram@vim.org>
parents:
4732
diff
changeset
|
486 reg_cpo_lit = vim_strchr(p_cpo, CPO_LITERAL) != NULL; |
a62695305e03
updated for version 7.3.1119
Bram Moolenaar <bram@vim.org>
parents:
4732
diff
changeset
|
487 reg_cpo_bsl = vim_strchr(p_cpo, CPO_BACKSL) != NULL; |
a62695305e03
updated for version 7.3.1119
Bram Moolenaar <bram@vim.org>
parents:
4732
diff
changeset
|
488 } |
167 | 489 |
490 /* | |
491 * Skip over a "[]" range. | |
492 * "p" must point to the character after the '['. | |
493 * The returned pointer is on the matching ']', or the terminating NUL. | |
494 */ | |
495 static char_u * | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
496 skip_anyof(char_u *p) |
167 | 497 { |
498 int l; | |
499 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
500 if (*p == '^') // Complement of range. |
167 | 501 ++p; |
502 if (*p == ']' || *p == '-') | |
503 ++p; | |
504 while (*p != NUL && *p != ']') | |
505 { | |
474 | 506 if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1) |
167 | 507 p += l; |
508 else | |
509 if (*p == '-') | |
510 { | |
511 ++p; | |
512 if (*p != ']' && *p != NUL) | |
11127
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11121
diff
changeset
|
513 MB_PTR_ADV(p); |
167 | 514 } |
515 else if (*p == '\\' | |
4744
a62695305e03
updated for version 7.3.1119
Bram Moolenaar <bram@vim.org>
parents:
4732
diff
changeset
|
516 && !reg_cpo_bsl |
167 | 517 && (vim_strchr(REGEXP_INRANGE, p[1]) != NULL |
4744
a62695305e03
updated for version 7.3.1119
Bram Moolenaar <bram@vim.org>
parents:
4732
diff
changeset
|
518 || (!reg_cpo_lit && vim_strchr(REGEXP_ABBR, p[1]) != NULL))) |
167 | 519 p += 2; |
520 else if (*p == '[') | |
521 { | |
522 if (get_char_class(&p) == CLASS_NONE | |
523 && get_equi_class(&p) == 0 | |
6830 | 524 && get_coll_element(&p) == 0 |
525 && *p != NUL) | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
526 ++p; // it is not a class name and not NUL |
167 | 527 } |
528 else | |
529 ++p; | |
530 } | |
531 | |
532 return p; | |
533 } | |
534 | |
535 /* | |
7 | 536 * Skip past regular expression. |
20113
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
537 * Stop at end of "startp" or where "delim" is found ('/', '?', etc). |
7 | 538 * Take care of characters with a backslash in front of it. |
539 * Skip strings inside [ and ]. | |
540 */ | |
541 char_u * | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
542 skip_regexp( |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
543 char_u *startp, |
20113
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
544 int delim, |
19892
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
545 int magic) |
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
546 { |
20113
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
547 return skip_regexp_ex(startp, delim, magic, NULL, NULL); |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
548 } |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
549 |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
550 /* |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
551 * Call skip_regexp() and when the delimiter does not match give an error and |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
552 * return NULL. |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
553 */ |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
554 char_u * |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
555 skip_regexp_err( |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
556 char_u *startp, |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
557 int delim, |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
558 int magic) |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
559 { |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
560 char_u *p = skip_regexp(startp, delim, magic); |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
561 |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
562 if (*p != delim) |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
563 { |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
564 semsg(_("E654: missing delimiter after search pattern: %s"), startp); |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
565 return NULL; |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
566 } |
2c23053c654a
patch 8.2.0612: Vim9: no check for space before #comment
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
567 return p; |
19892
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
568 } |
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
569 |
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
570 /* |
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
571 * skip_regexp() with extra arguments: |
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
572 * When "newp" is not NULL and "dirc" is '?', make an allocated copy of the |
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
573 * expression and change "\?" to "?". If "*newp" is not NULL the expression |
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
574 * is changed in-place. |
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
575 * If a "\?" is changed to "?" then "dropped" is incremented, unless NULL. |
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
576 */ |
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
577 char_u * |
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
578 skip_regexp_ex( |
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
579 char_u *startp, |
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
580 int dirc, |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
581 int magic, |
19892
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
582 char_u **newp, |
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
583 int *dropped) |
7 | 584 { |
585 int mymagic; | |
586 char_u *p = startp; | |
587 | |
588 if (magic) | |
589 mymagic = MAGIC_ON; | |
590 else | |
591 mymagic = MAGIC_OFF; | |
4744
a62695305e03
updated for version 7.3.1119
Bram Moolenaar <bram@vim.org>
parents:
4732
diff
changeset
|
592 get_cpo_flags(); |
7 | 593 |
11127
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11121
diff
changeset
|
594 for (; p[0] != NUL; MB_PTR_ADV(p)) |
7 | 595 { |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
596 if (p[0] == dirc) // found end of regexp |
7 | 597 break; |
598 if ((p[0] == '[' && mymagic >= MAGIC_ON) | |
599 || (p[0] == '\\' && p[1] == '[' && mymagic <= MAGIC_OFF)) | |
600 { | |
601 p = skip_anyof(p + 1); | |
602 if (p[0] == NUL) | |
603 break; | |
604 } | |
605 else if (p[0] == '\\' && p[1] != NUL) | |
606 { | |
607 if (dirc == '?' && newp != NULL && p[1] == '?') | |
608 { | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
609 // change "\?" to "?", make a copy first. |
7 | 610 if (*newp == NULL) |
611 { | |
612 *newp = vim_strsave(startp); | |
613 if (*newp != NULL) | |
614 p = *newp + (p - startp); | |
615 } | |
19892
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
616 if (dropped != NULL) |
5feb426d2ea1
patch 8.2.0502: Vim9: some code is not tested
Bram Moolenaar <Bram@vim.org>
parents:
19405
diff
changeset
|
617 ++*dropped; |
7 | 618 if (*newp != NULL) |
1621 | 619 STRMOVE(p, p + 1); |
7 | 620 else |
621 ++p; | |
622 } | |
623 else | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
624 ++p; // skip next character |
7 | 625 if (*p == 'v') |
626 mymagic = MAGIC_ALL; | |
627 else if (*p == 'V') | |
628 mymagic = MAGIC_NONE; | |
629 } | |
630 } | |
631 return p; | |
632 } | |
633 | |
11525
14b6b79d685b
patch 8.0.0645: no error for illegal back reference in NFA engine
Christian Brabandt <cb@256bit.org>
parents:
11521
diff
changeset
|
634 /* |
18019
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
635 * Functions for getting characters from the regexp input. |
7 | 636 */ |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
637 static int prevchr_len; // byte length of previous char |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
638 static int at_start; // True when on the first character |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
639 static int prev_at_start; // True when on the second character |
8021
b6b4f354df23
commit https://github.com/vim/vim/commit/7c29f387819b5817b003d2ba73e2b5cf3cb3d0dd
Christian Brabandt <cb@256bit.org>
parents:
7833
diff
changeset
|
640 |
7 | 641 /* |
4444 | 642 * Start parsing at "str". |
643 */ | |
7 | 644 static void |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
645 initchr(char_u *str) |
7 | 646 { |
647 regparse = str; | |
648 prevchr_len = 0; | |
649 curchr = prevprevchr = prevchr = nextchr = -1; | |
650 at_start = TRUE; | |
651 prev_at_start = FALSE; | |
652 } | |
653 | |
4444 | 654 /* |
4679
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
655 * Save the current parse state, so that it can be restored and parsing |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
656 * starts in the same state again. |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
657 */ |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
658 static void |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
659 save_parse_state(parse_state_T *ps) |
4679
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
660 { |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
661 ps->regparse = regparse; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
662 ps->prevchr_len = prevchr_len; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
663 ps->curchr = curchr; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
664 ps->prevchr = prevchr; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
665 ps->prevprevchr = prevprevchr; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
666 ps->nextchr = nextchr; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
667 ps->at_start = at_start; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
668 ps->prev_at_start = prev_at_start; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
669 ps->regnpar = regnpar; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
670 } |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
671 |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
672 /* |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
673 * Restore a previously saved parse state. |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
674 */ |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
675 static void |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
676 restore_parse_state(parse_state_T *ps) |
4679
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
677 { |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
678 regparse = ps->regparse; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
679 prevchr_len = ps->prevchr_len; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
680 curchr = ps->curchr; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
681 prevchr = ps->prevchr; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
682 prevprevchr = ps->prevprevchr; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
683 nextchr = ps->nextchr; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
684 at_start = ps->at_start; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
685 prev_at_start = ps->prev_at_start; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
686 regnpar = ps->regnpar; |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
687 } |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
688 |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
689 |
4d92b873acef
updated for version 7.3.1087
Bram Moolenaar <bram@vim.org>
parents:
4579
diff
changeset
|
690 /* |
4444 | 691 * Get the next character without advancing. |
692 */ | |
7 | 693 static int |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
694 peekchr(void) |
7 | 695 { |
167 | 696 static int after_slash = FALSE; |
697 | |
7 | 698 if (curchr == -1) |
699 { | |
700 switch (curchr = regparse[0]) | |
701 { | |
702 case '.': | |
703 case '[': | |
704 case '~': | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
705 // magic when 'magic' is on |
7 | 706 if (reg_magic >= MAGIC_ON) |
707 curchr = Magic(curchr); | |
708 break; | |
709 case '(': | |
710 case ')': | |
711 case '{': | |
712 case '%': | |
713 case '+': | |
714 case '=': | |
715 case '?': | |
716 case '@': | |
717 case '!': | |
718 case '&': | |
719 case '|': | |
720 case '<': | |
721 case '>': | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
722 case '#': // future ext. |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
723 case '"': // future ext. |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
724 case '\'': // future ext. |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
725 case ',': // future ext. |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
726 case '-': // future ext. |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
727 case ':': // future ext. |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
728 case ';': // future ext. |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
729 case '`': // future ext. |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
730 case '/': // Can't be used in / command |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
731 // magic only after "\v" |
7 | 732 if (reg_magic == MAGIC_ALL) |
733 curchr = Magic(curchr); | |
734 break; | |
735 case '*': | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
736 // * is not magic as the very first character, eg "?*ptr", when |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
737 // after '^', eg "/^*ptr" and when after "\(", "\|", "\&". But |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
738 // "\(\*" is not magic, thus must be magic if "after_slash" |
167 | 739 if (reg_magic >= MAGIC_ON |
740 && !at_start | |
741 && !(prev_at_start && prevchr == Magic('^')) | |
742 && (after_slash | |
743 || (prevchr != Magic('(') | |
744 && prevchr != Magic('&') | |
745 && prevchr != Magic('|')))) | |
7 | 746 curchr = Magic('*'); |
747 break; | |
748 case '^': | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
749 // '^' is only magic as the very first character and if it's after |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
750 // "\(", "\|", "\&' or "\n" |
7 | 751 if (reg_magic >= MAGIC_OFF |
752 && (at_start | |
753 || reg_magic == MAGIC_ALL | |
754 || prevchr == Magic('(') | |
755 || prevchr == Magic('|') | |
756 || prevchr == Magic('&') | |
757 || prevchr == Magic('n') | |
758 || (no_Magic(prevchr) == '(' | |
759 && prevprevchr == Magic('%')))) | |
760 { | |
761 curchr = Magic('^'); | |
762 at_start = TRUE; | |
763 prev_at_start = FALSE; | |
764 } | |
765 break; | |
766 case '$': | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
767 // '$' is only magic as the very last char and if it's in front of |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
768 // either "\|", "\)", "\&", or "\n" |
7 | 769 if (reg_magic >= MAGIC_OFF) |
770 { | |
771 char_u *p = regparse + 1; | |
6041 | 772 int is_magic_all = (reg_magic == MAGIC_ALL); |
773 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
774 // ignore \c \C \m \M \v \V and \Z after '$' |
7 | 775 while (p[0] == '\\' && (p[1] == 'c' || p[1] == 'C' |
6041 | 776 || p[1] == 'm' || p[1] == 'M' |
777 || p[1] == 'v' || p[1] == 'V' || p[1] == 'Z')) | |
778 { | |
779 if (p[1] == 'v') | |
780 is_magic_all = TRUE; | |
781 else if (p[1] == 'm' || p[1] == 'M' || p[1] == 'V') | |
782 is_magic_all = FALSE; | |
7 | 783 p += 2; |
6041 | 784 } |
7 | 785 if (p[0] == NUL |
786 || (p[0] == '\\' | |
787 && (p[1] == '|' || p[1] == '&' || p[1] == ')' | |
788 || p[1] == 'n')) | |
6041 | 789 || (is_magic_all |
790 && (p[0] == '|' || p[0] == '&' || p[0] == ')')) | |
7 | 791 || reg_magic == MAGIC_ALL) |
792 curchr = Magic('$'); | |
793 } | |
794 break; | |
795 case '\\': | |
796 { | |
797 int c = regparse[1]; | |
798 | |
799 if (c == NUL) | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
800 curchr = '\\'; // trailing '\' |
7 | 801 else if ( |
802 #ifdef EBCDIC | |
803 vim_strchr(META, c) | |
804 #else | |
805 c <= '~' && META_flags[c] | |
806 #endif | |
807 ) | |
808 { | |
809 /* | |
810 * META contains everything that may be magic sometimes, | |
811 * except ^ and $ ("\^" and "\$" are only magic after | |
6830 | 812 * "\V"). We now fetch the next character and toggle its |
7 | 813 * magicness. Therefore, \ is so meta-magic that it is |
814 * not in META. | |
815 */ | |
816 curchr = -1; | |
817 prev_at_start = at_start; | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
818 at_start = FALSE; // be able to say "/\*ptr" |
7 | 819 ++regparse; |
167 | 820 ++after_slash; |
7 | 821 peekchr(); |
822 --regparse; | |
167 | 823 --after_slash; |
7 | 824 curchr = toggle_Magic(curchr); |
825 } | |
826 else if (vim_strchr(REGEXP_ABBR, c)) | |
827 { | |
828 /* | |
829 * Handle abbreviations, like "\t" for TAB -- webb | |
830 */ | |
831 curchr = backslash_trans(c); | |
832 } | |
833 else if (reg_magic == MAGIC_NONE && (c == '$' || c == '^')) | |
834 curchr = toggle_Magic(c); | |
835 else | |
836 { | |
837 /* | |
838 * Next character can never be (made) magic? | |
839 * Then backslashing it won't do anything. | |
840 */ | |
841 if (has_mbyte) | |
842 curchr = (*mb_ptr2char)(regparse + 1); | |
843 else | |
844 curchr = c; | |
845 } | |
846 break; | |
847 } | |
848 | |
849 default: | |
850 if (has_mbyte) | |
851 curchr = (*mb_ptr2char)(regparse); | |
852 } | |
853 } | |
854 | |
855 return curchr; | |
856 } | |
857 | |
858 /* | |
859 * Eat one lexed character. Do this in a way that we can undo it. | |
860 */ | |
861 static void | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
862 skipchr(void) |
7 | 863 { |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
864 // peekchr() eats a backslash, do the same here |
7 | 865 if (*regparse == '\\') |
866 prevchr_len = 1; | |
867 else | |
868 prevchr_len = 0; | |
869 if (regparse[prevchr_len] != NUL) | |
870 { | |
714 | 871 if (enc_utf8) |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
872 // exclude composing chars that mb_ptr2len does include |
1449 | 873 prevchr_len += utf_ptr2len(regparse + prevchr_len); |
714 | 874 else if (has_mbyte) |
474 | 875 prevchr_len += (*mb_ptr2len)(regparse + prevchr_len); |
7 | 876 else |
877 ++prevchr_len; | |
878 } | |
879 regparse += prevchr_len; | |
880 prev_at_start = at_start; | |
881 at_start = FALSE; | |
882 prevprevchr = prevchr; | |
883 prevchr = curchr; | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
884 curchr = nextchr; // use previously unget char, or -1 |
7 | 885 nextchr = -1; |
886 } | |
887 | |
888 /* | |
889 * Skip a character while keeping the value of prev_at_start for at_start. | |
890 * prevchr and prevprevchr are also kept. | |
891 */ | |
892 static void | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
893 skipchr_keepstart(void) |
7 | 894 { |
895 int as = prev_at_start; | |
896 int pr = prevchr; | |
897 int prpr = prevprevchr; | |
898 | |
899 skipchr(); | |
900 at_start = as; | |
901 prevchr = pr; | |
902 prevprevchr = prpr; | |
903 } | |
904 | |
4444 | 905 /* |
906 * Get the next character from the pattern. We know about magic and such, so | |
907 * therefore we need a lexical analyzer. | |
908 */ | |
7 | 909 static int |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
910 getchr(void) |
7 | 911 { |
912 int chr = peekchr(); | |
913 | |
914 skipchr(); | |
915 return chr; | |
916 } | |
917 | |
918 /* | |
919 * put character back. Works only once! | |
920 */ | |
921 static void | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
922 ungetchr(void) |
7 | 923 { |
924 nextchr = curchr; | |
925 curchr = prevchr; | |
926 prevchr = prevprevchr; | |
927 at_start = prev_at_start; | |
928 prev_at_start = FALSE; | |
929 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
930 // Backup regparse, so that it's at the same position as before the |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
931 // getchr(). |
7 | 932 regparse -= prevchr_len; |
933 } | |
934 | |
935 /* | |
29 | 936 * Get and return the value of the hex string at the current position. |
937 * Return -1 if there is no valid hex number. | |
938 * The position is updated: | |
24 | 939 * blahblah\%x20asdf |
856 | 940 * before-^ ^-after |
24 | 941 * The parameter controls the maximum number of input characters. This will be |
942 * 2 when reading a \%x20 sequence and 4 when reading a \%u20AC sequence. | |
943 */ | |
12752
09c856605191
patch 8.0.1254: undefined left shift in gethexchrs()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
944 static long |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
945 gethexchrs(int maxinputlen) |
24 | 946 { |
12752
09c856605191
patch 8.0.1254: undefined left shift in gethexchrs()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
947 long_u nr = 0; |
24 | 948 int c; |
949 int i; | |
950 | |
951 for (i = 0; i < maxinputlen; ++i) | |
952 { | |
953 c = regparse[0]; | |
954 if (!vim_isxdigit(c)) | |
955 break; | |
956 nr <<= 4; | |
957 nr |= hex2nr(c); | |
958 ++regparse; | |
959 } | |
960 | |
961 if (i == 0) | |
962 return -1; | |
12752
09c856605191
patch 8.0.1254: undefined left shift in gethexchrs()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
963 return (long)nr; |
24 | 964 } |
965 | |
966 /* | |
4579
7a2be4a39423
updated for version 7.3.1037
Bram Moolenaar <bram@vim.org>
parents:
4505
diff
changeset
|
967 * Get and return the value of the decimal string immediately after the |
24 | 968 * current position. Return -1 for invalid. Consumes all digits. |
969 */ | |
12752
09c856605191
patch 8.0.1254: undefined left shift in gethexchrs()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
970 static long |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
971 getdecchrs(void) |
24 | 972 { |
12752
09c856605191
patch 8.0.1254: undefined left shift in gethexchrs()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
973 long_u nr = 0; |
24 | 974 int c; |
975 int i; | |
976 | |
977 for (i = 0; ; ++i) | |
978 { | |
979 c = regparse[0]; | |
980 if (c < '0' || c > '9') | |
981 break; | |
982 nr *= 10; | |
983 nr += c - '0'; | |
984 ++regparse; | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
985 curchr = -1; // no longer valid |
24 | 986 } |
987 | |
988 if (i == 0) | |
989 return -1; | |
12752
09c856605191
patch 8.0.1254: undefined left shift in gethexchrs()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
990 return (long)nr; |
24 | 991 } |
992 | |
993 /* | |
994 * get and return the value of the octal string immediately after the current | |
995 * position. Return -1 for invalid, or 0-255 for valid. Smart enough to handle | |
996 * numbers > 377 correctly (for example, 400 is treated as 40) and doesn't | |
997 * treat 8 or 9 as recognised characters. Position is updated: | |
998 * blahblah\%o210asdf | |
856 | 999 * before-^ ^-after |
24 | 1000 */ |
12752
09c856605191
patch 8.0.1254: undefined left shift in gethexchrs()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
1001 static long |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1002 getoctchrs(void) |
24 | 1003 { |
12752
09c856605191
patch 8.0.1254: undefined left shift in gethexchrs()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
1004 long_u nr = 0; |
24 | 1005 int c; |
1006 int i; | |
1007 | |
1008 for (i = 0; i < 3 && nr < 040; ++i) | |
1009 { | |
1010 c = regparse[0]; | |
1011 if (c < '0' || c > '7') | |
1012 break; | |
1013 nr <<= 3; | |
1014 nr |= hex2nr(c); | |
1015 ++regparse; | |
1016 } | |
1017 | |
1018 if (i == 0) | |
1019 return -1; | |
12752
09c856605191
patch 8.0.1254: undefined left shift in gethexchrs()
Christian Brabandt <cb@256bit.org>
parents:
12674
diff
changeset
|
1020 return (long)nr; |
24 | 1021 } |
1022 | |
1023 /* | |
7 | 1024 * read_limits - Read two integers to be taken as a minimum and maximum. |
1025 * If the first character is '-', then the range is reversed. | |
1026 * Should end with 'end'. If minval is missing, zero is default, if maxval is | |
1027 * missing, a very big number is the default. | |
1028 */ | |
1029 static int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1030 read_limits(long *minval, long *maxval) |
7 | 1031 { |
1032 int reverse = FALSE; | |
1033 char_u *first_char; | |
1034 long tmp; | |
1035 | |
1036 if (*regparse == '-') | |
1037 { | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1038 // Starts with '-', so reverse the range later |
7 | 1039 regparse++; |
1040 reverse = TRUE; | |
1041 } | |
1042 first_char = regparse; | |
1043 *minval = getdigits(®parse); | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1044 if (*regparse == ',') // There is a comma |
7 | 1045 { |
1046 if (vim_isdigit(*++regparse)) | |
1047 *maxval = getdigits(®parse); | |
1048 else | |
1049 *maxval = MAX_LIMIT; | |
1050 } | |
1051 else if (VIM_ISDIGIT(*first_char)) | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1052 *maxval = *minval; // It was \{n} or \{-n} |
7 | 1053 else |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1054 *maxval = MAX_LIMIT; // It was \{} or \{-} |
7 | 1055 if (*regparse == '\\') |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1056 regparse++; // Allow either \{...} or \{...\} |
167 | 1057 if (*regparse != '}') |
15480
bd12ace1bab2
patch 8.1.0748: using sprintf() instead of semsg()
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
1058 EMSG2_RET_FAIL(_("E554: Syntax error in %s{...}"), |
bd12ace1bab2
patch 8.1.0748: using sprintf() instead of semsg()
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
1059 reg_magic == MAGIC_ALL); |
7 | 1060 |
1061 /* | |
1062 * Reverse the range if there was a '-', or make sure it is in the right | |
1063 * order otherwise. | |
1064 */ | |
1065 if ((!reverse && *minval > *maxval) || (reverse && *minval < *maxval)) | |
1066 { | |
1067 tmp = *minval; | |
1068 *minval = *maxval; | |
1069 *maxval = tmp; | |
1070 } | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1071 skipchr(); // let's be friends with the lexer again |
7 | 1072 return OK; |
1073 } | |
1074 | |
1075 /* | |
1076 * vim_regexec and friends | |
1077 */ | |
1078 | |
1079 /* | |
1080 * Global work variables for vim_regexec(). | |
1081 */ | |
1082 | |
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7009
diff
changeset
|
1083 static void cleanup_subexpr(void); |
7 | 1084 #ifdef FEAT_SYN_HL |
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7009
diff
changeset
|
1085 static void cleanup_zsubexpr(void); |
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7009
diff
changeset
|
1086 #endif |
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7009
diff
changeset
|
1087 static void reg_nextline(void); |
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7009
diff
changeset
|
1088 static int match_with_backref(linenr_T start_lnum, colnr_T start_col, linenr_T end_lnum, colnr_T end_col, int *bytelen); |
7 | 1089 |
1090 /* | |
1091 * Sometimes need to save a copy of a line. Since alloc()/free() is very | |
1092 * slow, we keep one allocated piece of memory and only re-allocate it when | |
4444 | 1093 * it's too small. It's freed in bt_regexec_both() when finished. |
7 | 1094 */ |
1468 | 1095 static char_u *reg_tofree = NULL; |
7 | 1096 static unsigned reg_tofreelen; |
1097 | |
1098 /* | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1099 * Structure used to store the execution state of the regex engine. |
1209 | 1100 * Which ones are set depends on whether a single-line or multi-line match is |
7 | 1101 * done: |
1102 * single-line multi-line | |
1103 * reg_match ®match_T NULL | |
1104 * reg_mmatch NULL ®mmatch_T | |
1105 * reg_startp reg_match->startp <invalid> | |
1106 * reg_endp reg_match->endp <invalid> | |
1107 * reg_startpos <invalid> reg_mmatch->startpos | |
1108 * reg_endpos <invalid> reg_mmatch->endpos | |
1109 * reg_win NULL window in which to search | |
4061 | 1110 * reg_buf curbuf buffer in which to search |
7 | 1111 * reg_firstlnum <invalid> first line in which to search |
1112 * reg_maxline 0 last line nr | |
1113 * reg_line_lbr FALSE or TRUE FALSE | |
1114 */ | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1115 typedef struct { |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1116 regmatch_T *reg_match; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1117 regmmatch_T *reg_mmatch; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1118 char_u **reg_startp; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1119 char_u **reg_endp; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1120 lpos_T *reg_startpos; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1121 lpos_T *reg_endpos; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1122 win_T *reg_win; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1123 buf_T *reg_buf; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1124 linenr_T reg_firstlnum; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1125 linenr_T reg_maxline; |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1126 int reg_line_lbr; // "\n" in string is line break |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1127 |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1128 // The current match-position is stord in these variables: |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1129 linenr_T lnum; // line number, relative to first line |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1130 char_u *line; // start of current line |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1131 char_u *input; // current input, points into "regline" |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1132 |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1133 int need_clear_subexpr; // subexpressions still need to be cleared |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1134 #ifdef FEAT_SYN_HL |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1135 int need_clear_zsubexpr; // extmatch subexpressions still need to be |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1136 // cleared |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1137 #endif |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1138 |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1139 // Internal copy of 'ignorecase'. It is set at each call to vim_regexec(). |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1140 // Normally it gets the value of "rm_ic" or "rmm_ic", but when the pattern |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1141 // contains '\c' or '\C' the value is overruled. |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1142 int reg_ic; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1143 |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1144 // Similar to "reg_ic", but only for 'combining' characters. Set with \Z |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1145 // flag in the regexp. Defaults to false, always. |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1146 int reg_icombine; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1147 |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1148 // Copy of "rmm_maxcol": maximum column to search for a match. Zero when |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1149 // there is no maximum. |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1150 colnr_T reg_maxcol; |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1151 |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1152 // State for the NFA engine regexec. |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1153 int nfa_has_zend; // NFA regexp \ze operator encountered. |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1154 int nfa_has_backref; // NFA regexp \1 .. \9 encountered. |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1155 int nfa_nsubexpr; // Number of sub expressions actually being used |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1156 // during execution. 1 if only the whole match |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1157 // (subexpr 0) is used. |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1158 // listid is global, so that it increases on recursive calls to |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1159 // nfa_regmatch(), which means we don't have to clear the lastlist field of |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1160 // all the states. |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1161 int nfa_listid; |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1162 int nfa_alt_listid; |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1163 |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1164 #ifdef FEAT_SYN_HL |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1165 int nfa_has_zsubexpr; // NFA regexp has \z( ), set zsubexpr. |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1166 #endif |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1167 } regexec_T; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1168 |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1169 static regexec_T rex; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1170 static int rex_in_use = FALSE; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1171 |
7 | 1172 /* |
15709
2e2f07561f4b
patch 8.1.0862: no verbose version of character classes
Bram Moolenaar <Bram@vim.org>
parents:
15603
diff
changeset
|
1173 * Return TRUE if character 'c' is included in 'iskeyword' option for |
2e2f07561f4b
patch 8.1.0862: no verbose version of character classes
Bram Moolenaar <Bram@vim.org>
parents:
15603
diff
changeset
|
1174 * "reg_buf" buffer. |
2e2f07561f4b
patch 8.1.0862: no verbose version of character classes
Bram Moolenaar <Bram@vim.org>
parents:
15603
diff
changeset
|
1175 */ |
2e2f07561f4b
patch 8.1.0862: no verbose version of character classes
Bram Moolenaar <Bram@vim.org>
parents:
15603
diff
changeset
|
1176 static int |
2e2f07561f4b
patch 8.1.0862: no verbose version of character classes
Bram Moolenaar <Bram@vim.org>
parents:
15603
diff
changeset
|
1177 reg_iswordc(int c) |
2e2f07561f4b
patch 8.1.0862: no verbose version of character classes
Bram Moolenaar <Bram@vim.org>
parents:
15603
diff
changeset
|
1178 { |
2e2f07561f4b
patch 8.1.0862: no verbose version of character classes
Bram Moolenaar <Bram@vim.org>
parents:
15603
diff
changeset
|
1179 return vim_iswordc_buf(c, rex.reg_buf); |
2e2f07561f4b
patch 8.1.0862: no verbose version of character classes
Bram Moolenaar <Bram@vim.org>
parents:
15603
diff
changeset
|
1180 } |
2e2f07561f4b
patch 8.1.0862: no verbose version of character classes
Bram Moolenaar <Bram@vim.org>
parents:
15603
diff
changeset
|
1181 |
2e2f07561f4b
patch 8.1.0862: no verbose version of character classes
Bram Moolenaar <Bram@vim.org>
parents:
15603
diff
changeset
|
1182 /* |
7 | 1183 * Get pointer to the line "lnum", which is relative to "reg_firstlnum". |
1184 */ | |
1185 static char_u * | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1186 reg_getline(linenr_T lnum) |
7 | 1187 { |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1188 // when looking behind for a match/no-match lnum is negative. But we |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1189 // can't go before line 1 |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1190 if (rex.reg_firstlnum + lnum < 1) |
7 | 1191 return NULL; |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1192 if (lnum > rex.reg_maxline) |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1193 // Must have matched the "\n" in the last line. |
481 | 1194 return (char_u *)""; |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1195 return ml_get_buf(rex.reg_buf, rex.reg_firstlnum + lnum, FALSE); |
7 | 1196 } |
1197 | |
1198 #ifdef FEAT_SYN_HL | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1199 static char_u *reg_startzp[NSUBEXP]; // Workspace to mark beginning |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1200 static char_u *reg_endzp[NSUBEXP]; // and end of \z(...\) matches |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1201 static lpos_T reg_startzpos[NSUBEXP]; // idem, beginning pos |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1202 static lpos_T reg_endzpos[NSUBEXP]; // idem, end pos |
7 | 1203 #endif |
1204 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1205 // TRUE if using multi-line regexp. |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1206 #define REG_MULTI (rex.reg_match == NULL) |
4444 | 1207 |
7 | 1208 #ifdef FEAT_SYN_HL |
1209 /* | |
1210 * Create a new extmatch and mark it as referenced once. | |
1211 */ | |
1212 static reg_extmatch_T * | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1213 make_extmatch(void) |
7 | 1214 { |
1215 reg_extmatch_T *em; | |
1216 | |
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
1217 em = ALLOC_CLEAR_ONE(reg_extmatch_T); |
7 | 1218 if (em != NULL) |
1219 em->refcnt = 1; | |
1220 return em; | |
1221 } | |
1222 | |
1223 /* | |
1224 * Add a reference to an extmatch. | |
1225 */ | |
1226 reg_extmatch_T * | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1227 ref_extmatch(reg_extmatch_T *em) |
7 | 1228 { |
1229 if (em != NULL) | |
1230 em->refcnt++; | |
1231 return em; | |
1232 } | |
1233 | |
1234 /* | |
1235 * Remove a reference to an extmatch. If there are no references left, free | |
1236 * the info. | |
1237 */ | |
1238 void | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1239 unref_extmatch(reg_extmatch_T *em) |
7 | 1240 { |
1241 int i; | |
1242 | |
1243 if (em != NULL && --em->refcnt <= 0) | |
1244 { | |
1245 for (i = 0; i < NSUBEXP; ++i) | |
1246 vim_free(em->matches[i]); | |
1247 vim_free(em); | |
1248 } | |
1249 } | |
1250 #endif | |
1251 | |
1252 /* | |
1253 * Get class of previous character. | |
1254 */ | |
1255 static int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1256 reg_prev_class(void) |
7 | 1257 { |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1258 if (rex.input > rex.line) |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1259 return mb_get_class_buf(rex.input - 1 |
15603
639b8318472c
patch 8.1.0809: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
15555
diff
changeset
|
1260 - (*mb_head_off)(rex.line, rex.input - 1), rex.reg_buf); |
7 | 1261 return -1; |
1262 } | |
5735 | 1263 |
4730
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1264 /* |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1265 * Return TRUE if the current rex.input position matches the Visual area. |
4730
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1266 */ |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1267 static int |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1268 reg_match_visual(void) |
4730
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1269 { |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1270 pos_T top, bot; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1271 linenr_T lnum; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1272 colnr_T col; |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1273 win_T *wp = rex.reg_win == NULL ? curwin : rex.reg_win; |
4730
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1274 int mode; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1275 colnr_T start, end; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1276 colnr_T start2, end2; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1277 colnr_T cols; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1278 |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1279 // Check if the buffer is the current buffer. |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1280 if (rex.reg_buf != curbuf || VIsual.lnum == 0) |
4730
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1281 return FALSE; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1282 |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1283 if (VIsual_active) |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1284 { |
11121
778c10516955
patch 8.0.0448: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
1285 if (LT_POS(VIsual, wp->w_cursor)) |
4730
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1286 { |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1287 top = VIsual; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1288 bot = wp->w_cursor; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1289 } |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1290 else |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1291 { |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1292 top = wp->w_cursor; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1293 bot = VIsual; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1294 } |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1295 mode = VIsual_mode; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1296 } |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1297 else |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1298 { |
11121
778c10516955
patch 8.0.0448: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
1299 if (LT_POS(curbuf->b_visual.vi_start, curbuf->b_visual.vi_end)) |
4730
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1300 { |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1301 top = curbuf->b_visual.vi_start; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1302 bot = curbuf->b_visual.vi_end; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1303 } |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1304 else |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1305 { |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1306 top = curbuf->b_visual.vi_end; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1307 bot = curbuf->b_visual.vi_start; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1308 } |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1309 mode = curbuf->b_visual.vi_mode; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1310 } |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1311 lnum = rex.lnum + rex.reg_firstlnum; |
4730
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1312 if (lnum < top.lnum || lnum > bot.lnum) |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1313 return FALSE; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1314 |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1315 if (mode == 'v') |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1316 { |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1317 col = (colnr_T)(rex.input - rex.line); |
4730
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1318 if ((lnum == top.lnum && col < top.col) |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1319 || (lnum == bot.lnum && col >= bot.col + (*p_sel != 'e'))) |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1320 return FALSE; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1321 } |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1322 else if (mode == Ctrl_V) |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1323 { |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1324 getvvcol(wp, &top, &start, NULL, &end); |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1325 getvvcol(wp, &bot, &start2, NULL, &end2); |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1326 if (start2 < start) |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1327 start = start2; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1328 if (end2 > end) |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1329 end = end2; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1330 if (top.col == MAXCOL || bot.col == MAXCOL) |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1331 end = MAXCOL; |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1332 cols = win_linetabsize(wp, rex.line, (colnr_T)(rex.input - rex.line)); |
4730
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1333 if (cols < start || cols > end - (*p_sel == 'e')) |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1334 return FALSE; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1335 } |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1336 return TRUE; |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1337 } |
749e2b2755d5
updated for version 7.3.1112
Bram Moolenaar <bram@vim.org>
parents:
4720
diff
changeset
|
1338 |
7 | 1339 /* |
1340 * Check the regexp program for its magic number. | |
1341 * Return TRUE if it's wrong. | |
1342 */ | |
1343 static int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1344 prog_magic_wrong(void) |
7 | 1345 { |
4444 | 1346 regprog_T *prog; |
1347 | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1348 prog = REG_MULTI ? rex.reg_mmatch->regprog : rex.reg_match->regprog; |
4444 | 1349 if (prog->engine == &nfa_regengine) |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1350 // For NFA matcher we don't check the magic |
4444 | 1351 return FALSE; |
1352 | |
1353 if (UCHARAT(((bt_regprog_T *)prog)->program) != REGMAGIC) | |
7 | 1354 { |
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15339
diff
changeset
|
1355 emsg(_(e_re_corr)); |
7 | 1356 return TRUE; |
1357 } | |
1358 return FALSE; | |
1359 } | |
1360 | |
1361 /* | |
1362 * Cleanup the subexpressions, if this wasn't done yet. | |
1363 * This construction is used to clear the subexpressions only when they are | |
1364 * used (to increase speed). | |
1365 */ | |
1366 static void | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1367 cleanup_subexpr(void) |
7 | 1368 { |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1369 if (rex.need_clear_subexpr) |
7 | 1370 { |
1371 if (REG_MULTI) | |
1372 { | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1373 // Use 0xff to set lnum to -1 |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1374 vim_memset(rex.reg_startpos, 0xff, sizeof(lpos_T) * NSUBEXP); |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1375 vim_memset(rex.reg_endpos, 0xff, sizeof(lpos_T) * NSUBEXP); |
7 | 1376 } |
1377 else | |
1378 { | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1379 vim_memset(rex.reg_startp, 0, sizeof(char_u *) * NSUBEXP); |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1380 vim_memset(rex.reg_endp, 0, sizeof(char_u *) * NSUBEXP); |
7 | 1381 } |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1382 rex.need_clear_subexpr = FALSE; |
7 | 1383 } |
1384 } | |
1385 | |
1386 #ifdef FEAT_SYN_HL | |
1387 static void | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1388 cleanup_zsubexpr(void) |
7 | 1389 { |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1390 if (rex.need_clear_zsubexpr) |
7 | 1391 { |
1392 if (REG_MULTI) | |
1393 { | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1394 // Use 0xff to set lnum to -1 |
7 | 1395 vim_memset(reg_startzpos, 0xff, sizeof(lpos_T) * NSUBEXP); |
1396 vim_memset(reg_endzpos, 0xff, sizeof(lpos_T) * NSUBEXP); | |
1397 } | |
1398 else | |
1399 { | |
1400 vim_memset(reg_startzp, 0, sizeof(char_u *) * NSUBEXP); | |
1401 vim_memset(reg_endzp, 0, sizeof(char_u *) * NSUBEXP); | |
1402 } | |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1403 rex.need_clear_zsubexpr = FALSE; |
7 | 1404 } |
1405 } | |
1406 #endif | |
1407 | |
1408 /* | |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1409 * Advance rex.lnum, rex.line and rex.input to the next line. |
7 | 1410 */ |
1411 static void | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1412 reg_nextline(void) |
7 | 1413 { |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1414 rex.line = reg_getline(++rex.lnum); |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1415 rex.input = rex.line; |
7 | 1416 fast_breakcheck(); |
1417 } | |
1418 | |
1419 /* | |
4891
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1420 * Check whether a backreference matches. |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1421 * Returns RA_FAIL, RA_NOMATCH or RA_MATCH. |
5504 | 1422 * If "bytelen" is not NULL, it is set to the byte length of the match in the |
1423 * last line. | |
4891
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1424 */ |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1425 static int |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1426 match_with_backref( |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1427 linenr_T start_lnum, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1428 colnr_T start_col, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1429 linenr_T end_lnum, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1430 colnr_T end_col, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1431 int *bytelen) |
4891
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1432 { |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1433 linenr_T clnum = start_lnum; |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1434 colnr_T ccol = start_col; |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1435 int len; |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1436 char_u *p; |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1437 |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1438 if (bytelen != NULL) |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1439 *bytelen = 0; |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1440 for (;;) |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1441 { |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1442 // Since getting one line may invalidate the other, need to make copy. |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1443 // Slow! |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1444 if (rex.line != reg_tofree) |
4891
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1445 { |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1446 len = (int)STRLEN(rex.line); |
4891
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1447 if (reg_tofree == NULL || len >= (int)reg_tofreelen) |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1448 { |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1449 len += 50; // get some extra |
4891
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1450 vim_free(reg_tofree); |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1451 reg_tofree = alloc(len); |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1452 if (reg_tofree == NULL) |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1453 return RA_FAIL; // out of memory! |
4891
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1454 reg_tofreelen = len; |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1455 } |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1456 STRCPY(reg_tofree, rex.line); |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1457 rex.input = reg_tofree + (rex.input - rex.line); |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1458 rex.line = reg_tofree; |
4891
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1459 } |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1460 |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1461 // Get the line to compare with. |
4891
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1462 p = reg_getline(clnum); |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1463 if (clnum == end_lnum) |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1464 len = end_col - ccol; |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1465 else |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1466 len = (int)STRLEN(p + ccol); |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1467 |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1468 if (cstrncmp(p + ccol, rex.input, &len) != 0) |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1469 return RA_NOMATCH; // doesn't match |
4891
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1470 if (bytelen != NULL) |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1471 *bytelen += len; |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1472 if (clnum == end_lnum) |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1473 break; // match and at end! |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
1474 if (rex.lnum >= rex.reg_maxline) |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1475 return RA_NOMATCH; // text too short |
4891
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1476 |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1477 // Advance to next line. |
4891
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1478 reg_nextline(); |
5504 | 1479 if (bytelen != NULL) |
1480 *bytelen = 0; | |
4891
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1481 ++clnum; |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1482 ccol = 0; |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1483 if (got_int) |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1484 return RA_FAIL; |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1485 } |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1486 |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1487 // found a match! Note that rex.line may now point to a copy of the line, |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1488 // that should not matter. |
4891
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1489 return RA_MATCH; |
4c42efb4c098
updated for version 7.3.1191
Bram Moolenaar <bram@vim.org>
parents:
4805
diff
changeset
|
1490 } |
7 | 1491 |
6203 | 1492 /* |
1493 * Used in a place where no * or \+ can follow. | |
1494 */ | |
1495 static int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1496 re_mult_next(char *what) |
6203 | 1497 { |
1498 if (re_multi_type(peekchr()) == MULTI_MULT) | |
15480
bd12ace1bab2
patch 8.1.0748: using sprintf() instead of semsg()
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
1499 { |
bd12ace1bab2
patch 8.1.0748: using sprintf() instead of semsg()
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
1500 semsg(_("E888: (NFA regexp) cannot repeat %s"), what); |
bd12ace1bab2
patch 8.1.0748: using sprintf() instead of semsg()
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
1501 rc_did_emsg = TRUE; |
bd12ace1bab2
patch 8.1.0748: using sprintf() instead of semsg()
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
1502 return FAIL; |
bd12ace1bab2
patch 8.1.0748: using sprintf() instead of semsg()
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
1503 } |
6203 | 1504 return OK; |
1505 } | |
1506 | |
7 | 1507 typedef struct |
1508 { | |
1509 int a, b, c; | |
1510 } decomp_T; | |
1511 | |
1512 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1513 // 0xfb20 - 0xfb4f |
297 | 1514 static decomp_T decomp_table[0xfb4f-0xfb20+1] = |
7 | 1515 { |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1516 {0x5e2,0,0}, // 0xfb20 alt ayin |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1517 {0x5d0,0,0}, // 0xfb21 alt alef |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1518 {0x5d3,0,0}, // 0xfb22 alt dalet |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1519 {0x5d4,0,0}, // 0xfb23 alt he |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1520 {0x5db,0,0}, // 0xfb24 alt kaf |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1521 {0x5dc,0,0}, // 0xfb25 alt lamed |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1522 {0x5dd,0,0}, // 0xfb26 alt mem-sofit |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1523 {0x5e8,0,0}, // 0xfb27 alt resh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1524 {0x5ea,0,0}, // 0xfb28 alt tav |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1525 {'+', 0, 0}, // 0xfb29 alt plus |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1526 {0x5e9, 0x5c1, 0}, // 0xfb2a shin+shin-dot |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1527 {0x5e9, 0x5c2, 0}, // 0xfb2b shin+sin-dot |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1528 {0x5e9, 0x5c1, 0x5bc}, // 0xfb2c shin+shin-dot+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1529 {0x5e9, 0x5c2, 0x5bc}, // 0xfb2d shin+sin-dot+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1530 {0x5d0, 0x5b7, 0}, // 0xfb2e alef+patah |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1531 {0x5d0, 0x5b8, 0}, // 0xfb2f alef+qamats |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1532 {0x5d0, 0x5b4, 0}, // 0xfb30 alef+hiriq |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1533 {0x5d1, 0x5bc, 0}, // 0xfb31 bet+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1534 {0x5d2, 0x5bc, 0}, // 0xfb32 gimel+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1535 {0x5d3, 0x5bc, 0}, // 0xfb33 dalet+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1536 {0x5d4, 0x5bc, 0}, // 0xfb34 he+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1537 {0x5d5, 0x5bc, 0}, // 0xfb35 vav+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1538 {0x5d6, 0x5bc, 0}, // 0xfb36 zayin+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1539 {0xfb37, 0, 0}, // 0xfb37 -- UNUSED |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1540 {0x5d8, 0x5bc, 0}, // 0xfb38 tet+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1541 {0x5d9, 0x5bc, 0}, // 0xfb39 yud+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1542 {0x5da, 0x5bc, 0}, // 0xfb3a kaf sofit+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1543 {0x5db, 0x5bc, 0}, // 0xfb3b kaf+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1544 {0x5dc, 0x5bc, 0}, // 0xfb3c lamed+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1545 {0xfb3d, 0, 0}, // 0xfb3d -- UNUSED |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1546 {0x5de, 0x5bc, 0}, // 0xfb3e mem+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1547 {0xfb3f, 0, 0}, // 0xfb3f -- UNUSED |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1548 {0x5e0, 0x5bc, 0}, // 0xfb40 nun+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1549 {0x5e1, 0x5bc, 0}, // 0xfb41 samech+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1550 {0xfb42, 0, 0}, // 0xfb42 -- UNUSED |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1551 {0x5e3, 0x5bc, 0}, // 0xfb43 pe sofit+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1552 {0x5e4, 0x5bc,0}, // 0xfb44 pe+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1553 {0xfb45, 0, 0}, // 0xfb45 -- UNUSED |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1554 {0x5e6, 0x5bc, 0}, // 0xfb46 tsadi+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1555 {0x5e7, 0x5bc, 0}, // 0xfb47 qof+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1556 {0x5e8, 0x5bc, 0}, // 0xfb48 resh+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1557 {0x5e9, 0x5bc, 0}, // 0xfb49 shin+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1558 {0x5ea, 0x5bc, 0}, // 0xfb4a tav+dagesh |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1559 {0x5d5, 0x5b9, 0}, // 0xfb4b vav+holam |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1560 {0x5d1, 0x5bf, 0}, // 0xfb4c bet+rafe |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1561 {0x5db, 0x5bf, 0}, // 0xfb4d kaf+rafe |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1562 {0x5e4, 0x5bf, 0}, // 0xfb4e pe+rafe |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1563 {0x5d0, 0x5dc, 0} // 0xfb4f alef-lamed |
7 | 1564 }; |
1565 | |
1566 static void | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1567 mb_decompose(int c, int *c1, int *c2, int *c3) |
7 | 1568 { |
1569 decomp_T d; | |
1570 | |
4505
d037b9cbdaaa
updated for version 7.3.1000
Bram Moolenaar <bram@vim.org>
parents:
4466
diff
changeset
|
1571 if (c >= 0xfb20 && c <= 0xfb4f) |
7 | 1572 { |
1573 d = decomp_table[c - 0xfb20]; | |
1574 *c1 = d.a; | |
1575 *c2 = d.b; | |
1576 *c3 = d.c; | |
1577 } | |
1578 else | |
1579 { | |
1580 *c1 = c; | |
1581 *c2 = *c3 = 0; | |
1582 } | |
1583 } | |
1584 | |
1585 /* | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1586 * Compare two strings, ignore case if rex.reg_ic set. |
7 | 1587 * Return 0 if strings match, non-zero otherwise. |
1588 * Correct the length "*n" when composing characters are ignored. | |
1589 */ | |
1590 static int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1591 cstrncmp(char_u *s1, char_u *s2, int *n) |
7 | 1592 { |
1593 int result; | |
1594 | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1595 if (!rex.reg_ic) |
7 | 1596 result = STRNCMP(s1, s2, *n); |
1597 else | |
1598 result = MB_STRNICMP(s1, s2, *n); | |
1599 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1600 // if it failed and it's utf8 and we want to combineignore: |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1601 if (result != 0 && enc_utf8 && rex.reg_icombine) |
7 | 1602 { |
1603 char_u *str1, *str2; | |
1604 int c1, c2, c11, c12; | |
1605 int junk; | |
1606 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1607 // we have to handle the strcmp ourselves, since it is necessary to |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1608 // deal with the composing characters by ignoring them: |
7 | 1609 str1 = s1; |
1610 str2 = s2; | |
1611 c1 = c2 = 0; | |
507 | 1612 while ((int)(str1 - s1) < *n) |
7 | 1613 { |
1614 c1 = mb_ptr2char_adv(&str1); | |
1615 c2 = mb_ptr2char_adv(&str2); | |
1616 | |
18019
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
1617 // Decompose the character if necessary, into 'base' characters. |
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
1618 // Currently hard-coded for Hebrew, Arabic to be done... |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1619 if (c1 != c2 && (!rex.reg_ic || utf_fold(c1) != utf_fold(c2))) |
7 | 1620 { |
18019
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
1621 // decomposition necessary? |
7 | 1622 mb_decompose(c1, &c11, &junk, &junk); |
1623 mb_decompose(c2, &c12, &junk, &junk); | |
1624 c1 = c11; | |
1625 c2 = c12; | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1626 if (c11 != c12 |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1627 && (!rex.reg_ic || utf_fold(c11) != utf_fold(c12))) |
7 | 1628 break; |
1629 } | |
1630 } | |
1631 result = c2 - c1; | |
1632 if (result == 0) | |
1633 *n = (int)(str2 - s2); | |
1634 } | |
1635 | |
1636 return result; | |
1637 } | |
1638 | |
1639 /* | |
1640 * cstrchr: This function is used a lot for simple searches, keep it fast! | |
1641 */ | |
1642 static char_u * | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1643 cstrchr(char_u *s, int c) |
7 | 1644 { |
1645 char_u *p; | |
1646 int cc; | |
1647 | |
15603
639b8318472c
patch 8.1.0809: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
15555
diff
changeset
|
1648 if (!rex.reg_ic || (!enc_utf8 && mb_char2len(c) > 1)) |
7 | 1649 return vim_strchr(s, c); |
1650 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1651 // tolower() and toupper() can be slow, comparing twice should be a lot |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1652 // faster (esp. when using MS Visual C++!). |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1653 // For UTF-8 need to use folded case. |
7 | 1654 if (enc_utf8 && c > 0x80) |
1655 cc = utf_fold(c); | |
1656 else | |
1347 | 1657 if (MB_ISUPPER(c)) |
1658 cc = MB_TOLOWER(c); | |
1659 else if (MB_ISLOWER(c)) | |
1660 cc = MB_TOUPPER(c); | |
7 | 1661 else |
1662 return vim_strchr(s, c); | |
1663 | |
1664 if (has_mbyte) | |
1665 { | |
474 | 1666 for (p = s; *p != NUL; p += (*mb_ptr2len)(p)) |
7 | 1667 { |
1668 if (enc_utf8 && c > 0x80) | |
1669 { | |
1670 if (utf_fold(utf_ptr2char(p)) == cc) | |
1671 return p; | |
1672 } | |
1673 else if (*p == c || *p == cc) | |
1674 return p; | |
1675 } | |
1676 } | |
1677 else | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1678 // Faster version for when there are no multi-byte characters. |
7 | 1679 for (p = s; *p != NUL; ++p) |
1680 if (*p == c || *p == cc) | |
1681 return p; | |
1682 | |
1683 return NULL; | |
1684 } | |
1685 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1686 //////////////////////////////////////////////////////////////// |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1687 // regsub stuff // |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1688 //////////////////////////////////////////////////////////////// |
7 | 1689 |
1690 /* | |
1691 * We should define ftpr as a pointer to a function returning a pointer to | |
1692 * a function returning a pointer to a function ... | |
1693 * This is impossible, so we declare a pointer to a function returning a | |
1694 * pointer to a function returning void. This should work for all compilers. | |
1695 */ | |
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7009
diff
changeset
|
1696 typedef void (*(*fptr_T)(int *, int))(); |
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
7009
diff
changeset
|
1697 |
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
1698 static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest, int copy, int magic, int backslash); |
7 | 1699 |
772 | 1700 static fptr_T |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1701 do_upper(int *d, int c) |
7 | 1702 { |
772 | 1703 *d = MB_TOUPPER(c); |
1704 | |
1705 return (fptr_T)NULL; | |
7 | 1706 } |
1707 | |
772 | 1708 static fptr_T |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1709 do_Upper(int *d, int c) |
7 | 1710 { |
772 | 1711 *d = MB_TOUPPER(c); |
1712 | |
1713 return (fptr_T)do_Upper; | |
1714 } | |
1715 | |
1716 static fptr_T | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1717 do_lower(int *d, int c) |
772 | 1718 { |
1719 *d = MB_TOLOWER(c); | |
1720 | |
1721 return (fptr_T)NULL; | |
1722 } | |
1723 | |
1724 static fptr_T | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1725 do_Lower(int *d, int c) |
772 | 1726 { |
1727 *d = MB_TOLOWER(c); | |
1728 | |
1729 return (fptr_T)do_Lower; | |
7 | 1730 } |
1731 | |
1732 /* | |
1733 * regtilde(): Replace tildes in the pattern by the old pattern. | |
1734 * | |
1735 * Short explanation of the tilde: It stands for the previous replacement | |
1736 * pattern. If that previous pattern also contains a ~ we should go back a | |
1737 * step further... But we insert the previous pattern into the current one | |
1738 * and remember that. | |
772 | 1739 * This still does not handle the case where "magic" changes. So require the |
1740 * user to keep his hands off of "magic". | |
7 | 1741 * |
1742 * The tildes are parsed once before the first call to vim_regsub(). | |
1743 */ | |
1744 char_u * | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1745 regtilde(char_u *source, int magic) |
7 | 1746 { |
1747 char_u *newsub = source; | |
1748 char_u *tmpsub; | |
1749 char_u *p; | |
1750 int len; | |
1751 int prevlen; | |
1752 | |
1753 for (p = newsub; *p; ++p) | |
1754 { | |
1755 if ((*p == '~' && magic) || (*p == '\\' && *(p + 1) == '~' && !magic)) | |
1756 { | |
1757 if (reg_prev_sub != NULL) | |
1758 { | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1759 // length = len(newsub) - 1 + len(prev_sub) + 1 |
7 | 1760 prevlen = (int)STRLEN(reg_prev_sub); |
16764
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
16634
diff
changeset
|
1761 tmpsub = alloc(STRLEN(newsub) + prevlen); |
7 | 1762 if (tmpsub != NULL) |
1763 { | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1764 // copy prefix |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1765 len = (int)(p - newsub); // not including ~ |
7 | 1766 mch_memmove(tmpsub, newsub, (size_t)len); |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1767 // interpret tilde |
7 | 1768 mch_memmove(tmpsub + len, reg_prev_sub, (size_t)prevlen); |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1769 // copy postfix |
7 | 1770 if (!magic) |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1771 ++p; // back off backslash |
7 | 1772 STRCPY(tmpsub + len + prevlen, p + 1); |
1773 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1774 if (newsub != source) // already allocated newsub |
7 | 1775 vim_free(newsub); |
1776 newsub = tmpsub; | |
1777 p = newsub + len + prevlen; | |
1778 } | |
1779 } | |
1780 else if (magic) | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1781 STRMOVE(p, p + 1); // remove '~' |
7 | 1782 else |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1783 STRMOVE(p, p + 2); // remove '\~' |
7 | 1784 --p; |
1785 } | |
1786 else | |
1787 { | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1788 if (*p == '\\' && p[1]) // skip escaped characters |
7 | 1789 ++p; |
1790 if (has_mbyte) | |
474 | 1791 p += (*mb_ptr2len)(p) - 1; |
7 | 1792 } |
1793 } | |
1794 | |
1795 vim_free(reg_prev_sub); | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1796 if (newsub != source) // newsub was allocated, just keep it |
7 | 1797 reg_prev_sub = newsub; |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1798 else // no ~ found, need to save newsub |
7 | 1799 reg_prev_sub = vim_strsave(newsub); |
1800 return newsub; | |
1801 } | |
1802 | |
1803 #ifdef FEAT_EVAL | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1804 static int can_f_submatch = FALSE; // TRUE when submatch() can be used |
7 | 1805 |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1806 // These pointers are used for reg_submatch(). Needed for when the |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1807 // substitution string is an expression that contains a call to substitute() |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1808 // and submatch(). |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1809 typedef struct { |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1810 regmatch_T *sm_match; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1811 regmmatch_T *sm_mmatch; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1812 linenr_T sm_firstlnum; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1813 linenr_T sm_maxline; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1814 int sm_line_lbr; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1815 } regsubmatch_T; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1816 |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1817 static regsubmatch_T rsm; // can only be used when can_f_submatch is TRUE |
7 | 1818 #endif |
1819 | |
17966
46f95606b9ec
patch 8.1.1979: code for handling file names is spread out
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
1820 #ifdef FEAT_EVAL |
9626
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1821 |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1822 /* |
18572
23fef64352a1
patch 8.1.2280: crash when passing partial to substitute()
Bram Moolenaar <Bram@vim.org>
parents:
18019
diff
changeset
|
1823 * Put the submatches in "argv[argskip]" which is a list passed into |
23fef64352a1
patch 8.1.2280: crash when passing partial to substitute()
Bram Moolenaar <Bram@vim.org>
parents:
18019
diff
changeset
|
1824 * call_func() by vim_regsub_both(). |
9626
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1825 */ |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1826 static int |
18572
23fef64352a1
patch 8.1.2280: crash when passing partial to substitute()
Bram Moolenaar <Bram@vim.org>
parents:
18019
diff
changeset
|
1827 fill_submatch_list(int argc UNUSED, typval_T *argv, int argskip, int argcount) |
9626
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1828 { |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1829 listitem_T *li; |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1830 int i; |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1831 char_u *s; |
18572
23fef64352a1
patch 8.1.2280: crash when passing partial to substitute()
Bram Moolenaar <Bram@vim.org>
parents:
18019
diff
changeset
|
1832 typval_T *listarg = argv + argskip; |
9626
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1833 |
18572
23fef64352a1
patch 8.1.2280: crash when passing partial to substitute()
Bram Moolenaar <Bram@vim.org>
parents:
18019
diff
changeset
|
1834 if (argcount == argskip) |
23fef64352a1
patch 8.1.2280: crash when passing partial to substitute()
Bram Moolenaar <Bram@vim.org>
parents:
18019
diff
changeset
|
1835 // called function doesn't take a submatches argument |
23fef64352a1
patch 8.1.2280: crash when passing partial to substitute()
Bram Moolenaar <Bram@vim.org>
parents:
18019
diff
changeset
|
1836 return argskip; |
9626
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1837 |
18572
23fef64352a1
patch 8.1.2280: crash when passing partial to substitute()
Bram Moolenaar <Bram@vim.org>
parents:
18019
diff
changeset
|
1838 // Relies on sl_list to be the first item in staticList10_T. |
23fef64352a1
patch 8.1.2280: crash when passing partial to substitute()
Bram Moolenaar <Bram@vim.org>
parents:
18019
diff
changeset
|
1839 init_static_list((staticList10_T *)(listarg->vval.v_list)); |
9626
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1840 |
18572
23fef64352a1
patch 8.1.2280: crash when passing partial to substitute()
Bram Moolenaar <Bram@vim.org>
parents:
18019
diff
changeset
|
1841 // There are always 10 list items in staticList10_T. |
23fef64352a1
patch 8.1.2280: crash when passing partial to substitute()
Bram Moolenaar <Bram@vim.org>
parents:
18019
diff
changeset
|
1842 li = listarg->vval.v_list->lv_first; |
9626
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1843 for (i = 0; i < 10; ++i) |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1844 { |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1845 s = rsm.sm_match->startp[i]; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1846 if (s == NULL || rsm.sm_match->endp[i] == NULL) |
9626
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1847 s = NULL; |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1848 else |
20830
9064044fd4f6
patch 8.2.0967: unnecessary type casts for vim_strnsave()
Bram Moolenaar <Bram@vim.org>
parents:
20113
diff
changeset
|
1849 s = vim_strnsave(s, rsm.sm_match->endp[i] - s); |
9626
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1850 li->li_tv.v_type = VAR_STRING; |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1851 li->li_tv.vval.v_string = s; |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1852 li = li->li_next; |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1853 } |
18572
23fef64352a1
patch 8.1.2280: crash when passing partial to substitute()
Bram Moolenaar <Bram@vim.org>
parents:
18019
diff
changeset
|
1854 return argskip + 1; |
9626
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1855 } |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1856 |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1857 static void |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1858 clear_submatch_list(staticList10_T *sl) |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1859 { |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1860 int i; |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1861 |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1862 for (i = 0; i < 10; ++i) |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1863 vim_free(sl->sl_items[i].li_tv.vval.v_string); |
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1864 } |
17966
46f95606b9ec
patch 8.1.1979: code for handling file names is spread out
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
1865 #endif |
9626
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
1866 |
7 | 1867 /* |
1868 * vim_regsub() - perform substitutions after a vim_regexec() or | |
1869 * vim_regexec_multi() match. | |
1870 * | |
1871 * If "copy" is TRUE really copy into "dest". | |
1872 * If "copy" is FALSE nothing is copied, this is just to find out the length | |
1873 * of the result. | |
1874 * | |
1875 * If "backslash" is TRUE, a backslash will be removed later, need to double | |
1876 * them to keep them, and insert a backslash before a CR to avoid it being | |
1877 * replaced with a line break later. | |
1878 * | |
1879 * Note: The matched text must not change between the call of | |
1880 * vim_regexec()/vim_regexec_multi() and vim_regsub()! It would make the back | |
1881 * references invalid! | |
1882 * | |
1883 * Returns the size of the replacement, including terminating NUL. | |
1884 */ | |
1885 int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1886 vim_regsub( |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1887 regmatch_T *rmp, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1888 char_u *source, |
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
1889 typval_T *expr, |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1890 char_u *dest, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1891 int copy, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1892 int magic, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1893 int backslash) |
7 | 1894 { |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1895 int result; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1896 regexec_T rex_save; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1897 int rex_in_use_save = rex_in_use; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1898 |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1899 if (rex_in_use) |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1900 // Being called recursively, save the state. |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1901 rex_save = rex; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1902 rex_in_use = TRUE; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1903 |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1904 rex.reg_match = rmp; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1905 rex.reg_mmatch = NULL; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1906 rex.reg_maxline = 0; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1907 rex.reg_buf = curbuf; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1908 rex.reg_line_lbr = TRUE; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1909 result = vim_regsub_both(source, expr, dest, copy, magic, backslash); |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1910 |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1911 rex_in_use = rex_in_use_save; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1912 if (rex_in_use) |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1913 rex = rex_save; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1914 |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1915 return result; |
7 | 1916 } |
1917 | |
1918 int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1919 vim_regsub_multi( |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1920 regmmatch_T *rmp, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1921 linenr_T lnum, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1922 char_u *source, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1923 char_u *dest, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1924 int copy, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1925 int magic, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1926 int backslash) |
7 | 1927 { |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1928 int result; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1929 regexec_T rex_save; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1930 int rex_in_use_save = rex_in_use; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1931 |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1932 if (rex_in_use) |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1933 // Being called recursively, save the state. |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1934 rex_save = rex; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1935 rex_in_use = TRUE; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1936 |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1937 rex.reg_match = NULL; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1938 rex.reg_mmatch = rmp; |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1939 rex.reg_buf = curbuf; // always works on the current buffer! |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1940 rex.reg_firstlnum = lnum; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1941 rex.reg_maxline = curbuf->b_ml.ml_line_count - lnum; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1942 rex.reg_line_lbr = FALSE; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1943 result = vim_regsub_both(source, NULL, dest, copy, magic, backslash); |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1944 |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1945 rex_in_use = rex_in_use_save; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1946 if (rex_in_use) |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1947 rex = rex_save; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1948 |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1949 return result; |
7 | 1950 } |
1951 | |
1952 static int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1953 vim_regsub_both( |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1954 char_u *source, |
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
1955 typval_T *expr, |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1956 char_u *dest, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1957 int copy, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1958 int magic, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
1959 int backslash) |
7 | 1960 { |
1961 char_u *src; | |
1962 char_u *dst; | |
1963 char_u *s; | |
1964 int c; | |
772 | 1965 int cc; |
7 | 1966 int no = -1; |
4244 | 1967 fptr_T func_all = (fptr_T)NULL; |
1968 fptr_T func_one = (fptr_T)NULL; | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1969 linenr_T clnum = 0; // init for GCC |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1970 int len = 0; // init for GCC |
7 | 1971 #ifdef FEAT_EVAL |
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
1972 static char_u *eval_result = NULL; |
7 | 1973 #endif |
1974 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1975 // Be paranoid... |
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
1976 if ((source == NULL && expr == NULL) || dest == NULL) |
7 | 1977 { |
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15339
diff
changeset
|
1978 emsg(_(e_null)); |
7 | 1979 return 0; |
1980 } | |
1981 if (prog_magic_wrong()) | |
1982 return 0; | |
1983 src = source; | |
1984 dst = dest; | |
1985 | |
1986 /* | |
1987 * When the substitute part starts with "\=" evaluate it as an expression. | |
1988 */ | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
1989 if (expr != NULL || (source[0] == '\\' && source[1] == '=')) |
7 | 1990 { |
1991 #ifdef FEAT_EVAL | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1992 // To make sure that the length doesn't change between checking the |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1993 // length and copying the string, and to speed up things, the |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1994 // resulting string is saved from the call with "copy" == FALSE to the |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
1995 // call with "copy" == TRUE. |
7 | 1996 if (copy) |
1997 { | |
1998 if (eval_result != NULL) | |
1999 { | |
2000 STRCPY(dest, eval_result); | |
2001 dst += STRLEN(eval_result); | |
13244
ac42c4b11dbc
patch 8.0.1496: clearing a pointer takes two lines
Christian Brabandt <cb@256bit.org>
parents:
12752
diff
changeset
|
2002 VIM_CLEAR(eval_result); |
7 | 2003 } |
2004 } | |
2005 else | |
2006 { | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2007 int prev_can_f_submatch = can_f_submatch; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2008 regsubmatch_T rsm_save; |
7 | 2009 |
2010 vim_free(eval_result); | |
2011 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2012 // The expression may contain substitute(), which calls us |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2013 // recursively. Make sure submatch() gets the text from the first |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2014 // level. |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2015 if (can_f_submatch) |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2016 rsm_save = rsm; |
7 | 2017 can_f_submatch = TRUE; |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2018 rsm.sm_match = rex.reg_match; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2019 rsm.sm_mmatch = rex.reg_mmatch; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2020 rsm.sm_firstlnum = rex.reg_firstlnum; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2021 rsm.sm_maxline = rex.reg_maxline; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2022 rsm.sm_line_lbr = rex.reg_line_lbr; |
7 | 2023 |
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
2024 if (expr != NULL) |
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
2025 { |
9626
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
2026 typval_T argv[2]; |
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
2027 char_u buf[NUMBUFLEN]; |
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
2028 typval_T rettv; |
9626
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
2029 staticList10_T matchList; |
17606
ff097edaae89
patch 8.1.1800: function call functions have too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
17444
diff
changeset
|
2030 funcexe_T funcexe; |
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
2031 |
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
2032 rettv.v_type = VAR_STRING; |
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
2033 rettv.vval.v_string = NULL; |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2034 argv[0].v_type = VAR_LIST; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2035 argv[0].vval.v_list = &matchList.sl_list; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2036 matchList.sl_list.lv_len = 0; |
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19892
diff
changeset
|
2037 CLEAR_FIELD(funcexe); |
17606
ff097edaae89
patch 8.1.1800: function call functions have too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
17444
diff
changeset
|
2038 funcexe.argv_func = fill_submatch_list; |
ff097edaae89
patch 8.1.1800: function call functions have too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
17444
diff
changeset
|
2039 funcexe.evaluate = TRUE; |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2040 if (expr->v_type == VAR_FUNC) |
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
2041 { |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2042 s = expr->vval.v_string; |
17606
ff097edaae89
patch 8.1.1800: function call functions have too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
17444
diff
changeset
|
2043 call_func(s, -1, &rettv, 1, argv, &funcexe); |
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
2044 } |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2045 else if (expr->v_type == VAR_PARTIAL) |
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
2046 { |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2047 partial_T *partial = expr->vval.v_partial; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2048 |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2049 s = partial_name(partial); |
17606
ff097edaae89
patch 8.1.1800: function call functions have too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
17444
diff
changeset
|
2050 funcexe.partial = partial; |
ff097edaae89
patch 8.1.1800: function call functions have too many arguments
Bram Moolenaar <Bram@vim.org>
parents:
17444
diff
changeset
|
2051 call_func(s, -1, &rettv, 1, argv, &funcexe); |
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
2052 } |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2053 if (matchList.sl_list.lv_len > 0) |
18576
e9675870c480
patch 8.1.2282: crash when passing many arguments through a partial
Bram Moolenaar <Bram@vim.org>
parents:
18572
diff
changeset
|
2054 // fill_submatch_list() was called |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2055 clear_submatch_list(&matchList); |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2056 |
18576
e9675870c480
patch 8.1.2282: crash when passing many arguments through a partial
Bram Moolenaar <Bram@vim.org>
parents:
18572
diff
changeset
|
2057 if (rettv.v_type == VAR_UNKNOWN) |
e9675870c480
patch 8.1.2282: crash when passing many arguments through a partial
Bram Moolenaar <Bram@vim.org>
parents:
18572
diff
changeset
|
2058 // something failed, no need to report another error |
e9675870c480
patch 8.1.2282: crash when passing many arguments through a partial
Bram Moolenaar <Bram@vim.org>
parents:
18572
diff
changeset
|
2059 eval_result = NULL; |
e9675870c480
patch 8.1.2282: crash when passing many arguments through a partial
Bram Moolenaar <Bram@vim.org>
parents:
18572
diff
changeset
|
2060 else |
e9675870c480
patch 8.1.2282: crash when passing many arguments through a partial
Bram Moolenaar <Bram@vim.org>
parents:
18572
diff
changeset
|
2061 { |
e9675870c480
patch 8.1.2282: crash when passing many arguments through a partial
Bram Moolenaar <Bram@vim.org>
parents:
18572
diff
changeset
|
2062 eval_result = tv_get_string_buf_chk(&rettv, buf); |
e9675870c480
patch 8.1.2282: crash when passing many arguments through a partial
Bram Moolenaar <Bram@vim.org>
parents:
18572
diff
changeset
|
2063 if (eval_result != NULL) |
e9675870c480
patch 8.1.2282: crash when passing many arguments through a partial
Bram Moolenaar <Bram@vim.org>
parents:
18572
diff
changeset
|
2064 eval_result = vim_strsave(eval_result); |
e9675870c480
patch 8.1.2282: crash when passing many arguments through a partial
Bram Moolenaar <Bram@vim.org>
parents:
18572
diff
changeset
|
2065 } |
9626
172131507c85
commit https://github.com/vim/vim/commit/df48fb456fb6bf63d94cad9b302ff01d8ee8d311
Christian Brabandt <cb@256bit.org>
parents:
9589
diff
changeset
|
2066 clear_tv(&rettv); |
9589
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
2067 } |
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
2068 else |
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
2069 eval_result = eval_to_string(source + 2, NULL, TRUE); |
bf204ab1ce7d
commit https://github.com/vim/vim/commit/72ab729c3dcdea0fba44d8e676602c847e841bcd
Christian Brabandt <cb@256bit.org>
parents:
9015
diff
changeset
|
2070 |
7 | 2071 if (eval_result != NULL) |
2072 { | |
2125
b8744d1982d1
updated for version 7.2.407
Bram Moolenaar <bram@zimbu.org>
parents:
2012
diff
changeset
|
2073 int had_backslash = FALSE; |
b8744d1982d1
updated for version 7.2.407
Bram Moolenaar <bram@zimbu.org>
parents:
2012
diff
changeset
|
2074 |
11127
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11121
diff
changeset
|
2075 for (s = eval_result; *s != NUL; MB_PTR_ADV(s)) |
7 | 2076 { |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2077 // Change NL to CR, so that it becomes a line break, |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2078 // unless called from vim_regexec_nl(). |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2079 // Skip over a backslashed character. |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2080 if (*s == NL && !rsm.sm_line_lbr) |
7 | 2081 *s = CAR; |
2082 else if (*s == '\\' && s[1] != NUL) | |
2125
b8744d1982d1
updated for version 7.2.407
Bram Moolenaar <bram@zimbu.org>
parents:
2012
diff
changeset
|
2083 { |
7 | 2084 ++s; |
2173 | 2085 /* Change NL to CR here too, so that this works: |
2086 * :s/abc\\\ndef/\="aaa\\\nbbb"/ on text: | |
2087 * abc\ | |
2088 * def | |
2904 | 2089 * Not when called from vim_regexec_nl(). |
2173 | 2090 */ |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2091 if (*s == NL && !rsm.sm_line_lbr) |
2173 | 2092 *s = CAR; |
2125
b8744d1982d1
updated for version 7.2.407
Bram Moolenaar <bram@zimbu.org>
parents:
2012
diff
changeset
|
2093 had_backslash = TRUE; |
b8744d1982d1
updated for version 7.2.407
Bram Moolenaar <bram@zimbu.org>
parents:
2012
diff
changeset
|
2094 } |
b8744d1982d1
updated for version 7.2.407
Bram Moolenaar <bram@zimbu.org>
parents:
2012
diff
changeset
|
2095 } |
b8744d1982d1
updated for version 7.2.407
Bram Moolenaar <bram@zimbu.org>
parents:
2012
diff
changeset
|
2096 if (had_backslash && backslash) |
b8744d1982d1
updated for version 7.2.407
Bram Moolenaar <bram@zimbu.org>
parents:
2012
diff
changeset
|
2097 { |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2098 // Backslashes will be consumed, need to double them. |
2125
b8744d1982d1
updated for version 7.2.407
Bram Moolenaar <bram@zimbu.org>
parents:
2012
diff
changeset
|
2099 s = vim_strsave_escaped(eval_result, (char_u *)"\\"); |
b8744d1982d1
updated for version 7.2.407
Bram Moolenaar <bram@zimbu.org>
parents:
2012
diff
changeset
|
2100 if (s != NULL) |
b8744d1982d1
updated for version 7.2.407
Bram Moolenaar <bram@zimbu.org>
parents:
2012
diff
changeset
|
2101 { |
b8744d1982d1
updated for version 7.2.407
Bram Moolenaar <bram@zimbu.org>
parents:
2012
diff
changeset
|
2102 vim_free(eval_result); |
b8744d1982d1
updated for version 7.2.407
Bram Moolenaar <bram@zimbu.org>
parents:
2012
diff
changeset
|
2103 eval_result = s; |
b8744d1982d1
updated for version 7.2.407
Bram Moolenaar <bram@zimbu.org>
parents:
2012
diff
changeset
|
2104 } |
7 | 2105 } |
2106 | |
2107 dst += STRLEN(eval_result); | |
2108 } | |
2109 | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2110 can_f_submatch = prev_can_f_submatch; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2111 if (can_f_submatch) |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2112 rsm = rsm_save; |
7 | 2113 } |
2114 #endif | |
2115 } | |
2116 else | |
2117 while ((c = *src++) != NUL) | |
2118 { | |
2119 if (c == '&' && magic) | |
2120 no = 0; | |
2121 else if (c == '\\' && *src != NUL) | |
2122 { | |
2123 if (*src == '&' && !magic) | |
2124 { | |
2125 ++src; | |
2126 no = 0; | |
2127 } | |
2128 else if ('0' <= *src && *src <= '9') | |
2129 { | |
2130 no = *src++ - '0'; | |
2131 } | |
2132 else if (vim_strchr((char_u *)"uUlLeE", *src)) | |
2133 { | |
2134 switch (*src++) | |
2135 { | |
4244 | 2136 case 'u': func_one = (fptr_T)do_upper; |
7 | 2137 continue; |
4244 | 2138 case 'U': func_all = (fptr_T)do_Upper; |
7 | 2139 continue; |
4244 | 2140 case 'l': func_one = (fptr_T)do_lower; |
7 | 2141 continue; |
4244 | 2142 case 'L': func_all = (fptr_T)do_Lower; |
7 | 2143 continue; |
2144 case 'e': | |
4244 | 2145 case 'E': func_one = func_all = (fptr_T)NULL; |
7 | 2146 continue; |
2147 } | |
2148 } | |
2149 } | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2150 if (no < 0) // Ordinary character. |
7 | 2151 { |
798 | 2152 if (c == K_SPECIAL && src[0] != NUL && src[1] != NUL) |
2153 { | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2154 // Copy a special key as-is. |
798 | 2155 if (copy) |
2156 { | |
2157 *dst++ = c; | |
2158 *dst++ = *src++; | |
2159 *dst++ = *src++; | |
2160 } | |
2161 else | |
2162 { | |
2163 dst += 3; | |
2164 src += 2; | |
2165 } | |
2166 continue; | |
2167 } | |
2168 | |
7 | 2169 if (c == '\\' && *src != NUL) |
2170 { | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2171 // Check for abbreviations -- webb |
7 | 2172 switch (*src) |
2173 { | |
2174 case 'r': c = CAR; ++src; break; | |
2175 case 'n': c = NL; ++src; break; | |
2176 case 't': c = TAB; ++src; break; | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2177 // Oh no! \e already has meaning in subst pat :-( |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2178 // case 'e': c = ESC; ++src; break; |
7 | 2179 case 'b': c = Ctrl_H; ++src; break; |
2180 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2181 // If "backslash" is TRUE the backslash will be removed |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2182 // later. Used to insert a literal CR. |
7 | 2183 default: if (backslash) |
2184 { | |
2185 if (copy) | |
2186 *dst = '\\'; | |
2187 ++dst; | |
2188 } | |
2189 c = *src++; | |
2190 } | |
2191 } | |
798 | 2192 else if (has_mbyte) |
2193 c = mb_ptr2char(src - 1); | |
7 | 2194 |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2195 // Write to buffer, if copy is set. |
4244 | 2196 if (func_one != (fptr_T)NULL) |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2197 // Turbo C complains without the typecast |
4244 | 2198 func_one = (fptr_T)(func_one(&cc, c)); |
2199 else if (func_all != (fptr_T)NULL) | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2200 // Turbo C complains without the typecast |
4244 | 2201 func_all = (fptr_T)(func_all(&cc, c)); |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2202 else // just copy |
772 | 2203 cc = c; |
2204 | |
2205 if (has_mbyte) | |
7 | 2206 { |
2307
81527f127fb1
Fix: Composing characters in :s substitute text were dropped.
Bram Moolenaar <bram@vim.org>
parents:
2247
diff
changeset
|
2207 int totlen = mb_ptr2len(src - 1); |
81527f127fb1
Fix: Composing characters in :s substitute text were dropped.
Bram Moolenaar <bram@vim.org>
parents:
2247
diff
changeset
|
2208 |
7 | 2209 if (copy) |
772 | 2210 mb_char2bytes(cc, dst); |
2211 dst += mb_char2len(cc) - 1; | |
2307
81527f127fb1
Fix: Composing characters in :s substitute text were dropped.
Bram Moolenaar <bram@vim.org>
parents:
2247
diff
changeset
|
2212 if (enc_utf8) |
81527f127fb1
Fix: Composing characters in :s substitute text were dropped.
Bram Moolenaar <bram@vim.org>
parents:
2247
diff
changeset
|
2213 { |
81527f127fb1
Fix: Composing characters in :s substitute text were dropped.
Bram Moolenaar <bram@vim.org>
parents:
2247
diff
changeset
|
2214 int clen = utf_ptr2len(src - 1); |
81527f127fb1
Fix: Composing characters in :s substitute text were dropped.
Bram Moolenaar <bram@vim.org>
parents:
2247
diff
changeset
|
2215 |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2216 // If the character length is shorter than "totlen", there |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2217 // are composing characters; copy them as-is. |
2307
81527f127fb1
Fix: Composing characters in :s substitute text were dropped.
Bram Moolenaar <bram@vim.org>
parents:
2247
diff
changeset
|
2218 if (clen < totlen) |
81527f127fb1
Fix: Composing characters in :s substitute text were dropped.
Bram Moolenaar <bram@vim.org>
parents:
2247
diff
changeset
|
2219 { |
81527f127fb1
Fix: Composing characters in :s substitute text were dropped.
Bram Moolenaar <bram@vim.org>
parents:
2247
diff
changeset
|
2220 if (copy) |
81527f127fb1
Fix: Composing characters in :s substitute text were dropped.
Bram Moolenaar <bram@vim.org>
parents:
2247
diff
changeset
|
2221 mch_memmove(dst + 1, src - 1 + clen, |
81527f127fb1
Fix: Composing characters in :s substitute text were dropped.
Bram Moolenaar <bram@vim.org>
parents:
2247
diff
changeset
|
2222 (size_t)(totlen - clen)); |
81527f127fb1
Fix: Composing characters in :s substitute text were dropped.
Bram Moolenaar <bram@vim.org>
parents:
2247
diff
changeset
|
2223 dst += totlen - clen; |
81527f127fb1
Fix: Composing characters in :s substitute text were dropped.
Bram Moolenaar <bram@vim.org>
parents:
2247
diff
changeset
|
2224 } |
81527f127fb1
Fix: Composing characters in :s substitute text were dropped.
Bram Moolenaar <bram@vim.org>
parents:
2247
diff
changeset
|
2225 } |
81527f127fb1
Fix: Composing characters in :s substitute text were dropped.
Bram Moolenaar <bram@vim.org>
parents:
2247
diff
changeset
|
2226 src += totlen - 1; |
7 | 2227 } |
15603
639b8318472c
patch 8.1.0809: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
15555
diff
changeset
|
2228 else if (copy) |
772 | 2229 *dst = cc; |
7 | 2230 dst++; |
2231 } | |
2232 else | |
2233 { | |
2234 if (REG_MULTI) | |
2235 { | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2236 clnum = rex.reg_mmatch->startpos[no].lnum; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2237 if (clnum < 0 || rex.reg_mmatch->endpos[no].lnum < 0) |
7 | 2238 s = NULL; |
2239 else | |
2240 { | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2241 s = reg_getline(clnum) + rex.reg_mmatch->startpos[no].col; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2242 if (rex.reg_mmatch->endpos[no].lnum == clnum) |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2243 len = rex.reg_mmatch->endpos[no].col |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2244 - rex.reg_mmatch->startpos[no].col; |
7 | 2245 else |
2246 len = (int)STRLEN(s); | |
2247 } | |
2248 } | |
2249 else | |
2250 { | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2251 s = rex.reg_match->startp[no]; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2252 if (rex.reg_match->endp[no] == NULL) |
7 | 2253 s = NULL; |
2254 else | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2255 len = (int)(rex.reg_match->endp[no] - s); |
7 | 2256 } |
2257 if (s != NULL) | |
2258 { | |
2259 for (;;) | |
2260 { | |
2261 if (len == 0) | |
2262 { | |
2263 if (REG_MULTI) | |
2264 { | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2265 if (rex.reg_mmatch->endpos[no].lnum == clnum) |
7 | 2266 break; |
2267 if (copy) | |
2268 *dst = CAR; | |
2269 ++dst; | |
2270 s = reg_getline(++clnum); | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2271 if (rex.reg_mmatch->endpos[no].lnum == clnum) |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2272 len = rex.reg_mmatch->endpos[no].col; |
7 | 2273 else |
2274 len = (int)STRLEN(s); | |
2275 } | |
2276 else | |
2277 break; | |
2278 } | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2279 else if (*s == NUL) // we hit NUL. |
7 | 2280 { |
2281 if (copy) | |
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15339
diff
changeset
|
2282 emsg(_(e_re_damg)); |
7 | 2283 goto exit; |
2284 } | |
2285 else | |
2286 { | |
2287 if (backslash && (*s == CAR || *s == '\\')) | |
2288 { | |
2289 /* | |
2290 * Insert a backslash in front of a CR, otherwise | |
2291 * it will be replaced by a line break. | |
2292 * Number of backslashes will be halved later, | |
2293 * double them here. | |
2294 */ | |
2295 if (copy) | |
2296 { | |
2297 dst[0] = '\\'; | |
2298 dst[1] = *s; | |
2299 } | |
2300 dst += 2; | |
2301 } | |
2302 else | |
2303 { | |
772 | 2304 if (has_mbyte) |
2305 c = mb_ptr2char(s); | |
2306 else | |
2307 c = *s; | |
2308 | |
4244 | 2309 if (func_one != (fptr_T)NULL) |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2310 // Turbo C complains without the typecast |
4244 | 2311 func_one = (fptr_T)(func_one(&cc, c)); |
2312 else if (func_all != (fptr_T)NULL) | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2313 // Turbo C complains without the typecast |
4244 | 2314 func_all = (fptr_T)(func_all(&cc, c)); |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2315 else // just copy |
772 | 2316 cc = c; |
2317 | |
2318 if (has_mbyte) | |
7 | 2319 { |
1332 | 2320 int l; |
2321 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2322 // Copy composing characters separately, one |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2323 // at a time. |
1332 | 2324 if (enc_utf8) |
2325 l = utf_ptr2len(s) - 1; | |
2326 else | |
2327 l = mb_ptr2len(s) - 1; | |
772 | 2328 |
2329 s += l; | |
2330 len -= l; | |
2331 if (copy) | |
2332 mb_char2bytes(cc, dst); | |
2333 dst += mb_char2len(cc) - 1; | |
7 | 2334 } |
15603
639b8318472c
patch 8.1.0809: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
15555
diff
changeset
|
2335 else if (copy) |
772 | 2336 *dst = cc; |
2337 dst++; | |
7 | 2338 } |
772 | 2339 |
7 | 2340 ++s; |
2341 --len; | |
2342 } | |
2343 } | |
2344 } | |
2345 no = -1; | |
2346 } | |
2347 } | |
2348 if (copy) | |
2349 *dst = NUL; | |
2350 | |
2351 exit: | |
2352 return (int)((dst - dest) + 1); | |
2353 } | |
2354 | |
2355 #ifdef FEAT_EVAL | |
2356 /* | |
2011 | 2357 * Call reg_getline() with the line numbers from the submatch. If a |
2358 * substitute() was used the reg_maxline and other values have been | |
2359 * overwritten. | |
2360 */ | |
2361 static char_u * | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
2362 reg_getline_submatch(linenr_T lnum) |
2011 | 2363 { |
2364 char_u *s; | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2365 linenr_T save_first = rex.reg_firstlnum; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2366 linenr_T save_max = rex.reg_maxline; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2367 |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2368 rex.reg_firstlnum = rsm.sm_firstlnum; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2369 rex.reg_maxline = rsm.sm_maxline; |
2011 | 2370 |
2371 s = reg_getline(lnum); | |
2372 | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2373 rex.reg_firstlnum = save_first; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2374 rex.reg_maxline = save_max; |
2011 | 2375 return s; |
2376 } | |
2377 | |
2378 /* | |
1209 | 2379 * Used for the submatch() function: get the string from the n'th submatch in |
7 | 2380 * allocated memory. |
2381 * Returns NULL when not in a ":s" command and for a non-existing submatch. | |
2382 */ | |
2383 char_u * | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
2384 reg_submatch(int no) |
7 | 2385 { |
2386 char_u *retval = NULL; | |
2387 char_u *s; | |
2388 int len; | |
2389 int round; | |
2390 linenr_T lnum; | |
2391 | |
840 | 2392 if (!can_f_submatch || no < 0) |
7 | 2393 return NULL; |
2394 | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2395 if (rsm.sm_match == NULL) |
7 | 2396 { |
2397 /* | |
2398 * First round: compute the length and allocate memory. | |
2399 * Second round: copy the text. | |
2400 */ | |
2401 for (round = 1; round <= 2; ++round) | |
2402 { | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2403 lnum = rsm.sm_mmatch->startpos[no].lnum; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2404 if (lnum < 0 || rsm.sm_mmatch->endpos[no].lnum < 0) |
7 | 2405 return NULL; |
2406 | |
16040
13ab270dd68d
patch 8.1.1025: checking NULL pointer after addition
Bram Moolenaar <Bram@vim.org>
parents:
15967
diff
changeset
|
2407 s = reg_getline_submatch(lnum); |
13ab270dd68d
patch 8.1.1025: checking NULL pointer after addition
Bram Moolenaar <Bram@vim.org>
parents:
15967
diff
changeset
|
2408 if (s == NULL) // anti-crash check, cannot happen? |
7 | 2409 break; |
16040
13ab270dd68d
patch 8.1.1025: checking NULL pointer after addition
Bram Moolenaar <Bram@vim.org>
parents:
15967
diff
changeset
|
2410 s += rsm.sm_mmatch->startpos[no].col; |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2411 if (rsm.sm_mmatch->endpos[no].lnum == lnum) |
7 | 2412 { |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2413 // Within one line: take form start to end col. |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2414 len = rsm.sm_mmatch->endpos[no].col |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2415 - rsm.sm_mmatch->startpos[no].col; |
7 | 2416 if (round == 2) |
418 | 2417 vim_strncpy(retval, s, len); |
7 | 2418 ++len; |
2419 } | |
2420 else | |
2421 { | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2422 // Multiple lines: take start line from start col, middle |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2423 // lines completely and end line up to end col. |
7 | 2424 len = (int)STRLEN(s); |
2425 if (round == 2) | |
2426 { | |
2427 STRCPY(retval, s); | |
2428 retval[len] = '\n'; | |
2429 } | |
2430 ++len; | |
2431 ++lnum; | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2432 while (lnum < rsm.sm_mmatch->endpos[no].lnum) |
7 | 2433 { |
2011 | 2434 s = reg_getline_submatch(lnum++); |
7 | 2435 if (round == 2) |
2436 STRCPY(retval + len, s); | |
2437 len += (int)STRLEN(s); | |
2438 if (round == 2) | |
2439 retval[len] = '\n'; | |
2440 ++len; | |
2441 } | |
2442 if (round == 2) | |
2011 | 2443 STRNCPY(retval + len, reg_getline_submatch(lnum), |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2444 rsm.sm_mmatch->endpos[no].col); |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2445 len += rsm.sm_mmatch->endpos[no].col; |
7 | 2446 if (round == 2) |
2447 retval[len] = NUL; | |
2448 ++len; | |
2449 } | |
2450 | |
840 | 2451 if (retval == NULL) |
7 | 2452 { |
16768
695d9ef00b03
patch 8.1.1386: unessesary type casts for lalloc()
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
2453 retval = alloc(len); |
840 | 2454 if (retval == NULL) |
7 | 2455 return NULL; |
2456 } | |
2457 } | |
2458 } | |
2459 else | |
2460 { | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2461 s = rsm.sm_match->startp[no]; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2462 if (s == NULL || rsm.sm_match->endp[no] == NULL) |
7 | 2463 retval = NULL; |
2464 else | |
20830
9064044fd4f6
patch 8.2.0967: unnecessary type casts for vim_strnsave()
Bram Moolenaar <Bram@vim.org>
parents:
20113
diff
changeset
|
2465 retval = vim_strnsave(s, rsm.sm_match->endp[no] - s); |
7 | 2466 } |
2467 | |
2468 return retval; | |
2469 } | |
5794 | 2470 |
2471 /* | |
2472 * Used for the submatch() function with the optional non-zero argument: get | |
2473 * the list of strings from the n'th submatch in allocated memory with NULs | |
2474 * represented in NLs. | |
2475 * Returns a list of allocated strings. Returns NULL when not in a ":s" | |
2476 * command, for a non-existing submatch and for any error. | |
2477 */ | |
2478 list_T * | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
2479 reg_submatch_list(int no) |
5794 | 2480 { |
2481 char_u *s; | |
2482 linenr_T slnum; | |
2483 linenr_T elnum; | |
2484 colnr_T scol; | |
2485 colnr_T ecol; | |
2486 int i; | |
2487 list_T *list; | |
2488 int error = FALSE; | |
2489 | |
2490 if (!can_f_submatch || no < 0) | |
2491 return NULL; | |
2492 | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2493 if (rsm.sm_match == NULL) |
5794 | 2494 { |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2495 slnum = rsm.sm_mmatch->startpos[no].lnum; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2496 elnum = rsm.sm_mmatch->endpos[no].lnum; |
5794 | 2497 if (slnum < 0 || elnum < 0) |
2498 return NULL; | |
2499 | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2500 scol = rsm.sm_mmatch->startpos[no].col; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2501 ecol = rsm.sm_mmatch->endpos[no].col; |
5794 | 2502 |
2503 list = list_alloc(); | |
2504 if (list == NULL) | |
2505 return NULL; | |
2506 | |
2507 s = reg_getline_submatch(slnum) + scol; | |
2508 if (slnum == elnum) | |
2509 { | |
2510 if (list_append_string(list, s, ecol - scol) == FAIL) | |
2511 error = TRUE; | |
2512 } | |
2513 else | |
2514 { | |
2515 if (list_append_string(list, s, -1) == FAIL) | |
2516 error = TRUE; | |
2517 for (i = 1; i < elnum - slnum; i++) | |
2518 { | |
2519 s = reg_getline_submatch(slnum + i); | |
2520 if (list_append_string(list, s, -1) == FAIL) | |
2521 error = TRUE; | |
2522 } | |
2523 s = reg_getline_submatch(elnum); | |
2524 if (list_append_string(list, s, ecol) == FAIL) | |
2525 error = TRUE; | |
2526 } | |
2527 } | |
2528 else | |
2529 { | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2530 s = rsm.sm_match->startp[no]; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2531 if (s == NULL || rsm.sm_match->endp[no] == NULL) |
5794 | 2532 return NULL; |
2533 list = list_alloc(); | |
2534 if (list == NULL) | |
2535 return NULL; | |
2536 if (list_append_string(list, s, | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2537 (int)(rsm.sm_match->endp[no] - s)) == FAIL) |
5794 | 2538 error = TRUE; |
2539 } | |
2540 | |
2541 if (error) | |
2542 { | |
8863
e1b84109506a
commit https://github.com/vim/vim/commit/107e1eef1df3b786ad3ad49fbdb9e058649303b5
Christian Brabandt <cb@256bit.org>
parents:
8825
diff
changeset
|
2543 list_free(list); |
5794 | 2544 return NULL; |
2545 } | |
2546 return list; | |
2547 } | |
7 | 2548 #endif |
4444 | 2549 |
19405
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2550 /* |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2551 * Initialize the values used for matching against multiple lines |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2552 */ |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2553 static void |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2554 init_regexec_multi( |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2555 regmmatch_T *rmp, |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2556 win_T *win, // window in which to search or NULL |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2557 buf_T *buf, // buffer in which to search |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2558 linenr_T lnum) // nr of line to start looking for match |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2559 { |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2560 rex.reg_match = NULL; |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2561 rex.reg_mmatch = rmp; |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2562 rex.reg_buf = buf; |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2563 rex.reg_win = win; |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2564 rex.reg_firstlnum = lnum; |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2565 rex.reg_maxline = rex.reg_buf->b_ml.ml_line_count - lnum; |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2566 rex.reg_line_lbr = FALSE; |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2567 rex.reg_ic = rmp->rmm_ic; |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2568 rex.reg_icombine = FALSE; |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2569 rex.reg_maxcol = rmp->rmm_maxcol; |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2570 } |
08f4dc2ba716
patch 8.2.0260: several lines of code are duplicated
Bram Moolenaar <Bram@vim.org>
parents:
19384
diff
changeset
|
2571 |
18019
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
2572 #include "regexp_bt.c" |
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
2573 |
4444 | 2574 static regengine_T bt_regengine = |
2575 { | |
2576 bt_regcomp, | |
4805
66803af09906
updated for version 7.3.1149
Bram Moolenaar <bram@vim.org>
parents:
4770
diff
changeset
|
2577 bt_regfree, |
4444 | 2578 bt_regexec_nl, |
6328 | 2579 bt_regexec_multi, |
2580 (char_u *)"" | |
4444 | 2581 }; |
2582 | |
2583 #include "regexp_nfa.c" | |
2584 | |
2585 static regengine_T nfa_regengine = | |
2586 { | |
2587 nfa_regcomp, | |
4805
66803af09906
updated for version 7.3.1149
Bram Moolenaar <bram@vim.org>
parents:
4770
diff
changeset
|
2588 nfa_regfree, |
4444 | 2589 nfa_regexec_nl, |
6328 | 2590 nfa_regexec_multi, |
2591 (char_u *)"" | |
4444 | 2592 }; |
2593 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2594 // Which regexp engine to use? Needed for vim_regcomp(). |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2595 // Must match with 'regexpengine'. |
4444 | 2596 static int regexp_engine = 0; |
6328 | 2597 |
4444 | 2598 #ifdef DEBUG |
2599 static char_u regname[][30] = { | |
2600 "AUTOMATIC Regexp Engine", | |
4579
7a2be4a39423
updated for version 7.3.1037
Bram Moolenaar <bram@vim.org>
parents:
4505
diff
changeset
|
2601 "BACKTRACKING Regexp Engine", |
4444 | 2602 "NFA Regexp Engine" |
2603 }; | |
2604 #endif | |
2605 | |
2606 /* | |
2607 * Compile a regular expression into internal code. | |
4805
66803af09906
updated for version 7.3.1149
Bram Moolenaar <bram@vim.org>
parents:
4770
diff
changeset
|
2608 * Returns the program in allocated memory. |
66803af09906
updated for version 7.3.1149
Bram Moolenaar <bram@vim.org>
parents:
4770
diff
changeset
|
2609 * Use vim_regfree() to free the memory. |
66803af09906
updated for version 7.3.1149
Bram Moolenaar <bram@vim.org>
parents:
4770
diff
changeset
|
2610 * Returns NULL for an error. |
4444 | 2611 */ |
2612 regprog_T * | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
2613 vim_regcomp(char_u *expr_arg, int re_flags) |
4444 | 2614 { |
2615 regprog_T *prog = NULL; | |
2616 char_u *expr = expr_arg; | |
18949
5c405689da3e
patch 8.2.0035: saving and restoring called_emsg is clumsy
Bram Moolenaar <Bram@vim.org>
parents:
18812
diff
changeset
|
2617 int called_emsg_before; |
4444 | 2618 |
2619 regexp_engine = p_re; | |
2620 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2621 // Check for prefix "\%#=", that sets the regexp engine |
4444 | 2622 if (STRNCMP(expr, "\\%#=", 4) == 0) |
2623 { | |
2624 int newengine = expr[4] - '0'; | |
2625 | |
2626 if (newengine == AUTOMATIC_ENGINE | |
2627 || newengine == BACKTRACKING_ENGINE | |
2628 || newengine == NFA_ENGINE) | |
2629 { | |
2630 regexp_engine = expr[4] - '0'; | |
2631 expr += 5; | |
2632 #ifdef DEBUG | |
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15339
diff
changeset
|
2633 smsg("New regexp mode selected (%d): %s", |
5897 | 2634 regexp_engine, regname[newengine]); |
4444 | 2635 #endif |
2636 } | |
2637 else | |
2638 { | |
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15339
diff
changeset
|
2639 emsg(_("E864: \\%#= can only be followed by 0, 1, or 2. The automatic engine will be used ")); |
4444 | 2640 regexp_engine = AUTOMATIC_ENGINE; |
2641 } | |
2642 } | |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2643 #ifdef DEBUG |
4444 | 2644 bt_regengine.expr = expr; |
2645 nfa_regengine.expr = expr; | |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2646 #endif |
15856
e44b7caaf373
patch 8.1.0935: old regexp engine may use invalid buffer
Bram Moolenaar <Bram@vim.org>
parents:
15854
diff
changeset
|
2647 // reg_iswordc() uses rex.reg_buf |
e44b7caaf373
patch 8.1.0935: old regexp engine may use invalid buffer
Bram Moolenaar <Bram@vim.org>
parents:
15854
diff
changeset
|
2648 rex.reg_buf = curbuf; |
4444 | 2649 |
2650 /* | |
2651 * First try the NFA engine, unless backtracking was requested. | |
2652 */ | |
18949
5c405689da3e
patch 8.2.0035: saving and restoring called_emsg is clumsy
Bram Moolenaar <Bram@vim.org>
parents:
18812
diff
changeset
|
2653 called_emsg_before = called_emsg; |
4444 | 2654 if (regexp_engine != BACKTRACKING_ENGINE) |
13244
ac42c4b11dbc
patch 8.0.1496: clearing a pointer takes two lines
Christian Brabandt <cb@256bit.org>
parents:
12752
diff
changeset
|
2655 prog = nfa_regengine.regcomp(expr, |
6533 | 2656 re_flags + (regexp_engine == AUTOMATIC_ENGINE ? RE_AUTO : 0)); |
4444 | 2657 else |
2658 prog = bt_regengine.regcomp(expr, re_flags); | |
2659 | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2660 // Check for error compiling regexp with initial engine. |
6328 | 2661 if (prog == NULL) |
4444 | 2662 { |
4460 | 2663 #ifdef BT_REGEXP_DEBUG_LOG |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2664 if (regexp_engine != BACKTRACKING_ENGINE) // debugging log for NFA |
4444 | 2665 { |
2666 FILE *f; | |
4460 | 2667 f = fopen(BT_REGEXP_DEBUG_LOG_NAME, "a"); |
4444 | 2668 if (f) |
2669 { | |
4762
47906f888725
updated for version 7.3.1128
Bram Moolenaar <bram@vim.org>
parents:
4760
diff
changeset
|
2670 fprintf(f, "Syntax error in \"%s\"\n", expr); |
4444 | 2671 fclose(f); |
2672 } | |
2673 else | |
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15339
diff
changeset
|
2674 semsg("(NFA) Could not open \"%s\" to write !!!", |
13244
ac42c4b11dbc
patch 8.0.1496: clearing a pointer takes two lines
Christian Brabandt <cb@256bit.org>
parents:
12752
diff
changeset
|
2675 BT_REGEXP_DEBUG_LOG_NAME); |
4444 | 2676 } |
2677 #endif | |
2678 /* | |
6328 | 2679 * If the NFA engine failed, try the backtracking engine. |
6533 | 2680 * The NFA engine also fails for patterns that it can't handle well |
2681 * but are still valid patterns, thus a retry should work. | |
15935
ff00d207cc5e
patch 8.1.0973: pattern with syntax error gives threee error messages
Bram Moolenaar <Bram@vim.org>
parents:
15860
diff
changeset
|
2682 * But don't try if an error message was given. |
6533 | 2683 */ |
18949
5c405689da3e
patch 8.2.0035: saving and restoring called_emsg is clumsy
Bram Moolenaar <Bram@vim.org>
parents:
18812
diff
changeset
|
2684 if (regexp_engine == AUTOMATIC_ENGINE |
5c405689da3e
patch 8.2.0035: saving and restoring called_emsg is clumsy
Bram Moolenaar <Bram@vim.org>
parents:
18812
diff
changeset
|
2685 && called_emsg == called_emsg_before) |
6328 | 2686 { |
6533 | 2687 regexp_engine = BACKTRACKING_ENGINE; |
4762
47906f888725
updated for version 7.3.1128
Bram Moolenaar <bram@vim.org>
parents:
4760
diff
changeset
|
2688 prog = bt_regengine.regcomp(expr, re_flags); |
6328 | 2689 } |
4762
47906f888725
updated for version 7.3.1128
Bram Moolenaar <bram@vim.org>
parents:
4760
diff
changeset
|
2690 } |
4444 | 2691 |
6328 | 2692 if (prog != NULL) |
2693 { | |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2694 // Store the info needed to call regcomp() again when the engine turns |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2695 // out to be very slow when executing it. |
6328 | 2696 prog->re_engine = regexp_engine; |
2697 prog->re_flags = re_flags; | |
2698 } | |
2699 | |
4444 | 2700 return prog; |
2701 } | |
2702 | |
2703 /* | |
4805
66803af09906
updated for version 7.3.1149
Bram Moolenaar <bram@vim.org>
parents:
4770
diff
changeset
|
2704 * Free a compiled regexp program, returned by vim_regcomp(). |
66803af09906
updated for version 7.3.1149
Bram Moolenaar <bram@vim.org>
parents:
4770
diff
changeset
|
2705 */ |
66803af09906
updated for version 7.3.1149
Bram Moolenaar <bram@vim.org>
parents:
4770
diff
changeset
|
2706 void |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
2707 vim_regfree(regprog_T *prog) |
4805
66803af09906
updated for version 7.3.1149
Bram Moolenaar <bram@vim.org>
parents:
4770
diff
changeset
|
2708 { |
66803af09906
updated for version 7.3.1149
Bram Moolenaar <bram@vim.org>
parents:
4770
diff
changeset
|
2709 if (prog != NULL) |
66803af09906
updated for version 7.3.1149
Bram Moolenaar <bram@vim.org>
parents:
4770
diff
changeset
|
2710 prog->engine->regfree(prog); |
66803af09906
updated for version 7.3.1149
Bram Moolenaar <bram@vim.org>
parents:
4770
diff
changeset
|
2711 } |
66803af09906
updated for version 7.3.1149
Bram Moolenaar <bram@vim.org>
parents:
4770
diff
changeset
|
2712 |
18019
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
2713 #if defined(EXITFREE) || defined(PROTO) |
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
2714 void |
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
2715 free_regexp_stuff(void) |
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
2716 { |
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
2717 ga_clear(®stack); |
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
2718 ga_clear(&backpos); |
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
2719 vim_free(reg_tofree); |
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
2720 vim_free(reg_prev_sub); |
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
2721 } |
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
2722 #endif |
68fd5296bf73
patch 8.1.2005: the regexp.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17966
diff
changeset
|
2723 |
6328 | 2724 #ifdef FEAT_EVAL |
2725 static void | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
2726 report_re_switch(char_u *pat) |
6328 | 2727 { |
2728 if (p_verbose > 0) | |
2729 { | |
2730 verbose_enter(); | |
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15480
diff
changeset
|
2731 msg_puts(_("Switching to backtracking RE engine for pattern: ")); |
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15480
diff
changeset
|
2732 msg_puts((char *)pat); |
6328 | 2733 verbose_leave(); |
2734 } | |
2735 } | |
2736 #endif | |
2737 | |
15555
d89c5b339c2a
patch 8.1.0785: depending on the configuration some functions are unused
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
2738 #if (defined(FEAT_X11) && (defined(FEAT_TITLE) || defined(FEAT_XCLIPBOARD))) \ |
d89c5b339c2a
patch 8.1.0785: depending on the configuration some functions are unused
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
2739 || defined(PROTO) |
4805
66803af09906
updated for version 7.3.1149
Bram Moolenaar <bram@vim.org>
parents:
4770
diff
changeset
|
2740 /* |
15306
7fff2d18e191
patch 8.1.0661: clipboard regexp might be used recursively
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
2741 * Return whether "prog" is currently being executed. |
7fff2d18e191
patch 8.1.0661: clipboard regexp might be used recursively
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
2742 */ |
7fff2d18e191
patch 8.1.0661: clipboard regexp might be used recursively
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
2743 int |
7fff2d18e191
patch 8.1.0661: clipboard regexp might be used recursively
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
2744 regprog_in_use(regprog_T *prog) |
7fff2d18e191
patch 8.1.0661: clipboard regexp might be used recursively
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
2745 { |
7fff2d18e191
patch 8.1.0661: clipboard regexp might be used recursively
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
2746 return prog->re_in_use; |
7fff2d18e191
patch 8.1.0661: clipboard regexp might be used recursively
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
2747 } |
15555
d89c5b339c2a
patch 8.1.0785: depending on the configuration some functions are unused
Bram Moolenaar <Bram@vim.org>
parents:
15543
diff
changeset
|
2748 #endif |
15306
7fff2d18e191
patch 8.1.0661: clipboard regexp might be used recursively
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
2749 |
7fff2d18e191
patch 8.1.0661: clipboard regexp might be used recursively
Bram Moolenaar <Bram@vim.org>
parents:
15211
diff
changeset
|
2750 /* |
4444 | 2751 * Match a regexp against a string. |
2752 * "rmp->regprog" is a compiled regexp as returned by vim_regcomp(). | |
6375 | 2753 * Note: "rmp->regprog" may be freed and changed. |
4444 | 2754 * Uses curbuf for line count and 'iskeyword'. |
6328 | 2755 * When "nl" is TRUE consider a "\n" in "line" to be a line break. |
4444 | 2756 * |
2757 * Return TRUE if there is a match, FALSE if not. | |
2758 */ | |
6328 | 2759 static int |
11529
998d2cf59caa
patch 8.0.0647: syntax highlighting can make cause a freeze
Christian Brabandt <cb@256bit.org>
parents:
11527
diff
changeset
|
2760 vim_regexec_string( |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
2761 regmatch_T *rmp, |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2762 char_u *line, // string to match against |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2763 colnr_T col, // column to start looking for match |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
2764 int nl) |
6328 | 2765 { |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2766 int result; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2767 regexec_T rex_save; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2768 int rex_in_use_save = rex_in_use; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2769 |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2770 // Cannot use the same prog recursively, it contains state. |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2771 if (rmp->regprog->re_in_use) |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2772 { |
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15339
diff
changeset
|
2773 emsg(_(e_recursive)); |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2774 return FALSE; |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2775 } |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2776 rmp->regprog->re_in_use = TRUE; |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2777 |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2778 if (rex_in_use) |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2779 // Being called recursively, save the state. |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2780 rex_save = rex; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2781 rex_in_use = TRUE; |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2782 |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2783 rex.reg_startp = NULL; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2784 rex.reg_endp = NULL; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2785 rex.reg_startpos = NULL; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2786 rex.reg_endpos = NULL; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2787 |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2788 result = rmp->regprog->engine->regexec_nl(rmp, line, col, nl); |
14358
72d506d94f3f
patch 8.1.0194: possibly use of NULL pointer
Christian Brabandt <cb@256bit.org>
parents:
14354
diff
changeset
|
2789 rmp->regprog->re_in_use = FALSE; |
6328 | 2790 |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2791 // NFA engine aborted because it's very slow. |
6328 | 2792 if (rmp->regprog->re_engine == AUTOMATIC_ENGINE |
2793 && result == NFA_TOO_EXPENSIVE) | |
2794 { | |
2795 int save_p_re = p_re; | |
2796 int re_flags = rmp->regprog->re_flags; | |
2797 char_u *pat = vim_strsave(((nfa_regprog_T *)rmp->regprog)->pattern); | |
2798 | |
2799 p_re = BACKTRACKING_ENGINE; | |
2800 vim_regfree(rmp->regprog); | |
2801 if (pat != NULL) | |
2802 { | |
2803 #ifdef FEAT_EVAL | |
2804 report_re_switch(pat); | |
2805 #endif | |
2806 rmp->regprog = vim_regcomp(pat, re_flags); | |
2807 if (rmp->regprog != NULL) | |
14358
72d506d94f3f
patch 8.1.0194: possibly use of NULL pointer
Christian Brabandt <cb@256bit.org>
parents:
14354
diff
changeset
|
2808 { |
72d506d94f3f
patch 8.1.0194: possibly use of NULL pointer
Christian Brabandt <cb@256bit.org>
parents:
14354
diff
changeset
|
2809 rmp->regprog->re_in_use = TRUE; |
6328 | 2810 result = rmp->regprog->engine->regexec_nl(rmp, line, col, nl); |
14358
72d506d94f3f
patch 8.1.0194: possibly use of NULL pointer
Christian Brabandt <cb@256bit.org>
parents:
14354
diff
changeset
|
2811 rmp->regprog->re_in_use = FALSE; |
72d506d94f3f
patch 8.1.0194: possibly use of NULL pointer
Christian Brabandt <cb@256bit.org>
parents:
14354
diff
changeset
|
2812 } |
6328 | 2813 vim_free(pat); |
2814 } | |
2815 | |
2816 p_re = save_p_re; | |
2817 } | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2818 |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2819 rex_in_use = rex_in_use_save; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2820 if (rex_in_use) |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2821 rex = rex_save; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2822 |
6390 | 2823 return result > 0; |
6328 | 2824 } |
2825 | |
6375 | 2826 /* |
2827 * Note: "*prog" may be freed and changed. | |
6390 | 2828 * Return TRUE if there is a match, FALSE if not. |
6375 | 2829 */ |
2830 int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
2831 vim_regexec_prog( |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
2832 regprog_T **prog, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
2833 int ignore_case, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
2834 char_u *line, |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
2835 colnr_T col) |
6375 | 2836 { |
11529
998d2cf59caa
patch 8.0.0647: syntax highlighting can make cause a freeze
Christian Brabandt <cb@256bit.org>
parents:
11527
diff
changeset
|
2837 int r; |
998d2cf59caa
patch 8.0.0647: syntax highlighting can make cause a freeze
Christian Brabandt <cb@256bit.org>
parents:
11527
diff
changeset
|
2838 regmatch_T regmatch; |
6375 | 2839 |
2840 regmatch.regprog = *prog; | |
2841 regmatch.rm_ic = ignore_case; | |
11529
998d2cf59caa
patch 8.0.0647: syntax highlighting can make cause a freeze
Christian Brabandt <cb@256bit.org>
parents:
11527
diff
changeset
|
2842 r = vim_regexec_string(®match, line, col, FALSE); |
6375 | 2843 *prog = regmatch.regprog; |
2844 return r; | |
2845 } | |
2846 | |
2847 /* | |
2848 * Note: "rmp->regprog" may be freed and changed. | |
6390 | 2849 * Return TRUE if there is a match, FALSE if not. |
6375 | 2850 */ |
4444 | 2851 int |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
2852 vim_regexec(regmatch_T *rmp, char_u *line, colnr_T col) |
4444 | 2853 { |
11529
998d2cf59caa
patch 8.0.0647: syntax highlighting can make cause a freeze
Christian Brabandt <cb@256bit.org>
parents:
11527
diff
changeset
|
2854 return vim_regexec_string(rmp, line, col, FALSE); |
4444 | 2855 } |
2856 | |
2857 /* | |
2858 * Like vim_regexec(), but consider a "\n" in "line" to be a line break. | |
6375 | 2859 * Note: "rmp->regprog" may be freed and changed. |
6390 | 2860 * Return TRUE if there is a match, FALSE if not. |
4444 | 2861 */ |
2862 int | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
2863 vim_regexec_nl(regmatch_T *rmp, char_u *line, colnr_T col) |
4444 | 2864 { |
11529
998d2cf59caa
patch 8.0.0647: syntax highlighting can make cause a freeze
Christian Brabandt <cb@256bit.org>
parents:
11527
diff
changeset
|
2865 return vim_regexec_string(rmp, line, col, TRUE); |
4444 | 2866 } |
2867 | |
2868 /* | |
2869 * Match a regexp against multiple lines. | |
14161
7cac4646c552
patch 8.1.0098: segfault when pattern with z() is very slow
Christian Brabandt <cb@256bit.org>
parents:
13286
diff
changeset
|
2870 * "rmp->regprog" must be a compiled regexp as returned by vim_regcomp(). |
7cac4646c552
patch 8.1.0098: segfault when pattern with z() is very slow
Christian Brabandt <cb@256bit.org>
parents:
13286
diff
changeset
|
2871 * Note: "rmp->regprog" may be freed and changed, even set to NULL. |
4444 | 2872 * Uses curbuf for line count and 'iskeyword'. |
2873 * | |
2874 * Return zero if there is no match. Return number of lines contained in the | |
2875 * match otherwise. | |
2876 */ | |
2877 long | |
7833
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
2878 vim_regexec_multi( |
c079097365f3
commit https://github.com/vim/vim/commit/055409764ca5f7978d4c399d2c440af0ce971c4f
Christian Brabandt <cb@256bit.org>
parents:
7807
diff
changeset
|
2879 regmmatch_T *rmp, |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2880 win_T *win, // window in which to search or NULL |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2881 buf_T *buf, // buffer in which to search |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2882 linenr_T lnum, // nr of line to start looking for match |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2883 colnr_T col, // column to start looking for match |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2884 proftime_T *tm, // timeout limit or NULL |
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2885 int *timed_out) // flag is set when timeout limit reached |
4444 | 2886 { |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2887 int result; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2888 regexec_T rex_save; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2889 int rex_in_use_save = rex_in_use; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2890 |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2891 // Cannot use the same prog recursively, it contains state. |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2892 if (rmp->regprog->re_in_use) |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2893 { |
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15339
diff
changeset
|
2894 emsg(_(e_recursive)); |
14354
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2895 return FALSE; |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2896 } |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2897 rmp->regprog->re_in_use = TRUE; |
ffd834f893aa
patch 8.1.0192: executing regexp recursively fails with a crash
Christian Brabandt <cb@256bit.org>
parents:
14169
diff
changeset
|
2898 |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2899 if (rex_in_use) |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2900 // Being called recursively, save the state. |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2901 rex_save = rex; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2902 rex_in_use = TRUE; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2903 |
11521
578df034735d
patch 8.0.0643: when a pattern search is slow Vim becomes unusable
Christian Brabandt <cb@256bit.org>
parents:
11482
diff
changeset
|
2904 result = rmp->regprog->engine->regexec_multi( |
578df034735d
patch 8.0.0643: when a pattern search is slow Vim becomes unusable
Christian Brabandt <cb@256bit.org>
parents:
11482
diff
changeset
|
2905 rmp, win, buf, lnum, col, tm, timed_out); |
14358
72d506d94f3f
patch 8.1.0194: possibly use of NULL pointer
Christian Brabandt <cb@256bit.org>
parents:
14354
diff
changeset
|
2906 rmp->regprog->re_in_use = FALSE; |
6328 | 2907 |
18812
d34ec6fe207d
patch 8.1.2394: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18576
diff
changeset
|
2908 // NFA engine aborted because it's very slow. |
6328 | 2909 if (rmp->regprog->re_engine == AUTOMATIC_ENGINE |
2910 && result == NFA_TOO_EXPENSIVE) | |
2911 { | |
2912 int save_p_re = p_re; | |
2913 int re_flags = rmp->regprog->re_flags; | |
2914 char_u *pat = vim_strsave(((nfa_regprog_T *)rmp->regprog)->pattern); | |
2915 | |
2916 p_re = BACKTRACKING_ENGINE; | |
2917 vim_regfree(rmp->regprog); | |
2918 if (pat != NULL) | |
2919 { | |
2920 #ifdef FEAT_EVAL | |
2921 report_re_switch(pat); | |
2922 #endif | |
14169
42a9178374d1
patch 8.1.0102: cannot build without syntax highlighting
Christian Brabandt <cb@256bit.org>
parents:
14161
diff
changeset
|
2923 #ifdef FEAT_SYN_HL |
14161
7cac4646c552
patch 8.1.0098: segfault when pattern with z() is very slow
Christian Brabandt <cb@256bit.org>
parents:
13286
diff
changeset
|
2924 // checking for \z misuse was already done when compiling for NFA, |
7cac4646c552
patch 8.1.0098: segfault when pattern with z() is very slow
Christian Brabandt <cb@256bit.org>
parents:
13286
diff
changeset
|
2925 // allow all here |
7cac4646c552
patch 8.1.0098: segfault when pattern with z() is very slow
Christian Brabandt <cb@256bit.org>
parents:
13286
diff
changeset
|
2926 reg_do_extmatch = REX_ALL; |
14169
42a9178374d1
patch 8.1.0102: cannot build without syntax highlighting
Christian Brabandt <cb@256bit.org>
parents:
14161
diff
changeset
|
2927 #endif |
6328 | 2928 rmp->regprog = vim_regcomp(pat, re_flags); |
14169
42a9178374d1
patch 8.1.0102: cannot build without syntax highlighting
Christian Brabandt <cb@256bit.org>
parents:
14161
diff
changeset
|
2929 #ifdef FEAT_SYN_HL |
14161
7cac4646c552
patch 8.1.0098: segfault when pattern with z() is very slow
Christian Brabandt <cb@256bit.org>
parents:
13286
diff
changeset
|
2930 reg_do_extmatch = 0; |
14169
42a9178374d1
patch 8.1.0102: cannot build without syntax highlighting
Christian Brabandt <cb@256bit.org>
parents:
14161
diff
changeset
|
2931 #endif |
14161
7cac4646c552
patch 8.1.0098: segfault when pattern with z() is very slow
Christian Brabandt <cb@256bit.org>
parents:
13286
diff
changeset
|
2932 |
6328 | 2933 if (rmp->regprog != NULL) |
14358
72d506d94f3f
patch 8.1.0194: possibly use of NULL pointer
Christian Brabandt <cb@256bit.org>
parents:
14354
diff
changeset
|
2934 { |
72d506d94f3f
patch 8.1.0194: possibly use of NULL pointer
Christian Brabandt <cb@256bit.org>
parents:
14354
diff
changeset
|
2935 rmp->regprog->re_in_use = TRUE; |
6328 | 2936 result = rmp->regprog->engine->regexec_multi( |
11521
578df034735d
patch 8.0.0643: when a pattern search is slow Vim becomes unusable
Christian Brabandt <cb@256bit.org>
parents:
11482
diff
changeset
|
2937 rmp, win, buf, lnum, col, tm, timed_out); |
14358
72d506d94f3f
patch 8.1.0194: possibly use of NULL pointer
Christian Brabandt <cb@256bit.org>
parents:
14354
diff
changeset
|
2938 rmp->regprog->re_in_use = FALSE; |
72d506d94f3f
patch 8.1.0194: possibly use of NULL pointer
Christian Brabandt <cb@256bit.org>
parents:
14354
diff
changeset
|
2939 } |
6328 | 2940 vim_free(pat); |
2941 } | |
2942 p_re = save_p_re; | |
2943 } | |
2944 | |
10245
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2945 rex_in_use = rex_in_use_save; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2946 if (rex_in_use) |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2947 rex = rex_save; |
d76ccdacb41e
commit https://github.com/vim/vim/commit/6100d02aab7c8294b581cb299250eea164b50e9d
Christian Brabandt <cb@256bit.org>
parents:
10187
diff
changeset
|
2948 |
6390 | 2949 return result <= 0 ? 0 : result; |
4444 | 2950 } |