1 /* vi:set ts=8 sts=4 sw=4:
3 * Handling of regular expressions: vim_regcomp(), vim_regexec(), vim_regsub()
7 * This is NOT the original regular expression code as written by Henry
8 * Spencer. This code has been modified specifically for use with the VIM
9 * editor, and should not be used separately from Vim. If you want a good
10 * regular expression library, get the original code. The copyright notice
11 * that follows is from the original.
15 * Copyright (c) 1986 by University of Toronto.
16 * Written by Henry Spencer. Not derived from licensed software.
18 * Permission is granted to anyone to use this software for any
19 * purpose on any computer system, and to redistribute it freely,
20 * subject to the following restrictions:
22 * 1. The author is not responsible for the consequences of use of
23 * this software, no matter how awful, even if they arise
26 * 2. The origin of this software must not be misrepresented, either
27 * by explicit claim or by omission.
29 * 3. Altered versions must be plainly marked as such, and must not
30 * be misrepresented as being the original software.
32 * Beware that some of this code is subtly aware of the way operator
33 * precedence is structured in regular expressions. Serious changes in
34 * regular-expression syntax might require a total rethink.
36 * Changes have been made by Tony Andrews, Olaf 'Rhialto' Seibert, Robert
37 * Webb, Ciaran McCreesh and Bram Moolenaar.
38 * Named character class support added by Walter Briscoe (1998 Jul 01)
46 * The "internal use only" fields in regexp.h are present to pass info from
47 * compile to execute that permits the execute phase to run lots faster on
48 * simple cases. They are:
50 * regstart char that must begin a match; NUL if none obvious; Can be a
51 * multi-byte character.
52 * reganch is the match anchored (at beginning-of-line only)?
53 * regmust string (pointer into program) that match must include, or NULL
54 * regmlen length of regmust string
55 * regflags RF_ values or'ed together
57 * Regstart and reganch permit very fast decisions on suitable starting points
58 * for a match, cutting down the work a lot. Regmust permits fast rejection
59 * of lines that cannot possibly match. The regmust tests are costly enough
60 * that vim_regcomp() supplies a regmust only if the r.e. contains something
61 * potentially expensive (at present, the only such thing detected is * or +
62 * at the start of the r.e., which can involve a lot of backup). Regmlen is
63 * supplied because the test in vim_regexec() needs it and vim_regcomp() is
64 * computing it anyway.
68 * Structure for regexp "program". This is essentially a linear encoding
69 * of a nondeterministic finite-state machine (aka syntax charts or
70 * "railroad normal form" in parsing technology). Each node is an opcode
71 * plus a "next" pointer, possibly plus an operand. "Next" pointers of
72 * all nodes except BRANCH and BRACES_COMPLEX implement concatenation; a "next"
73 * pointer with a BRANCH on both ends of it is connecting two alternatives.
74 * (Here we have one of the subtle syntax dependencies: an individual BRANCH
75 * (as opposed to a collection of them) is never concatenated with anything
76 * because of operator precedence). The "next" pointer of a BRACES_COMPLEX
77 * node points to the node after the stuff to be repeated.
78 * The operand of some types of node is a literal string; for others, it is a
79 * node leading into a sub-FSM. In particular, the operand of a BRANCH node
80 * is the first node of the branch.
81 * (NB this is *not* a tree structure: the tail of the branch connects to the
82 * thing following the set of BRANCHes.)
84 * pattern is coded like:
88 * <aa>\|<bb> BRANCH <aa> BRANCH <bb> --> END
90 * +------+ +----------+
93 * +------------------+
95 * <aa>* BRANCH BRANCH <aa> --> BACK BRANCH --> NOTHING --> END
97 * | +---------------+ |
98 * +---------------------------------------------+
101 * +----------------------+
103 * <aa>\+ BRANCH <aa> --> BRANCH --> BACK BRANCH --> NOTHING --> END
106 * +--------------------------------------------------+
109 * +-------------------------+
111 * <aa>\{} BRANCH BRACE_LIMITS --> BRACE_COMPLEX <aa> --> BACK END
113 * | +----------------+
114 * +-----------------------------------------------+
117 * <aa>\@!<bb> BRANCH NOMATCH <aa> --> END <bb> --> END
119 * | +----------------+ |
120 * +--------------------------------+
124 * \z[abc] BRANCH BRANCH a BRANCH b BRANCH c BRANCH NOTHING --> END
127 * | | +----------------+ |
128 * | +---------------------------+ |
129 * +------------------------------------------------------+
131 * They all start with a BRANCH for "\|" alternatives, even when there is only
139 /* definition number opnd? meaning */
140 #define END 0 /* End of program or NOMATCH operand. */
141 #define BOL 1 /* Match "" at beginning of line. */
142 #define EOL 2 /* Match "" at end of line. */
143 #define BRANCH 3 /* node Match this alternative, or the
145 #define BACK 4 /* Match "", "next" ptr points backward. */
146 #define EXACTLY 5 /* str Match this string. */
147 #define NOTHING 6 /* Match empty string. */
148 #define STAR 7 /* node Match this (simple) thing 0 or more
150 #define PLUS 8 /* node Match this (simple) thing 1 or more
152 #define MATCH 9 /* node match the operand zero-width */
153 #define NOMATCH 10 /* node check for no match with operand */
154 #define BEHIND 11 /* node look behind for a match with operand */
155 #define NOBEHIND 12 /* node look behind for no match with operand */
156 #define SUBPAT 13 /* node match the operand here */
157 #define BRACE_SIMPLE 14 /* node Match this (simple) thing between m and
158 * n times (\{m,n\}). */
159 #define BOW 15 /* Match "" after [^a-zA-Z0-9_] */
160 #define EOW 16 /* Match "" at [^a-zA-Z0-9_] */
161 #define BRACE_LIMITS 17 /* nr nr define the min & max for BRACE_SIMPLE
162 * and BRACE_COMPLEX. */
163 #define NEWL 18 /* Match line-break */
164 #define BHPOS 19 /* End position for BEHIND or NOBEHIND */
167 /* character classes: 20-48 normal, 50-78 include a line-break */
169 #define FIRST_NL ANY + ADD_NL
170 #define ANY 20 /* Match any one character. */
171 #define ANYOF 21 /* str Match any character in this string. */
172 #define ANYBUT 22 /* str Match any character not in this
174 #define IDENT 23 /* Match identifier char */
175 #define SIDENT 24 /* Match identifier char but no digit */
176 #define KWORD 25 /* Match keyword char */
177 #define SKWORD 26 /* Match word char but no digit */
178 #define FNAME 27 /* Match file name char */
179 #define SFNAME 28 /* Match file name char but no digit */
180 #define PRINT 29 /* Match printable char */
181 #define SPRINT 30 /* Match printable char but no digit */
182 #define WHITE 31 /* Match whitespace char */
183 #define NWHITE 32 /* Match non-whitespace char */
184 #define DIGIT 33 /* Match digit char */
185 #define NDIGIT 34 /* Match non-digit char */
186 #define HEX 35 /* Match hex char */
187 #define NHEX 36 /* Match non-hex char */
188 #define OCTAL 37 /* Match octal char */
189 #define NOCTAL 38 /* Match non-octal char */
190 #define WORD 39 /* Match word char */
191 #define NWORD 40 /* Match non-word char */
192 #define HEAD 41 /* Match head char */
193 #define NHEAD 42 /* Match non-head char */
194 #define ALPHA 43 /* Match alpha char */
195 #define NALPHA 44 /* Match non-alpha char */
196 #define LOWER 45 /* Match lowercase char */
197 #define NLOWER 46 /* Match non-lowercase char */
198 #define UPPER 47 /* Match uppercase char */
199 #define NUPPER 48 /* Match non-uppercase char */
200 #define LAST_NL NUPPER + ADD_NL
201 #define WITH_NL(op) ((op) >= FIRST_NL && (op) <= LAST_NL)
203 #define MOPEN 80 /* -89 Mark this point in input as start of
204 * \( subexpr. MOPEN + 0 marks start of
206 #define MCLOSE 90 /* -99 Analogous to MOPEN. MCLOSE + 0 marks
208 #define BACKREF 100 /* -109 node Match same string again \1-\9 */
211 # define ZOPEN 110 /* -119 Mark this point in input as start of
213 # define ZCLOSE 120 /* -129 Analogous to ZOPEN. */
214 # define ZREF 130 /* -139 node Match external submatch \z1-\z9 */
217 #define BRACE_COMPLEX 140 /* -149 node Match nodes between m & n times */
219 #define NOPEN 150 /* Mark this point in input as start of
221 #define NCLOSE 151 /* Analogous to NOPEN. */
223 #define MULTIBYTECODE 200 /* mbc Match one multi-byte character */
224 #define RE_BOF 201 /* Match "" at beginning of file. */
225 #define RE_EOF 202 /* Match "" at end of file. */
226 #define CURSOR 203 /* Match location of cursor. */
228 #define RE_LNUM 204 /* nr cmp Match line number */
229 #define RE_COL 205 /* nr cmp Match column number */
230 #define RE_VCOL 206 /* nr cmp Match virtual column number */
232 #define RE_MARK 207 /* mark cmp Match mark position */
233 #define RE_VISUAL 208 /* Match Visual area */
236 * Magic characters have a special meaning, they don't match literally.
237 * Magic characters are negative. This separates them from literal characters
238 * (possibly multi-byte). Only ASCII characters can be Magic.
240 #define Magic(x) ((int)(x) - 256)
241 #define un_Magic(x) ((x) + 256)
242 #define is_Magic(x) ((x) < 0)
244 static int no_Magic
__ARGS((int x
));
245 static int toggle_Magic
__ARGS((int x
));
266 * The first byte of the regexp internal "program" is actually this magic
267 * number; the start node begins in the second byte. It's used to catch the
268 * most severe mutilation of the program by the caller.
271 #define REGMAGIC 0234
276 * BRANCH The set of branches constituting a single choice are hooked
277 * together with their "next" pointers, since precedence prevents
278 * anything being concatenated to any individual branch. The
279 * "next" pointer of the last BRANCH in a choice points to the
280 * thing following the whole choice. This is also where the
281 * final "next" pointer of each individual branch points; each
282 * branch starts with the operand node of a BRANCH node.
284 * BACK Normal "next" pointers all implicitly point forward; BACK
285 * exists to make loop structures possible.
287 * STAR,PLUS '=', and complex '*' and '+', are implemented as circular
288 * BRANCH structures using BACK. Simple cases (one character
289 * per match) are implemented with STAR and PLUS for speed
290 * and to minimize recursive plunges.
292 * BRACE_LIMITS This is always followed by a BRACE_SIMPLE or BRACE_COMPLEX
293 * node, and defines the min and max limits to be used for that
296 * MOPEN,MCLOSE ...are numbered at compile time.
297 * ZOPEN,ZCLOSE ...ditto
301 * A node is one char of opcode followed by two chars of "next" pointer.
302 * "Next" pointers are stored as two 8-bit bytes, high order first. The
303 * value is a positive offset from the opcode of the node containing it.
304 * An operand, if any, simply follows the node. (Note that much of the
305 * code generation knows about this implicit relationship.)
307 * Using two bytes for the "next" pointer is vast overkill for most things,
308 * but allows patterns to get big without disasters.
310 #define OP(p) ((int)*(p))
311 #define NEXT(p) (((*((p) + 1) & 0377) << 8) + (*((p) + 2) & 0377))
312 #define OPERAND(p) ((p) + 3)
313 /* Obtain an operand that was stored as four bytes, MSB first. */
314 #define OPERAND_MIN(p) (((long)(p)[3] << 24) + ((long)(p)[4] << 16) \
315 + ((long)(p)[5] << 8) + (long)(p)[6])
316 /* Obtain a second operand stored as four bytes. */
317 #define OPERAND_MAX(p) OPERAND_MIN((p) + 4)
318 /* Obtain a second single-byte operand stored after a four bytes operand. */
319 #define OPERAND_CMP(p) (p)[7]
322 * Utility definitions.
324 #define UCHARAT(p) ((int)*(char_u *)(p))
326 /* Used for an error (down from) vim_regcomp(): give the error message, set
327 * rc_did_emsg and return NULL */
328 #define EMSG_RET_NULL(m) return (EMSG(m), rc_did_emsg = TRUE, (void *)NULL)
329 #define EMSG_M_RET_NULL(m, c) return (EMSG2((m), (c) ? "" : "\\"), rc_did_emsg = TRUE, (void *)NULL)
330 #define EMSG_RET_FAIL(m) return (EMSG(m), rc_did_emsg = TRUE, FAIL)
331 #define EMSG_ONE_RET_NULL EMSG_M_RET_NULL(_("E369: invalid item in %s%%[]"), reg_magic == MAGIC_ALL)
333 #define MAX_LIMIT (32767L << 16L)
335 static int re_multi_type
__ARGS((int));
336 static int cstrncmp
__ARGS((char_u
*s1
, char_u
*s2
, int *n
));
337 static char_u
*cstrchr
__ARGS((char_u
*, int));
340 static void regdump
__ARGS((char_u
*, regprog_T
*));
341 static char_u
*regprop
__ARGS((char_u
*));
348 * Return NOT_MULTI if c is not a "multi" operator.
349 * Return MULTI_ONE if c is a single "multi" operator.
350 * Return MULTI_MULT if c is a multi "multi" operator.
356 if (c
== Magic('@') || c
== Magic('=') || c
== Magic('?'))
358 if (c
== Magic('*') || c
== Magic('+') || c
== Magic('{'))
364 * Flags to be passed up and down.
366 #define HASWIDTH 0x1 /* Known never to match null string. */
367 #define SIMPLE 0x2 /* Simple enough to be STAR/PLUS operand. */
368 #define SPSTART 0x4 /* Starts with * or +. */
369 #define HASNL 0x8 /* Contains some \n. */
370 #define HASLOOKBH 0x10 /* Contains "\@<=" or "\@<!". */
371 #define WORST 0 /* Worst case. */
374 * When regcode is set to this value, code is not emitted and size is computed
377 #define JUST_CALC_SIZE ((char_u *) -1)
379 static char_u
*reg_prev_sub
= NULL
;
382 * REGEXP_INRANGE contains all characters which are always special in a []
384 * REGEXP_ABBR contains all characters which act as abbreviations after '\'.
386 * \n - New line (NL).
387 * \r - Carriage Return (CR).
390 * \b - Backspace (Ctrl_H).
391 * \d - Character code in decimal, eg \d123
392 * \o - Character code in octal, eg \o80
393 * \x - Character code in hex, eg \x4a
394 * \u - Multibyte character code, eg \u20ac
395 * \U - Long multibyte character code, eg \U12345678
397 static char_u REGEXP_INRANGE
[] = "]^-n\\";
398 static char_u REGEXP_ABBR
[] = "nrtebdoxuU";
400 static int backslash_trans
__ARGS((int c
));
401 static int get_char_class
__ARGS((char_u
**pp
));
402 static int get_equi_class
__ARGS((char_u
**pp
));
403 static void reg_equi_class
__ARGS((int c
));
404 static int get_coll_element
__ARGS((char_u
**pp
));
405 static char_u
*skip_anyof
__ARGS((char_u
*p
));
406 static void init_class_tab
__ARGS((void));
409 * Translate '\x' to its control character, except "\n", which is Magic.
417 case 'r': return CAR
;
418 case 't': return TAB
;
419 case 'e': return ESC
;
426 * Check for a character class name "[:name:]". "pp" points to the '['.
427 * Returns one of the CLASS_ items. CLASS_NONE means that no item was
428 * recognized. Otherwise "pp" is advanced to after the item.
434 static const char *(class_names
[]) =
437 #define CLASS_ALNUM 0
439 #define CLASS_ALPHA 1
441 #define CLASS_BLANK 2
443 #define CLASS_CNTRL 3
445 #define CLASS_DIGIT 4
447 #define CLASS_GRAPH 5
449 #define CLASS_LOWER 6
451 #define CLASS_PRINT 7
453 #define CLASS_PUNCT 8
455 #define CLASS_SPACE 9
457 #define CLASS_UPPER 10
459 #define CLASS_XDIGIT 11
463 #define CLASS_RETURN 13
465 #define CLASS_BACKSPACE 14
467 #define CLASS_ESCAPE 15
469 #define CLASS_NONE 99
474 for (i
= 0; i
< sizeof(class_names
) / sizeof(*class_names
); ++i
)
475 if (STRNCMP(*pp
+ 2, class_names
[i
], STRLEN(class_names
[i
])) == 0)
477 *pp
+= STRLEN(class_names
[i
]) + 2;
485 * Specific version of character class functions.
486 * Using a table to keep this fast.
488 static short class_tab
[256];
490 #define RI_DIGIT 0x01
492 #define RI_OCTAL 0x04
495 #define RI_ALPHA 0x20
496 #define RI_LOWER 0x40
497 #define RI_UPPER 0x80
498 #define RI_WHITE 0x100
504 static int done
= FALSE
;
509 for (i
= 0; i
< 256; ++i
)
511 if (i
>= '0' && i
<= '7')
512 class_tab
[i
] = RI_DIGIT
+ RI_HEX
+ RI_OCTAL
+ RI_WORD
;
513 else if (i
>= '8' && i
<= '9')
514 class_tab
[i
] = RI_DIGIT
+ RI_HEX
+ RI_WORD
;
515 else if (i
>= 'a' && i
<= 'f')
516 class_tab
[i
] = RI_HEX
+ RI_WORD
+ RI_HEAD
+ RI_ALPHA
+ RI_LOWER
;
518 else if ((i
>= 'g' && i
<= 'i') || (i
>= 'j' && i
<= 'r')
519 || (i
>= 's' && i
<= 'z'))
521 else if (i
>= 'g' && i
<= 'z')
523 class_tab
[i
] = RI_WORD
+ RI_HEAD
+ RI_ALPHA
+ RI_LOWER
;
524 else if (i
>= 'A' && i
<= 'F')
525 class_tab
[i
] = RI_HEX
+ RI_WORD
+ RI_HEAD
+ RI_ALPHA
+ RI_UPPER
;
527 else if ((i
>= 'G' && i
<= 'I') || ( i
>= 'J' && i
<= 'R')
528 || (i
>= 'S' && i
<= 'Z'))
530 else if (i
>= 'G' && i
<= 'Z')
532 class_tab
[i
] = RI_WORD
+ RI_HEAD
+ RI_ALPHA
+ RI_UPPER
;
534 class_tab
[i
] = RI_WORD
+ RI_HEAD
;
538 class_tab
[' '] |= RI_WHITE
;
539 class_tab
['\t'] |= RI_WHITE
;
544 # define ri_digit(c) (c < 0x100 && (class_tab[c] & RI_DIGIT))
545 # define ri_hex(c) (c < 0x100 && (class_tab[c] & RI_HEX))
546 # define ri_octal(c) (c < 0x100 && (class_tab[c] & RI_OCTAL))
547 # define ri_word(c) (c < 0x100 && (class_tab[c] & RI_WORD))
548 # define ri_head(c) (c < 0x100 && (class_tab[c] & RI_HEAD))
549 # define ri_alpha(c) (c < 0x100 && (class_tab[c] & RI_ALPHA))
550 # define ri_lower(c) (c < 0x100 && (class_tab[c] & RI_LOWER))
551 # define ri_upper(c) (c < 0x100 && (class_tab[c] & RI_UPPER))
552 # define ri_white(c) (c < 0x100 && (class_tab[c] & RI_WHITE))
554 # define ri_digit(c) (class_tab[c] & RI_DIGIT)
555 # define ri_hex(c) (class_tab[c] & RI_HEX)
556 # define ri_octal(c) (class_tab[c] & RI_OCTAL)
557 # define ri_word(c) (class_tab[c] & RI_WORD)
558 # define ri_head(c) (class_tab[c] & RI_HEAD)
559 # define ri_alpha(c) (class_tab[c] & RI_ALPHA)
560 # define ri_lower(c) (class_tab[c] & RI_LOWER)
561 # define ri_upper(c) (class_tab[c] & RI_UPPER)
562 # define ri_white(c) (class_tab[c] & RI_WHITE)
565 /* flags for regflags */
566 #define RF_ICASE 1 /* ignore case */
567 #define RF_NOICASE 2 /* don't ignore case */
568 #define RF_HASNL 4 /* can match a NL */
569 #define RF_ICOMBINE 8 /* ignore combining characters */
570 #define RF_LOOKBH 16 /* uses "\@<=" or "\@<!" */
573 * Global work variables for vim_regcomp().
576 static char_u
*regparse
; /* Input-scan pointer. */
577 static int prevchr_len
; /* byte length of previous char */
578 static int num_complex_braces
; /* Complex \{...} count */
579 static int regnpar
; /* () count. */
581 static int regnzpar
; /* \z() count. */
582 static int re_has_z
; /* \z item detected */
584 static char_u
*regcode
; /* Code-emit pointer, or JUST_CALC_SIZE */
585 static long regsize
; /* Code size. */
586 static char_u had_endbrace
[NSUBEXP
]; /* flags, TRUE if end of () found */
587 static unsigned regflags
; /* RF_ flags for prog */
588 static long brace_min
[10]; /* Minimums for complex brace repeats */
589 static long brace_max
[10]; /* Maximums for complex brace repeats */
590 static int brace_count
[10]; /* Current counts for complex brace repeats */
591 #if defined(FEAT_SYN_HL) || defined(PROTO)
592 static int had_eol
; /* TRUE when EOL found by vim_regcomp() */
594 static int one_exactly
= FALSE
; /* only do one char for EXACTLY */
596 static int reg_magic
; /* magicness of the pattern: */
597 #define MAGIC_NONE 1 /* "\V" very unmagic */
598 #define MAGIC_OFF 2 /* "\M" or 'magic' off */
599 #define MAGIC_ON 3 /* "\m" or 'magic' */
600 #define MAGIC_ALL 4 /* "\v" very magic */
602 static int reg_string
; /* matching with a string instead of a buffer
604 static int reg_strict
; /* "[abc" is illegal */
607 * META contains all characters that may be magic, except '^' and '$'.
611 static char_u META
[] = "%&()*+.123456789<=>?@ACDFHIKLMOPSUVWX[_acdfhiklmnopsuvwxz{|~";
613 /* META[] is used often enough to justify turning it into a table. */
614 static char_u META_flags
[] = {
615 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
616 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
618 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0,
619 /* 1 2 3 4 5 6 7 8 9 < = > ? */
620 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,
621 /* @ A C D F H I K L M O */
622 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1,
623 /* P S U V W X Z [ _ */
624 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1,
625 /* a c d f h i k l m n o */
626 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1,
627 /* p s u v w x z { | ~ */
628 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1
634 /* arguments for reg() */
635 #define REG_NOPAREN 0 /* toplevel reg() */
636 #define REG_PAREN 1 /* \(\) */
637 #define REG_ZPAREN 2 /* \z(\) */
638 #define REG_NPAREN 3 /* \%(\) */
641 * Forward declarations for vim_regcomp()'s friends.
643 static void initchr
__ARGS((char_u
*));
644 static int getchr
__ARGS((void));
645 static void skipchr_keepstart
__ARGS((void));
646 static int peekchr
__ARGS((void));
647 static void skipchr
__ARGS((void));
648 static void ungetchr
__ARGS((void));
649 static int gethexchrs
__ARGS((int maxinputlen
));
650 static int getoctchrs
__ARGS((void));
651 static int getdecchrs
__ARGS((void));
652 static int coll_get_char
__ARGS((void));
653 static void regcomp_start
__ARGS((char_u
*expr
, int flags
));
654 static char_u
*reg
__ARGS((int, int *));
655 static char_u
*regbranch
__ARGS((int *flagp
));
656 static char_u
*regconcat
__ARGS((int *flagp
));
657 static char_u
*regpiece
__ARGS((int *));
658 static char_u
*regatom
__ARGS((int *));
659 static char_u
*regnode
__ARGS((int));
661 static int use_multibytecode
__ARGS((int c
));
663 static int prog_magic_wrong
__ARGS((void));
664 static char_u
*regnext
__ARGS((char_u
*));
665 static void regc
__ARGS((int b
));
667 static void regmbc
__ARGS((int c
));
669 # define regmbc(c) regc(c)
671 static void reginsert
__ARGS((int, char_u
*));
672 static void reginsert_limits
__ARGS((int, long, long, char_u
*));
673 static char_u
*re_put_long
__ARGS((char_u
*pr
, long_u val
));
674 static int read_limits
__ARGS((long *, long *));
675 static void regtail
__ARGS((char_u
*, char_u
*));
676 static void regoptail
__ARGS((char_u
*, char_u
*));
679 * Return TRUE if compiled regular expression "prog" can match a line break.
685 return (prog
->regflags
& RF_HASNL
);
689 * Return TRUE if compiled regular expression "prog" looks before the start
690 * position (pattern contains "\@<=" or "\@<!").
696 return (prog
->regflags
& RF_LOOKBH
);
700 * Check for an equivalence class name "[=a=]". "pp" points to the '['.
701 * Returns a character representing the class. Zero means that no item was
702 * recognized. Otherwise "pp" is advanced to after the item.
716 l
= (*mb_ptr2len
)(p
+ 2);
718 if (p
[l
+ 2] == '=' && p
[l
+ 3] == ']')
722 c
= mb_ptr2char(p
+ 2);
734 * Produce the bytes for equivalence class "c".
735 * Currently only handles latin1, latin9 and utf-8.
742 if (enc_utf8
|| STRCMP(p_enc
, "latin1") == 0
743 || STRCMP(p_enc
, "iso-8859-15") == 0)
748 case 'A': case '\300': case '\301': case '\302':
749 case '\303': case '\304': case '\305':
750 regmbc('A'); regmbc('\300'); regmbc('\301');
751 regmbc('\302'); regmbc('\303'); regmbc('\304');
754 case 'C': case '\307':
755 regmbc('C'); regmbc('\307');
757 case 'E': case '\310': case '\311': case '\312': case '\313':
758 regmbc('E'); regmbc('\310'); regmbc('\311');
759 regmbc('\312'); regmbc('\313');
761 case 'I': case '\314': case '\315': case '\316': case '\317':
762 regmbc('I'); regmbc('\314'); regmbc('\315');
763 regmbc('\316'); regmbc('\317');
765 case 'N': case '\321':
766 regmbc('N'); regmbc('\321');
768 case 'O': case '\322': case '\323': case '\324': case '\325':
770 regmbc('O'); regmbc('\322'); regmbc('\323');
771 regmbc('\324'); regmbc('\325'); regmbc('\326');
773 case 'U': case '\331': case '\332': case '\333': case '\334':
774 regmbc('U'); regmbc('\331'); regmbc('\332');
775 regmbc('\333'); regmbc('\334');
777 case 'Y': case '\335':
778 regmbc('Y'); regmbc('\335');
780 case 'a': case '\340': case '\341': case '\342':
781 case '\343': case '\344': case '\345':
782 regmbc('a'); regmbc('\340'); regmbc('\341');
783 regmbc('\342'); regmbc('\343'); regmbc('\344');
786 case 'c': case '\347':
787 regmbc('c'); regmbc('\347');
789 case 'e': case '\350': case '\351': case '\352': case '\353':
790 regmbc('e'); regmbc('\350'); regmbc('\351');
791 regmbc('\352'); regmbc('\353');
793 case 'i': case '\354': case '\355': case '\356': case '\357':
794 regmbc('i'); regmbc('\354'); regmbc('\355');
795 regmbc('\356'); regmbc('\357');
797 case 'n': case '\361':
798 regmbc('n'); regmbc('\361');
800 case 'o': case '\362': case '\363': case '\364': case '\365':
802 regmbc('o'); regmbc('\362'); regmbc('\363');
803 regmbc('\364'); regmbc('\365'); regmbc('\366');
805 case 'u': case '\371': case '\372': case '\373': case '\374':
806 regmbc('u'); regmbc('\371'); regmbc('\372');
807 regmbc('\373'); regmbc('\374');
809 case 'y': case '\375': case '\377':
810 regmbc('y'); regmbc('\375'); regmbc('\377');
818 * Check for a collating element "[.a.]". "pp" points to the '['.
819 * Returns a character. Zero means that no item was recognized. Otherwise
820 * "pp" is advanced to after the item.
821 * Currently only single characters are recognized!
835 l
= (*mb_ptr2len
)(p
+ 2);
837 if (p
[l
+ 2] == '.' && p
[l
+ 3] == ']')
841 c
= mb_ptr2char(p
+ 2);
854 * Skip over a "[]" range.
855 * "p" must point to the character after the '['.
856 * The returned pointer is on the matching ']', or the terminating NUL.
862 int cpo_lit
; /* 'cpoptions' contains 'l' flag */
863 int cpo_bsl
; /* 'cpoptions' contains '\' flag */
868 cpo_lit
= vim_strchr(p_cpo
, CPO_LITERAL
) != NULL
;
869 cpo_bsl
= vim_strchr(p_cpo
, CPO_BACKSL
) != NULL
;
871 if (*p
== '^') /* Complement of range. */
873 if (*p
== ']' || *p
== '-')
875 while (*p
!= NUL
&& *p
!= ']')
878 if (has_mbyte
&& (l
= (*mb_ptr2len
)(p
)) > 1)
885 if (*p
!= ']' && *p
!= NUL
)
890 && (vim_strchr(REGEXP_INRANGE
, p
[1]) != NULL
891 || (!cpo_lit
&& vim_strchr(REGEXP_ABBR
, p
[1]) != NULL
)))
895 if (get_char_class(&p
) == CLASS_NONE
896 && get_equi_class(&p
) == 0
897 && get_coll_element(&p
) == 0)
898 ++p
; /* It was not a class name */
908 * Skip past regular expression.
909 * Stop at end of "startp" or where "dirc" is found ('/', '?', etc).
910 * Take care of characters with a backslash in front of it.
911 * Skip strings inside [ and ].
912 * When "newp" is not NULL and "dirc" is '?', make an allocated copy of the
913 * expression and change "\?" to "?". If "*newp" is not NULL the expression
914 * is changed in-place.
917 skip_regexp(startp
, dirc
, magic
, newp
)
931 for (; p
[0] != NUL
; mb_ptr_adv(p
))
933 if (p
[0] == dirc
) /* found end of regexp */
935 if ((p
[0] == '[' && mymagic
>= MAGIC_ON
)
936 || (p
[0] == '\\' && p
[1] == '[' && mymagic
<= MAGIC_OFF
))
938 p
= skip_anyof(p
+ 1);
942 else if (p
[0] == '\\' && p
[1] != NUL
)
944 if (dirc
== '?' && newp
!= NULL
&& p
[1] == '?')
946 /* change "\?" to "?", make a copy first. */
949 *newp
= vim_strsave(startp
);
951 p
= *newp
+ (p
- startp
);
954 mch_memmove(p
, p
+ 1, STRLEN(p
));
959 ++p
; /* skip next character */
963 mymagic
= MAGIC_NONE
;
970 * vim_regcomp() - compile a regular expression into internal code
971 * Returns the program in allocated space. Returns NULL for an error.
973 * We can't allocate space until we know how big the compiled form will be,
974 * but we can't compile it (and thus know how big it is) until we've got a
975 * place to put the code. So we cheat: we compile it twice, once with code
976 * generation turned off and size counting turned on, and once "for real".
977 * This also means that we don't allocate space until we are sure that the
978 * thing really will compile successfully, and we never have to move the
979 * code and thus invalidate pointers into it. (Note that it has to be in
980 * one piece because vim_free() must be able to free it all.)
982 * Whether upper/lower case is to be ignored is decided when executing the
983 * program, it does not matter here.
985 * Beware that the optimization-preparation code in here knows about some
986 * of the structure of the compiled regexp.
987 * "re_flags": RE_MAGIC and/or RE_STRING.
990 vim_regcomp(expr
, re_flags
)
1001 EMSG_RET_NULL(_(e_null
));
1006 * First pass: determine size, legality.
1008 regcomp_start(expr
, re_flags
);
1009 regcode
= JUST_CALC_SIZE
;
1011 if (reg(REG_NOPAREN
, &flags
) == NULL
)
1014 /* Small enough for pointer-storage convention? */
1015 #ifdef SMALL_MALLOC /* 16 bit storage allocation */
1016 if (regsize
>= 65536L - 256L)
1017 EMSG_RET_NULL(_("E339: Pattern too long"));
1020 /* Allocate space. */
1021 r
= (regprog_T
*)lalloc(sizeof(regprog_T
) + regsize
, TRUE
);
1026 * Second pass: emit code.
1028 regcomp_start(expr
, re_flags
);
1029 regcode
= r
->program
;
1031 if (reg(REG_NOPAREN
, &flags
) == NULL
)
1037 /* Dig out information for optimizations. */
1038 r
->regstart
= NUL
; /* Worst-case defaults. */
1042 r
->regflags
= regflags
;
1044 r
->regflags
|= RF_HASNL
;
1045 if (flags
& HASLOOKBH
)
1046 r
->regflags
|= RF_LOOKBH
;
1048 /* Remember whether this pattern has any \z specials in it. */
1049 r
->reghasz
= re_has_z
;
1051 scan
= r
->program
+ 1; /* First BRANCH. */
1052 if (OP(regnext(scan
)) == END
) /* Only one top-level choice. */
1054 scan
= OPERAND(scan
);
1056 /* Starting-point info. */
1057 if (OP(scan
) == BOL
|| OP(scan
) == RE_BOF
)
1060 scan
= regnext(scan
);
1063 if (OP(scan
) == EXACTLY
)
1067 r
->regstart
= (*mb_ptr2char
)(OPERAND(scan
));
1070 r
->regstart
= *OPERAND(scan
);
1072 else if ((OP(scan
) == BOW
1074 || OP(scan
) == NOTHING
1075 || OP(scan
) == MOPEN
+ 0 || OP(scan
) == NOPEN
1076 || OP(scan
) == MCLOSE
+ 0 || OP(scan
) == NCLOSE
)
1077 && OP(regnext(scan
)) == EXACTLY
)
1081 r
->regstart
= (*mb_ptr2char
)(OPERAND(regnext(scan
)));
1084 r
->regstart
= *OPERAND(regnext(scan
));
1088 * If there's something expensive in the r.e., find the longest
1089 * literal string that must appear and make it the regmust. Resolve
1090 * ties in favor of later strings, since the regstart check works
1091 * with the beginning of the r.e. and avoiding duplication
1092 * strengthens checking. Not a strong reason, but sufficient in the
1093 * absence of others.
1096 * When the r.e. starts with BOW, it is faster to look for a regmust
1097 * first. Used a lot for "#" and "*" commands. (Added by mool).
1099 if ((flags
& SPSTART
|| OP(scan
) == BOW
|| OP(scan
) == EOW
)
1100 && !(flags
& HASNL
))
1104 for (; scan
!= NULL
; scan
= regnext(scan
))
1105 if (OP(scan
) == EXACTLY
&& STRLEN(OPERAND(scan
)) >= (size_t)len
)
1107 longest
= OPERAND(scan
);
1108 len
= (int)STRLEN(OPERAND(scan
));
1110 r
->regmust
= longest
;
1121 * Setup to parse the regexp. Used once to get the length and once to do it.
1124 regcomp_start(expr
, re_flags
)
1126 int re_flags
; /* see vim_regcomp() */
1129 if (re_flags
& RE_MAGIC
)
1130 reg_magic
= MAGIC_ON
;
1132 reg_magic
= MAGIC_OFF
;
1133 reg_string
= (re_flags
& RE_STRING
);
1134 reg_strict
= (re_flags
& RE_STRICT
);
1136 num_complex_braces
= 0;
1138 vim_memset(had_endbrace
, 0, sizeof(had_endbrace
));
1145 #if defined(FEAT_SYN_HL) || defined(PROTO)
1150 #if defined(FEAT_SYN_HL) || defined(PROTO)
1152 * Check if during the previous call to vim_regcomp the EOL item "$" has been
1153 * found. This is messy, but it works fine.
1156 vim_regcomp_had_eol()
1163 * reg - regular expression, i.e. main body or parenthesized thing
1165 * Caller must absorb opening parenthesis.
1167 * Combining parenthesis handling with the base level of regular expression
1168 * is a trifle forced, but the need to tie the tails of the branches to what
1169 * follows makes it hard to avoid.
1173 int paren
; /* REG_NOPAREN, REG_PAREN, REG_NPAREN or REG_ZPAREN */
1182 *flagp
= HASWIDTH
; /* Tentatively. */
1185 if (paren
== REG_ZPAREN
)
1187 /* Make a ZOPEN node. */
1188 if (regnzpar
>= NSUBEXP
)
1189 EMSG_RET_NULL(_("E50: Too many \\z("));
1192 ret
= regnode(ZOPEN
+ parno
);
1196 if (paren
== REG_PAREN
)
1198 /* Make a MOPEN node. */
1199 if (regnpar
>= NSUBEXP
)
1200 EMSG_M_RET_NULL(_("E51: Too many %s("), reg_magic
== MAGIC_ALL
);
1203 ret
= regnode(MOPEN
+ parno
);
1205 else if (paren
== REG_NPAREN
)
1207 /* Make a NOPEN node. */
1208 ret
= regnode(NOPEN
);
1213 /* Pick up the branches, linking them together. */
1214 br
= regbranch(&flags
);
1218 regtail(ret
, br
); /* [MZ]OPEN -> first. */
1221 /* If one of the branches can be zero-width, the whole thing can.
1222 * If one of the branches has * at start or matches a line-break, the
1223 * whole thing can. */
1224 if (!(flags
& HASWIDTH
))
1225 *flagp
&= ~HASWIDTH
;
1226 *flagp
|= flags
& (SPSTART
| HASNL
| HASLOOKBH
);
1227 while (peekchr() == Magic('|'))
1230 br
= regbranch(&flags
);
1233 regtail(ret
, br
); /* BRANCH -> BRANCH. */
1234 if (!(flags
& HASWIDTH
))
1235 *flagp
&= ~HASWIDTH
;
1236 *flagp
|= flags
& (SPSTART
| HASNL
| HASLOOKBH
);
1239 /* Make a closing node, and hook it on the end. */
1242 paren
== REG_ZPAREN
? ZCLOSE
+ parno
:
1244 paren
== REG_PAREN
? MCLOSE
+ parno
:
1245 paren
== REG_NPAREN
? NCLOSE
: END
);
1246 regtail(ret
, ender
);
1248 /* Hook the tails of the branches to the closing node. */
1249 for (br
= ret
; br
!= NULL
; br
= regnext(br
))
1250 regoptail(br
, ender
);
1252 /* Check for proper termination. */
1253 if (paren
!= REG_NOPAREN
&& getchr() != Magic(')'))
1256 if (paren
== REG_ZPAREN
)
1257 EMSG_RET_NULL(_("E52: Unmatched \\z("));
1260 if (paren
== REG_NPAREN
)
1261 EMSG_M_RET_NULL(_("E53: Unmatched %s%%("), reg_magic
== MAGIC_ALL
);
1263 EMSG_M_RET_NULL(_("E54: Unmatched %s("), reg_magic
== MAGIC_ALL
);
1265 else if (paren
== REG_NOPAREN
&& peekchr() != NUL
)
1267 if (curchr
== Magic(')'))
1268 EMSG_M_RET_NULL(_("E55: Unmatched %s)"), reg_magic
== MAGIC_ALL
);
1270 EMSG_RET_NULL(_(e_trailing
)); /* "Can't happen". */
1274 * Here we set the flag allowing back references to this set of
1277 if (paren
== REG_PAREN
)
1278 had_endbrace
[parno
] = TRUE
; /* have seen the close paren */
1283 * Handle one alternative of an | operator.
1284 * Implements the & operator.
1291 char_u
*chain
= NULL
;
1295 *flagp
= WORST
| HASNL
; /* Tentatively. */
1297 ret
= regnode(BRANCH
);
1300 latest
= regconcat(&flags
);
1303 /* If one of the branches has width, the whole thing has. If one of
1304 * the branches anchors at start-of-line, the whole thing does.
1305 * If one of the branches uses look-behind, the whole thing does. */
1306 *flagp
|= flags
& (HASWIDTH
| SPSTART
| HASLOOKBH
);
1307 /* If one of the branches doesn't match a line-break, the whole thing
1309 *flagp
&= ~HASNL
| (flags
& HASNL
);
1311 regtail(chain
, latest
);
1312 if (peekchr() != Magic('&'))
1315 regtail(latest
, regnode(END
)); /* operand ends */
1316 reginsert(MATCH
, latest
);
1324 * Handle one alternative of an | or & operator.
1325 * Implements the concatenation operator.
1331 char_u
*first
= NULL
;
1332 char_u
*chain
= NULL
;
1337 *flagp
= WORST
; /* Tentatively. */
1351 regflags
|= RF_ICOMBINE
;
1353 skipchr_keepstart();
1356 regflags
|= RF_ICASE
;
1357 skipchr_keepstart();
1360 regflags
|= RF_NOICASE
;
1361 skipchr_keepstart();
1364 reg_magic
= MAGIC_ALL
;
1365 skipchr_keepstart();
1369 reg_magic
= MAGIC_ON
;
1370 skipchr_keepstart();
1374 reg_magic
= MAGIC_OFF
;
1375 skipchr_keepstart();
1379 reg_magic
= MAGIC_NONE
;
1380 skipchr_keepstart();
1384 latest
= regpiece(&flags
);
1387 *flagp
|= flags
& (HASWIDTH
| HASNL
| HASLOOKBH
);
1388 if (chain
== NULL
) /* First piece. */
1389 *flagp
|= flags
& SPSTART
;
1391 regtail(chain
, latest
);
1398 if (first
== NULL
) /* Loop ran zero times. */
1399 first
= regnode(NOTHING
);
1404 * regpiece - something followed by possible [*+=]
1406 * Note that the branching code sequences used for = and the general cases
1407 * of * and + are somewhat optimized: they use the same NOTHING node as
1408 * both the endmarker for their branch list and the body of the last branch.
1409 * It might seem that this node could be dispensed with entirely, but the
1410 * endmarker role is not redundant.
1423 ret
= regatom(&flags
);
1428 if (re_multi_type(op
) == NOT_MULTI
)
1434 *flagp
= (WORST
| SPSTART
| (flags
& (HASNL
| HASLOOKBH
)));
1441 reginsert(STAR
, ret
);
1444 /* Emit x* as (x&|), where & means "self". */
1445 reginsert(BRANCH
, ret
); /* Either x */
1446 regoptail(ret
, regnode(BACK
)); /* and loop */
1447 regoptail(ret
, ret
); /* back */
1448 regtail(ret
, regnode(BRANCH
)); /* or */
1449 regtail(ret
, regnode(NOTHING
)); /* null. */
1455 reginsert(PLUS
, ret
);
1458 /* Emit x+ as x(&|), where & means "self". */
1459 next
= regnode(BRANCH
); /* Either */
1461 regtail(regnode(BACK
), ret
); /* loop back */
1462 regtail(next
, regnode(BRANCH
)); /* or */
1463 regtail(ret
, regnode(NOTHING
)); /* null. */
1465 *flagp
= (WORST
| HASWIDTH
| (flags
& (HASNL
| HASLOOKBH
)));
1472 switch (no_Magic(getchr()))
1474 case '=': lop
= MATCH
; break; /* \@= */
1475 case '!': lop
= NOMATCH
; break; /* \@! */
1476 case '>': lop
= SUBPAT
; break; /* \@> */
1477 case '<': switch (no_Magic(getchr()))
1479 case '=': lop
= BEHIND
; break; /* \@<= */
1480 case '!': lop
= NOBEHIND
; break; /* \@<! */
1484 EMSG_M_RET_NULL(_("E59: invalid character after %s@"),
1485 reg_magic
== MAGIC_ALL
);
1486 /* Look behind must match with behind_pos. */
1487 if (lop
== BEHIND
|| lop
== NOBEHIND
)
1489 regtail(ret
, regnode(BHPOS
));
1490 *flagp
|= HASLOOKBH
;
1492 regtail(ret
, regnode(END
)); /* operand ends */
1493 reginsert(lop
, ret
);
1499 /* Emit x= as (x|) */
1500 reginsert(BRANCH
, ret
); /* Either x */
1501 regtail(ret
, regnode(BRANCH
)); /* or */
1502 next
= regnode(NOTHING
); /* null. */
1504 regoptail(ret
, next
);
1508 if (!read_limits(&minval
, &maxval
))
1512 reginsert(BRACE_SIMPLE
, ret
);
1513 reginsert_limits(BRACE_LIMITS
, minval
, maxval
, ret
);
1517 if (num_complex_braces
>= 10)
1518 EMSG_M_RET_NULL(_("E60: Too many complex %s{...}s"),
1519 reg_magic
== MAGIC_ALL
);
1520 reginsert(BRACE_COMPLEX
+ num_complex_braces
, ret
);
1521 regoptail(ret
, regnode(BACK
));
1522 regoptail(ret
, ret
);
1523 reginsert_limits(BRACE_LIMITS
, minval
, maxval
, ret
);
1524 ++num_complex_braces
;
1526 if (minval
> 0 && maxval
> 0)
1527 *flagp
= (HASWIDTH
| (flags
& (HASNL
| HASLOOKBH
)));
1530 if (re_multi_type(peekchr()) != NOT_MULTI
)
1532 /* Can't have a multi follow a multi. */
1533 if (peekchr() == Magic('*'))
1534 sprintf((char *)IObuff
, _("E61: Nested %s*"),
1535 reg_magic
>= MAGIC_ON
? "" : "\\");
1537 sprintf((char *)IObuff
, _("E62: Nested %s%c"),
1538 reg_magic
== MAGIC_ALL
? "" : "\\", no_Magic(peekchr()));
1539 EMSG_RET_NULL(IObuff
);
1546 * regatom - the lowest level
1548 * Optimization: gobbles an entire sequence of ordinary characters so that
1549 * it can turn them into a single node, which is smaller to store and
1550 * faster to run. Don't do this when one_exactly is set.
1558 int cpo_lit
; /* 'cpoptions' contains 'l' flag */
1559 int cpo_bsl
; /* 'cpoptions' contains '\' flag */
1561 static char_u
*classchars
= (char_u
*)".iIkKfFpPsSdDxXoOwWhHaAlLuU";
1562 static int classcodes
[] = {ANY
, IDENT
, SIDENT
, KWORD
, SKWORD
,
1563 FNAME
, SFNAME
, PRINT
, SPRINT
,
1564 WHITE
, NWHITE
, DIGIT
, NDIGIT
,
1565 HEX
, NHEX
, OCTAL
, NOCTAL
,
1566 WORD
, NWORD
, HEAD
, NHEAD
,
1567 ALPHA
, NALPHA
, LOWER
, NLOWER
,
1573 *flagp
= WORST
; /* Tentatively. */
1574 cpo_lit
= vim_strchr(p_cpo
, CPO_LITERAL
) != NULL
;
1575 cpo_bsl
= vim_strchr(p_cpo
, CPO_BACKSL
) != NULL
;
1586 #if defined(FEAT_SYN_HL) || defined(PROTO)
1600 c
= no_Magic(getchr());
1601 if (c
== '^') /* "\_^" is start-of-line */
1606 if (c
== '$') /* "\_$" is end-of-line */
1609 #if defined(FEAT_SYN_HL) || defined(PROTO)
1618 /* "\_[" is character range plus newline */
1622 /* "\_x" is character class plus newline */
1626 * Character classes.
1655 p
= vim_strchr(classchars
, no_Magic(c
));
1657 EMSG_RET_NULL(_("E63: invalid use of \\_"));
1659 /* When '.' is followed by a composing char ignore the dot, so that
1660 * the composing char is matched here. */
1661 if (enc_utf8
&& c
== Magic('.') && utf_iscomposing(peekchr()))
1667 ret
= regnode(classcodes
[p
- classchars
] + extra
);
1668 *flagp
|= HASWIDTH
| SIMPLE
;
1674 /* In a string "\n" matches a newline character. */
1675 ret
= regnode(EXACTLY
);
1678 *flagp
|= HASWIDTH
| SIMPLE
;
1682 /* In buffer text "\n" matches the end of a line. */
1683 ret
= regnode(NEWL
);
1684 *flagp
|= HASWIDTH
| HASNL
;
1691 ret
= reg(REG_PAREN
, &flags
);
1694 *flagp
|= flags
& (HASWIDTH
| SPSTART
| HASNL
| HASLOOKBH
);
1703 EMSG_RET_NULL(_(e_internal
)); /* Supposed to be caught earlier. */
1713 sprintf((char *)IObuff
, _("E64: %s%c follows nothing"),
1714 (c
== '*' ? reg_magic
>= MAGIC_ON
: reg_magic
== MAGIC_ALL
)
1716 EMSG_RET_NULL(IObuff
);
1719 case Magic('~'): /* previous substitute pattern */
1720 if (reg_prev_sub
!= NULL
)
1724 ret
= regnode(EXACTLY
);
1729 if (*reg_prev_sub
!= NUL
)
1732 if ((lp
- reg_prev_sub
) == 1)
1737 EMSG_RET_NULL(_(e_nopresub
));
1752 refnum
= c
- Magic('0');
1754 * Check if the back reference is legal. We must have seen the
1756 * TODO: Should also check that we don't refer to something
1757 * that is repeated (+*=): what instance of the repetition
1760 if (!had_endbrace
[refnum
])
1762 /* Trick: check if "@<=" or "@<!" follows, in which case
1763 * the \1 can appear before the referenced match. */
1764 for (p
= regparse
; *p
!= NUL
; ++p
)
1765 if (p
[0] == '@' && p
[1] == '<'
1766 && (p
[2] == '!' || p
[2] == '='))
1769 EMSG_RET_NULL(_("E65: Illegal back reference"));
1771 ret
= regnode(BACKREF
+ refnum
);
1777 c
= no_Magic(getchr());
1781 case '(': if (reg_do_extmatch
!= REX_SET
)
1782 EMSG_RET_NULL(_("E66: \\z( not allowed here"));
1785 ret
= reg(REG_ZPAREN
, &flags
);
1788 *flagp
|= flags
& (HASWIDTH
|SPSTART
|HASNL
|HASLOOKBH
);
1800 case '9': if (reg_do_extmatch
!= REX_USE
)
1801 EMSG_RET_NULL(_("E67: \\z1 et al. not allowed here"));
1802 ret
= regnode(ZREF
+ c
- '0');
1807 case 's': ret
= regnode(MOPEN
+ 0);
1810 case 'e': ret
= regnode(MCLOSE
+ 0);
1813 default: EMSG_RET_NULL(_("E68: Invalid character after \\z"));
1820 c
= no_Magic(getchr());
1823 /* () without a back reference */
1827 ret
= reg(REG_NPAREN
, &flags
);
1830 *flagp
|= flags
& (HASWIDTH
| SPSTART
| HASNL
| HASLOOKBH
);
1833 /* Catch \%^ and \%$ regardless of where they appear in the
1834 * pattern -- regardless of whether or not it makes sense. */
1836 ret
= regnode(RE_BOF
);
1840 ret
= regnode(RE_EOF
);
1844 ret
= regnode(CURSOR
);
1848 ret
= regnode(RE_VISUAL
);
1851 /* \%[abc]: Emit as a list of branches, all ending at the last
1852 * branch which matches nothing. */
1854 if (one_exactly
) /* doesn't nest */
1858 char_u
*lastnode
= NULL
;
1862 while ((c
= getchr()) != ']')
1865 EMSG_M_RET_NULL(_("E69: Missing ] after %s%%["),
1866 reg_magic
== MAGIC_ALL
);
1867 br
= regnode(BRANCH
);
1871 regtail(lastnode
, br
);
1875 lastnode
= regatom(flagp
);
1876 one_exactly
= FALSE
;
1877 if (lastnode
== NULL
)
1881 EMSG_M_RET_NULL(_("E70: Empty %s%%[]"),
1882 reg_magic
== MAGIC_ALL
);
1883 lastbranch
= regnode(BRANCH
);
1884 br
= regnode(NOTHING
);
1885 if (ret
!= JUST_CALC_SIZE
)
1887 regtail(lastnode
, br
);
1888 regtail(lastbranch
, br
);
1889 /* connect all branches to the NOTHING
1890 * branch at the end */
1891 for (br
= ret
; br
!= lastnode
; )
1893 if (OP(br
) == BRANCH
)
1895 regtail(br
, lastbranch
);
1902 *flagp
&= ~HASWIDTH
;
1906 case 'd': /* %d123 decimal */
1907 case 'o': /* %o123 octal */
1908 case 'x': /* %xab hex 2 */
1909 case 'u': /* %uabcd hex 4 */
1910 case 'U': /* %U1234abcd hex 8 */
1916 case 'd': i
= getdecchrs(); break;
1917 case 'o': i
= getoctchrs(); break;
1918 case 'x': i
= gethexchrs(2); break;
1919 case 'u': i
= gethexchrs(4); break;
1920 case 'U': i
= gethexchrs(8); break;
1921 default: i
= -1; break;
1926 _("E678: Invalid character after %s%%[dxouU]"),
1927 reg_magic
== MAGIC_ALL
);
1929 if (use_multibytecode(i
))
1930 ret
= regnode(MULTIBYTECODE
);
1933 ret
= regnode(EXACTLY
);
1948 if (VIM_ISDIGIT(c
) || c
== '<' || c
== '>'
1955 if (cmp
== '<' || cmp
== '>')
1957 while (VIM_ISDIGIT(c
))
1959 n
= n
* 10 + (c
- '0');
1962 if (c
== '\'' && n
== 0)
1964 /* "\%'m", "\%<'m" and "\%>'m": Mark */
1966 ret
= regnode(RE_MARK
);
1967 if (ret
== JUST_CALC_SIZE
)
1976 else if (c
== 'l' || c
== 'c' || c
== 'v')
1979 ret
= regnode(RE_LNUM
);
1981 ret
= regnode(RE_COL
);
1983 ret
= regnode(RE_VCOL
);
1984 if (ret
== JUST_CALC_SIZE
)
1988 /* put the number and the optional
1989 * comparator after the opcode */
1990 regcode
= re_put_long(regcode
, n
);
1997 EMSG_M_RET_NULL(_("E71: Invalid character after %s%%"),
1998 reg_magic
== MAGIC_ALL
);
2009 * If there is no matching ']', we assume the '[' is a normal
2010 * character. This makes 'incsearch' and ":help [" work.
2012 lp
= skip_anyof(regparse
);
2013 if (*lp
== ']') /* there is a matching ']' */
2015 int startc
= -1; /* > 0 when next '-' is a range */
2019 * In a character class, different parsing rules apply.
2020 * Not even \ is special anymore, nothing is.
2022 if (*regparse
== '^') /* Complement of range. */
2024 ret
= regnode(ANYBUT
+ extra
);
2028 ret
= regnode(ANYOF
+ extra
);
2030 /* At the start ']' and '-' mean the literal character. */
2031 if (*regparse
== ']' || *regparse
== '-')
2037 while (*regparse
!= NUL
&& *regparse
!= ']')
2039 if (*regparse
== '-')
2042 /* The '-' is not used for a range at the end and
2043 * after or before a '\n'. */
2044 if (*regparse
== ']' || *regparse
== NUL
2046 || (regparse
[0] == '\\' && regparse
[1] == 'n'))
2049 startc
= '-'; /* [--x] is a range */
2053 /* Also accept "a-[.z.]" */
2055 if (*regparse
== '[')
2056 endc
= get_coll_element(®parse
);
2061 endc
= mb_ptr2char_adv(®parse
);
2067 /* Handle \o40, \x20 and \u20AC style sequences */
2068 if (endc
== '\\' && !cpo_lit
&& !cpo_bsl
)
2069 endc
= coll_get_char();
2072 EMSG_RET_NULL(_(e_invrange
));
2074 if (has_mbyte
&& ((*mb_char2len
)(startc
) > 1
2075 || (*mb_char2len
)(endc
) > 1))
2077 /* Limit to a range of 256 chars */
2078 if (endc
> startc
+ 256)
2079 EMSG_RET_NULL(_(e_invrange
));
2080 while (++startc
<= endc
)
2087 int alpha_only
= FALSE
;
2089 /* for alphabetical range skip the gaps
2090 * 'i'-'j', 'r'-'s', 'I'-'J' and 'R'-'S'. */
2091 if (isalpha(startc
) && isalpha(endc
))
2094 while (++startc
<= endc
)
2096 if (!alpha_only
|| isalpha(startc
))
2104 * Only "\]", "\^", "\]" and "\\" are special in Vi. Vim
2105 * accepts "\t", "\e", etc., but only when the 'l' flag in
2106 * 'cpoptions' is not included.
2107 * Posix doesn't recognize backslash at all.
2109 else if (*regparse
== '\\'
2111 && (vim_strchr(REGEXP_INRANGE
, regparse
[1]) != NULL
2113 && vim_strchr(REGEXP_ABBR
,
2114 regparse
[1]) != NULL
)))
2117 if (*regparse
== 'n')
2119 /* '\n' in range: also match NL */
2120 if (ret
!= JUST_CALC_SIZE
)
2123 *ret
= ANYBUT
+ ADD_NL
;
2124 else if (*ret
== ANYOF
)
2125 *ret
= ANYOF
+ ADD_NL
;
2126 /* else: must have had a \n already */
2132 else if (*regparse
== 'd'
2136 || *regparse
== 'U')
2138 startc
= coll_get_char();
2150 startc
= backslash_trans(*regparse
++);
2154 else if (*regparse
== '[')
2159 c_class
= get_char_class(®parse
);
2161 /* Characters assumed to be 8 bits! */
2165 c_class
= get_equi_class(®parse
);
2168 /* produce equivalence class */
2169 reg_equi_class(c_class
);
2172 get_coll_element(®parse
)) != 0)
2174 /* produce a collating element */
2179 /* literal '[', allow [[-x] as a range */
2180 startc
= *regparse
++;
2185 for (cu
= 1; cu
<= 255; cu
++)
2190 for (cu
= 1; cu
<= 255; cu
++)
2199 for (cu
= 1; cu
<= 255; cu
++)
2204 for (cu
= 1; cu
<= 255; cu
++)
2205 if (VIM_ISDIGIT(cu
))
2209 for (cu
= 1; cu
<= 255; cu
++)
2214 for (cu
= 1; cu
<= 255; cu
++)
2219 for (cu
= 1; cu
<= 255; cu
++)
2220 if (vim_isprintc(cu
))
2224 for (cu
= 1; cu
<= 255; cu
++)
2229 for (cu
= 9; cu
<= 13; cu
++)
2234 for (cu
= 1; cu
<= 255; cu
++)
2239 for (cu
= 1; cu
<= 255; cu
++)
2240 if (vim_isxdigit(cu
))
2249 case CLASS_BACKSPACE
:
2264 /* produce a multibyte character, including any
2265 * following composing characters */
2266 startc
= mb_ptr2char(regparse
);
2267 len
= (*mb_ptr2len
)(regparse
);
2268 if (enc_utf8
&& utf_char2len(startc
) != len
)
2269 startc
= -1; /* composing chars */
2276 startc
= *regparse
++;
2282 prevchr_len
= 1; /* last char was the ']' */
2283 if (*regparse
!= ']')
2284 EMSG_RET_NULL(_(e_toomsbra
)); /* Cannot happen? */
2285 skipchr(); /* let's be friends with the lexer again */
2286 *flagp
|= HASWIDTH
| SIMPLE
;
2289 else if (reg_strict
)
2290 EMSG_M_RET_NULL(_("E769: Missing ] after %s["),
2291 reg_magic
> MAGIC_OFF
);
2300 /* A multi-byte character is handled as a separate atom if it's
2301 * before a multi and when it's a composing char. */
2302 if (use_multibytecode(c
))
2305 ret
= regnode(MULTIBYTECODE
);
2307 *flagp
|= HASWIDTH
| SIMPLE
;
2312 ret
= regnode(EXACTLY
);
2315 * Append characters as long as:
2316 * - there is no following multi, we then need the character in
2317 * front of it as a single character operand
2318 * - not running into a Magic character
2319 * - "one_exactly" is not set
2320 * But always emit at least one character. Might be a Multi,
2321 * e.g., a "[" without matching "]".
2323 for (len
= 0; c
!= NUL
&& (len
== 0
2324 || (re_multi_type(peekchr()) == NOT_MULTI
2326 && !is_Magic(c
))); ++len
)
2337 /* Need to get composing character too. */
2340 l
= utf_ptr2len(regparse
);
2341 if (!UTF_COMPOSINGLIKE(regparse
, regparse
+ l
))
2343 regmbc(utf_ptr2char(regparse
));
2368 * Return TRUE if MULTIBYTECODE should be used instead of EXACTLY for
2372 use_multibytecode(c
)
2375 return has_mbyte
&& (*mb_char2len
)(c
) > 1
2376 && (re_multi_type(peekchr()) != NOT_MULTI
2377 || (enc_utf8
&& utf_iscomposing(c
)));
2383 * Return pointer to generated code.
2392 if (ret
== JUST_CALC_SIZE
)
2397 *regcode
++ = NUL
; /* Null "next" pointer. */
2404 * Emit (if appropriate) a byte of code
2410 if (regcode
== JUST_CALC_SIZE
)
2418 * Emit (if appropriate) a multi-byte character of code
2424 if (regcode
== JUST_CALC_SIZE
)
2425 regsize
+= (*mb_char2len
)(c
);
2427 regcode
+= (*mb_char2bytes
)(c
, regcode
);
2432 * reginsert - insert an operator in front of already-emitted operand
2434 * Means relocating the operand.
2445 if (regcode
== JUST_CALC_SIZE
)
2456 place
= opnd
; /* Op node, where operand used to be. */
2463 * reginsert_limits - insert an operator in front of already-emitted operand.
2464 * The operator has the given limit values as operands. Also set next pointer.
2466 * Means relocating the operand.
2469 reginsert_limits(op
, minval
, maxval
, opnd
)
2479 if (regcode
== JUST_CALC_SIZE
)
2490 place
= opnd
; /* Op node, where operand used to be. */
2494 place
= re_put_long(place
, (long_u
)minval
);
2495 place
= re_put_long(place
, (long_u
)maxval
);
2496 regtail(opnd
, place
);
2500 * Write a long as four bytes at "p" and return pointer to the next char.
2507 *p
++ = (char_u
) ((val
>> 24) & 0377);
2508 *p
++ = (char_u
) ((val
>> 16) & 0377);
2509 *p
++ = (char_u
) ((val
>> 8) & 0377);
2510 *p
++ = (char_u
) (val
& 0377);
2515 * regtail - set the next-pointer at the end of a node chain
2526 if (p
== JUST_CALC_SIZE
)
2529 /* Find last node. */
2533 temp
= regnext(scan
);
2539 if (OP(scan
) == BACK
)
2540 offset
= (int)(scan
- val
);
2542 offset
= (int)(val
- scan
);
2543 *(scan
+ 1) = (char_u
) (((unsigned)offset
>> 8) & 0377);
2544 *(scan
+ 2) = (char_u
) (offset
& 0377);
2548 * regoptail - regtail on item after a BRANCH; nop if none
2555 /* When op is neither BRANCH nor BRACE_COMPLEX0-9, it is "operandless" */
2556 if (p
== NULL
|| p
== JUST_CALC_SIZE
2558 && (OP(p
) < BRACE_COMPLEX
|| OP(p
) > BRACE_COMPLEX
+ 9)))
2560 regtail(OPERAND(p
), val
);
2564 * getchr() - get the next character from the pattern. We know about
2565 * magic and such, so therefore we need a lexical analyzer.
2568 /* static int curchr; */
2569 static int prevprevchr
;
2571 static int nextchr
; /* used for ungetchr() */
2573 * Note: prevchr is sometimes -1 when we are not at the start,
2574 * eg in /[ ^I]^ the pattern was never found even if it existed, because ^ was
2575 * taken to be magic -- webb
2577 static int at_start
; /* True when on the first character */
2578 static int prev_at_start
; /* True when on the second character */
2586 curchr
= prevprevchr
= prevchr
= nextchr
= -1;
2588 prev_at_start
= FALSE
;
2594 static int after_slash
= FALSE
;
2598 switch (curchr
= regparse
[0])
2603 /* magic when 'magic' is on */
2604 if (reg_magic
>= MAGIC_ON
)
2605 curchr
= Magic(curchr
);
2620 case '#': /* future ext. */
2621 case '"': /* future ext. */
2622 case '\'': /* future ext. */
2623 case ',': /* future ext. */
2624 case '-': /* future ext. */
2625 case ':': /* future ext. */
2626 case ';': /* future ext. */
2627 case '`': /* future ext. */
2628 case '/': /* Can't be used in / command */
2629 /* magic only after "\v" */
2630 if (reg_magic
== MAGIC_ALL
)
2631 curchr
= Magic(curchr
);
2634 /* * is not magic as the very first character, eg "?*ptr", when
2635 * after '^', eg "/^*ptr" and when after "\(", "\|", "\&". But
2636 * "\(\*" is not magic, thus must be magic if "after_slash" */
2637 if (reg_magic
>= MAGIC_ON
2639 && !(prev_at_start
&& prevchr
== Magic('^'))
2641 || (prevchr
!= Magic('(')
2642 && prevchr
!= Magic('&')
2643 && prevchr
!= Magic('|'))))
2644 curchr
= Magic('*');
2647 /* '^' is only magic as the very first character and if it's after
2648 * "\(", "\|", "\&' or "\n" */
2649 if (reg_magic
>= MAGIC_OFF
2651 || reg_magic
== MAGIC_ALL
2652 || prevchr
== Magic('(')
2653 || prevchr
== Magic('|')
2654 || prevchr
== Magic('&')
2655 || prevchr
== Magic('n')
2656 || (no_Magic(prevchr
) == '('
2657 && prevprevchr
== Magic('%'))))
2659 curchr
= Magic('^');
2661 prev_at_start
= FALSE
;
2665 /* '$' is only magic as the very last char and if it's in front of
2666 * either "\|", "\)", "\&", or "\n" */
2667 if (reg_magic
>= MAGIC_OFF
)
2669 char_u
*p
= regparse
+ 1;
2671 /* ignore \c \C \m and \M after '$' */
2672 while (p
[0] == '\\' && (p
[1] == 'c' || p
[1] == 'C'
2673 || p
[1] == 'm' || p
[1] == 'M' || p
[1] == 'Z'))
2677 && (p
[1] == '|' || p
[1] == '&' || p
[1] == ')'
2679 || reg_magic
== MAGIC_ALL
)
2680 curchr
= Magic('$');
2685 int c
= regparse
[1];
2688 curchr
= '\\'; /* trailing '\' */
2693 c
<= '~' && META_flags
[c
]
2698 * META contains everything that may be magic sometimes,
2699 * except ^ and $ ("\^" and "\$" are only magic after
2700 * "\v"). We now fetch the next character and toggle its
2701 * magicness. Therefore, \ is so meta-magic that it is
2705 prev_at_start
= at_start
;
2706 at_start
= FALSE
; /* be able to say "/\*ptr" */
2712 curchr
= toggle_Magic(curchr
);
2714 else if (vim_strchr(REGEXP_ABBR
, c
))
2717 * Handle abbreviations, like "\t" for TAB -- webb
2719 curchr
= backslash_trans(c
);
2721 else if (reg_magic
== MAGIC_NONE
&& (c
== '$' || c
== '^'))
2722 curchr
= toggle_Magic(c
);
2726 * Next character can never be (made) magic?
2727 * Then backslashing it won't do anything.
2731 curchr
= (*mb_ptr2char
)(regparse
+ 1);
2742 curchr
= (*mb_ptr2char
)(regparse
);
2751 * Eat one lexed character. Do this in a way that we can undo it.
2756 /* peekchr() eats a backslash, do the same here */
2757 if (*regparse
== '\\')
2761 if (regparse
[prevchr_len
] != NUL
)
2765 /* exclude composing chars that mb_ptr2len does include */
2766 prevchr_len
+= utf_ptr2len(regparse
+ prevchr_len
);
2768 prevchr_len
+= (*mb_ptr2len
)(regparse
+ prevchr_len
);
2773 regparse
+= prevchr_len
;
2774 prev_at_start
= at_start
;
2776 prevprevchr
= prevchr
;
2778 curchr
= nextchr
; /* use previously unget char, or -1 */
2783 * Skip a character while keeping the value of prev_at_start for at_start.
2784 * prevchr and prevprevchr are also kept.
2789 int as
= prev_at_start
;
2791 int prpr
= prevprevchr
;
2802 int chr
= peekchr();
2809 * put character back. Works only once!
2816 prevchr
= prevprevchr
;
2817 at_start
= prev_at_start
;
2818 prev_at_start
= FALSE
;
2820 /* Backup regparse, so that it's at the same position as before the
2822 regparse
-= prevchr_len
;
2826 * Get and return the value of the hex string at the current position.
2827 * Return -1 if there is no valid hex number.
2828 * The position is updated:
2831 * The parameter controls the maximum number of input characters. This will be
2832 * 2 when reading a \%x20 sequence and 4 when reading a \%u20AC sequence.
2835 gethexchrs(maxinputlen
)
2842 for (i
= 0; i
< maxinputlen
; ++i
)
2845 if (!vim_isxdigit(c
))
2858 * get and return the value of the decimal string immediately after the
2859 * current position. Return -1 for invalid. Consumes all digits.
2871 if (c
< '0' || c
> '9')
2884 * get and return the value of the octal string immediately after the current
2885 * position. Return -1 for invalid, or 0-255 for valid. Smart enough to handle
2886 * numbers > 377 correctly (for example, 400 is treated as 40) and doesn't
2887 * treat 8 or 9 as recognised characters. Position is updated:
2888 * blahblah\%o210asdf
2898 for (i
= 0; i
< 3 && nr
< 040; ++i
)
2901 if (c
< '0' || c
> '7')
2914 * Get a number after a backslash that is inside [].
2915 * When nothing is recognized return a backslash.
2922 switch (*regparse
++)
2924 case 'd': nr
= getdecchrs(); break;
2925 case 'o': nr
= getoctchrs(); break;
2926 case 'x': nr
= gethexchrs(2); break;
2927 case 'u': nr
= gethexchrs(4); break;
2928 case 'U': nr
= gethexchrs(8); break;
2932 /* If getting the number fails be backwards compatible: the character
2933 * is a backslash. */
2941 * read_limits - Read two integers to be taken as a minimum and maximum.
2942 * If the first character is '-', then the range is reversed.
2943 * Should end with 'end'. If minval is missing, zero is default, if maxval is
2944 * missing, a very big number is the default.
2947 read_limits(minval
, maxval
)
2951 int reverse
= FALSE
;
2955 if (*regparse
== '-')
2957 /* Starts with '-', so reverse the range later */
2961 first_char
= regparse
;
2962 *minval
= getdigits(®parse
);
2963 if (*regparse
== ',') /* There is a comma */
2965 if (vim_isdigit(*++regparse
))
2966 *maxval
= getdigits(®parse
);
2968 *maxval
= MAX_LIMIT
;
2970 else if (VIM_ISDIGIT(*first_char
))
2971 *maxval
= *minval
; /* It was \{n} or \{-n} */
2973 *maxval
= MAX_LIMIT
; /* It was \{} or \{-} */
2974 if (*regparse
== '\\')
2975 regparse
++; /* Allow either \{...} or \{...\} */
2976 if (*regparse
!= '}')
2978 sprintf((char *)IObuff
, _("E554: Syntax error in %s{...}"),
2979 reg_magic
== MAGIC_ALL
? "" : "\\");
2980 EMSG_RET_FAIL(IObuff
);
2984 * Reverse the range if there was a '-', or make sure it is in the right
2987 if ((!reverse
&& *minval
> *maxval
) || (reverse
&& *minval
< *maxval
))
2993 skipchr(); /* let's be friends with the lexer again */
2998 * vim_regexec and friends
3002 * Global work variables for vim_regexec().
3005 /* The current match-position is remembered with these variables: */
3006 static linenr_T reglnum
; /* line number, relative to first line */
3007 static char_u
*regline
; /* start of current line */
3008 static char_u
*reginput
; /* current input, points into "regline" */
3010 static int need_clear_subexpr
; /* subexpressions still need to be
3013 static int need_clear_zsubexpr
= FALSE
; /* extmatch subexpressions
3014 * still need to be cleared */
3018 * Structure used to save the current input state, when it needs to be
3019 * restored after trying a match. Used by reg_save() and reg_restore().
3020 * Also stores the length of "backpos".
3026 char_u
*ptr
; /* reginput pointer, for single-line regexp */
3027 lpos_T pos
; /* reginput pos, for multi-line regexp */
3032 /* struct to save start/end pointer/position in for \(\) */
3042 static char_u
*reg_getline
__ARGS((linenr_T lnum
));
3043 static long vim_regexec_both
__ARGS((char_u
*line
, colnr_T col
, proftime_T
*tm
));
3044 static long regtry
__ARGS((regprog_T
*prog
, colnr_T col
));
3045 static void cleanup_subexpr
__ARGS((void));
3047 static void cleanup_zsubexpr
__ARGS((void));
3049 static void reg_nextline
__ARGS((void));
3050 static void reg_save
__ARGS((regsave_T
*save
, garray_T
*gap
));
3051 static void reg_restore
__ARGS((regsave_T
*save
, garray_T
*gap
));
3052 static int reg_save_equal
__ARGS((regsave_T
*save
));
3053 static void save_se_multi
__ARGS((save_se_T
*savep
, lpos_T
*posp
));
3054 static void save_se_one
__ARGS((save_se_T
*savep
, char_u
**pp
));
3056 /* Save the sub-expressions before attempting a match. */
3057 #define save_se(savep, posp, pp) \
3058 REG_MULTI ? save_se_multi((savep), (posp)) : save_se_one((savep), (pp))
3060 /* After a failed match restore the sub-expressions. */
3061 #define restore_se(savep, posp, pp) { \
3063 *(posp) = (savep)->se_u.pos; \
3065 *(pp) = (savep)->se_u.ptr; }
3067 static int re_num_cmp
__ARGS((long_u val
, char_u
*scan
));
3068 static int regmatch
__ARGS((char_u
*prog
));
3069 static int regrepeat
__ARGS((char_u
*p
, long maxcount
));
3076 * Internal copy of 'ignorecase'. It is set at each call to vim_regexec().
3077 * Normally it gets the value of "rm_ic" or "rmm_ic", but when the pattern
3078 * contains '\c' or '\C' the value is overruled.
3084 * Similar to ireg_ic, but only for 'combining' characters. Set with \Z flag
3085 * in the regexp. Defaults to false, always.
3087 static int ireg_icombine
;
3091 * Copy of "rmm_maxcol": maximum column to search for a match. Zero when
3092 * there is no maximum.
3094 static colnr_T ireg_maxcol
;
3097 * Sometimes need to save a copy of a line. Since alloc()/free() is very
3098 * slow, we keep one allocated piece of memory and only re-allocate it when
3099 * it's too small. It's freed in vim_regexec_both() when finished.
3101 static char_u
*reg_tofree
= NULL
;
3102 static unsigned reg_tofreelen
;
3105 * These variables are set when executing a regexp to speed up the execution.
3106 * Which ones are set depends on whether a single-line or multi-line match is
3108 * single-line multi-line
3109 * reg_match ®match_T NULL
3110 * reg_mmatch NULL ®mmatch_T
3111 * reg_startp reg_match->startp <invalid>
3112 * reg_endp reg_match->endp <invalid>
3113 * reg_startpos <invalid> reg_mmatch->startpos
3114 * reg_endpos <invalid> reg_mmatch->endpos
3115 * reg_win NULL window in which to search
3116 * reg_buf <invalid> buffer in which to search
3117 * reg_firstlnum <invalid> first line in which to search
3118 * reg_maxline 0 last line nr
3119 * reg_line_lbr FALSE or TRUE FALSE
3121 static regmatch_T
*reg_match
;
3122 static regmmatch_T
*reg_mmatch
;
3123 static char_u
**reg_startp
= NULL
;
3124 static char_u
**reg_endp
= NULL
;
3125 static lpos_T
*reg_startpos
= NULL
;
3126 static lpos_T
*reg_endpos
= NULL
;
3127 static win_T
*reg_win
;
3128 static buf_T
*reg_buf
;
3129 static linenr_T reg_firstlnum
;
3130 static linenr_T reg_maxline
;
3131 static int reg_line_lbr
; /* "\n" in string is line break */
3133 /* Values for rs_state in regitem_T. */
3134 typedef enum regstate_E
3136 RS_NOPEN
= 0 /* NOPEN and NCLOSE */
3137 , RS_MOPEN
/* MOPEN + [0-9] */
3138 , RS_MCLOSE
/* MCLOSE + [0-9] */
3140 , RS_ZOPEN
/* ZOPEN + [0-9] */
3141 , RS_ZCLOSE
/* ZCLOSE + [0-9] */
3143 , RS_BRANCH
/* BRANCH */
3144 , RS_BRCPLX_MORE
/* BRACE_COMPLEX and trying one more match */
3145 , RS_BRCPLX_LONG
/* BRACE_COMPLEX and trying longest match */
3146 , RS_BRCPLX_SHORT
/* BRACE_COMPLEX and trying shortest match */
3147 , RS_NOMATCH
/* NOMATCH */
3148 , RS_BEHIND1
/* BEHIND / NOBEHIND matching rest */
3149 , RS_BEHIND2
/* BEHIND / NOBEHIND matching behind part */
3150 , RS_STAR_LONG
/* STAR/PLUS/BRACE_SIMPLE longest match */
3151 , RS_STAR_SHORT
/* STAR/PLUS/BRACE_SIMPLE shortest match */
3155 * When there are alternatives a regstate_T is put on the regstack to remember
3156 * what we are doing.
3157 * Before it may be another type of item, depending on rs_state, to remember
3160 typedef struct regitem_S
3162 regstate_T rs_state
; /* what we are doing, one of RS_ above */
3163 char_u
*rs_scan
; /* current node in program */
3168 } rs_un
; /* room for saving reginput */
3169 short rs_no
; /* submatch nr */
3172 static regitem_T
*regstack_push
__ARGS((regstate_T state
, char_u
*scan
));
3173 static void regstack_pop
__ARGS((char_u
**scan
));
3175 /* used for BEHIND and NOBEHIND matching */
3176 typedef struct regbehind_S
3178 regsave_T save_after
;
3179 regsave_T save_behind
;
3182 /* used for STAR, PLUS and BRACE_SIMPLE matching */
3183 typedef struct regstar_S
3185 int nextb
; /* next byte */
3186 int nextb_ic
; /* next byte reverse case */
3192 /* used to store input position when a BACK was encountered, so that we now if
3193 * we made any progress since the last time. */
3194 typedef struct backpos_S
3196 char_u
*bp_scan
; /* "scan" where BACK was encountered */
3197 regsave_T bp_pos
; /* last input position */
3201 * "regstack" and "backpos" are used by regmatch(). They are kept over calls
3202 * to avoid invoking malloc() and free() often.
3203 * "regstack" is a stack with regitem_T items, sometimes preceded by regstar_T
3205 * "backpos_T" is a table with backpos_T for BACK
3207 static garray_T regstack
= {0, 0, 0, 0, NULL
};
3208 static garray_T backpos
= {0, 0, 0, 0, NULL
};
3211 * Both for regstack and backpos tables we use the following strategy of
3212 * allocation (to reduce malloc/free calls):
3213 * - Initial size is fairly small.
3214 * - When needed, the tables are grown bigger (8 times at first, double after
3216 * - After executing the match we free the memory only if the array has grown.
3217 * Thus the memory is kept allocated when it's at the initial size.
3218 * This makes it fast while not keeping a lot of memory allocated.
3219 * A three times speed increase was observed when using many simple patterns.
3221 #define REGSTACK_INITIAL 2048
3222 #define BACKPOS_INITIAL 64
3224 #if defined(EXITFREE) || defined(PROTO)
3228 ga_clear(®stack
);
3230 vim_free(reg_tofree
);
3231 vim_free(reg_prev_sub
);
3236 * Get pointer to the line "lnum", which is relative to "reg_firstlnum".
3242 /* when looking behind for a match/no-match lnum is negative. But we
3243 * can't go before line 1 */
3244 if (reg_firstlnum
+ lnum
< 1)
3246 if (lnum
> reg_maxline
)
3247 /* Must have matched the "\n" in the last line. */
3248 return (char_u
*)"";
3249 return ml_get_buf(reg_buf
, reg_firstlnum
+ lnum
, FALSE
);
3252 static regsave_T behind_pos
;
3255 static char_u
*reg_startzp
[NSUBEXP
]; /* Workspace to mark beginning */
3256 static char_u
*reg_endzp
[NSUBEXP
]; /* and end of \z(...\) matches */
3257 static lpos_T reg_startzpos
[NSUBEXP
]; /* idem, beginning pos */
3258 static lpos_T reg_endzpos
[NSUBEXP
]; /* idem, end pos */
3261 /* TRUE if using multi-line regexp. */
3262 #define REG_MULTI (reg_match == NULL)
3265 * Match a regexp against a string.
3266 * "rmp->regprog" is a compiled regexp as returned by vim_regcomp().
3267 * Uses curbuf for line count and 'iskeyword'.
3269 * Return TRUE if there is a match, FALSE if not.
3272 vim_regexec(rmp
, line
, col
)
3274 char_u
*line
; /* string to match against */
3275 colnr_T col
; /* column to start looking for match */
3280 reg_line_lbr
= FALSE
;
3282 ireg_ic
= rmp
->rm_ic
;
3284 ireg_icombine
= FALSE
;
3287 return (vim_regexec_both(line
, col
, NULL
) != 0);
3290 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) \
3291 || defined(FIND_REPLACE_DIALOG) || defined(PROTO)
3293 * Like vim_regexec(), but consider a "\n" in "line" to be a line break.
3296 vim_regexec_nl(rmp
, line
, col
)
3298 char_u
*line
; /* string to match against */
3299 colnr_T col
; /* column to start looking for match */
3304 reg_line_lbr
= TRUE
;
3306 ireg_ic
= rmp
->rm_ic
;
3308 ireg_icombine
= FALSE
;
3311 return (vim_regexec_both(line
, col
, NULL
) != 0);
3316 * Match a regexp against multiple lines.
3317 * "rmp->regprog" is a compiled regexp as returned by vim_regcomp().
3318 * Uses curbuf for line count and 'iskeyword'.
3320 * Return zero if there is no match. Return number of lines contained in the
3324 vim_regexec_multi(rmp
, win
, buf
, lnum
, col
, tm
)
3326 win_T
*win
; /* window in which to search or NULL */
3327 buf_T
*buf
; /* buffer in which to search */
3328 linenr_T lnum
; /* nr of line to start looking for match */
3329 colnr_T col
; /* column to start looking for match */
3330 proftime_T
*tm
; /* timeout limit or NULL */
3333 buf_T
*save_curbuf
= curbuf
;
3339 reg_firstlnum
= lnum
;
3340 reg_maxline
= reg_buf
->b_ml
.ml_line_count
- lnum
;
3341 reg_line_lbr
= FALSE
;
3342 ireg_ic
= rmp
->rmm_ic
;
3344 ireg_icombine
= FALSE
;
3346 ireg_maxcol
= rmp
->rmm_maxcol
;
3348 /* Need to switch to buffer "buf" to make vim_iswordc() work. */
3350 r
= vim_regexec_both(NULL
, col
, tm
);
3351 curbuf
= save_curbuf
;
3357 * Match a regexp against a string ("line" points to the string) or multiple
3358 * lines ("line" is NULL, use reg_getline()).
3362 vim_regexec_both(line
, col
, tm
)
3364 colnr_T col
; /* column to start looking for match */
3365 proftime_T
*tm
; /* timeout limit or NULL */
3371 /* Create "regstack" and "backpos" if they are not allocated yet.
3372 * We allocate *_INITIAL amount of bytes first and then set the grow size
3373 * to much bigger value to avoid many malloc calls in case of deep regular
3375 if (regstack
.ga_data
== NULL
)
3377 /* Use an item size of 1 byte, since we push different things
3378 * onto the regstack. */
3379 ga_init2(®stack
, 1, REGSTACK_INITIAL
);
3380 ga_grow(®stack
, REGSTACK_INITIAL
);
3381 regstack
.ga_growsize
= REGSTACK_INITIAL
* 8;
3384 if (backpos
.ga_data
== NULL
)
3386 ga_init2(&backpos
, sizeof(backpos_T
), BACKPOS_INITIAL
);
3387 ga_grow(&backpos
, BACKPOS_INITIAL
);
3388 backpos
.ga_growsize
= BACKPOS_INITIAL
* 8;
3393 prog
= reg_mmatch
->regprog
;
3394 line
= reg_getline((linenr_T
)0);
3395 reg_startpos
= reg_mmatch
->startpos
;
3396 reg_endpos
= reg_mmatch
->endpos
;
3400 prog
= reg_match
->regprog
;
3401 reg_startp
= reg_match
->startp
;
3402 reg_endp
= reg_match
->endp
;
3405 /* Be paranoid... */
3406 if (prog
== NULL
|| line
== NULL
)
3412 /* Check validity of program. */
3413 if (prog_magic_wrong())
3416 /* If the start column is past the maximum column: no need to try. */
3417 if (ireg_maxcol
> 0 && col
>= ireg_maxcol
)
3420 /* If pattern contains "\c" or "\C": overrule value of ireg_ic */
3421 if (prog
->regflags
& RF_ICASE
)
3423 else if (prog
->regflags
& RF_NOICASE
)
3427 /* If pattern contains "\Z" overrule value of ireg_icombine */
3428 if (prog
->regflags
& RF_ICOMBINE
)
3429 ireg_icombine
= TRUE
;
3432 /* If there is a "must appear" string, look for it. */
3433 if (prog
->regmust
!= NULL
)
3439 c
= (*mb_ptr2char
)(prog
->regmust
);
3446 * This is used very often, esp. for ":global". Use three versions of
3447 * the loop to avoid overhead of conditions.
3454 while ((s
= vim_strbyte(s
, c
)) != NULL
)
3456 if (cstrncmp(s
, prog
->regmust
, &prog
->regmlen
) == 0)
3457 break; /* Found it. */
3461 else if (!ireg_ic
|| (!enc_utf8
&& mb_char2len(c
) > 1))
3462 while ((s
= vim_strchr(s
, c
)) != NULL
)
3464 if (cstrncmp(s
, prog
->regmust
, &prog
->regmlen
) == 0)
3465 break; /* Found it. */
3470 while ((s
= cstrchr(s
, c
)) != NULL
)
3472 if (cstrncmp(s
, prog
->regmust
, &prog
->regmlen
) == 0)
3473 break; /* Found it. */
3476 if (s
== NULL
) /* Not present. */
3483 /* Simplest case: Anchored match need be tried only once. */
3490 c
= (*mb_ptr2char
)(regline
+ col
);
3494 if (prog
->regstart
== NUL
3495 || prog
->regstart
== c
3498 (enc_utf8
&& utf_fold(prog
->regstart
) == utf_fold(c
)))
3499 || (c
< 255 && prog
->regstart
< 255 &&
3501 MB_TOLOWER(prog
->regstart
) == MB_TOLOWER(c
)))))
3502 retval
= regtry(prog
, col
);
3511 /* Messy cases: unanchored match. */
3514 if (prog
->regstart
!= NUL
)
3516 /* Skip until the char we know it must start with.
3517 * Used often, do some work to avoid call overhead. */
3523 s
= vim_strbyte(regline
+ col
, prog
->regstart
);
3525 s
= cstrchr(regline
+ col
, prog
->regstart
);
3531 col
= (int)(s
- regline
);
3534 /* Check for maximum column to try. */
3535 if (ireg_maxcol
> 0 && col
>= ireg_maxcol
)
3541 retval
= regtry(prog
, col
);
3545 /* if not currently on the first line, get it again */
3549 regline
= reg_getline((linenr_T
)0);
3551 if (regline
[col
] == NUL
)
3555 col
+= (*mb_ptr2len
)(regline
+ col
);
3560 /* Check for timeout once in a twenty times to avoid overhead. */
3561 if (tm
!= NULL
&& ++tm_count
== 20)
3564 if (profile_passed_limit(tm
))
3572 /* Free "reg_tofree" when it's a bit big.
3573 * Free regstack and backpos if they are bigger than their initial size. */
3574 if (reg_tofreelen
> 400)
3576 vim_free(reg_tofree
);
3579 if (regstack
.ga_maxlen
> REGSTACK_INITIAL
)
3580 ga_clear(®stack
);
3581 if (backpos
.ga_maxlen
> BACKPOS_INITIAL
)
3588 static reg_extmatch_T
*make_extmatch
__ARGS((void));
3591 * Create a new extmatch and mark it as referenced once.
3593 static reg_extmatch_T
*
3598 em
= (reg_extmatch_T
*)alloc_clear((unsigned)sizeof(reg_extmatch_T
));
3605 * Add a reference to an extmatch.
3617 * Remove a reference to an extmatch. If there are no references left, free
3626 if (em
!= NULL
&& --em
->refcnt
<= 0)
3628 for (i
= 0; i
< NSUBEXP
; ++i
)
3629 vim_free(em
->matches
[i
]);
3636 * regtry - try match of "prog" with at regline["col"].
3637 * Returns 0 for failure, number of lines contained in the match otherwise.
3644 reginput
= regline
+ col
;
3645 need_clear_subexpr
= TRUE
;
3647 /* Clear the external match subpointers if necessary. */
3648 if (prog
->reghasz
== REX_SET
)
3649 need_clear_zsubexpr
= TRUE
;
3652 if (regmatch(prog
->program
+ 1) == 0)
3658 if (reg_startpos
[0].lnum
< 0)
3660 reg_startpos
[0].lnum
= 0;
3661 reg_startpos
[0].col
= col
;
3663 if (reg_endpos
[0].lnum
< 0)
3665 reg_endpos
[0].lnum
= reglnum
;
3666 reg_endpos
[0].col
= (int)(reginput
- regline
);
3669 /* Use line number of "\ze". */
3670 reglnum
= reg_endpos
[0].lnum
;
3674 if (reg_startp
[0] == NULL
)
3675 reg_startp
[0] = regline
+ col
;
3676 if (reg_endp
[0] == NULL
)
3677 reg_endp
[0] = reginput
;
3680 /* Package any found \z(...\) matches for export. Default is none. */
3681 unref_extmatch(re_extmatch_out
);
3682 re_extmatch_out
= NULL
;
3684 if (prog
->reghasz
== REX_SET
)
3689 re_extmatch_out
= make_extmatch();
3690 for (i
= 0; i
< NSUBEXP
; i
++)
3694 /* Only accept single line matches. */
3695 if (reg_startzpos
[i
].lnum
>= 0
3696 && reg_endzpos
[i
].lnum
== reg_startzpos
[i
].lnum
)
3697 re_extmatch_out
->matches
[i
] =
3698 vim_strnsave(reg_getline(reg_startzpos
[i
].lnum
)
3699 + reg_startzpos
[i
].col
,
3700 reg_endzpos
[i
].col
- reg_startzpos
[i
].col
);
3704 if (reg_startzp
[i
] != NULL
&& reg_endzp
[i
] != NULL
)
3705 re_extmatch_out
->matches
[i
] =
3706 vim_strnsave(reg_startzp
[i
],
3707 (int)(reg_endzp
[i
] - reg_startzp
[i
]));
3716 static int reg_prev_class
__ARGS((void));
3719 * Get class of previous character.
3724 if (reginput
> regline
)
3725 return mb_get_class(reginput
- 1
3726 - (*mb_head_off
)(regline
, reginput
- 1));
3731 #define ADVANCE_REGINPUT() mb_ptr_adv(reginput)
3734 * The arguments from BRACE_LIMITS are stored here. They are actually local
3735 * to regmatch(), but they are here to reduce the amount of stack space used
3736 * (it can be called recursively many times).
3738 static long bl_minval
;
3739 static long bl_maxval
;
3742 * regmatch - main matching routine
3744 * Conceptually the strategy is simple: Check to see whether the current node
3745 * matches, push an item onto the regstack and loop to see whether the rest
3746 * matches, and then act accordingly. In practice we make some effort to
3747 * avoid using the regstack, in particular by going through "ordinary" nodes
3748 * (that don't need to know whether the rest of the match failed) by a nested
3751 * Returns TRUE when there is a match. Leaves reginput and reglnum just after
3752 * the last matched character.
3753 * Returns FALSE when there is no match. Leaves reginput and reglnum in an
3758 char_u
*scan
; /* Current node. */
3760 char_u
*next
; /* Next node. */
3765 int status
; /* one of the RA_ values: */
3766 #define RA_FAIL 1 /* something failed, abort */
3767 #define RA_CONT 2 /* continue in inner loop */
3768 #define RA_BREAK 3 /* break inner loop */
3769 #define RA_MATCH 4 /* successful match */
3770 #define RA_NOMATCH 5 /* didn't match */
3772 /* Make "regstack" and "backpos" empty. They are allocated and freed in
3773 * vim_regexec_both() to reduce malloc()/free() calls. */
3774 regstack
.ga_len
= 0;
3778 * Repeat until "regstack" is empty.
3782 /* Some patterns my cause a long time to match, even though they are not
3783 * illegal. E.g., "\([a-z]\+\)\+Q". Allow breaking them with CTRL-C. */
3787 if (scan
!= NULL
&& regnarrate
)
3789 mch_errmsg(regprop(scan
));
3795 * Repeat for items that can be matched sequentially, without using the
3800 if (got_int
|| scan
== NULL
)
3810 mch_errmsg(regprop(scan
));
3811 mch_errmsg("...\n");
3813 if (re_extmatch_in
!= NULL
)
3817 mch_errmsg(_("External submatches:\n"));
3818 for (i
= 0; i
< NSUBEXP
; i
++)
3821 if (re_extmatch_in
->matches
[i
] != NULL
)
3822 mch_errmsg(re_extmatch_in
->matches
[i
]);
3829 next
= regnext(scan
);
3832 /* Check for character class with NL added. */
3833 if (!reg_line_lbr
&& WITH_NL(op
) && REG_MULTI
3834 && *reginput
== NUL
&& reglnum
<= reg_maxline
)
3838 else if (reg_line_lbr
&& WITH_NL(op
) && *reginput
== '\n')
3848 c
= (*mb_ptr2char
)(reginput
);
3855 if (reginput
!= regline
)
3856 status
= RA_NOMATCH
;
3861 status
= RA_NOMATCH
;
3865 /* We're not at the beginning of the file when below the first
3866 * line where we started, not at the start of the line or we
3867 * didn't start at the first line of the buffer. */
3868 if (reglnum
!= 0 || reginput
!= regline
3869 || (REG_MULTI
&& reg_firstlnum
> 1))
3870 status
= RA_NOMATCH
;
3874 if (reglnum
!= reg_maxline
|| c
!= NUL
)
3875 status
= RA_NOMATCH
;
3879 /* Check if the buffer is in a window and compare the
3880 * reg_win->w_cursor position to the match position. */
3882 || (reglnum
+ reg_firstlnum
!= reg_win
->w_cursor
.lnum
)
3883 || ((colnr_T
)(reginput
- regline
) != reg_win
->w_cursor
.col
))
3884 status
= RA_NOMATCH
;
3888 /* Compare the mark position to the match position. NOTE: Always
3889 * uses the current buffer. */
3891 int mark
= OPERAND(scan
)[0];
3892 int cmp
= OPERAND(scan
)[1];
3895 pos
= getmark(mark
, FALSE
);
3896 if (pos
== NULL
/* mark doesn't exist */
3897 || pos
->lnum
<= 0 /* mark isn't set (in curbuf) */
3898 || (pos
->lnum
== reglnum
+ reg_firstlnum
3899 ? (pos
->col
== (colnr_T
)(reginput
- regline
)
3900 ? (cmp
== '<' || cmp
== '>')
3901 : (pos
->col
< (colnr_T
)(reginput
- regline
)
3904 : (pos
->lnum
< reglnum
+ reg_firstlnum
3907 status
= RA_NOMATCH
;
3913 /* Check if the buffer is the current buffer. and whether the
3914 * position is inside the Visual area. */
3915 if (reg_buf
!= curbuf
|| VIsual
.lnum
== 0)
3916 status
= RA_NOMATCH
;
3922 win_T
*wp
= reg_win
== NULL
? curwin
: reg_win
;
3927 if (lt(VIsual
, wp
->w_cursor
))
3941 if (lt(curbuf
->b_visual
.vi_start
, curbuf
->b_visual
.vi_end
))
3943 top
= curbuf
->b_visual
.vi_start
;
3944 bot
= curbuf
->b_visual
.vi_end
;
3948 top
= curbuf
->b_visual
.vi_end
;
3949 bot
= curbuf
->b_visual
.vi_start
;
3951 mode
= curbuf
->b_visual
.vi_mode
;
3953 lnum
= reglnum
+ reg_firstlnum
;
3954 col
= (colnr_T
)(reginput
- regline
);
3955 if (lnum
< top
.lnum
|| lnum
> bot
.lnum
)
3956 status
= RA_NOMATCH
;
3957 else if (mode
== 'v')
3959 if ((lnum
== top
.lnum
&& col
< top
.col
)
3960 || (lnum
== bot
.lnum
3961 && col
>= bot
.col
+ (*p_sel
!= 'e')))
3962 status
= RA_NOMATCH
;
3964 else if (mode
== Ctrl_V
)
3967 colnr_T start2
, end2
;
3970 getvvcol(wp
, &top
, &start
, NULL
, &end
);
3971 getvvcol(wp
, &bot
, &start2
, NULL
, &end2
);
3976 if (top
.col
== MAXCOL
|| bot
.col
== MAXCOL
)
3978 cols
= win_linetabsize(wp
,
3979 regline
, (colnr_T
)(reginput
- regline
));
3980 if (cols
< start
|| cols
> end
- (*p_sel
== 'e'))
3981 status
= RA_NOMATCH
;
3985 status
= RA_NOMATCH
;
3990 if (!REG_MULTI
|| !re_num_cmp((long_u
)(reglnum
+ reg_firstlnum
),
3992 status
= RA_NOMATCH
;
3996 if (!re_num_cmp((long_u
)(reginput
- regline
) + 1, scan
))
3997 status
= RA_NOMATCH
;
4001 if (!re_num_cmp((long_u
)win_linetabsize(
4002 reg_win
== NULL
? curwin
: reg_win
,
4003 regline
, (colnr_T
)(reginput
- regline
)) + 1, scan
))
4004 status
= RA_NOMATCH
;
4007 case BOW
: /* \<word; reginput points to w */
4008 if (c
== NUL
) /* Can't match at end of line */
4009 status
= RA_NOMATCH
;
4015 /* Get class of current and previous char (if it exists). */
4016 this_class
= mb_get_class(reginput
);
4017 if (this_class
<= 1)
4018 status
= RA_NOMATCH
; /* not on a word at all */
4019 else if (reg_prev_class() == this_class
)
4020 status
= RA_NOMATCH
; /* previous char is in same word */
4026 || (reginput
> regline
&& vim_iswordc(reginput
[-1])))
4027 status
= RA_NOMATCH
;
4031 case EOW
: /* word\>; reginput points after d */
4032 if (reginput
== regline
) /* Can't match at start of line */
4033 status
= RA_NOMATCH
;
4037 int this_class
, prev_class
;
4039 /* Get class of current and previous char (if it exists). */
4040 this_class
= mb_get_class(reginput
);
4041 prev_class
= reg_prev_class();
4042 if (this_class
== prev_class
4043 || prev_class
== 0 || prev_class
== 1)
4044 status
= RA_NOMATCH
;
4049 if (!vim_iswordc(reginput
[-1])
4050 || (reginput
[0] != NUL
&& vim_iswordc(c
)))
4051 status
= RA_NOMATCH
;
4053 break; /* Matched with EOW */
4057 status
= RA_NOMATCH
;
4064 status
= RA_NOMATCH
;
4070 if (VIM_ISDIGIT(*reginput
) || !vim_isIDc(c
))
4071 status
= RA_NOMATCH
;
4077 if (!vim_iswordp(reginput
))
4078 status
= RA_NOMATCH
;
4084 if (VIM_ISDIGIT(*reginput
) || !vim_iswordp(reginput
))
4085 status
= RA_NOMATCH
;
4091 if (!vim_isfilec(c
))
4092 status
= RA_NOMATCH
;
4098 if (VIM_ISDIGIT(*reginput
) || !vim_isfilec(c
))
4099 status
= RA_NOMATCH
;
4105 if (ptr2cells(reginput
) != 1)
4106 status
= RA_NOMATCH
;
4112 if (VIM_ISDIGIT(*reginput
) || ptr2cells(reginput
) != 1)
4113 status
= RA_NOMATCH
;
4119 if (!vim_iswhite(c
))
4120 status
= RA_NOMATCH
;
4126 if (c
== NUL
|| vim_iswhite(c
))
4127 status
= RA_NOMATCH
;
4134 status
= RA_NOMATCH
;
4140 if (c
== NUL
|| ri_digit(c
))
4141 status
= RA_NOMATCH
;
4148 status
= RA_NOMATCH
;
4154 if (c
== NUL
|| ri_hex(c
))
4155 status
= RA_NOMATCH
;
4162 status
= RA_NOMATCH
;
4168 if (c
== NUL
|| ri_octal(c
))
4169 status
= RA_NOMATCH
;
4176 status
= RA_NOMATCH
;
4182 if (c
== NUL
|| ri_word(c
))
4183 status
= RA_NOMATCH
;
4190 status
= RA_NOMATCH
;
4196 if (c
== NUL
|| ri_head(c
))
4197 status
= RA_NOMATCH
;
4204 status
= RA_NOMATCH
;
4210 if (c
== NUL
|| ri_alpha(c
))
4211 status
= RA_NOMATCH
;
4218 status
= RA_NOMATCH
;
4224 if (c
== NUL
|| ri_lower(c
))
4225 status
= RA_NOMATCH
;
4232 status
= RA_NOMATCH
;
4238 if (c
== NUL
|| ri_upper(c
))
4239 status
= RA_NOMATCH
;
4249 opnd
= OPERAND(scan
);
4250 /* Inline the first byte, for speed. */
4251 if (*opnd
!= *reginput
4256 MB_TOLOWER(*opnd
) != MB_TOLOWER(*reginput
))))
4257 status
= RA_NOMATCH
;
4258 else if (*opnd
== NUL
)
4260 /* match empty string always works; happens when "~" is
4263 else if (opnd
[1] == NUL
4265 && !(enc_utf8
&& ireg_ic
)
4268 ++reginput
; /* matched a single char */
4271 len
= (int)STRLEN(opnd
);
4272 /* Need to match first byte again for multi-byte. */
4273 if (cstrncmp(opnd
, reginput
, &len
) != 0)
4274 status
= RA_NOMATCH
;
4276 /* Check for following composing character. */
4278 && UTF_COMPOSINGLIKE(reginput
, reginput
+ len
))
4280 /* raaron: This code makes a composing character get
4281 * ignored, which is the correct behavior (sometimes)
4282 * for voweled Hebrew texts. */
4284 status
= RA_NOMATCH
;
4296 status
= RA_NOMATCH
;
4297 else if ((cstrchr(OPERAND(scan
), c
) == NULL
) == (op
== ANYOF
))
4298 status
= RA_NOMATCH
;
4309 int opndc
= 0, inpc
;
4311 opnd
= OPERAND(scan
);
4312 /* Safety check (just in case 'encoding' was changed since
4313 * compiling the program). */
4314 if ((len
= (*mb_ptr2len
)(opnd
)) < 2)
4316 status
= RA_NOMATCH
;
4320 opndc
= mb_ptr2char(opnd
);
4321 if (enc_utf8
&& utf_iscomposing(opndc
))
4323 /* When only a composing char is given match at any
4324 * position where that composing char appears. */
4325 status
= RA_NOMATCH
;
4326 for (i
= 0; reginput
[i
] != NUL
; i
+= utf_char2len(inpc
))
4328 inpc
= mb_ptr2char(reginput
+ i
);
4329 if (!utf_iscomposing(inpc
))
4334 else if (opndc
== inpc
)
4336 /* Include all following composing chars. */
4337 len
= i
+ mb_ptr2len(reginput
+ i
);
4344 for (i
= 0; i
< len
; ++i
)
4345 if (opnd
[i
] != reginput
[i
])
4347 status
= RA_NOMATCH
;
4353 status
= RA_NOMATCH
;
4366 * When we run into BACK we need to check if we don't keep
4367 * looping without matching any input. The second and later
4368 * times a BACK is encountered it fails if the input is still
4369 * at the same position as the previous time.
4370 * The positions are stored in "backpos" and found by the
4371 * current value of "scan", the position in the RE program.
4373 bp
= (backpos_T
*)backpos
.ga_data
;
4374 for (i
= 0; i
< backpos
.ga_len
; ++i
)
4375 if (bp
[i
].bp_scan
== scan
)
4377 if (i
== backpos
.ga_len
)
4379 /* First time at this BACK, make room to store the pos. */
4380 if (ga_grow(&backpos
, 1) == FAIL
)
4384 /* get "ga_data" again, it may have changed */
4385 bp
= (backpos_T
*)backpos
.ga_data
;
4386 bp
[i
].bp_scan
= scan
;
4390 else if (reg_save_equal(&bp
[i
].bp_pos
))
4391 /* Still at same position as last time, fail. */
4392 status
= RA_NOMATCH
;
4394 if (status
!= RA_FAIL
&& status
!= RA_NOMATCH
)
4395 reg_save(&bp
[i
].bp_pos
, &backpos
);
4399 case MOPEN
+ 0: /* Match start: \zs */
4400 case MOPEN
+ 1: /* \( */
4412 rp
= regstack_push(RS_MOPEN
, scan
);
4418 save_se(&rp
->rs_un
.sesave
, ®_startpos
[no
],
4420 /* We simply continue and handle the result when done. */
4425 case NOPEN
: /* \%( */
4426 case NCLOSE
: /* \) after \%( */
4427 if (regstack_push(RS_NOPEN
, scan
) == NULL
)
4429 /* We simply continue and handle the result when done. */
4445 rp
= regstack_push(RS_ZOPEN
, scan
);
4451 save_se(&rp
->rs_un
.sesave
, ®_startzpos
[no
],
4453 /* We simply continue and handle the result when done. */
4459 case MCLOSE
+ 0: /* Match end: \ze */
4460 case MCLOSE
+ 1: /* \) */
4472 rp
= regstack_push(RS_MCLOSE
, scan
);
4478 save_se(&rp
->rs_un
.sesave
, ®_endpos
[no
], ®_endp
[no
]);
4479 /* We simply continue and handle the result when done. */
4485 case ZCLOSE
+ 1: /* \) after \z( */
4497 rp
= regstack_push(RS_ZCLOSE
, scan
);
4503 save_se(&rp
->rs_un
.sesave
, ®_endzpos
[no
],
4505 /* We simply continue and handle the result when done. */
4528 if (!REG_MULTI
) /* Single-line regexp */
4530 if (reg_endp
[no
] == NULL
)
4532 /* Backref was not set: Match an empty string. */
4537 /* Compare current input with back-ref in the same
4539 len
= (int)(reg_endp
[no
] - reg_startp
[no
]);
4540 if (cstrncmp(reg_startp
[no
], reginput
, &len
) != 0)
4541 status
= RA_NOMATCH
;
4544 else /* Multi-line regexp */
4546 if (reg_endpos
[no
].lnum
< 0)
4548 /* Backref was not set: Match an empty string. */
4553 if (reg_startpos
[no
].lnum
== reglnum
4554 && reg_endpos
[no
].lnum
== reglnum
)
4556 /* Compare back-ref within the current line. */
4557 len
= reg_endpos
[no
].col
- reg_startpos
[no
].col
;
4558 if (cstrncmp(regline
+ reg_startpos
[no
].col
,
4559 reginput
, &len
) != 0)
4560 status
= RA_NOMATCH
;
4564 /* Messy situation: Need to compare between two
4566 ccol
= reg_startpos
[no
].col
;
4567 clnum
= reg_startpos
[no
].lnum
;
4570 /* Since getting one line may invalidate
4571 * the other, need to make copy. Slow! */
4572 if (regline
!= reg_tofree
)
4574 len
= (int)STRLEN(regline
);
4575 if (reg_tofree
== NULL
4576 || len
>= (int)reg_tofreelen
)
4578 len
+= 50; /* get some extra */
4579 vim_free(reg_tofree
);
4580 reg_tofree
= alloc(len
);
4581 if (reg_tofree
== NULL
)
4583 status
= RA_FAIL
; /* outof memory!*/
4586 reg_tofreelen
= len
;
4588 STRCPY(reg_tofree
, regline
);
4589 reginput
= reg_tofree
4590 + (reginput
- regline
);
4591 regline
= reg_tofree
;
4594 /* Get the line to compare with. */
4595 p
= reg_getline(clnum
);
4596 if (clnum
== reg_endpos
[no
].lnum
)
4597 len
= reg_endpos
[no
].col
- ccol
;
4599 len
= (int)STRLEN(p
+ ccol
);
4601 if (cstrncmp(p
+ ccol
, reginput
, &len
) != 0)
4603 status
= RA_NOMATCH
; /* doesn't match */
4606 if (clnum
== reg_endpos
[no
].lnum
)
4607 break; /* match and at end! */
4608 if (reglnum
>= reg_maxline
)
4610 status
= RA_NOMATCH
; /* text too short */
4614 /* Advance to next line. */
4625 /* found a match! Note that regline may now point
4626 * to a copy of the line, that should not matter. */
4631 /* Matched the backref, skip over it. */
4651 if (re_extmatch_in
!= NULL
4652 && re_extmatch_in
->matches
[no
] != NULL
)
4654 len
= (int)STRLEN(re_extmatch_in
->matches
[no
]);
4655 if (cstrncmp(re_extmatch_in
->matches
[no
],
4656 reginput
, &len
) != 0)
4657 status
= RA_NOMATCH
;
4663 /* Backref was not set: Match an empty string. */
4671 if (OP(next
) != BRANCH
) /* No choice. */
4672 next
= OPERAND(scan
); /* Avoid recursion. */
4675 rp
= regstack_push(RS_BRANCH
, scan
);
4679 status
= RA_BREAK
; /* rest is below */
4686 if (OP(next
) == BRACE_SIMPLE
)
4688 bl_minval
= OPERAND_MIN(scan
);
4689 bl_maxval
= OPERAND_MAX(scan
);
4691 else if (OP(next
) >= BRACE_COMPLEX
4692 && OP(next
) < BRACE_COMPLEX
+ 10)
4694 no
= OP(next
) - BRACE_COMPLEX
;
4695 brace_min
[no
] = OPERAND_MIN(scan
);
4696 brace_max
[no
] = OPERAND_MAX(scan
);
4697 brace_count
[no
] = 0;
4701 EMSG(_(e_internal
)); /* Shouldn't happen */
4707 case BRACE_COMPLEX
+ 0:
4708 case BRACE_COMPLEX
+ 1:
4709 case BRACE_COMPLEX
+ 2:
4710 case BRACE_COMPLEX
+ 3:
4711 case BRACE_COMPLEX
+ 4:
4712 case BRACE_COMPLEX
+ 5:
4713 case BRACE_COMPLEX
+ 6:
4714 case BRACE_COMPLEX
+ 7:
4715 case BRACE_COMPLEX
+ 8:
4716 case BRACE_COMPLEX
+ 9:
4718 no
= op
- BRACE_COMPLEX
;
4721 /* If not matched enough times yet, try one more */
4722 if (brace_count
[no
] <= (brace_min
[no
] <= brace_max
[no
]
4723 ? brace_min
[no
] : brace_max
[no
]))
4725 rp
= regstack_push(RS_BRCPLX_MORE
, scan
);
4731 reg_save(&rp
->rs_un
.regsave
, &backpos
);
4732 next
= OPERAND(scan
);
4733 /* We continue and handle the result when done. */
4738 /* If matched enough times, may try matching some more */
4739 if (brace_min
[no
] <= brace_max
[no
])
4741 /* Range is the normal way around, use longest match */
4742 if (brace_count
[no
] <= brace_max
[no
])
4744 rp
= regstack_push(RS_BRCPLX_LONG
, scan
);
4750 reg_save(&rp
->rs_un
.regsave
, &backpos
);
4751 next
= OPERAND(scan
);
4752 /* We continue and handle the result when done. */
4758 /* Range is backwards, use shortest match first */
4759 if (brace_count
[no
] <= brace_min
[no
])
4761 rp
= regstack_push(RS_BRCPLX_SHORT
, scan
);
4766 reg_save(&rp
->rs_un
.regsave
, &backpos
);
4767 /* We continue and handle the result when done. */
4781 * Lookahead to avoid useless match attempts when we know
4782 * what character comes next.
4784 if (OP(next
) == EXACTLY
)
4786 rst
.nextb
= *OPERAND(next
);
4789 if (MB_ISUPPER(rst
.nextb
))
4790 rst
.nextb_ic
= MB_TOLOWER(rst
.nextb
);
4792 rst
.nextb_ic
= MB_TOUPPER(rst
.nextb
);
4795 rst
.nextb_ic
= rst
.nextb
;
4802 if (op
!= BRACE_SIMPLE
)
4804 rst
.minval
= (op
== STAR
) ? 0 : 1;
4805 rst
.maxval
= MAX_LIMIT
;
4809 rst
.minval
= bl_minval
;
4810 rst
.maxval
= bl_maxval
;
4814 * When maxval > minval, try matching as much as possible, up
4815 * to maxval. When maxval < minval, try matching at least the
4816 * minimal number (since the range is backwards, that's also
4819 rst
.count
= regrepeat(OPERAND(scan
), rst
.maxval
);
4825 if (rst
.minval
<= rst
.maxval
4826 ? rst
.count
>= rst
.minval
: rst
.count
>= rst
.maxval
)
4828 /* It could match. Prepare for trying to match what
4829 * follows. The code is below. Parameters are stored in
4830 * a regstar_T on the regstack. */
4831 if ((long)((unsigned)regstack
.ga_len
>> 10) >= p_mmp
)
4833 EMSG(_(e_maxmempat
));
4836 else if (ga_grow(®stack
, sizeof(regstar_T
)) == FAIL
)
4840 regstack
.ga_len
+= sizeof(regstar_T
);
4841 rp
= regstack_push(rst
.minval
<= rst
.maxval
4842 ? RS_STAR_LONG
: RS_STAR_SHORT
, scan
);
4847 *(((regstar_T
*)rp
) - 1) = rst
;
4848 status
= RA_BREAK
; /* skip the restore bits */
4853 status
= RA_NOMATCH
;
4861 rp
= regstack_push(RS_NOMATCH
, scan
);
4867 reg_save(&rp
->rs_un
.regsave
, &backpos
);
4868 next
= OPERAND(scan
);
4869 /* We continue and handle the result when done. */
4875 /* Need a bit of room to store extra positions. */
4876 if ((long)((unsigned)regstack
.ga_len
>> 10) >= p_mmp
)
4878 EMSG(_(e_maxmempat
));
4881 else if (ga_grow(®stack
, sizeof(regbehind_T
)) == FAIL
)
4885 regstack
.ga_len
+= sizeof(regbehind_T
);
4886 rp
= regstack_push(RS_BEHIND1
, scan
);
4892 reg_save(&rp
->rs_un
.regsave
, &backpos
);
4893 /* First try if what follows matches. If it does then we
4894 * check the behind match by looping. */
4902 if (behind_pos
.rs_u
.pos
.col
!= (colnr_T
)(reginput
- regline
)
4903 || behind_pos
.rs_u
.pos
.lnum
!= reglnum
)
4904 status
= RA_NOMATCH
;
4906 else if (behind_pos
.rs_u
.ptr
!= reginput
)
4907 status
= RA_NOMATCH
;
4911 if ((c
!= NUL
|| !REG_MULTI
|| reglnum
> reg_maxline
4912 || reg_line_lbr
) && (c
!= '\n' || !reg_line_lbr
))
4913 status
= RA_NOMATCH
;
4914 else if (reg_line_lbr
)
4921 status
= RA_MATCH
; /* Success! */
4927 printf("Illegal op code %d\n", op
);
4934 /* If we can't continue sequentially, break the inner loop. */
4935 if (status
!= RA_CONT
)
4938 /* Continue in inner loop, advance to next item. */
4941 } /* end of inner loop */
4944 * If there is something on the regstack execute the code for the state.
4945 * If the state is popped then loop and use the older state.
4947 while (regstack
.ga_len
> 0 && status
!= RA_FAIL
)
4949 rp
= (regitem_T
*)((char *)regstack
.ga_data
+ regstack
.ga_len
) - 1;
4950 switch (rp
->rs_state
)
4953 /* Result is passed on as-is, simply pop the state. */
4954 regstack_pop(&scan
);
4958 /* Pop the state. Restore pointers when there is no match. */
4959 if (status
== RA_NOMATCH
)
4960 restore_se(&rp
->rs_un
.sesave
, ®_startpos
[rp
->rs_no
],
4961 ®_startp
[rp
->rs_no
]);
4962 regstack_pop(&scan
);
4967 /* Pop the state. Restore pointers when there is no match. */
4968 if (status
== RA_NOMATCH
)
4969 restore_se(&rp
->rs_un
.sesave
, ®_startzpos
[rp
->rs_no
],
4970 ®_startzp
[rp
->rs_no
]);
4971 regstack_pop(&scan
);
4976 /* Pop the state. Restore pointers when there is no match. */
4977 if (status
== RA_NOMATCH
)
4978 restore_se(&rp
->rs_un
.sesave
, ®_endpos
[rp
->rs_no
],
4979 ®_endp
[rp
->rs_no
]);
4980 regstack_pop(&scan
);
4985 /* Pop the state. Restore pointers when there is no match. */
4986 if (status
== RA_NOMATCH
)
4987 restore_se(&rp
->rs_un
.sesave
, ®_endzpos
[rp
->rs_no
],
4988 ®_endzp
[rp
->rs_no
]);
4989 regstack_pop(&scan
);
4994 if (status
== RA_MATCH
)
4995 /* this branch matched, use it */
4996 regstack_pop(&scan
);
4999 if (status
!= RA_BREAK
)
5001 /* After a non-matching branch: try next one. */
5002 reg_restore(&rp
->rs_un
.regsave
, &backpos
);
5005 if (scan
== NULL
|| OP(scan
) != BRANCH
)
5007 /* no more branches, didn't find a match */
5008 status
= RA_NOMATCH
;
5009 regstack_pop(&scan
);
5013 /* Prepare to try a branch. */
5014 rp
->rs_scan
= regnext(scan
);
5015 reg_save(&rp
->rs_un
.regsave
, &backpos
);
5016 scan
= OPERAND(scan
);
5021 case RS_BRCPLX_MORE
:
5022 /* Pop the state. Restore pointers when there is no match. */
5023 if (status
== RA_NOMATCH
)
5025 reg_restore(&rp
->rs_un
.regsave
, &backpos
);
5026 --brace_count
[rp
->rs_no
]; /* decrement match count */
5028 regstack_pop(&scan
);
5031 case RS_BRCPLX_LONG
:
5032 /* Pop the state. Restore pointers when there is no match. */
5033 if (status
== RA_NOMATCH
)
5035 /* There was no match, but we did find enough matches. */
5036 reg_restore(&rp
->rs_un
.regsave
, &backpos
);
5037 --brace_count
[rp
->rs_no
];
5038 /* continue with the items after "\{}" */
5041 regstack_pop(&scan
);
5042 if (status
== RA_CONT
)
5043 scan
= regnext(scan
);
5046 case RS_BRCPLX_SHORT
:
5047 /* Pop the state. Restore pointers when there is no match. */
5048 if (status
== RA_NOMATCH
)
5049 /* There was no match, try to match one more item. */
5050 reg_restore(&rp
->rs_un
.regsave
, &backpos
);
5051 regstack_pop(&scan
);
5052 if (status
== RA_NOMATCH
)
5054 scan
= OPERAND(scan
);
5060 /* Pop the state. If the operand matches for NOMATCH or
5061 * doesn't match for MATCH/SUBPAT, we fail. Otherwise backup,
5062 * except for SUBPAT, and continue with the next item. */
5063 if (status
== (rp
->rs_no
== NOMATCH
? RA_MATCH
: RA_NOMATCH
))
5064 status
= RA_NOMATCH
;
5068 if (rp
->rs_no
!= SUBPAT
) /* zero-width */
5069 reg_restore(&rp
->rs_un
.regsave
, &backpos
);
5071 regstack_pop(&scan
);
5072 if (status
== RA_CONT
)
5073 scan
= regnext(scan
);
5077 if (status
== RA_NOMATCH
)
5079 regstack_pop(&scan
);
5080 regstack
.ga_len
-= sizeof(regbehind_T
);
5084 /* The stuff after BEHIND/NOBEHIND matches. Now try if
5085 * the behind part does (not) match before the current
5086 * position in the input. This must be done at every
5087 * position in the input and checking if the match ends at
5088 * the current position. */
5090 /* save the position after the found match for next */
5091 reg_save(&(((regbehind_T
*)rp
) - 1)->save_after
, &backpos
);
5093 /* start looking for a match with operand at the current
5094 * position. Go back one character until we find the
5095 * result, hitting the start of the line or the previous
5096 * line (for multi-line matching).
5097 * Set behind_pos to where the match should end, BHPOS
5098 * will match it. Save the current value. */
5099 (((regbehind_T
*)rp
) - 1)->save_behind
= behind_pos
;
5100 behind_pos
= rp
->rs_un
.regsave
;
5102 rp
->rs_state
= RS_BEHIND2
;
5104 reg_restore(&rp
->rs_un
.regsave
, &backpos
);
5105 scan
= OPERAND(rp
->rs_scan
);
5111 * Looping for BEHIND / NOBEHIND match.
5113 if (status
== RA_MATCH
&& reg_save_equal(&behind_pos
))
5115 /* found a match that ends where "next" started */
5116 behind_pos
= (((regbehind_T
*)rp
) - 1)->save_behind
;
5117 if (rp
->rs_no
== BEHIND
)
5118 reg_restore(&(((regbehind_T
*)rp
) - 1)->save_after
,
5121 /* But we didn't want a match. */
5122 status
= RA_NOMATCH
;
5123 regstack_pop(&scan
);
5124 regstack
.ga_len
-= sizeof(regbehind_T
);
5128 /* No match: Go back one character. May go to previous
5133 if (rp
->rs_un
.regsave
.rs_u
.pos
.col
== 0)
5135 if (rp
->rs_un
.regsave
.rs_u
.pos
.lnum
5136 < behind_pos
.rs_u
.pos
.lnum
5138 --rp
->rs_un
.regsave
.rs_u
.pos
.lnum
)
5143 reg_restore(&rp
->rs_un
.regsave
, &backpos
);
5144 rp
->rs_un
.regsave
.rs_u
.pos
.col
=
5145 (colnr_T
)STRLEN(regline
);
5149 --rp
->rs_un
.regsave
.rs_u
.pos
.col
;
5153 if (rp
->rs_un
.regsave
.rs_u
.ptr
== regline
)
5156 --rp
->rs_un
.regsave
.rs_u
.ptr
;
5160 /* Advanced, prepare for finding match again. */
5161 reg_restore(&rp
->rs_un
.regsave
, &backpos
);
5162 scan
= OPERAND(rp
->rs_scan
);
5166 /* Can't advance. For NOBEHIND that's a match. */
5167 behind_pos
= (((regbehind_T
*)rp
) - 1)->save_behind
;
5168 if (rp
->rs_no
== NOBEHIND
)
5170 reg_restore(&(((regbehind_T
*)rp
) - 1)->save_after
,
5175 status
= RA_NOMATCH
;
5176 regstack_pop(&scan
);
5177 regstack
.ga_len
-= sizeof(regbehind_T
);
5185 regstar_T
*rst
= ((regstar_T
*)rp
) - 1;
5187 if (status
== RA_MATCH
)
5189 regstack_pop(&scan
);
5190 regstack
.ga_len
-= sizeof(regstar_T
);
5194 /* Tried once already, restore input pointers. */
5195 if (status
!= RA_BREAK
)
5196 reg_restore(&rp
->rs_un
.regsave
, &backpos
);
5198 /* Repeat until we found a position where it could match. */
5201 if (status
!= RA_BREAK
)
5203 /* Tried first position already, advance. */
5204 if (rp
->rs_state
== RS_STAR_LONG
)
5206 /* Trying for longest match, but couldn't or
5207 * didn't match -- back up one char. */
5208 if (--rst
->count
< rst
->minval
)
5210 if (reginput
== regline
)
5212 /* backup to last char of previous line */
5214 regline
= reg_getline(reglnum
);
5215 /* Just in case regrepeat() didn't count
5217 if (regline
== NULL
)
5219 reginput
= regline
+ STRLEN(regline
);
5223 mb_ptr_back(regline
, reginput
);
5227 /* Range is backwards, use shortest match first.
5228 * Careful: maxval and minval are exchanged!
5229 * Couldn't or didn't match: try advancing one
5231 if (rst
->count
== rst
->minval
5232 || regrepeat(OPERAND(rp
->rs_scan
), 1L) == 0)
5240 status
= RA_NOMATCH
;
5242 /* If it could match, try it. */
5243 if (rst
->nextb
== NUL
|| *reginput
== rst
->nextb
5244 || *reginput
== rst
->nextb_ic
)
5246 reg_save(&rp
->rs_un
.regsave
, &backpos
);
5247 scan
= regnext(rp
->rs_scan
);
5252 if (status
!= RA_CONT
)
5255 regstack_pop(&scan
);
5256 regstack
.ga_len
-= sizeof(regstar_T
);
5257 status
= RA_NOMATCH
;
5263 /* If we want to continue the inner loop or didn't pop a state
5264 * continue matching loop */
5265 if (status
== RA_CONT
|| rp
== (regitem_T
*)
5266 ((char *)regstack
.ga_data
+ regstack
.ga_len
) - 1)
5270 /* May need to continue with the inner loop, starting at "scan". */
5271 if (status
== RA_CONT
)
5275 * If the regstack is empty or something failed we are done.
5277 if (regstack
.ga_len
== 0 || status
== RA_FAIL
)
5282 * We get here only if there's trouble -- normally "case END" is
5283 * the terminating point.
5287 printf("Premature EOL\n");
5290 if (status
== RA_FAIL
)
5292 return (status
== RA_MATCH
);
5295 } /* End of loop until the regstack is empty. */
5301 * Push an item onto the regstack.
5302 * Returns pointer to new item. Returns NULL when out of memory.
5305 regstack_push(state
, scan
)
5311 if ((long)((unsigned)regstack
.ga_len
>> 10) >= p_mmp
)
5313 EMSG(_(e_maxmempat
));
5316 if (ga_grow(®stack
, sizeof(regitem_T
)) == FAIL
)
5319 rp
= (regitem_T
*)((char *)regstack
.ga_data
+ regstack
.ga_len
);
5320 rp
->rs_state
= state
;
5323 regstack
.ga_len
+= sizeof(regitem_T
);
5328 * Pop an item from the regstack.
5336 rp
= (regitem_T
*)((char *)regstack
.ga_data
+ regstack
.ga_len
) - 1;
5337 *scan
= rp
->rs_scan
;
5339 regstack
.ga_len
-= sizeof(regitem_T
);
5343 * regrepeat - repeatedly match something simple, return how many.
5344 * Advances reginput (and reglnum) to just after the matched chars.
5347 regrepeat(p
, maxcount
)
5349 long maxcount
; /* maximum number of matches allowed */
5357 scan
= reginput
; /* Make local copy of reginput for speed. */
5363 while (count
< maxcount
)
5365 /* Matching anything means we continue until end-of-line (or
5366 * end-of-file for ANY + ADD_NL), only limited by maxcount. */
5367 while (*scan
!= NUL
&& count
< maxcount
)
5372 if (!REG_MULTI
|| !WITH_NL(OP(p
)) || reglnum
> reg_maxline
5373 || reg_line_lbr
|| count
== maxcount
)
5375 ++count
; /* count the line-break */
5384 case IDENT
+ ADD_NL
:
5388 case SIDENT
+ ADD_NL
:
5389 while (count
< maxcount
)
5391 if (vim_isIDc(*scan
) && (testval
|| !VIM_ISDIGIT(*scan
)))
5395 else if (*scan
== NUL
)
5397 if (!REG_MULTI
|| !WITH_NL(OP(p
)) || reglnum
> reg_maxline
5405 else if (reg_line_lbr
&& *scan
== '\n' && WITH_NL(OP(p
)))
5414 case KWORD
+ ADD_NL
:
5418 case SKWORD
+ ADD_NL
:
5419 while (count
< maxcount
)
5421 if (vim_iswordp(scan
) && (testval
|| !VIM_ISDIGIT(*scan
)))
5425 else if (*scan
== NUL
)
5427 if (!REG_MULTI
|| !WITH_NL(OP(p
)) || reglnum
> reg_maxline
5435 else if (reg_line_lbr
&& *scan
== '\n' && WITH_NL(OP(p
)))
5444 case FNAME
+ ADD_NL
:
5448 case SFNAME
+ ADD_NL
:
5449 while (count
< maxcount
)
5451 if (vim_isfilec(*scan
) && (testval
|| !VIM_ISDIGIT(*scan
)))
5455 else if (*scan
== NUL
)
5457 if (!REG_MULTI
|| !WITH_NL(OP(p
)) || reglnum
> reg_maxline
5465 else if (reg_line_lbr
&& *scan
== '\n' && WITH_NL(OP(p
)))
5474 case PRINT
+ ADD_NL
:
5478 case SPRINT
+ ADD_NL
:
5479 while (count
< maxcount
)
5483 if (!REG_MULTI
|| !WITH_NL(OP(p
)) || reglnum
> reg_maxline
5491 else if (ptr2cells(scan
) == 1 && (testval
|| !VIM_ISDIGIT(*scan
)))
5495 else if (reg_line_lbr
&& *scan
== '\n' && WITH_NL(OP(p
)))
5504 case WHITE
+ ADD_NL
:
5505 testval
= mask
= RI_WHITE
;
5507 while (count
< maxcount
)
5514 if (!REG_MULTI
|| !WITH_NL(OP(p
)) || reglnum
> reg_maxline
5523 else if (has_mbyte
&& (l
= (*mb_ptr2len
)(scan
)) > 1)
5530 else if ((class_tab
[*scan
] & mask
) == testval
)
5532 else if (reg_line_lbr
&& *scan
== '\n' && WITH_NL(OP(p
)))
5541 case NWHITE
+ ADD_NL
:
5545 case DIGIT
+ ADD_NL
:
5546 testval
= mask
= RI_DIGIT
;
5549 case NDIGIT
+ ADD_NL
:
5554 testval
= mask
= RI_HEX
;
5561 case OCTAL
+ ADD_NL
:
5562 testval
= mask
= RI_OCTAL
;
5565 case NOCTAL
+ ADD_NL
:
5570 testval
= mask
= RI_WORD
;
5573 case NWORD
+ ADD_NL
:
5578 testval
= mask
= RI_HEAD
;
5581 case NHEAD
+ ADD_NL
:
5585 case ALPHA
+ ADD_NL
:
5586 testval
= mask
= RI_ALPHA
;
5589 case NALPHA
+ ADD_NL
:
5593 case LOWER
+ ADD_NL
:
5594 testval
= mask
= RI_LOWER
;
5597 case NLOWER
+ ADD_NL
:
5601 case UPPER
+ ADD_NL
:
5602 testval
= mask
= RI_UPPER
;
5605 case NUPPER
+ ADD_NL
:
5613 /* This doesn't do a multi-byte character, because a MULTIBYTECODE
5614 * would have been used for it. It does handle single-byte
5615 * characters, such as latin1. */
5618 cu
= MB_TOUPPER(*opnd
);
5619 cl
= MB_TOLOWER(*opnd
);
5620 while (count
< maxcount
&& (*scan
== cu
|| *scan
== cl
))
5629 while (count
< maxcount
&& *scan
== cu
)
5643 /* Safety check (just in case 'encoding' was changed since
5644 * compiling the program). */
5645 if ((len
= (*mb_ptr2len
)(opnd
)) > 1)
5647 if (ireg_ic
&& enc_utf8
)
5648 cf
= utf_fold(utf_ptr2char(opnd
));
5649 while (count
< maxcount
)
5651 for (i
= 0; i
< len
; ++i
)
5652 if (opnd
[i
] != scan
[i
])
5654 if (i
< len
&& (!ireg_ic
|| !enc_utf8
5655 || utf_fold(utf_ptr2char(scan
)) != cf
))
5666 case ANYOF
+ ADD_NL
:
5671 case ANYBUT
+ ADD_NL
:
5672 while (count
< maxcount
)
5679 if (!REG_MULTI
|| !WITH_NL(OP(p
)) || reglnum
> reg_maxline
5687 else if (reg_line_lbr
&& *scan
== '\n' && WITH_NL(OP(p
)))
5690 else if (has_mbyte
&& (len
= (*mb_ptr2len
)(scan
)) > 1)
5692 if ((cstrchr(opnd
, (*mb_ptr2char
)(scan
)) == NULL
) == testval
)
5699 if ((cstrchr(opnd
, *scan
) == NULL
) == testval
)
5708 while (count
< maxcount
5709 && ((*scan
== NUL
&& reglnum
<= reg_maxline
&& !reg_line_lbr
5710 && REG_MULTI
) || (*scan
== '\n' && reg_line_lbr
)))
5723 default: /* Oh dear. Called inappropriately. */
5726 printf("Called regrepeat with op code %d\n", OP(p
));
5737 * regnext - dig the "next" pointer out of a node
5745 if (p
== JUST_CALC_SIZE
)
5759 * Check the regexp program for its magic number.
5760 * Return TRUE if it's wrong.
5765 if (UCHARAT(REG_MULTI
5766 ? reg_mmatch
->regprog
->program
5767 : reg_match
->regprog
->program
) != REGMAGIC
)
5776 * Cleanup the subexpressions, if this wasn't done yet.
5777 * This construction is used to clear the subexpressions only when they are
5778 * used (to increase speed).
5783 if (need_clear_subexpr
)
5787 /* Use 0xff to set lnum to -1 */
5788 vim_memset(reg_startpos
, 0xff, sizeof(lpos_T
) * NSUBEXP
);
5789 vim_memset(reg_endpos
, 0xff, sizeof(lpos_T
) * NSUBEXP
);
5793 vim_memset(reg_startp
, 0, sizeof(char_u
*) * NSUBEXP
);
5794 vim_memset(reg_endp
, 0, sizeof(char_u
*) * NSUBEXP
);
5796 need_clear_subexpr
= FALSE
;
5804 if (need_clear_zsubexpr
)
5808 /* Use 0xff to set lnum to -1 */
5809 vim_memset(reg_startzpos
, 0xff, sizeof(lpos_T
) * NSUBEXP
);
5810 vim_memset(reg_endzpos
, 0xff, sizeof(lpos_T
) * NSUBEXP
);
5814 vim_memset(reg_startzp
, 0, sizeof(char_u
*) * NSUBEXP
);
5815 vim_memset(reg_endzp
, 0, sizeof(char_u
*) * NSUBEXP
);
5817 need_clear_zsubexpr
= FALSE
;
5823 * Advance reglnum, regline and reginput to the next line.
5828 regline
= reg_getline(++reglnum
);
5834 * Save the input line and position in a regsave_T.
5843 save
->rs_u
.pos
.col
= (colnr_T
)(reginput
- regline
);
5844 save
->rs_u
.pos
.lnum
= reglnum
;
5847 save
->rs_u
.ptr
= reginput
;
5848 save
->rs_len
= gap
->ga_len
;
5852 * Restore the input line and position from a regsave_T.
5855 reg_restore(save
, gap
)
5861 if (reglnum
!= save
->rs_u
.pos
.lnum
)
5863 /* only call reg_getline() when the line number changed to save
5865 reglnum
= save
->rs_u
.pos
.lnum
;
5866 regline
= reg_getline(reglnum
);
5868 reginput
= regline
+ save
->rs_u
.pos
.col
;
5871 reginput
= save
->rs_u
.ptr
;
5872 gap
->ga_len
= save
->rs_len
;
5876 * Return TRUE if current position is equal to saved position.
5879 reg_save_equal(save
)
5883 return reglnum
== save
->rs_u
.pos
.lnum
5884 && reginput
== regline
+ save
->rs_u
.pos
.col
;
5885 return reginput
== save
->rs_u
.ptr
;
5889 * Tentatively set the sub-expression start to the current position (after
5890 * calling regmatch() they will have changed). Need to save the existing
5891 * values for when there is no match.
5892 * Use se_save() to use pointer (save_se_multi()) or position (save_se_one()),
5893 * depending on REG_MULTI.
5896 save_se_multi(savep
, posp
)
5900 savep
->se_u
.pos
= *posp
;
5901 posp
->lnum
= reglnum
;
5902 posp
->col
= (colnr_T
)(reginput
- regline
);
5906 save_se_one(savep
, pp
)
5910 savep
->se_u
.ptr
= *pp
;
5915 * Compare a number with the operand of RE_LNUM, RE_COL or RE_VCOL.
5918 re_num_cmp(val
, scan
)
5922 long_u n
= OPERAND_MIN(scan
);
5924 if (OPERAND_CMP(scan
) == '>')
5926 if (OPERAND_CMP(scan
) == '<')
5935 * regdump - dump a regexp onto stdout in vaguely comprehensible form
5943 int op
= EXACTLY
; /* Arbitrary non-END op. */
5947 printf("\r\nregcomp(%s):\r\n", pattern
);
5951 * Loop until we find the END that isn't before a referred next (an END
5952 * can also appear in a NOMATCH operand).
5954 while (op
!= END
|| s
<= end
)
5957 printf("%2d%s", (int)(s
- r
->program
), regprop(s
)); /* Where, what. */
5959 if (next
== NULL
) /* Next ptr. */
5962 printf("(%d)", (int)((s
- r
->program
) + (next
- s
)));
5965 if (op
== BRACE_LIMITS
)
5967 /* Two short ints */
5968 printf(" minval %ld, maxval %ld", OPERAND_MIN(s
), OPERAND_MAX(s
));
5972 if (op
== ANYOF
|| op
== ANYOF
+ ADD_NL
5973 || op
== ANYBUT
|| op
== ANYBUT
+ ADD_NL
5976 /* Literal string, where present. */
5984 /* Header fields of interest. */
5985 if (r
->regstart
!= NUL
)
5986 printf("start `%s' 0x%x; ", r
->regstart
< 256
5987 ? (char *)transchar(r
->regstart
)
5988 : "multibyte", r
->regstart
);
5990 printf("anchored; ");
5991 if (r
->regmust
!= NULL
)
5992 printf("must have \"%s\"", r
->regmust
);
5997 * regprop - printable representation of opcode
6004 static char_u buf
[50];
6006 (void) strcpy(buf
, ":");
6055 case ANYOF
+ ADD_NL
:
6061 case ANYBUT
+ ADD_NL
:
6067 case IDENT
+ ADD_NL
:
6073 case SIDENT
+ ADD_NL
:
6079 case KWORD
+ ADD_NL
:
6085 case SKWORD
+ ADD_NL
:
6091 case FNAME
+ ADD_NL
:
6097 case SFNAME
+ ADD_NL
:
6103 case PRINT
+ ADD_NL
:
6109 case SPRINT
+ ADD_NL
:
6115 case WHITE
+ ADD_NL
:
6121 case NWHITE
+ ADD_NL
:
6127 case DIGIT
+ ADD_NL
:
6133 case NDIGIT
+ ADD_NL
:
6151 case OCTAL
+ ADD_NL
:
6157 case NOCTAL
+ ADD_NL
:
6169 case NWORD
+ ADD_NL
:
6181 case NHEAD
+ ADD_NL
:
6187 case ALPHA
+ ADD_NL
:
6193 case NALPHA
+ ADD_NL
:
6199 case LOWER
+ ADD_NL
:
6205 case NLOWER
+ ADD_NL
:
6211 case UPPER
+ ADD_NL
:
6217 case NUPPER
+ ADD_NL
:
6247 sprintf(buf
+ STRLEN(buf
), "MOPEN%d", OP(op
) - MOPEN
);
6262 sprintf(buf
+ STRLEN(buf
), "MCLOSE%d", OP(op
) - MCLOSE
);
6274 sprintf(buf
+ STRLEN(buf
), "BACKREF%d", OP(op
) - BACKREF
);
6293 sprintf(buf
+ STRLEN(buf
), "ZOPEN%d", OP(op
) - ZOPEN
);
6305 sprintf(buf
+ STRLEN(buf
), "ZCLOSE%d", OP(op
) - ZCLOSE
);
6317 sprintf(buf
+ STRLEN(buf
), "ZREF%d", OP(op
) - ZREF
);
6348 case BRACE_COMPLEX
+ 0:
6349 case BRACE_COMPLEX
+ 1:
6350 case BRACE_COMPLEX
+ 2:
6351 case BRACE_COMPLEX
+ 3:
6352 case BRACE_COMPLEX
+ 4:
6353 case BRACE_COMPLEX
+ 5:
6354 case BRACE_COMPLEX
+ 6:
6355 case BRACE_COMPLEX
+ 7:
6356 case BRACE_COMPLEX
+ 8:
6357 case BRACE_COMPLEX
+ 9:
6358 sprintf(buf
+ STRLEN(buf
), "BRACE_COMPLEX%d", OP(op
) - BRACE_COMPLEX
);
6363 p
= "MULTIBYTECODE";
6370 sprintf(buf
+ STRLEN(buf
), "corrupt %d", OP(op
));
6375 (void) strcat(buf
, p
);
6381 static void mb_decompose
__ARGS((int c
, int *c1
, int *c2
, int *c3
));
6389 /* 0xfb20 - 0xfb4f */
6390 static decomp_T decomp_table
[0xfb4f-0xfb20+1] =
6392 {0x5e2,0,0}, /* 0xfb20 alt ayin */
6393 {0x5d0,0,0}, /* 0xfb21 alt alef */
6394 {0x5d3,0,0}, /* 0xfb22 alt dalet */
6395 {0x5d4,0,0}, /* 0xfb23 alt he */
6396 {0x5db,0,0}, /* 0xfb24 alt kaf */
6397 {0x5dc,0,0}, /* 0xfb25 alt lamed */
6398 {0x5dd,0,0}, /* 0xfb26 alt mem-sofit */
6399 {0x5e8,0,0}, /* 0xfb27 alt resh */
6400 {0x5ea,0,0}, /* 0xfb28 alt tav */
6401 {'+', 0, 0}, /* 0xfb29 alt plus */
6402 {0x5e9, 0x5c1, 0}, /* 0xfb2a shin+shin-dot */
6403 {0x5e9, 0x5c2, 0}, /* 0xfb2b shin+sin-dot */
6404 {0x5e9, 0x5c1, 0x5bc}, /* 0xfb2c shin+shin-dot+dagesh */
6405 {0x5e9, 0x5c2, 0x5bc}, /* 0xfb2d shin+sin-dot+dagesh */
6406 {0x5d0, 0x5b7, 0}, /* 0xfb2e alef+patah */
6407 {0x5d0, 0x5b8, 0}, /* 0xfb2f alef+qamats */
6408 {0x5d0, 0x5b4, 0}, /* 0xfb30 alef+hiriq */
6409 {0x5d1, 0x5bc, 0}, /* 0xfb31 bet+dagesh */
6410 {0x5d2, 0x5bc, 0}, /* 0xfb32 gimel+dagesh */
6411 {0x5d3, 0x5bc, 0}, /* 0xfb33 dalet+dagesh */
6412 {0x5d4, 0x5bc, 0}, /* 0xfb34 he+dagesh */
6413 {0x5d5, 0x5bc, 0}, /* 0xfb35 vav+dagesh */
6414 {0x5d6, 0x5bc, 0}, /* 0xfb36 zayin+dagesh */
6415 {0xfb37, 0, 0}, /* 0xfb37 -- UNUSED */
6416 {0x5d8, 0x5bc, 0}, /* 0xfb38 tet+dagesh */
6417 {0x5d9, 0x5bc, 0}, /* 0xfb39 yud+dagesh */
6418 {0x5da, 0x5bc, 0}, /* 0xfb3a kaf sofit+dagesh */
6419 {0x5db, 0x5bc, 0}, /* 0xfb3b kaf+dagesh */
6420 {0x5dc, 0x5bc, 0}, /* 0xfb3c lamed+dagesh */
6421 {0xfb3d, 0, 0}, /* 0xfb3d -- UNUSED */
6422 {0x5de, 0x5bc, 0}, /* 0xfb3e mem+dagesh */
6423 {0xfb3f, 0, 0}, /* 0xfb3f -- UNUSED */
6424 {0x5e0, 0x5bc, 0}, /* 0xfb40 nun+dagesh */
6425 {0x5e1, 0x5bc, 0}, /* 0xfb41 samech+dagesh */
6426 {0xfb42, 0, 0}, /* 0xfb42 -- UNUSED */
6427 {0x5e3, 0x5bc, 0}, /* 0xfb43 pe sofit+dagesh */
6428 {0x5e4, 0x5bc,0}, /* 0xfb44 pe+dagesh */
6429 {0xfb45, 0, 0}, /* 0xfb45 -- UNUSED */
6430 {0x5e6, 0x5bc, 0}, /* 0xfb46 tsadi+dagesh */
6431 {0x5e7, 0x5bc, 0}, /* 0xfb47 qof+dagesh */
6432 {0x5e8, 0x5bc, 0}, /* 0xfb48 resh+dagesh */
6433 {0x5e9, 0x5bc, 0}, /* 0xfb49 shin+dagesh */
6434 {0x5ea, 0x5bc, 0}, /* 0xfb4a tav+dagesh */
6435 {0x5d5, 0x5b9, 0}, /* 0xfb4b vav+holam */
6436 {0x5d1, 0x5bf, 0}, /* 0xfb4c bet+rafe */
6437 {0x5db, 0x5bf, 0}, /* 0xfb4d kaf+rafe */
6438 {0x5e4, 0x5bf, 0}, /* 0xfb4e pe+rafe */
6439 {0x5d0, 0x5dc, 0} /* 0xfb4f alef-lamed */
6443 mb_decompose(c
, c1
, c2
, c3
)
6444 int c
, *c1
, *c2
, *c3
;
6448 if (c
>= 0x4b20 && c
<= 0xfb4f)
6450 d
= decomp_table
[c
- 0xfb20];
6464 * Compare two strings, ignore case if ireg_ic set.
6465 * Return 0 if strings match, non-zero otherwise.
6466 * Correct the length "*n" when composing characters are ignored.
6476 result
= STRNCMP(s1
, s2
, *n
);
6478 result
= MB_STRNICMP(s1
, s2
, *n
);
6481 /* if it failed and it's utf8 and we want to combineignore: */
6482 if (result
!= 0 && enc_utf8
&& ireg_icombine
)
6484 char_u
*str1
, *str2
;
6485 int c1
, c2
, c11
, c12
;
6488 /* we have to handle the strcmp ourselves, since it is necessary to
6489 * deal with the composing characters by ignoring them: */
6493 while ((int)(str1
- s1
) < *n
)
6495 c1
= mb_ptr2char_adv(&str1
);
6496 c2
= mb_ptr2char_adv(&str2
);
6498 /* decompose the character if necessary, into 'base' characters
6499 * because I don't care about Arabic, I will hard-code the Hebrew
6500 * which I *do* care about! So sue me... */
6501 if (c1
!= c2
&& (!ireg_ic
|| utf_fold(c1
) != utf_fold(c2
)))
6503 /* decomposition necessary? */
6504 mb_decompose(c1
, &c11
, &junk
, &junk
);
6505 mb_decompose(c2
, &c12
, &junk
, &junk
);
6508 if (c11
!= c12
&& (!ireg_ic
|| utf_fold(c11
) != utf_fold(c12
)))
6514 *n
= (int)(str2
- s2
);
6522 * cstrchr: This function is used a lot for simple searches, keep it fast!
6534 || (!enc_utf8
&& mb_char2len(c
) > 1)
6537 return vim_strchr(s
, c
);
6539 /* tolower() and toupper() can be slow, comparing twice should be a lot
6540 * faster (esp. when using MS Visual C++!).
6541 * For UTF-8 need to use folded case. */
6543 if (enc_utf8
&& c
> 0x80)
6549 else if (MB_ISLOWER(c
))
6552 return vim_strchr(s
, c
);
6557 for (p
= s
; *p
!= NUL
; p
+= (*mb_ptr2len
)(p
))
6559 if (enc_utf8
&& c
> 0x80)
6561 if (utf_fold(utf_ptr2char(p
)) == cc
)
6564 else if (*p
== c
|| *p
== cc
)
6570 /* Faster version for when there are no multi-byte characters. */
6571 for (p
= s
; *p
!= NUL
; ++p
)
6572 if (*p
== c
|| *p
== cc
)
6578 /***************************************************************
6580 ***************************************************************/
6582 /* This stuff below really confuses cc on an SGI -- webb */
6585 # define __ARGS(x) ()
6589 * We should define ftpr as a pointer to a function returning a pointer to
6590 * a function returning a pointer to a function ...
6591 * This is impossible, so we declare a pointer to a function returning a
6592 * pointer to a function returning void. This should work for all compilers.
6594 typedef void (*(*fptr_T
) __ARGS((int *, int)))();
6596 static fptr_T do_upper
__ARGS((int *, int));
6597 static fptr_T do_Upper
__ARGS((int *, int));
6598 static fptr_T do_lower
__ARGS((int *, int));
6599 static fptr_T do_Lower
__ARGS((int *, int));
6601 static int vim_regsub_both
__ARGS((char_u
*source
, char_u
*dest
, int copy
, int magic
, int backslash
));
6610 return (fptr_T
)NULL
;
6620 return (fptr_T
)do_Upper
;
6630 return (fptr_T
)NULL
;
6640 return (fptr_T
)do_Lower
;
6644 * regtilde(): Replace tildes in the pattern by the old pattern.
6646 * Short explanation of the tilde: It stands for the previous replacement
6647 * pattern. If that previous pattern also contains a ~ we should go back a
6648 * step further... But we insert the previous pattern into the current one
6649 * and remember that.
6650 * This still does not handle the case where "magic" changes. So require the
6651 * user to keep his hands off of "magic".
6653 * The tildes are parsed once before the first call to vim_regsub().
6656 regtilde(source
, magic
)
6660 char_u
*newsub
= source
;
6666 for (p
= newsub
; *p
; ++p
)
6668 if ((*p
== '~' && magic
) || (*p
== '\\' && *(p
+ 1) == '~' && !magic
))
6670 if (reg_prev_sub
!= NULL
)
6672 /* length = len(newsub) - 1 + len(prev_sub) + 1 */
6673 prevlen
= (int)STRLEN(reg_prev_sub
);
6674 tmpsub
= alloc((unsigned)(STRLEN(newsub
) + prevlen
));
6678 len
= (int)(p
- newsub
); /* not including ~ */
6679 mch_memmove(tmpsub
, newsub
, (size_t)len
);
6680 /* interpret tilde */
6681 mch_memmove(tmpsub
+ len
, reg_prev_sub
, (size_t)prevlen
);
6684 ++p
; /* back off \ */
6685 STRCPY(tmpsub
+ len
+ prevlen
, p
+ 1);
6687 if (newsub
!= source
) /* already allocated newsub */
6690 p
= newsub
+ len
+ prevlen
;
6694 mch_memmove(p
, p
+ 1, STRLEN(p
)); /* remove '~' */
6696 mch_memmove(p
, p
+ 2, STRLEN(p
) - 1); /* remove '\~' */
6701 if (*p
== '\\' && p
[1]) /* skip escaped characters */
6705 p
+= (*mb_ptr2len
)(p
) - 1;
6710 vim_free(reg_prev_sub
);
6711 if (newsub
!= source
) /* newsub was allocated, just keep it */
6712 reg_prev_sub
= newsub
;
6713 else /* no ~ found, need to save newsub */
6714 reg_prev_sub
= vim_strsave(newsub
);
6719 static int can_f_submatch
= FALSE
; /* TRUE when submatch() can be used */
6721 /* These pointers are used instead of reg_match and reg_mmatch for
6722 * reg_submatch(). Needed for when the substitution string is an expression
6723 * that contains a call to substitute() and submatch(). */
6724 static regmatch_T
*submatch_match
;
6725 static regmmatch_T
*submatch_mmatch
;
6728 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
6730 * vim_regsub() - perform substitutions after a vim_regexec() or
6731 * vim_regexec_multi() match.
6733 * If "copy" is TRUE really copy into "dest".
6734 * If "copy" is FALSE nothing is copied, this is just to find out the length
6737 * If "backslash" is TRUE, a backslash will be removed later, need to double
6738 * them to keep them, and insert a backslash before a CR to avoid it being
6739 * replaced with a line break later.
6741 * Note: The matched text must not change between the call of
6742 * vim_regexec()/vim_regexec_multi() and vim_regsub()! It would make the back
6743 * references invalid!
6745 * Returns the size of the replacement, including terminating NUL.
6748 vim_regsub(rmp
, source
, dest
, copy
, magic
, backslash
)
6759 return vim_regsub_both(source
, dest
, copy
, magic
, backslash
);
6764 vim_regsub_multi(rmp
, lnum
, source
, dest
, copy
, magic
, backslash
)
6775 reg_buf
= curbuf
; /* always works on the current buffer! */
6776 reg_firstlnum
= lnum
;
6777 reg_maxline
= curbuf
->b_ml
.ml_line_count
- lnum
;
6778 return vim_regsub_both(source
, dest
, copy
, magic
, backslash
);
6782 vim_regsub_both(source
, dest
, copy
, magic
, backslash
)
6795 fptr_T func
= (fptr_T
)NULL
;
6796 linenr_T clnum
= 0; /* init for GCC */
6797 int len
= 0; /* init for GCC */
6799 static char_u
*eval_result
= NULL
;
6802 /* Be paranoid... */
6803 if (source
== NULL
|| dest
== NULL
)
6808 if (prog_magic_wrong())
6814 * When the substitute part starts with "\=" evaluate it as an expression.
6816 if (source
[0] == '\\' && source
[1] == '='
6818 && !can_f_submatch
/* can't do this recursively */
6823 /* To make sure that the length doesn't change between checking the
6824 * length and copying the string, and to speed up things, the
6825 * resulting string is saved from the call with "copy" == FALSE to the
6826 * call with "copy" == TRUE. */
6829 if (eval_result
!= NULL
)
6831 STRCPY(dest
, eval_result
);
6832 dst
+= STRLEN(eval_result
);
6833 vim_free(eval_result
);
6839 linenr_T save_reg_maxline
;
6840 win_T
*save_reg_win
;
6843 vim_free(eval_result
);
6845 /* The expression may contain substitute(), which calls us
6846 * recursively. Make sure submatch() gets the text from the first
6847 * level. Don't need to save "reg_buf", because
6848 * vim_regexec_multi() can't be called recursively. */
6849 submatch_match
= reg_match
;
6850 submatch_mmatch
= reg_mmatch
;
6851 save_reg_maxline
= reg_maxline
;
6852 save_reg_win
= reg_win
;
6853 save_ireg_ic
= ireg_ic
;
6854 can_f_submatch
= TRUE
;
6856 eval_result
= eval_to_string(source
+ 2, NULL
, TRUE
);
6857 if (eval_result
!= NULL
)
6859 for (s
= eval_result
; *s
!= NUL
; mb_ptr_adv(s
))
6861 /* Change NL to CR, so that it becomes a line break.
6862 * Skip over a backslashed character. */
6865 else if (*s
== '\\' && s
[1] != NUL
)
6869 dst
+= STRLEN(eval_result
);
6872 reg_match
= submatch_match
;
6873 reg_mmatch
= submatch_mmatch
;
6874 reg_maxline
= save_reg_maxline
;
6875 reg_win
= save_reg_win
;
6876 ireg_ic
= save_ireg_ic
;
6877 can_f_submatch
= FALSE
;
6882 while ((c
= *src
++) != NUL
)
6884 if (c
== '&' && magic
)
6886 else if (c
== '\\' && *src
!= NUL
)
6888 if (*src
== '&' && !magic
)
6893 else if ('0' <= *src
&& *src
<= '9')
6897 else if (vim_strchr((char_u
*)"uUlLeE", *src
))
6901 case 'u': func
= (fptr_T
)do_upper
;
6903 case 'U': func
= (fptr_T
)do_Upper
;
6905 case 'l': func
= (fptr_T
)do_lower
;
6907 case 'L': func
= (fptr_T
)do_Lower
;
6910 case 'E': func
= (fptr_T
)NULL
;
6915 if (no
< 0) /* Ordinary character. */
6917 if (c
== K_SPECIAL
&& src
[0] != NUL
&& src
[1] != NUL
)
6919 /* Copy a special key as-is. */
6934 if (c
== '\\' && *src
!= NUL
)
6936 /* Check for abbreviations -- webb */
6939 case 'r': c
= CAR
; ++src
; break;
6940 case 'n': c
= NL
; ++src
; break;
6941 case 't': c
= TAB
; ++src
; break;
6942 /* Oh no! \e already has meaning in subst pat :-( */
6943 /* case 'e': c = ESC; ++src; break; */
6944 case 'b': c
= Ctrl_H
; ++src
; break;
6946 /* If "backslash" is TRUE the backslash will be removed
6947 * later. Used to insert a literal CR. */
6948 default: if (backslash
)
6959 c
= mb_ptr2char(src
- 1);
6962 /* Write to buffer, if copy is set. */
6963 if (func
== (fptr_T
)NULL
) /* just copy */
6966 /* Turbo C complains without the typecast */
6967 func
= (fptr_T
)(func(&cc
, c
));
6972 src
+= mb_ptr2len(src
- 1) - 1;
6974 mb_char2bytes(cc
, dst
);
6975 dst
+= mb_char2len(cc
) - 1;
6987 clnum
= reg_mmatch
->startpos
[no
].lnum
;
6988 if (clnum
< 0 || reg_mmatch
->endpos
[no
].lnum
< 0)
6992 s
= reg_getline(clnum
) + reg_mmatch
->startpos
[no
].col
;
6993 if (reg_mmatch
->endpos
[no
].lnum
== clnum
)
6994 len
= reg_mmatch
->endpos
[no
].col
6995 - reg_mmatch
->startpos
[no
].col
;
6997 len
= (int)STRLEN(s
);
7002 s
= reg_match
->startp
[no
];
7003 if (reg_match
->endp
[no
] == NULL
)
7006 len
= (int)(reg_match
->endp
[no
] - s
);
7016 if (reg_mmatch
->endpos
[no
].lnum
== clnum
)
7021 s
= reg_getline(++clnum
);
7022 if (reg_mmatch
->endpos
[no
].lnum
== clnum
)
7023 len
= reg_mmatch
->endpos
[no
].col
;
7025 len
= (int)STRLEN(s
);
7030 else if (*s
== NUL
) /* we hit NUL. */
7038 if (backslash
&& (*s
== CAR
|| *s
== '\\'))
7041 * Insert a backslash in front of a CR, otherwise
7042 * it will be replaced by a line break.
7043 * Number of backslashes will be halved later,
7062 if (func
== (fptr_T
)NULL
) /* just copy */
7065 /* Turbo C complains without the typecast */
7066 func
= (fptr_T
)(func(&cc
, c
));
7073 /* Copy composing characters separately, one
7076 l
= utf_ptr2len(s
) - 1;
7078 l
= mb_ptr2len(s
) - 1;
7083 mb_char2bytes(cc
, dst
);
7084 dst
+= mb_char2len(cc
) - 1;
7105 return (int)((dst
- dest
) + 1);
7110 * Used for the submatch() function: get the string from the n'th submatch in
7112 * Returns NULL when not in a ":s" command and for a non-existing submatch.
7118 char_u
*retval
= NULL
;
7124 if (!can_f_submatch
|| no
< 0)
7127 if (submatch_match
== NULL
)
7130 * First round: compute the length and allocate memory.
7131 * Second round: copy the text.
7133 for (round
= 1; round
<= 2; ++round
)
7135 lnum
= submatch_mmatch
->startpos
[no
].lnum
;
7136 if (lnum
< 0 || submatch_mmatch
->endpos
[no
].lnum
< 0)
7139 s
= reg_getline(lnum
) + submatch_mmatch
->startpos
[no
].col
;
7140 if (s
== NULL
) /* anti-crash check, cannot happen? */
7142 if (submatch_mmatch
->endpos
[no
].lnum
== lnum
)
7144 /* Within one line: take form start to end col. */
7145 len
= submatch_mmatch
->endpos
[no
].col
7146 - submatch_mmatch
->startpos
[no
].col
;
7148 vim_strncpy(retval
, s
, len
);
7153 /* Multiple lines: take start line from start col, middle
7154 * lines completely and end line up to end col. */
7155 len
= (int)STRLEN(s
);
7163 while (lnum
< submatch_mmatch
->endpos
[no
].lnum
)
7165 s
= reg_getline(lnum
++);
7167 STRCPY(retval
+ len
, s
);
7168 len
+= (int)STRLEN(s
);
7174 STRNCPY(retval
+ len
, reg_getline(lnum
),
7175 submatch_mmatch
->endpos
[no
].col
);
7176 len
+= submatch_mmatch
->endpos
[no
].col
;
7184 retval
= lalloc((long_u
)len
, TRUE
);
7192 if (submatch_match
->endp
[no
] == NULL
)
7196 s
= submatch_match
->startp
[no
];
7197 retval
= vim_strnsave(s
, (int)(submatch_match
->endp
[no
] - s
));