diff options
| author | Bram Moolenaar <Bram@vim.org> | 2004-06-13 20:20:40 +0000 |
|---|---|---|
| committer | Bram Moolenaar <Bram@vim.org> | 2004-06-13 20:20:40 +0000 |
| commit | 071d4279d6ab81b7187b48f3a0fc61e587b6db6c (patch) | |
| tree | 221cbe3c40e043163c06f61c52a7ba2eb41e12ce /src/regexp.c | |
| parent | b4210b3bc14e2918f153a7307530fbe6eba659e1 (diff) | |
| download | vim-071d4279d6ab81b7187b48f3a0fc61e587b6db6c.zip | |
updated for version 7.0001
Diffstat (limited to 'src/regexp.c')
| -rw-r--r-- | src/regexp.c | 6115 |
1 files changed, 6115 insertions, 0 deletions
diff --git a/src/regexp.c b/src/regexp.c new file mode 100644 index 000000000..9715a1ea5 --- /dev/null +++ b/src/regexp.c @@ -0,0 +1,6115 @@ +/* vi:set ts=8 sts=4 sw=4: + * + * Handling of regular expressions: vim_regcomp(), vim_regexec(), vim_regsub() + * + * NOTICE: + * + * This is NOT the original regular expression code as written by Henry + * Spencer. This code has been modified specifically for use with the VIM + * editor, and should not be used separately from Vim. If you want a good + * regular expression library, get the original code. The copyright notice + * that follows is from the original. + * + * END NOTICE + * + * Copyright (c) 1986 by University of Toronto. + * Written by Henry Spencer. Not derived from licensed software. + * + * Permission is granted to anyone to use this software for any + * purpose on any computer system, and to redistribute it freely, + * subject to the following restrictions: + * + * 1. The author is not responsible for the consequences of use of + * this software, no matter how awful, even if they arise + * from defects in it. + * + * 2. The origin of this software must not be misrepresented, either + * by explicit claim or by omission. + * + * 3. Altered versions must be plainly marked as such, and must not + * be misrepresented as being the original software. + * + * Beware that some of this code is subtly aware of the way operator + * precedence is structured in regular expressions. Serious changes in + * regular-expression syntax might require a total rethink. + * + * Changes have been made by Tony Andrews, Olaf 'Rhialto' Seibert, Robert Webb + * and Bram Moolenaar. + * Named character class support added by Walter Briscoe (1998 Jul 01) + */ + +#include "vim.h" + +#undef DEBUG + +/* + * The "internal use only" fields in regexp.h are present to pass info from + * compile to execute that permits the execute phase to run lots faster on + * simple cases. They are: + * + * regstart char that must begin a match; NUL if none obvious; Can be a + * multi-byte character. + * reganch is the match anchored (at beginning-of-line only)? + * regmust string (pointer into program) that match must include, or NULL + * regmlen length of regmust string + * regflags RF_ values or'ed together + * + * Regstart and reganch permit very fast decisions on suitable starting points + * for a match, cutting down the work a lot. Regmust permits fast rejection + * of lines that cannot possibly match. The regmust tests are costly enough + * that vim_regcomp() supplies a regmust only if the r.e. contains something + * potentially expensive (at present, the only such thing detected is * or + + * at the start of the r.e., which can involve a lot of backup). Regmlen is + * supplied because the test in vim_regexec() needs it and vim_regcomp() is + * computing it anyway. + */ + +/* + * Structure for regexp "program". This is essentially a linear encoding + * of a nondeterministic finite-state machine (aka syntax charts or + * "railroad normal form" in parsing technology). Each node is an opcode + * plus a "next" pointer, possibly plus an operand. "Next" pointers of + * all nodes except BRANCH and BRACES_COMPLEX implement concatenation; a "next" + * pointer with a BRANCH on both ends of it is connecting two alternatives. + * (Here we have one of the subtle syntax dependencies: an individual BRANCH + * (as opposed to a collection of them) is never concatenated with anything + * because of operator precedence). The "next" pointer of a BRACES_COMPLEX + * node points to the node after the stuff to be repeated. The operand of some + * types of node is a literal string; for others, it is a node leading into a + * sub-FSM. In particular, the operand of a BRANCH node is the first node of + * the branch. (NB this is *not* a tree structure: the tail of the branch + * connects to the thing following the set of BRANCHes.) + * + * pattern is coded like: + * + * +-----------------+ + * | V + * <aa>\|<bb> BRANCH <aa> BRANCH <bb> --> END + * | ^ | ^ + * +------+ +----------+ + * + * + * +------------------+ + * V | + * <aa>* BRANCH BRANCH <aa> --> BACK BRANCH --> NOTHING --> END + * | | ^ ^ + * | +---------------+ | + * +---------------------------------------------+ + * + * + * +-------------------------+ + * V | + * <aa>\{} BRANCH BRACE_LIMITS --> BRACE_COMPLEX <aa> --> BACK END + * | | ^ + * | +----------------+ + * +-----------------------------------------------+ + * + * + * <aa>\@!<bb> BRANCH NOMATCH <aa> --> END <bb> --> END + * | | ^ ^ + * | +----------------+ | + * +--------------------------------+ + * + * +---------+ + * | V + * \z[abc] BRANCH BRANCH a BRANCH b BRANCH c BRANCH NOTHING --> END + * | | | | ^ ^ + * | | | +-----+ | + * | | +----------------+ | + * | +---------------------------+ | + * +------------------------------------------------------+ + * + * They all start with a BRANCH for "\|" alternaties, even when there is only + * one alternative. + */ + +/* + * The opcodes are: + */ + +/* definition number opnd? meaning */ +#define END 0 /* End of program or NOMATCH operand. */ +#define BOL 1 /* Match "" at beginning of line. */ +#define EOL 2 /* Match "" at end of line. */ +#define BRANCH 3 /* node Match this alternative, or the + * next... */ +#define BACK 4 /* Match "", "next" ptr points backward. */ +#define EXACTLY 5 /* str Match this string. */ +#define NOTHING 6 /* Match empty string. */ +#define STAR 7 /* node Match this (simple) thing 0 or more + * times. */ +#define PLUS 8 /* node Match this (simple) thing 1 or more + * times. */ +#define MATCH 9 /* node match the operand zero-width */ +#define NOMATCH 10 /* node check for no match with operand */ +#define BEHIND 11 /* node look behind for a match with operand */ +#define NOBEHIND 12 /* node look behind for no match with operand */ +#define SUBPAT 13 /* node match the operand here */ +#define BRACE_SIMPLE 14 /* node Match this (simple) thing between m and + * n times (\{m,n\}). */ +#define BOW 15 /* Match "" after [^a-zA-Z0-9_] */ +#define EOW 16 /* Match "" at [^a-zA-Z0-9_] */ +#define BRACE_LIMITS 17 /* nr nr define the min & max for BRACE_SIMPLE + * and BRACE_COMPLEX. */ +#define NEWL 18 /* Match line-break */ +#define BHPOS 19 /* End position for BEHIND or NOBEHIND */ + + +/* character classes: 20-48 normal, 50-78 include a line-break */ +#define ADD_NL 30 +#define FIRST_NL ANY + ADD_NL +#define ANY 20 /* Match any one character. */ +#define ANYOF 21 /* str Match any character in this string. */ +#define ANYBUT 22 /* str Match any character not in this + * string. */ +#define IDENT 23 /* Match identifier char */ +#define SIDENT 24 /* Match identifier char but no digit */ +#define KWORD 25 /* Match keyword char */ +#define SKWORD 26 /* Match word char but no digit */ +#define FNAME 27 /* Match file name char */ +#define SFNAME 28 /* Match file name char but no digit */ +#define PRINT 29 /* Match printable char */ +#define SPRINT 30 /* Match printable char but no digit */ +#define WHITE 31 /* Match whitespace char */ +#define NWHITE 32 /* Match non-whitespace char */ +#define DIGIT 33 /* Match digit char */ +#define NDIGIT 34 /* Match non-digit char */ +#define HEX 35 /* Match hex char */ +#define NHEX 36 /* Match non-hex char */ +#define OCTAL 37 /* Match octal char */ +#define NOCTAL 38 /* Match non-octal char */ +#define WORD 39 /* Match word char */ +#define NWORD 40 /* Match non-word char */ +#define HEAD 41 /* Match head char */ +#define NHEAD 42 /* Match non-head char */ +#define ALPHA 43 /* Match alpha char */ +#define NALPHA 44 /* Match non-alpha char */ +#define LOWER 45 /* Match lowercase char */ +#define NLOWER 46 /* Match non-lowercase char */ +#define UPPER 47 /* Match uppercase char */ +#define NUPPER 48 /* Match non-uppercase char */ +#define LAST_NL NUPPER + ADD_NL +#define WITH_NL(op) ((op) >= FIRST_NL && (op) <= LAST_NL) + +#define MOPEN 80 /* -89 Mark this point in input as start of + * \( subexpr. MOPEN + 0 marks start of + * match. */ +#define MCLOSE 90 /* -99 Analogous to MOPEN. MCLOSE + 0 marks + * end of match. */ +#define BACKREF 100 /* -109 node Match same string again \1-\9 */ + +#ifdef FEAT_SYN_HL +# define ZOPEN 110 /* -119 Mark this point in input as start of + * \z( subexpr. */ +# define ZCLOSE 120 /* -129 Analogous to ZOPEN. */ +# define ZREF 130 /* -139 node Match external submatch \z1-\z9 */ +#endif + +#define BRACE_COMPLEX 140 /* -149 node Match nodes between m & n times */ + +#define NOPEN 150 /* Mark this point in input as start of + \%( subexpr. */ +#define NCLOSE 151 /* Analogous to NOPEN. */ + +#define MULTIBYTECODE 200 /* mbc Match one multi-byte character */ +#define RE_BOF 201 /* Match "" at beginning of file. */ +#define RE_EOF 202 /* Match "" at end of file. */ +#define CURSOR 203 /* Match location of cursor. */ + +#define RE_LNUM 204 /* nr cmp Match line number */ +#define RE_COL 205 /* nr cmp Match column number */ +#define RE_VCOL 206 /* nr cmp Match virtual column number */ + +/* + * Magic characters have a special meaning, they don't match literally. + * Magic characters are negative. This separates them from literal characters + * (possibly multi-byte). Only ASCII characters can be Magic. + */ +#define Magic(x) ((int)(x) - 256) +#define un_Magic(x) ((x) + 256) +#define is_Magic(x) ((x) < 0) + +static int no_Magic __ARGS((int x)); +static int toggle_Magic __ARGS((int x)); + + static int +no_Magic(x) + int x; +{ + if (is_Magic(x)) + return un_Magic(x); + return x; +} + + static int +toggle_Magic(x) + int x; +{ + if (is_Magic(x)) + return un_Magic(x); + return Magic(x); +} + +/* + * The first byte of the regexp internal "program" is actually this magic + * number; the start node begins in the second byte. It's used to catch the + * most severe mutilation of the program by the caller. + */ + +#define REGMAGIC 0234 + +/* + * Opcode notes: + * + * BRANCH The set of branches constituting a single choice are hooked + * together with their "next" pointers, since precedence prevents + * anything being concatenated to any individual branch. The + * "next" pointer of the last BRANCH in a choice points to the + * thing following the whole choice. This is also where the + * final "next" pointer of each individual branch points; each + * branch starts with the operand node of a BRANCH node. + * + * BACK Normal "next" pointers all implicitly point forward; BACK + * exists to make loop structures possible. + * + * STAR,PLUS '=', and complex '*' and '+', are implemented as circular + * BRANCH structures using BACK. Simple cases (one character + * per match) are implemented with STAR and PLUS for speed + * and to minimize recursive plunges. + * + * BRACE_LIMITS This is always followed by a BRACE_SIMPLE or BRACE_COMPLEX + * node, and defines the min and max limits to be used for that + * node. + * + * MOPEN,MCLOSE ...are numbered at compile time. + * ZOPEN,ZCLOSE ...ditto + */ + +/* + * A node is one char of opcode followed by two chars of "next" pointer. + * "Next" pointers are stored as two 8-bit bytes, high order first. The + * value is a positive offset from the opcode of the node containing it. + * An operand, if any, simply follows the node. (Note that much of the + * code generation knows about this implicit relationship.) + * + * Using two bytes for the "next" pointer is vast overkill for most things, + * but allows patterns to get big without disasters. + */ +#define OP(p) ((int)*(p)) +#define NEXT(p) (((*((p) + 1) & 0377) << 8) + (*((p) + 2) & 0377)) +#define OPERAND(p) ((p) + 3) +/* Obtain an operand that was stored as four bytes, MSB first. */ +#define OPERAND_MIN(p) (((long)(p)[3] << 24) + ((long)(p)[4] << 16) \ + + ((long)(p)[5] << 8) + (long)(p)[6]) +/* Obtain a second operand stored as four bytes. */ +#define OPERAND_MAX(p) OPERAND_MIN((p) + 4) +/* Obtain a second single-byte operand stored after a four bytes operand. */ +#define OPERAND_CMP(p) (p)[7] + +/* + * Utility definitions. + */ +#define UCHARAT(p) ((int)*(char_u *)(p)) + +/* Used for an error (down from) vim_regcomp(): give the error message, set + * rc_did_emsg and return NULL */ +#define EMSG_RET_NULL(m) { EMSG(m); rc_did_emsg = TRUE; return NULL; } +#define EMSG_M_RET_NULL(m, c) { EMSG2(m, c ? "" : "\\"); rc_did_emsg = TRUE; return NULL; } +#define EMSG_RET_FAIL(m) { EMSG(m); rc_did_emsg = TRUE; return FAIL; } +#define EMSG_ONE_RET_NULL EMSG_M_RET_NULL(_("E369: invalid item in %s%%[]"), reg_magic == MAGIC_ALL) + +#define MAX_LIMIT (32767L << 16L) + +static int re_multi_type __ARGS((int)); +static int cstrncmp __ARGS((char_u *s1, char_u *s2, int *n)); +static char_u *cstrchr __ARGS((char_u *, int)); + +#ifdef DEBUG +static void regdump __ARGS((char_u *, regprog_T *)); +static char_u *regprop __ARGS((char_u *)); +#endif + +#define NOT_MULTI 0 +#define MULTI_ONE 1 +#define MULTI_MULT 2 +/* + * Return NOT_MULTI if c is not a "multi" operator. + * Return MULTI_ONE if c is a single "multi" operator. + * Return MULTI_MULT if c is a multi "multi" operator. + */ + static int +re_multi_type(c) + int c; +{ + if (c == Magic('@') || c == Magic('=') || c == Magic('?')) + return MULTI_ONE; + if (c == Magic('*') || c == Magic('+') || c == Magic('{')) + return MULTI_MULT; + return NOT_MULTI; +} + +/* + * Flags to be passed up and down. + */ +#define HASWIDTH 0x1 /* Known never to match null string. */ +#define SIMPLE 0x2 /* Simple enough to be STAR/PLUS operand. */ +#define SPSTART 0x4 /* Starts with * or +. */ +#define HASNL 0x8 /* Contains some \n. */ +#define HASLOOKBH 0x10 /* Contains "\@<=" or "\@<!". */ +#define WORST 0 /* Worst case. */ + +/* + * When regcode is set to this value, code is not emitted and size is computed + * instead. + */ +#define JUST_CALC_SIZE ((char_u *) -1) + +static char_u *reg_prev_sub; + +/* + * REGEXP_INRANGE contains all characters which are always special in a [] + * range after '\'. + * REGEXP_ABBR contains all characters which act as abbreviations after '\'. + * These are: + * \n - New line (NL). + * \r - Carriage Return (CR). + * \t - Tab (TAB). + * \e - Escape (ESC). + * \b - Backspace (Ctrl_H). + */ +static char_u REGEXP_INRANGE[] = "]^-n\\"; +static char_u REGEXP_ABBR[] = "nrteb"; + +static int backslash_trans __ARGS((int c)); +static int skip_class_name __ARGS((char_u **pp)); +static char_u *skip_anyof __ARGS((char_u *p)); +static void init_class_tab __ARGS((void)); + +/* + * Translate '\x' to its control character, except "\n", which is Magic. + */ + static int +backslash_trans(c) + int c; +{ + switch (c) + { + case 'r': return CAR; + case 't': return TAB; + case 'e': return ESC; + case 'b': return BS; + } + return c; +} + +/* + * Check for a character class name. "pp" points to the '['. + * Returns one of the CLASS_ items. CLASS_NONE means that no item was + * recognized. Otherwise "pp" is advanced to after the item. + */ + static int +skip_class_name(pp) + char_u **pp; +{ + static const char *(class_names[]) = + { + "alnum:]", +#define CLASS_ALNUM 0 + "alpha:]", +#define CLASS_ALPHA 1 + "blank:]", +#define CLASS_BLANK 2 + "cntrl:]", +#define CLASS_CNTRL 3 + "digit:]", +#define CLASS_DIGIT 4 + "graph:]", +#define CLASS_GRAPH 5 + "lower:]", +#define CLASS_LOWER 6 + "print:]", +#define CLASS_PRINT 7 + "punct:]", +#define CLASS_PUNCT 8 + "space:]", +#define CLASS_SPACE 9 + "upper:]", +#define CLASS_UPPER 10 + "xdigit:]", +#define CLASS_XDIGIT 11 + "tab:]", +#define CLASS_TAB 12 + "return:]", +#define CLASS_RETURN 13 + "backspace:]", +#define CLASS_BACKSPACE 14 + "escape:]", +#define CLASS_ESCAPE 15 + }; +#define CLASS_NONE 99 + int i; + + if ((*pp)[1] == ':') + { + for (i = 0; i < sizeof(class_names) / sizeof(*class_names); ++i) + if (STRNCMP(*pp + 2, class_names[i], STRLEN(class_names[i])) == 0) + { + *pp += STRLEN(class_names[i]) + 2; + return i; + } + } + return CLASS_NONE; +} + +/* + * Skip over a "[]" range. + * "p" must point to the character after the '['. + * The returned pointer is on the matching ']', or the terminating NUL. + */ + static char_u * +skip_anyof(p) + char_u *p; +{ + int cpo_lit; /* 'cpoptions' contains 'l' flag */ +#ifdef FEAT_MBYTE + int l; +#endif + + cpo_lit = (!reg_syn && vim_strchr(p_cpo, CPO_LITERAL) != NULL); + + if (*p == '^') /* Complement of range. */ + ++p; + if (*p == ']' || *p == '-') + ++p; + while (*p != NUL && *p != ']') + { +#ifdef FEAT_MBYTE + if (has_mbyte && (l = (*mb_ptr2len_check)(p)) > 1) + p += l; + else +#endif + if (*p == '-') + { + ++p; + if (*p != ']' && *p != NUL) + { +#ifdef FEAT_MBYTE + if (has_mbyte) + p += (*mb_ptr2len_check)(p); + else +#endif + ++p; + } + } + else if (*p == '\\' + && (vim_strchr(REGEXP_INRANGE, p[1]) != NULL + || (!cpo_lit && vim_strchr(REGEXP_ABBR, p[1]) != NULL))) + p += 2; + else if (*p == '[') + { + if (skip_class_name(&p) == CLASS_NONE) + ++p; /* It was not a class name */ + } + else + ++p; + } + + return p; +} + +/* + * Specific version of character class functions. + * Using a table to keep this fast. + */ +static short class_tab[256]; + +#define RI_DIGIT 0x01 +#define RI_HEX 0x02 +#define RI_OCTAL 0x04 +#define RI_WORD 0x08 +#define RI_HEAD 0x10 +#define RI_ALPHA 0x20 +#define RI_LOWER 0x40 +#define RI_UPPER 0x80 +#define RI_WHITE 0x100 + + static void +init_class_tab() +{ + int i; + static int done = FALSE; + + if (done) + return; + + for (i = 0; i < 256; ++i) + { + if (i >= '0' && i <= '7') + class_tab[i] = RI_DIGIT + RI_HEX + RI_OCTAL + RI_WORD; + else if (i >= '8' && i <= '9') + class_tab[i] = RI_DIGIT + RI_HEX + RI_WORD; + else if (i >= 'a' && i <= 'f') + class_tab[i] = RI_HEX + RI_WORD + RI_HEAD + RI_ALPHA + RI_LOWER; +#ifdef EBCDIC + else if ((i >= 'g' && i <= 'i') || (i >= 'j' && i <= 'r') + || (i >= 's' && i <= 'z')) +#else + else if (i >= 'g' && i <= 'z') +#endif + class_tab[i] = RI_WORD + RI_HEAD + RI_ALPHA + RI_LOWER; + else if (i >= 'A' && i <= 'F') + class_tab[i] = RI_HEX + RI_WORD + RI_HEAD + RI_ALPHA + RI_UPPER; +#ifdef EBCDIC + else if ((i >= 'G' && i <= 'I') || ( i >= 'J' && i <= 'R') + || (i >= 'S' && i <= 'Z')) +#else + else if (i >= 'G' && i <= 'Z') +#endif + class_tab[i] = RI_WORD + RI_HEAD + RI_ALPHA + RI_UPPER; + else if (i == '_') + class_tab[i] = RI_WORD + RI_HEAD; + else + class_tab[i] = 0; + } + class_tab[' '] |= RI_WHITE; + class_tab['\t'] |= RI_WHITE; + done = TRUE; +} + +#ifdef FEAT_MBYTE +# define ri_digit(c) (c < 0x100 && (class_tab[c] & RI_DIGIT)) +# define ri_hex(c) (c < 0x100 && (class_tab[c] & RI_HEX)) +# define ri_octal(c) (c < 0x100 && (class_tab[c] & RI_OCTAL)) +# define ri_word(c) (c < 0x100 && (class_tab[c] & RI_WORD)) +# define ri_head(c) (c < 0x100 && (class_tab[c] & RI_HEAD)) +# define ri_alpha(c) (c < 0x100 && (class_tab[c] & RI_ALPHA)) +# define ri_lower(c) (c < 0x100 && (class_tab[c] & RI_LOWER)) +# define ri_upper(c) (c < 0x100 && (class_tab[c] & RI_UPPER)) +# define ri_white(c) (c < 0x100 && (class_tab[c] & RI_WHITE)) +#else +# define ri_digit(c) (class_tab[c] & RI_DIGIT) +# define ri_hex(c) (class_tab[c] & RI_HEX) +# define ri_octal(c) (class_tab[c] & RI_OCTAL) +# define ri_word(c) (class_tab[c] & RI_WORD) +# define ri_head(c) (class_tab[c] & RI_HEAD) +# define ri_alpha(c) (class_tab[c] & RI_ALPHA) +# define ri_lower(c) (class_tab[c] & RI_LOWER) +# define ri_upper(c) (class_tab[c] & RI_UPPER) +# define ri_white(c) (class_tab[c] & RI_WHITE) +#endif + +/* flags for regflags */ +#define RF_ICASE 1 /* ignore case */ +#define RF_NOICASE 2 /* don't ignore case */ +#define RF_HASNL 4 /* can match a NL */ +#define RF_ICOMBINE 8 /* ignore combining characters */ +#define RF_LOOKBH 16 /* uses "\@<=" or "\@<!" */ + +/* + * Global work variables for vim_regcomp(). + */ + +static char_u *regparse; /* Input-scan pointer. */ +static int prevchr_len; /* byte length of previous char */ +static int num_complex_braces; /* Complex \{...} count */ +static int regnpar; /* () count. */ +#ifdef FEAT_SYN_HL +static int regnzpar; /* \z() count. */ +static int re_has_z; /* \z item detected */ +#endif +static char_u *regcode; /* Code-emit pointer, or JUST_CALC_SIZE */ +static long regsize; /* Code size. */ +static char_u had_endbrace[NSUBEXP]; /* flags, TRUE if end of () found */ +static unsigned regflags; /* RF_ flags for prog */ +static long brace_min[10]; /* Minimums for complex brace repeats */ +static long brace_max[10]; /* Maximums for complex brace repeats */ +static int brace_count[10]; /* Current counts for complex brace repeats */ +#if defined(FEAT_SYN_HL) || defined(PROTO) +static int had_eol; /* TRUE when EOL found by vim_regcomp() */ +#endif +static int one_exactly = FALSE; /* only do one char for EXACTLY */ + +static int reg_magic; /* magicness of the pattern: */ +#define MAGIC_NONE 1 /* "\V" very unmagic */ +#define MAGIC_OFF 2 /* "\M" or 'magic' off */ +#define MAGIC_ON 3 /* "\m" or 'magic' */ +#define MAGIC_ALL 4 /* "\v" very magic */ + +static int reg_string; /* matching with a string instead of a buffer + line */ + +/* + * META contains all characters that may be magic, except '^' and '$'. + */ + +#ifdef EBCDIC +static char_u META[] = "%&()*+.123456789<=>?@ACDFHIKLMOPSUVWX[_acdfhiklmnopsuvwxz{|~"; +#else +/* META[] is used often enough to justify turning it into a table. */ +static char_u META_flags[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* % & ( ) * + . */ + 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, +/* 1 2 3 4 5 6 7 8 9 < = > ? */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, +/* @ A C D F H I K L M O */ + 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, +/* P S U V W X Z [ _ */ + 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, +/* a c d f h i k l m n o */ + 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, +/* p s u v w x z { | ~ */ + 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1 +}; +#endif + +static int curchr; + +/* arguments for reg() */ +#define REG_NOPAREN 0 /* toplevel reg() */ +#define REG_PAREN 1 /* \(\) */ +#define REG_ZPAREN 2 /* \z(\) */ +#define REG_NPAREN 3 /* \%(\) */ + +/* + * Forward declarations for vim_regcomp()'s friends. + */ +static void initchr __ARGS((char_u *)); +static int getchr __ARGS((void)); +static void skipchr_keepstart __ARGS((void)); +static int peekchr __ARGS((void)); +static void skipchr __ARGS((void)); +static void ungetchr __ARGS((void)); +static void regcomp_start __ARGS((char_u *expr, int flags)); +static char_u *reg __ARGS((int, int *)); +static char_u *regbranch __ARGS((int *flagp)); +static char_u *regconcat __ARGS((int *flagp)); +static char_u *regpiece __ARGS((int *)); +static char_u *regatom __ARGS((int *)); +static char_u *regnode __ARGS((int)); +static int prog_magic_wrong __ARGS((void)); +static char_u *regnext __ARGS((char_u *)); +static void regc __ARGS((int b)); +#ifdef FEAT_MBYTE +static void regmbc __ARGS((int c)); +#endif +static void reginsert __ARGS((int, char_u *)); +static void reginsert_limits __ARGS((int, long, long, char_u *)); +static char_u *re_put_long __ARGS((char_u *pr, long_u val)); +static int read_limits __ARGS((long *, long *)); +static void regtail __ARGS((char_u *, char_u *)); +static void regoptail __ARGS((char_u *, char_u *)); + +/* + * Return TRUE if compiled regular expression "prog" can match a line break. + */ + int +re_multiline(prog) + regprog_T *prog; +{ + return (prog->regflags & RF_HASNL); +} + +/* + * Return TRUE if compiled regular expression "prog" looks before the start + * position (pattern contains "\@<=" or "\@<!"). + */ + int +re_lookbehind(prog) + regprog_T *prog; +{ + return (prog->regflags & RF_LOOKBH); +} + +/* + * Skip past regular expression. + * Stop at end of 'p' of where 'dirc' is found ('/', '?', etc). + * Take care of characters with a backslash in front of it. + * Skip strings inside [ and ]. + * When "newp" is not NULL and "dirc" is '?', make an allocated copy of the + * expression and change "\?" to "?". If "*newp" is not NULL the expression + * is changed in-place. + */ + char_u * +skip_regexp(startp, dirc, magic, newp) + char_u *startp; + int dirc; + int magic; + char_u **newp; +{ + int mymagic; + char_u *p = startp; + + if (magic) + mymagic = MAGIC_ON; + else + mymagic = MAGIC_OFF; + + for (; p[0] != NUL; ++p) + { + if (p[0] == dirc) /* found end of regexp */ + break; + if ((p[0] == '[' && mymagic >= MAGIC_ON) + || (p[0] == '\\' && p[1] == '[' && mymagic <= MAGIC_OFF)) + { + p = skip_anyof(p + 1); + if (p[0] == NUL) + break; + } + else if (p[0] == '\\' && p[1] != NUL) + { + if (dirc == '?' && newp != NULL && p[1] == '?') + { + /* change "\?" to "?", make a copy first. */ + if (*newp == NULL) + { + *newp = vim_strsave(startp); + if (*newp != NULL) + p = *newp + (p - startp); + } + if (*newp != NULL) + mch_memmove(p, p + 1, STRLEN(p)); + else + ++p; + } + else + ++p; /* skip next character */ + if (*p == 'v') + mymagic = MAGIC_ALL; + else if (*p == 'V') + mymagic = MAGIC_NONE; + } +#ifdef FEAT_MBYTE + else if (has_mbyte) + p += (*mb_ptr2len_check)(p) - 1; +#endif + } + return p; +} + +/* + * vim_regcomp - compile a regular expression into internal code + * + * We can't allocate space until we know how big the compiled form will be, + * but we can't compile it (and thus know how big it is) until we've got a + * place to put the code. So we cheat: we compile it twice, once with code + * generation turned off and size counting turned on, and once "for real". + * This also means that we don't allocate space until we are sure that the + * thing really will compile successfully, and we never have to move the + * code and thus invalidate pointers into it. (Note that it has to be in + * one piece because vim_free() must be able to free it all.) + * + * Whether upper/lower case is to be ignored is decided when executing the + * program, it does not matter here. + * + * Beware that the optimization-preparation code in here knows about some + * of the structure of the compiled regexp. + * "re_flags": RE_MAGIC and/or RE_STRING. + */ + regprog_T * +vim_regcomp(expr, re_flags) + char_u *expr; + int re_flags; +{ + regprog_T *r; + char_u *scan; + char_u *longest; + int len; + int flags; + + if (expr == NULL) + EMSG_RET_NULL(_(e_null)); + + init_class_tab(); + + /* + * First pass: determine size, legality. + */ + regcomp_start(expr, re_flags); + regcode = JUST_CALC_SIZE; + regc(REGMAGIC); + if (reg(REG_NOPAREN, &flags) == NULL) + return NULL; + + /* Small enough for pointer-storage convention? */ +#ifdef SMALL_MALLOC /* 16 bit storage allocation */ + if (regsize >= 65536L - 256L) + EMSG_RET_NULL(_("E339: Pattern too long")); +#endif + + /* Allocate space. */ + r = (regprog_T *)lalloc(sizeof(regprog_T) + regsize, TRUE); + if (r == NULL) + return NULL; + + /* + * Second pass: emit code. + */ + regcomp_start(expr, re_flags); + regcode = r->program; + regc(REGMAGIC); + if (reg(REG_NOPAREN, &flags) == NULL) + { + vim_free(r); + return NULL; + } + + /* Dig out information for optimizations. */ + r->regstart = NUL; /* Worst-case defaults. */ + r->reganch = 0; + r->regmust = NULL; + r->regmlen = 0; + r->regflags = regflags; + if (flags & HASNL) + r->regflags |= RF_HASNL; + if (flags & HASLOOKBH) + r->regflags |= RF_LOOKBH; +#ifdef FEAT_SYN_HL + /* Remember whether this pattern has any \z specials in it. */ + r->reghasz = re_has_z; +#endif + scan = r->program + 1; /* First BRANCH. */ + if (OP(regnext(scan)) == END) /* Only one top-level choice. */ + { + scan = OPERAND(scan); + + /* Starting-point info. */ + if (OP(scan) == BOL || OP(scan) == RE_BOF) + { + r->reganch++; + scan = regnext(scan); + } + + if (OP(scan) == EXACTLY) + { +#ifdef FEAT_MBYTE + if (has_mbyte) + r->regstart = (*mb_ptr2char)(OPERAND(scan)); + else +#endif + r->regstart = *OPERAND(scan); + } + else if ((OP(scan) == BOW + || OP(scan) == EOW + || OP(scan) == NOTHING + || OP(scan) == MOPEN + 0 || OP(scan) == NOPEN + || OP(scan) == MCLOSE + 0 || OP(scan) == NCLOSE) + && OP(regnext(scan)) == EXACTLY) + { +#ifdef FEAT_MBYTE + if (has_mbyte) + r->regstart = (*mb_ptr2char)(OPERAND(regnext(scan))); + else +#endif + r->regstart = *OPERAND(regnext(scan)); + } + + /* + * If there's something expensive in the r.e., find the longest + * literal string that must appear and make it the regmust. Resolve + * ties in favor of later strings, since the regstart check works + * with the beginning of the r.e. and avoiding duplication + * strengthens checking. Not a strong reason, but sufficient in the + * absence of others. + */ + /* + * When the r.e. starts with BOW, it is faster to look for a regmust + * first. Used a lot for "#" and "*" commands. (Added by mool). + */ + if ((flags & SPSTART || OP(scan) == BOW || OP(scan) == EOW) + && !(flags & HASNL)) + { + longest = NULL; + len = 0; + for (; scan != NULL; scan = regnext(scan)) + if (OP(scan) == EXACTLY && STRLEN(OPERAND(scan)) >= (size_t)len) + { + longest = OPERAND(scan); + len = (int)STRLEN(OPERAND(scan)); + } + r->regmust = longest; + r->regmlen = len; + } + } +#ifdef DEBUG + regdump(expr, r); +#endif + return r; +} + +/* + * Setup to parse the regexp. Used once to get the length and once to do it. + */ + static void +regcomp_start(expr, re_flags) + char_u *expr; + int re_flags; /* see vim_regcomp() */ +{ + initchr(expr); + if (re_flags & RE_MAGIC) + reg_magic = MAGIC_ON; + else + reg_magic = MAGIC_OFF; + reg_string = (re_flags & RE_STRING); + + num_complex_braces = 0; + regnpar = 1; + vim_memset(had_endbrace, 0, sizeof(had_endbrace)); +#ifdef FEAT_SYN_HL + regnzpar = 1; + re_has_z = 0; +#endif + regsize = 0L; + regflags = 0; +#if defined(FEAT_SYN_HL) || defined(PROTO) + had_eol = FALSE; +#endif +} + +#if defined(FEAT_SYN_HL) || defined(PROTO) +/* + * Check if during the previous call to vim_regcomp the EOL item "$" has been + * found. This is messy, but it works fine. + */ + int +vim_regcomp_had_eol() +{ + return had_eol; +} +#endif + +/* + * reg - regular expression, i.e. main body or parenthesized thing + * + * Caller must absorb opening parenthesis. + * + * Combining parenthesis handling with the base level of regular expression + * is a trifle forced, but the need to tie the tails of the branches to what + * follows makes it hard to avoid. + */ + static char_u * +reg(paren, flagp) + int paren; /* REG_NOPAREN, REG_PAREN, REG_NPAREN or REG_ZPAREN */ + int *flagp; +{ + char_u *ret; + char_u *br; + char_u *ender; + int parno = 0; + int flags; + + *flagp = HASWIDTH; /* Tentatively. */ + +#ifdef FEAT_SYN_HL + if (paren == REG_ZPAREN) + { + /* Make a ZOPEN node. */ + if (regnzpar >= NSUBEXP) + EMSG_RET_NULL(_("E50: Too many \\z(")); + parno = regnzpar; + regnzpar++; + ret = regnode(ZOPEN + parno); + } + else +#endif + if (paren == REG_PAREN) + { + /* Make a MOPEN node. */ + if (regnpar >= NSUBEXP) + EMSG_M_RET_NULL(_("E51: Too many %s("), reg_magic == MAGIC_ALL); + parno = regnpar; + ++regnpar; + ret = regnode(MOPEN + parno); + } + else if (paren == REG_NPAREN) + { + /* Make a NOPEN node. */ + ret = regnode(NOPEN); + } + else + ret = NULL; + + /* Pick up the branches, linking them together. */ + br = regbranch(&flags); + if (br == NULL) + return NULL; + if (ret != NULL) + regtail(ret, br); /* [MZ]OPEN -> first. */ + else + ret = br; + /* If one of the branches can be zero-width, the whole thing can. + * If one of the branches has * at start or matches a line-break, the + * whole thing can. */ + if (!(flags & HASWIDTH)) + *flagp &= ~HASWIDTH; + *flagp |= flags & (SPSTART | HASNL | HASLOOKBH); + while (peekchr() == Magic('|')) + { + skipchr(); + br = regbranch(&flags); + if (br == NULL) + return NULL; + regtail(ret, br); /* BRANCH -> BRANCH. */ + if (!(flags & HASWIDTH)) + *flagp &= ~HASWIDTH; + *flagp |= flags & (SPSTART | HASNL | HASLOOKBH); + } + + /* Make a closing node, and hook it on the end. */ + ender = regnode( +#ifdef FEAT_SYN_HL + paren == REG_ZPAREN ? ZCLOSE + parno : +#endif + paren == REG_PAREN ? MCLOSE + parno : + paren == REG_NPAREN ? NCLOSE : END); + regtail(ret, ender); + + /* Hook the tails of the branches to the closing node. */ + for (br = ret; br != NULL; br = regnext(br)) + regoptail(br, ender); + + /* Check for proper termination. */ + if (paren != REG_NOPAREN && getchr() != Magic(')')) + { +#ifdef FEAT_SYN_HL + if (paren == REG_ZPAREN) + EMSG_RET_NULL(_("E52: Unmatched \\z(")) + else +#endif + if (paren == REG_NPAREN) + EMSG_M_RET_NULL(_("E53: Unmatched %s%%("), reg_magic == MAGIC_ALL) + else + EMSG_M_RET_NULL(_("E54: Unmatched %s("), reg_magic == MAGIC_ALL) + } + else if (paren == REG_NOPAREN && peekchr() != NUL) + { + if (curchr == Magic(')')) + EMSG_M_RET_NULL(_("E55: Unmatched %s)"), reg_magic == MAGIC_ALL) + else + EMSG_RET_NULL(_(e_trailing)) /* "Can't happen". */ + /* NOTREACHED */ + } + /* + * Here we set the flag allowing back references to this set of + * parentheses. + */ + if (paren == REG_PAREN) + had_endbrace[parno] = TRUE; /* have seen the close paren */ + return ret; +} + +/* + * regbranch - one alternative of an | operator + * + * Implements the & operator. + */ + static char_u * +regbranch(flagp) + int *flagp; +{ + char_u *ret; + char_u *chain = NULL; + char_u *latest; + int flags; + + *flagp = WORST | HASNL; /* Tentatively. */ + + ret = regnode(BRANCH); + for (;;) + { + latest = regconcat(&flags); + if (latest == NULL) + return NULL; + /* If one of the branches has width, the whole thing has. If one of + * the branches anchors at start-of-line, the whole thing does. + * If one of the branches uses look-behind, the whole thing does. */ + *flagp |= flags & (HASWIDTH | SPSTART | HASLOOKBH); + /* If one of the branches doesn't match a line-break, the whole thing + * doesn't. */ + *flagp &= ~HASNL | (flags & HASNL); + if (chain != NULL) + regtail(chain, latest); + if (peekchr() != Magic('&')) + break; + skipchr(); + regtail(latest, regnode(END)); /* operand ends */ + reginsert(MATCH, latest); + chain = latest; + } + + return ret; +} + +/* + * regbranch - one alternative of an | or & operator + * + * Implements the concatenation operator. + */ + static char_u * +regconcat(flagp) + int *flagp; +{ + char_u *first = NULL; + char_u *chain = NULL; + char_u *latest; + int flags; + int cont = TRUE; + + *flagp = WORST; /* Tentatively. */ + + while (cont) + { + switch (peekchr()) + { + case NUL: + case Magic('|'): + case Magic('&'): + case Magic(')'): + cont = FALSE; + break; + case Magic('Z'): +#ifdef FEAT_MBYTE + regflags |= RF_ICOMBINE; +#endif + skipchr_keepstart(); + break; + case Magic('c'): + regflags |= RF_ICASE; + skipchr_keepstart(); + break; + case Magic('C'): + regflags |= RF_NOICASE; + skipchr_keepstart(); + break; + case Magic('v'): + reg_magic = MAGIC_ALL; + skipchr_keepstart(); + curchr = -1; + break; + case Magic('m'): + reg_magic = MAGIC_ON; + skipchr_keepstart(); + curchr = -1; + break; + case Magic('M'): + reg_magic = MAGIC_OFF; + skipchr_keepstart(); + curchr = -1; + break; + case Magic('V'): + reg_magic = MAGIC_NONE; + skipchr_keepstart(); + curchr = -1; + break; + default: + latest = regpiece(&flags); + if (latest == NULL) + return NULL; + *flagp |= flags & (HASWIDTH | HASNL | HASLOOKBH); + if (chain == NULL) /* First piece. */ + *flagp |= flags & SPSTART; + else + regtail(chain, latest); + chain = latest; + if (first == NULL) + first = latest; + break; + } + } + if (first == NULL) /* Loop ran zero times. */ + first = regnode(NOTHING); + return first; +} + +/* + * regpiece - something followed by possible [*+=] + * + * Note that the branching code sequences used for = and the general cases + * of * and + are somewhat optimized: they use the same NOTHING node as + * both the endmarker for their branch list and the body of the last branch. + * It might seem that this node could be dispensed with entirely, but the + * endmarker role is not redundant. + */ + static char_u * +regpiece(flagp) + int *flagp; +{ + char_u *ret; + int op; + char_u *next; + int flags; + long minval; + long maxval; + + ret = regatom(&flags); + if (ret == NULL) + return NULL; + + op = peekchr(); + if (re_multi_type(op) == NOT_MULTI) + { + *flagp = flags; + return ret; + } + if (!(flags & HASWIDTH) && re_multi_type(op) == MULTI_MULT) + { + if (op == Magic('*')) + EMSG_M_RET_NULL(_("E56: %s* operand could be empty"), + reg_magic >= MAGIC_ON); + if (op == Magic('+')) + EMSG_M_RET_NULL(_("E57: %s+ operand could be empty"), + reg_magic == MAGIC_ALL); + /* "\{}" is checked below, it's allowed when there is an upper limit */ + } + /* default flags */ + *flagp = (WORST | SPSTART | (flags & (HASNL | HASLOOKBH))); + + skipchr(); + switch (op) + { + case Magic('*'): + if (flags & SIMPLE) + reginsert(STAR, ret); + else + { + /* Emit x* as (x&|), where & means "self". */ + reginsert(BRANCH, ret); /* Either x */ + regoptail(ret, regnode(BACK)); /* and loop */ + regoptail(ret, ret); /* back */ + regtail(ret, regnode(BRANCH)); /* or */ + regtail(ret, regnode(NOTHING)); /* null. */ + } + break; + + case Magic('+'): + if (flags & SIMPLE) + reginsert(PLUS, ret); + else + { + /* Emit x+ as x(&|), where & means "self". */ + next = regnode(BRANCH); /* Either */ + regtail(ret, next); + regtail(regnode(BACK), ret); /* loop back */ + regtail(next, regnode(BRANCH)); /* or */ + regtail(ret, regnode(NOTHING)); /* null. */ + } + *flagp = (WORST | HASWIDTH | (flags & (HASNL | HASLOOKBH))); + break; + + case Magic('@'): + { + int lop = END; + + switch (no_Magic(getchr())) + { + case '=': lop = MATCH; break; /* \@= */ + case '!': lop = NOMATCH; break; /* \@! */ + case '>': lop = SUBPAT; break; /* \@> */ + case '<': switch (no_Magic(getchr())) + { + case '=': lop = BEHIND; break; /* \@<= */ + case '!': lop = NOBEHIND; break; /* \@<! */ + } + } + if (lop == END) + EMSG_M_RET_NULL(_("E59: invalid character after %s@"), + reg_magic == MAGIC_ALL); + /* Look behind must match with behind_pos. */ + if (lop == BEHIND || lop == NOBEHIND) + { + regtail(ret, regnode(BHPOS)); + *flagp |= HASLOOKBH; + } + regtail(ret, regnode(END)); /* operand ends */ + reginsert(lop, ret); + break; + } + + case Magic('?'): + case Magic('='): + /* Emit x= as (x|) */ + reginsert(BRANCH, ret); /* Either x */ + regtail(ret, regnode(BRANCH)); /* or */ + next = regnode(NOTHING); /* null. */ + regtail(ret, next); + regoptail(ret, next); + break; + + case Magic('{'): + if (!read_limits(&minval, &maxval)) + return NULL; + if (!(flags & HASWIDTH) && (maxval > minval + ? maxval >= MAX_LIMIT : minval >= MAX_LIMIT)) + EMSG_M_RET_NULL(_("E58: %s{ operand could be empty"), + reg_magic == MAGIC_ALL); + if (flags & SIMPLE) + { + reginsert(BRACE_SIMPLE, ret); + reginsert_limits(BRACE_LIMITS, minval, maxval, ret); + } + else + { + if (num_complex_braces >= 10) + EMSG_M_RET_NULL(_("E60: Too many complex %s{...}s"), + reg_magic == MAGIC_ALL); + reginsert(BRACE_COMPLEX + num_complex_braces, ret); + regoptail(ret, regnode(BACK)); + regoptail(ret, ret); + reginsert_limits(BRACE_LIMITS, minval, maxval, ret); + ++num_complex_braces; + } + if (minval > 0 && maxval > 0) + *flagp = (HASWIDTH | (flags & (HASNL | HASLOOKBH))); + break; + } + if (re_multi_type(peekchr()) != NOT_MULTI) + { + /* Can't have a multi follow a multi. */ + if (peekchr() == Magic('*')) + sprintf((char *)IObuff, _("E61: Nested %s*"), + reg_magic >= MAGIC_ON ? "" : "\\"); + else + sprintf((char *)IObuff, _("E62: Nested %s%c"), + reg_magic == MAGIC_ALL ? "" : "\\", no_Magic(peekchr())); + EMSG_RET_NULL(IObuff); + } + + return ret; +} + +/* + * regatom - the lowest level + * + * Optimization: gobbles an entire sequence of ordinary characters so that + * it can turn them into a single node, which is smaller to store and + * faster to run. Don't do this when one_exactly is set. + */ + static char_u * +regatom(flagp) + int *flagp; +{ + char_u *ret; + int flags; + int cpo_lit; /* 'cpoptions' contains 'l' flag */ + int c; + static char_u *classchars = (char_u *)".iIkKfFpPsSdDxXoOwWhHaAlLuU"; + static int classcodes[] = {ANY, IDENT, SIDENT, KWORD, SKWORD, + FNAME, SFNAME, PRINT, SPRINT, + WHITE, NWHITE, DIGIT, NDIGIT, + HEX, NHEX, OCTAL, NOCTAL, + WORD, NWORD, HEAD, NHEAD, + ALPHA, NALPHA, LOWER, NLOWER, + UPPER, NUPPER + }; + char_u *p; + int extra = 0; + + *flagp = WORST; /* Tentatively. */ + cpo_lit = (!reg_syn && vim_strchr(p_cpo, CPO_LITERAL) != NULL); + + c = getchr(); + switch (c) + { + case Magic('^'): + ret = regnode(BOL); + break; + + case Magic('$'): + ret = regnode(EOL); +#if defined(FEAT_SYN_HL) || defined(PROTO) + had_eol = TRUE; +#endif + break; + + case Magic('<'): + ret = regnode(BOW); + break; + + case Magic('>'): + ret = regnode(EOW); + break; + + case Magic('_'): + c = no_Magic(getchr()); + if (c == '^') /* "\_^" is start-of-line */ + { + ret = regnode(BOL); + break; + } + if (c == '$') /* "\_$" is end-of-line */ + { + ret = regnode(EOL); +#if defined(FEAT_SYN_HL) || defined(PROTO) + had_eol = TRUE; +#endif + break; + } + + extra = ADD_NL; + *flagp |= HASNL; + + /* "\_[" is character range plus newline */ + if (c == '[') + goto collection; + + /* "\_x" is character class plus newline */ + /*FALLTHROUGH*/ + + /* + * Character classes. + */ + case Magic('.'): + case Magic('i'): + case Magic('I'): + case Magic('k'): + case Magic('K'): + case Magic('f'): + case Magic('F'): + case Magic('p'): + case Magic('P'): + case Magic('s'): + case Magic('S'): + case Magic('d'): + case Magic('D'): + case Magic('x'): + case Magic('X'): + case Magic('o'): + case Magic('O'): + case Magic('w'): + case Magic('W'): + case Magic('h'): + case Magic('H'): + case Magic('a'): + case Magic('A'): + case Magic('l'): + case Magic('L'): + case Magic('u'): + case Magic('U'): + p = vim_strchr(classchars, no_Magic(c)); + if (p == NULL) + EMSG_RET_NULL(_("E63: invalid use of \\_")); + ret = regnode(classcodes[p - classchars] + extra); + *flagp |= HASWIDTH | SIMPLE; + break; + + case Magic('n'): + if (reg_string) + { + /* In a string "\n" matches a newline character. */ + ret = regnode(EXACTLY); + regc(NL); + regc(NUL); + *flagp |= HASWIDTH | SIMPLE; + } + else + { + /* In buffer text "\n" matches the end of a line. */ + ret = regnode(NEWL); + *flagp |= HASWIDTH | HASNL; + } + break; + + case Magic('('): + if (one_exactly) + EMSG_ONE_RET_NULL; + ret = reg(REG_PAREN, &flags); + if (ret == NULL) + return NULL; + *flagp |= flags & (HASWIDTH | SPSTART | HASNL | HASLOOKBH); + break; + + case NUL: + case Magic('|'): + case Magic('&'): + case Magic(')'): + EMSG_RET_NULL(_(e_internal)); /* Supposed to be caught earlier. */ + /* NOTREACHED */ + + case Magic('='): + case Magic('?'): + case Magic('+'): + case Magic('@'): + case Magic('{'): + case Magic('*'): + c = no_Magic(c); + sprintf((char *)IObuff, _("E64: %s%c follows nothing"), + (c == '*' ? reg_magic >= MAGIC_ON : reg_magic == MAGIC_ALL) + ? "" : "\\", c); + EMSG_RET_NULL(IObuff); + /* NOTREACHED */ + + case Magic('~'): /* previous substitute pattern */ + if (reg_prev_sub) + { + char_u *lp; + + ret = regnode(EXACTLY); + lp = reg_prev_sub; + while (*lp != NUL) + regc(*lp++); + regc(NUL); + if (*reg_prev_sub != NUL) + { + *flagp |= HASWIDTH; + if ((lp - reg_prev_sub) == 1) + *flagp |= SIMPLE; + } + } + else + EMSG_RET_NULL(_(e_nopresub)); + break; + + case Magic('1'): + case Magic('2'): + case Magic('3'): + case Magic('4'): + case Magic('5'): + case Magic('6'): + case Magic('7'): + case Magic('8'): + case Magic('9'): + { + int refnum; + + refnum = c - Magic('0'); + /* + * Check if the back reference is legal. We must have seen the + * close brace. + * TODO: Should also check that we don't refer to something + * that is repeated (+*=): what instance of the repetition + * should we match? + */ + if (!had_endbrace[refnum]) + { + /* Trick: check if "@<=" or "@<!" follows, in which case + * the \1 can appear before the referenced match. */ + for (p = regparse; *p != NUL; ++p) + if (p[0] == '@' && p[1] == '<' + && (p[2] == '!' || p[2] == '=')) + break; + if (*p == NUL) + EMSG_RET_NULL(_("E65: Illegal back reference")); + } + ret = regnode(BACKREF + refnum); + } + break; + +#ifdef FEAT_SYN_HL + case Magic('z'): + { + c = no_Magic(getchr()); + switch (c) + { + case '(': if (reg_do_extmatch != REX_SET) + EMSG_RET_NULL(_("E66: \\z( not allowed here")); + if (one_exactly) + EMSG_ONE_RET_NULL; + ret = reg(REG_ZPAREN, &flags); + if (ret == NULL) + return NULL; + *flagp |= flags & (HASWIDTH|SPSTART|HASNL|HASLOOKBH); + re_has_z = REX_SET; + break; + + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': if (reg_do_extmatch != REX_USE) + EMSG_RET_NULL(_("E67: \\z1 et al. not allowed here")); + ret = regnode(ZREF + c - '0'); + re_has_z = REX_USE; + break; + + case 's': ret = regnode(MOPEN + 0); + break; + + case 'e': ret = regnode(MCLOSE + 0); + break; + + default: EMSG_RET_NULL(_("E68: Invalid character after \\z")); + } + } + break; +#endif + + case Magic('%'): + { + c = no_Magic(getchr()); + switch (c) + { + /* () without a back reference */ + case '(': + if (one_exactly) + EMSG_ONE_RET_NULL; + ret = reg(REG_NPAREN, &flags); + if (ret == NULL) + return NULL; + *flagp |= flags & (HASWIDTH | SPSTART | HASNL | HASLOOKBH); + break; + + /* Catch \%^ and \%$ regardless of where they appear in the + * pattern -- regardless of whether or not it makes sense. */ + case '^': + ret = regnode(RE_BOF); + break; + + case '$': + ret = regnode(RE_EOF); + break; + + case '#': + ret = regnode(CURSOR); + break; + + /* \%[abc]: Emit as a list of branches, all ending at the last + * branch which matches nothing. */ + case '[': + if (one_exactly) /* doesn't nest */ + EMSG_ONE_RET_NULL; + { + char_u *lastbranch; + char_u *lastnode = NULL; + char_u *br; + + ret = NULL; + while ((c = getchr()) != ']') + { + if (c == NUL) + EMSG_M_RET_NULL(_("E69: Missing ] after %s%%["), + reg_magic == MAGIC_ALL); + br = regnode(BRANCH); + if (ret == NULL) + ret = br; + else + regtail(lastnode, br); + + ungetchr(); + one_exactly = TRUE; + lastnode = regatom(flagp); + one_exactly = FALSE; + if (lastnode == NULL) + return NULL; + } + if (ret == NULL) + EMSG_M_RET_NULL(_("E70: Empty %s%%[]"), + reg_magic == MAGIC_ALL); + lastbranch = regnode(BRANCH); + br = regnode(NOTHING); + if (ret != JUST_CALC_SIZE) + { + regtail(lastnode, br); + regtail(lastbranch, br); + /* connect all branches to the NOTHING + * branch at the end */ + for (br = ret; br != lastnode; ) + { + if (OP(br) == BRANCH) + { + regtail(br, lastbranch); + br = OPERAND(br); + } + else + br = regnext(br); + } + } + *flagp &= ~HASWIDTH; + break; + } + + default: + if (VIM_ISDIGIT(c) || c == '<' || c == '>') + { + long_u n = 0; + int cmp; + + cmp = c; + if (cmp == '<' || cmp == '>') + c = getchr(); + while (VIM_ISDIGIT(c)) + { + n = n * 10 + (c - '0'); + c = getchr(); + } + if (c == 'l' || c == 'c' || c == 'v') + { + if (c == 'l') + ret = regnode(RE_LNUM); + else if (c == 'c') + ret = regnode(RE_COL); + else + ret = regnode(RE_VCOL); + if (ret == JUST_CALC_SIZE) + regsize += 5; + else + { + /* put the number and the optional + * comparator after the opcode */ + regcode = re_put_long(regcode, n); + *regcode++ = cmp; + } + break; + } + } + + EMSG_M_RET_NULL(_("E71: Invalid character after %s%%"), + reg_magic == MAGIC_ALL); + } + } + break; + + case Magic('['): +collection: + { + char_u *lp; + + /* + * If there is no matching ']', we assume the '[' is a normal + * character. This makes 'incsearch' and ":help [" work. + */ + lp = skip_anyof(regparse); + if (*lp == ']') /* there is a matching ']' */ + { + int startc = -1; /* > 0 when next '-' is a range */ + int endc; + + /* + * In a character class, different parsing rules apply. + * Not even \ is special anymore, nothing is. + */ + if (*regparse == '^') /* Complement of range. */ + { + ret = regnode(ANYBUT + extra); + regparse++; + } + else + ret = regnode(ANYOF + extra); + + /* At the start ']' and '-' mean the literal character. */ + if (*regparse == ']' || *regparse == '-') + regc(*regparse++); + + while (*regparse != NUL && *regparse != ']') + { + if (*regparse == '-') + { + ++regparse; + /* The '-' is not used for a range at the end and + * after or before a '\n'. */ + if (*regparse == ']' || *regparse == NUL + || startc == -1 + || (regparse[0] == '\\' && regparse[1] == 'n')) + { + regc('-'); + startc = '-'; /* [--x] is a range */ + } + else + { +#ifdef FEAT_MBYTE + if (has_mbyte) + endc = mb_ptr2char_adv(®parse); + else +#endif + endc = *regparse++; + if (startc > endc) + EMSG_RET_NULL(_(e_invrange)); +#ifdef FEAT_MBYTE + if (has_mbyte && ((*mb_char2len)(startc) > 1 + || (*mb_char2len)(endc) > 1)) + { + /* Limit to a range of 256 chars */ + if (endc > startc + 256) + EMSG_RET_NULL(_(e_invrange)); + while (++startc <= endc) + regmbc(startc); + } + else +#endif + { +#ifdef EBCDIC + int alpha_only = FALSE; + + /* for alphabetical range skip the gaps + * 'i'-'j', 'r'-'s', 'I'-'J' and 'R'-'S'. */ + if (isalpha(startc) && isalpha(endc)) + alpha_only = TRUE; +#endif + while (++startc <= endc) +#ifdef EBCDIC + if (!alpha_only || isalpha(startc)) +#endif + regc(startc); + } + startc = -1; + } + } + /* + * Only "\]", "\^", "\]" and "\\" are special in Vi. Vim + * accepts "\t", "\e", etc., but only when the 'l' flag in + * 'cpoptions' is not included. + */ + else if (*regparse == '\\' + && (vim_strchr(REGEXP_INRANGE, regparse[1]) != NULL + || (!cpo_lit + && vim_strchr(REGEXP_ABBR, + regparse[1]) != NULL))) + { + regparse++; + if (*regparse == 'n') + { + /* '\n' in range: also match NL */ + if (ret != JUST_CALC_SIZE) + { + if (*ret == ANYBUT) + *ret = ANYBUT + ADD_NL; + else if (*ret == ANYOF) + *ret = ANYOF + ADD_NL; + /* else: must have had a \n already */ + } + *flagp |= HASNL; + regparse++; + startc = -1; + } + else + { + startc = backslash_trans(*regparse++); + regc(startc); + } + } + else if (*regparse == '[') + { + int c_class; + int cu; + + c_class = skip_class_name(®parse); + startc = -1; + /* Characters assumed to be 8 bits! */ + switch (c_class) + { + case CLASS_NONE: + /* literal '[', allow [[-x] as a range */ + startc = *regparse++; + regc(startc); + break; + case CLASS_ALNUM: + for (cu = 1; cu <= 255; cu++) + if (isalnum(cu)) + regc(cu); + break; + case CLASS_ALPHA: + for (cu = 1; cu <= 255; cu++) + if (isalpha(cu)) + regc(cu); + break; + case CLASS_BLANK: + regc(' '); + regc('\t'); + break; + case CLASS_CNTRL: + for (cu = 1; cu <= 255; cu++) + if (iscntrl(cu)) + regc(cu); + break; + case CLASS_DIGIT: + for (cu = 1; cu <= 255; cu++) + if (VIM_ISDIGIT(cu)) + regc(cu); + break; + case CLASS_GRAPH: + for (cu = 1; cu <= 255; cu++) + if (isgraph(cu)) + regc(cu); + break; + case CLASS_LOWER: + for (cu = 1; cu <= 255; cu++) + if (islower(cu)) + regc(cu); + break; + case CLASS_PRINT: + for (cu = 1; cu <= 255; cu++) + if (vim_isprintc(cu)) + regc(cu); + break; + case CLASS_PUNCT: + for (cu = 1; cu <= 255; cu++) + if (ispunct(cu)) + regc(cu); + break; + case CLASS_SPACE: + for (cu = 9; cu <= 13; cu++) + regc(cu); + regc(' '); + break; + case CLASS_UPPER: + for (cu = 1; cu <= 255; cu++) + if (isupper(cu)) + regc(cu); + break; + case CLASS_XDIGIT: + for (cu = 1; cu <= 255; cu++) + if (vim_isxdigit(cu)) + regc(cu); + break; + case CLASS_TAB: + regc('\t'); + break; + case CLASS_RETURN: + regc('\r'); + break; + case CLASS_BACKSPACE: + regc('\b'); + break; + case CLASS_ESCAPE: + regc('\033'); + break; + } + } + else + { +#ifdef FEAT_MBYTE + if (has_mbyte) + { + int len; + + /* produce a multibyte character, including any + * following composing characters */ + startc = mb_ptr2char(regparse); + len = (*mb_ptr2len_check)(regparse); + if (enc_utf8 && utf_char2len(startc) != len) + startc = -1; /* composing chars */ + while (--len >= 0) + regc(*regparse++); + } + else +#endif + { + startc = *regparse++; + regc(startc); + } + } + } + regc(NUL); + prevchr_len = 1; /* last char was the ']' */ + if (*regparse != ']') + EMSG_RET_NULL(_(e_toomsbra)); /* Cannot happen? */ + skipchr(); /* let's be friends with the lexer again */ + *flagp |= HASWIDTH | SIMPLE; + break; + } + } + /* FALLTHROUGH */ + + default: + { + int len; + +#ifdef FEAT_MBYTE + /* A multi-byte character is handled as a separate atom if it's + * before a multi. */ + if (has_mbyte && (*mb_char2len)(c) > 1 + && re_multi_type(peekchr()) != NOT_MULTI) + { + ret = regnode(MULTIBYTECODE); + regmbc(c); + *flagp |= HASWIDTH | SIMPLE; + break; + } +#endif + + ret = regnode(EXACTLY); + + /* + * Append characters as long as: + * - there is no following multi, we then need the character in + * front of it as a single character operand + * - not running into a Magic character + * - "one_exactly" is not set + * But always emit at least one character. Might be a Multi, + * e.g., a "[" without matching "]". + */ + for (len = 0; c != NUL && (len == 0 + || (re_multi_type(peekchr()) == NOT_MULTI + && !one_exactly + && !is_Magic(c))); ++len) + { + c = no_Magic(c); +#ifdef FEAT_MBYTE + if (has_mbyte) + { + regmbc(c); + if (enc_utf8) + { + int off; + int l; + + /* Need to get composing character too, directly + * access regparse for that, because skipchr() skips + * over composing chars. */ + ungetchr(); + if (*regparse == '\\' && regparse[1] != NUL) + off = 1; + else + off = 0; + for (;;) + { + l = utf_ptr2len_check(regparse + off); + if (!UTF_COMPOSINGLIKE(regparse + off, + regparse + off + l)) + break; + off += l; + regmbc(utf_ptr2char(regparse + off)); + } + skipchr(); + } + } + else +#endif + regc(c); + c = getchr(); + } + ungetchr(); + + regc(NUL); + *flagp |= HASWIDTH; + if (len == 1) + *flagp |= SIMPLE; + } + break; + } + + return ret; +} + +/* + * emit a node + * Return pointer to generated code. + */ + static char_u * +regnode(op) + int op; +{ + char_u *ret; + + ret = regcode; + if (ret == JUST_CALC_SIZE) + regsize += 3; + else + { + *regcode++ = op; + *regcode++ = NUL; /* Null "next" pointer. */ + *regcode++ = NUL; + } + return ret; +} + +/* + * Emit (if appropriate) a byte of code + */ + static void +regc(b) + int b; +{ + if (regcode == JUST_CALC_SIZE) + regsize++; + else + *regcode++ = b; +} + +#ifdef FEAT_MBYTE +/* + * Emit (if appropriate) a multi-byte character of code + */ + static void +regmbc(c) + int c; +{ + if (regcode == JUST_CALC_SIZE) + regsize += (*mb_char2len)(c); + else + regcode += (*mb_char2bytes)(c, regcode); +} +#endif + +/* + * reginsert - insert an operator in front of already-emitted operand + * + * Means relocating the operand. + */ + static void +reginsert(op, opnd) + int op; + char_u *opnd; +{ + char_u *src; + char_u *dst; + char_u *place; + + if (regcode == JUST_CALC_SIZE) + { + regsize += 3; + return; + } + src = regcode; + regcode += 3; + dst = regcode; + while (src > opnd) + *--dst = *--src; + + place = opnd; /* Op node, where operand used to be. */ + *place++ = op; + *place++ = NUL; + *place = NUL; +} + +/* + * reginsert_limits - insert an operator in front of already-emitted operand. + * The operator has the given limit values as operands. Also set next pointer. + * + * Means relocating the operand. + */ + static void +reginsert_limits(op, minval, maxval, opnd) + int op; + long minval; + long maxval; + char_u *opnd; +{ + char_u *src; + char_u *dst; + char_u *place; + + if (regcode == JUST_CALC_SIZE) + { + regsize += 11; + return; + } + src = regcode; + regcode += 11; + dst = regcode; + while (src > opnd) + *--dst = *--src; + + place = opnd; /* Op node, where operand used to be. */ + *place++ = op; + *place++ = NUL; + *place++ = NUL; + place = re_put_long(place, (long_u)minval); + place = re_put_long(place, (long_u)maxval); + regtail(opnd, place); +} + +/* + * Write a long as four bytes at "p" and return pointer to the next char. + */ + static char_u * +re_put_long(p, val) + char_u *p; + long_u val; +{ + *p++ = (char_u) ((val >> 24) & 0377); + *p++ = (char_u) ((val >> 16) & 0377); + *p++ = (char_u) ((val >> 8) & 0377); + *p++ = (char_u) (val & 0377); + return p; +} + +/* + * regtail - set the next-pointer at the end of a node chain + */ + static void +regtail(p, val) + char_u *p; + char_u *val; +{ + char_u *scan; + char_u *temp; + int offset; + + if (p == JUST_CALC_SIZE) + return; + + /* Find last node. */ + scan = p; + for (;;) + { + temp = regnext(scan); + if (temp == NULL) + break; + scan = temp; + } + + if (OP(scan) == BACK) + offset = (int)(scan - val); + else + offset = (int)(val - scan); + *(scan + 1) = (char_u) (((unsigned)offset >> 8) & 0377); + *(scan + 2) = (char_u) (offset & 0377); +} + +/* + * regoptail - regtail on item after a BRANCH; nop if none + */ + static void +regoptail(p, val) + char_u *p; + char_u *val; +{ + /* When op is neither BRANCH nor BRACE_COMPLEX0-9, it is "operandless" */ + if (p == NULL || p == JUST_CALC_SIZE + || (OP(p) != BRANCH + && (OP(p) < BRACE_COMPLEX || OP(p) > BRACE_COMPLEX + 9))) + return; + regtail(OPERAND(p), val); +} + +/* + * getchr() - get the next character from the pattern. We know about + * magic and such, so therefore we need a lexical analyzer. + */ + +/* static int curchr; */ +static int prevprevchr; +static int prevchr; +static int nextchr; /* used for ungetchr() */ +/* + * Note: prevchr is sometimes -1 when we are not at the start, + * eg in /[ ^I]^ the pattern was never found even if it existed, because ^ was + * taken to be magic -- webb + */ +static int at_start; /* True when on the first character */ +static int prev_at_start; /* True when on the second character */ + + static void +initchr(str) + char_u *str; +{ + regparse = str; + prevchr_len = 0; + curchr = prevprevchr = prevchr = nextchr = -1; + at_start = TRUE; + prev_at_start = FALSE; +} + + static int +peekchr() +{ + if (curchr == -1) + { + switch (curchr = regparse[0]) + { + case '.': + case '[': + case '~': + /* magic when 'magic' is on */ + if (reg_magic >= MAGIC_ON) + curchr = Magic(curchr); + break; + case '(': + case ')': + case '{': + case '%': + case '+': + case '=': + case '?': + case '@': + case '!': + case '&': + case '|': + case '<': + case '>': + case '#': /* future ext. */ + case '"': /* future ext. */ + case '\'': /* future ext. */ + case ',': /* future ext. */ + case '-': /* future ext. */ + case ':': /* future ext. */ + case ';': /* future ext. */ + case '`': /* future ext. */ + case '/': /* Can't be used in / command */ + /* magic only after "\v" */ + if (reg_magic == MAGIC_ALL) + curchr = Magic(curchr); + break; + case '*': + /* * is not magic as the very first character, eg "?*ptr" and when + * after '^', eg "/^*ptr" */ + if (reg_magic >= MAGIC_ON && !at_start + && !(prev_at_start && prevchr == Magic('^'))) + curchr = Magic('*'); + break; + case '^': + /* '^' is only magic as the very first character and if it's after + * "\(", "\|", "\&' or "\n" */ + if (reg_magic >= MAGIC_OFF + && (at_start + || reg_magic == MAGIC_ALL + || prevchr == Magic('(') + || prevchr == Magic('|') + || prevchr == Magic('&') + || prevchr == Magic('n') + || (no_Magic(prevchr) == '(' + && prevprevchr == Magic('%')))) + { + curchr = Magic('^'); + at_start = TRUE; + prev_at_start = FALSE; + } + break; + case '$': + /* '$' is only magic as the very last char and if it's in front of + * either "\|", "\)", "\&", or "\n" */ + if (reg_magic >= MAGIC_OFF) + { + char_u *p = regparse + 1; + + /* ignore \c \C \m and \M after '$' */ + while (p[0] == '\\' && (p[1] == 'c' || p[1] == 'C' + || p[1] == 'm' || p[1] == 'M' || p[1] == 'Z')) + p += 2; + if (p[0] == NUL + || (p[0] == '\\' + && (p[1] == '|' || p[1] == '&' || p[1] == ')' + || p[1] == 'n')) + || reg_magic == MAGIC_ALL) + curchr = Magic('$'); + } + break; + case '\\': + { + int c = regparse[1]; + + if (c == NUL) + curchr = '\\'; /* trailing '\' */ + else if ( +#ifdef EBCDIC + vim_strchr(META, c) +#else + c <= '~' && META_flags[c] +#endif + ) + { + /* + * META contains everything that may be magic sometimes, + * except ^ and $ ("\^" and "\$" are only magic after + * "\v"). We now fetch the next character and toggle its + * magicness. Therefore, \ is so meta-magic that it is + * not in META. + */ + curchr = -1; + prev_at_start = at_start; + at_start = FALSE; /* be able to say "/\*ptr" */ + ++regparse; + peekchr(); + --regparse; + curchr = toggle_Magic(curchr); + } + else if (vim_strchr(REGEXP_ABBR, c)) + { + /* + * Handle abbreviations, like "\t" for TAB -- webb + */ + curchr = backslash_trans(c); + } + else if (reg_magic == MAGIC_NONE && (c == '$' || c == '^')) + curchr = toggle_Magic(c); + else + { + /* + * Next character can never be (made) magic? + * Then backslashing it won't do anything. + */ +#ifdef FEAT_MBYTE + if (has_mbyte) + curchr = (*mb_ptr2char)(regparse + 1); + else +#endif + curchr = c; + } + break; + } + +#ifdef FEAT_MBYTE + default: + if (has_mbyte) + curchr = (*mb_ptr2char)(regparse); +#endif + } + } + + return curchr; +} + +/* + * Eat one lexed character. Do this in a way that we can undo it. + */ + static void +skipchr() +{ + /* peekchr() eats a backslash, do the same here */ + if (*regparse == '\\') + prevchr_len = 1; + else + prevchr_len = 0; + if (regparse[prevchr_len] != NUL) + { +#ifdef FEAT_MBYTE + if (has_mbyte) + prevchr_len += (*mb_ptr2len_check)(regparse + prevchr_len); + else +#endif + ++prevchr_len; + } + regparse += prevchr_len; + prev_at_start = at_start; + at_start = FALSE; + prevprevchr = prevchr; + prevchr = curchr; + curchr = nextchr; /* use previously unget char, or -1 */ + nextchr = -1; +} + +/* + * Skip a character while keeping the value of prev_at_start for at_start. + * prevchr and prevprevchr are also kept. + */ + static void +skipchr_keepstart() +{ + int as = prev_at_start; + int pr = prevchr; + int prpr = prevprevchr; + + skipchr(); + at_start = as; + prevchr = pr; + prevprevchr = prpr; +} + + static int +getchr() +{ + int chr = peekchr(); + + skipchr(); + return chr; +} + +/* + * put character back. Works only once! + */ + static void +ungetchr() +{ + nextchr = curchr; + curchr = prevchr; + prevchr = prevprevchr; + at_start = prev_at_start; + prev_at_start = FALSE; + + /* Backup regparse, so that it's at the same position as before the + * getchr(). */ + regparse -= prevchr_len; +} + +/* + * read_limits - Read two integers to be taken as a minimum and maximum. + * If the first character is '-', then the range is reversed. + * Should end with 'end'. If minval is missing, zero is default, if maxval is + * missing, a very big number is the default. + */ + static int +read_limits(minval, maxval) + long *minval; + long *maxval; +{ + int reverse = FALSE; + char_u *first_char; + long tmp; + + if (*regparse == '-') + { + /* Starts with '-', so reverse the range later */ + regparse++; + reverse = TRUE; + } + first_char = regparse; + *minval = getdigits(®parse); + if (*regparse == ',') /* There is a comma */ + { + if (vim_isdigit(*++regparse)) + *maxval = getdigits(®parse); + else + *maxval = MAX_LIMIT; + } + else if (VIM_ISDIGIT(*first_char)) + *maxval = *minval; /* It was \{n} or \{-n} */ + else + *maxval = MAX_LIMIT; /* It was \{} or \{-} */ + if (*regparse == '\\') + regparse++; /* Allow either \{...} or \{...\} */ + if (*regparse != '}' || (*maxval == 0 && *minval == 0)) + { + sprintf((char *)IObuff, _("E554: Syntax error in %s{...}"), + reg_magic == MAGIC_ALL ? "" : "\\"); + EMSG_RET_FAIL(IObuff); + } + + /* + * Reverse the range if there was a '-', or make sure it is in the right + * order otherwise. + */ + if ((!reverse && *minval > *maxval) || (reverse && *minval < *maxval)) + { + tmp = *minval; + *minval = *maxval; + *maxval = tmp; + } + skipchr(); /* let's be friends with the lexer again */ + return OK; +} + +/* + * vim_regexec and friends + */ + +/* + * Global work variables for vim_regexec(). + */ + +/* The current match-position is remembered with these variables: */ +static linenr_T reglnum; /* line number, relative to first line */ +static char_u *regline; /* start of current line */ +static char_u *reginput; /* current input, points into "regline" */ + +static int need_clear_subexpr; /* subexpressions still need to be + * cleared */ +#ifdef FEAT_SYN_HL +static int need_clear_zsubexpr = FALSE; /* extmatch subexpressions + * still need to be cleared */ +#endif + +static int out_of_stack; /* TRUE when ran out of stack space */ + +/* + * Structure used to save the current input state, when it needs to be + * restored after trying a match. Used by reg_save() and reg_restore(). + */ +typedef struct +{ + union + { + char_u *ptr; /* reginput pointer, for single-line regexp */ + lpos_T pos; /* reginput pos, for multi-line regexp */ + } rs_u; +} regsave_T; + +/* struct to save start/end pointer/position in for \(\) */ +typedef struct +{ + union + { + char_u *ptr; + lpos_T pos; + } se_u; +} save_se_T; + +static char_u *reg_getline __ARGS((linenr_T lnum)); +static long vim_regexec_both __ARGS((char_u *line, colnr_T col)); +static long regtry __ARGS((regprog_T *prog, colnr_T col)); +static void cleanup_subexpr __ARGS((void)); +#ifdef FEAT_SYN_HL +static void cleanup_zsubexpr __ARGS((void)); +#endif +static void reg_nextline __ARGS((void)); +static void reg_save __ARGS((regsave_T *save)); +static void reg_restore __ARGS((regsave_T *save)); +static int reg_save_equal __ARGS((regsave_T *save)); +static void save_se_multi __ARGS((save_se_T *savep, lpos_T *posp)); +static void save_se_one __ARGS((save_se_T *savep, char_u **pp)); + +/* Save the sub-expressions before attempting a match. */ +#define save_se(savep, posp, pp) \ + REG_MULTI ? save_se_multi((savep), (posp)) : save_se_one((savep), (pp)) + +/* After a failed match restore the sub-expressions. */ +#define restore_se(savep, posp, pp) { \ + if (REG_MULTI) \ + *(posp) = (savep)->se_u.pos; \ + else \ + *(pp) = (savep)->se_u.ptr; } + +static int re_num_cmp __ARGS((long_u val, char_u *scan)); +static int regmatch __ARGS((char_u *prog)); +static int regrepeat __ARGS((char_u *p, long maxcount)); + +#ifdef DEBUG +int regnarrate = 0; +#endif + +/* + * Internal copy of 'ignorecase'. It is set at each call to vim_regexec(). + * Normally it gets the value of "rm_ic" or "rmm_ic", but when the pattern + * contains '\c' or '\C' the value is overruled. + */ +static int ireg_ic; + +#ifdef FEAT_MBYTE +/* + * Similar to ireg_ic, but only for 'combining' characters. Set with \Z flag + * in the regexp. Defaults to false, always. + */ +static int ireg_icombine; +#endif + +/* + * Sometimes need to save a copy of a line. Since alloc()/free() is very + * slow, we keep one allocated piece of memory and only re-allocate it when + * it's too small. It's freed in vim_regexec_both() when finished. + */ +static char_u *reg_tofree; +static unsigned reg_tofreelen; + +/* + * These variables are set when executing a regexp to speed up the execution. + * Which ones are set depends on whethere a single-line or multi-line match is + * done: + * single-line multi-line + * reg_match ®match_T NULL + * reg_mmatch NULL ®mmatch_T + * reg_startp reg_match->startp <invalid> + * reg_endp reg_match->endp <invalid> + * reg_startpos <invalid> reg_mmatch->startpos + * reg_endpos <invalid> reg_mmatch->endpos + * reg_win NULL window in which to search + * reg_buf <invalid> buffer in which to search + * reg_firstlnum <invalid> first line in which to search + * reg_maxline 0 last line nr + * reg_line_lbr FALSE or TRUE FALSE + */ +static regmatch_T *reg_match; +static regmmatch_T *reg_mmatch; +static char_u **reg_startp = NULL; +static char_u **reg_endp = NULL; +static lpos_T *reg_startpos = NULL; +static lpos_T *reg_endpos = NULL; +static win_T *reg_win; +static buf_T *reg_buf; +static linenr_T reg_firstlnum; +static linenr_T reg_maxline; +static int reg_line_lbr; /* "\n" in string is line break */ + +/* + * Get pointer to the line "lnum", which is relative to "reg_firstlnum". + */ + static char_u * +reg_getline(lnum) + linenr_T lnum; +{ + /* when looking behind for a match/no-match lnum is negative. But we + * can't go before line 1 */ + if (reg_firstlnum + lnum < 1) + return NULL; + return ml_get_buf(reg_buf, reg_firstlnum + lnum, FALSE); +} + +static regsave_T behind_pos; + +#ifdef FEAT_SYN_HL +static char_u *reg_startzp[NSUBEXP]; /* Workspace to mark beginning */ +static char_u *reg_endzp[NSUBEXP]; /* and end of \z(...\) matches */ +static lpos_T reg_startzpos[NSUBEXP]; /* idem, beginning pos */ +static lpos_T reg_endzpos[NSUBEXP]; /* idem, end pos */ +#endif + +/* TRUE if using multi-line regexp. */ +#define REG_MULTI (reg_match == NULL) + +/* + * Match a regexp against a string. + * "rmp->regprog" is a compiled regexp as returned by vim_regcomp(). + * Uses curbuf for line count and 'iskeyword'. + * + * Return TRUE if there is a match, FALSE if not. + */ + int +vim_regexec(rmp, line, col) + regmatch_T *rmp; + char_u *line; /* string to match against */ + colnr_T col; /* column to start looking for match */ +{ + reg_match = rmp; + reg_mmatch = NULL; + reg_maxline = 0; + reg_line_lbr = FALSE; + reg_win = NULL; + ireg_ic = rmp->rm_ic; +#ifdef FEAT_MBYTE + ireg_icombine = FALSE; +#endif + return (vim_regexec_both(line, col) != 0); +} + +#if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO) +/* + * Like vim_regexec(), but consider a "\n" in "line" to be a line break. + */ + int +vim_regexec_nl(rmp, line, col) + regmatch_T *rmp; + char_u *line; /* string to match against */ + colnr_T col; /* column to start looking for match */ +{ + reg_match = rmp; + reg_mmatch = NULL; + reg_maxline = 0; + reg_line_lbr = TRUE; + reg_win = NULL; + ireg_ic = rmp->rm_ic; +#ifdef FEAT_MBYTE + ireg_icombine = FALSE; +#endif + return (vim_regexec_both(line, col) != 0); +} +#endif + +/* + * Match a regexp against multiple lines. + * "rmp->regprog" is a compiled regexp as returned by vim_regcomp(). + * Uses curbuf for line count and 'iskeyword'. + * + * Return zero if there is no match. Return number of lines contained in the + * match otherwise. + */ + long +vim_regexec_multi(rmp, win, buf, lnum, col) + regmmatch_T *rmp; + win_T *win; /* window in which to search or NULL */ + buf_T *buf; /* buffer in which to search */ + linenr_T lnum; /* nr of line to start looking for match */ + colnr_T col; /* column to start looking for match */ +{ + long r; + buf_T *save_curbuf = curbuf; + + reg_match = NULL; + reg_mmatch = rmp; + reg_buf = buf; + reg_win = win; + reg_firstlnum = lnum; + reg_maxline = reg_buf->b_ml.ml_line_count - lnum; + reg_line_lbr = FALSE; + ireg_ic = rmp->rmm_ic; +#ifdef FEAT_MBYTE + ireg_icombine = FALSE; +#endif + + /* Need to switch to buffer "buf" to make vim_iswordc() work. */ + curbuf = buf; + r = vim_regexec_both(NULL, col); + curbuf = save_curbuf; + + return r; +} + +/* + * Match a regexp against a string ("line" points to the string) or multiple + * lines ("line" is NULL, use reg_getline()). + */ +#ifdef HAVE_SETJMP_H + static long +vim_regexec_both(line_arg, col_arg) + char_u *line_arg; + colnr_T col_arg; /* column to start looking for match */ +#else + static long +vim_regexec_both(line, col) + char_u *line; + colnr_T col; /* column to start looking for match */ +#endif +{ + regprog_T *prog; + char_u *s; + long retval; +#ifdef HAVE_SETJMP_H + char_u *line; + colnr_T col; +#endif + + reg_tofree = NULL; + +#ifdef HAVE_TRY_EXCEPT + __try + { +#endif + +#ifdef HAVE_SETJMP_H + /* + * Matching with a regexp may cause a very deep recursive call of + * regmatch(). Vim will crash when running out of stack space. Catch + * this here if the system supports it. + */ + mch_startjmp(); + if (SETJMP(lc_jump_env) != 0) + { + mch_didjmp(); +# ifdef SIGHASARG + if (lc_signal != SIGINT) +# endif + EMSG(_("E361: Crash intercepted; regexp too complex?")); + retval = 0L; + goto theend; + } + + /* Trick to avoid "might be clobbered by `longjmp'" warning from gcc. */ + line = line_arg; + col = col_arg; +#endif + retval = 0L; + + if (REG_MULTI) + { + prog = reg_mmatch->regprog; + line = reg_getline((linenr_T)0); + reg_startpos = reg_mmatch->startpos; + reg_endpos = reg_mmatch->endpos; + } + else + { + prog = reg_match->regprog; + reg_startp = reg_match->startp; + reg_endp = reg_match->endp; + } + + /* Be paranoid... */ + if (prog == NULL || line == NULL) + { + EMSG(_(e_null)); + goto theend; + } + + /* Check validity of program. */ + if (prog_magic_wrong()) + goto theend; + + /* If pattern contains "\c" or "\C": overrule value of ireg_ic */ + if (prog->regflags & RF_ICASE) + ireg_ic = TRUE; + else if (prog->regflags & RF_NOICASE) + ireg_ic = FALSE; + +#ifdef FEAT_MBYTE + /* If pattern contains "\Z" overrule value of ireg_icombine */ + if (prog->regflags & RF_ICOMBINE) + ireg_icombine = TRUE; +#endif + + /* If there is a "must appear" string, look for it. */ + if (prog->regmust != NULL) + { + int c; + +#ifdef FEAT_MBYTE + if (has_mbyte) + c = (*mb_ptr2char)(prog->regmust); + else +#endif + c = *prog->regmust; + s = line + col; + while ((s = cstrchr(s, c)) != NULL) + { + if (cstrncmp(s, prog->regmust, &prog->regmlen) == 0) + break; /* Found it. */ +#ifdef FEAT_MBYTE + if (has_mbyte) + s += (*mb_ptr2len_check)(s); + else +#endif + ++s; + } + if (s == NULL) /* Not present. */ + goto theend; + } + + regline = line; + reglnum = 0; + out_of_stack = FALSE; + + /* Simplest case: Anchored match need be tried only once. */ + if (prog->reganch) + { + int c; + +#ifdef FEAT_MBYTE + if (has_mbyte) + c = (*mb_ptr2char)(regline + col); + else +#endif + c = regline[col]; + if (prog->regstart == NUL + || prog->regstart == c + || (ireg_ic && (( +#ifdef FEAT_MBYTE + (enc_utf8 && utf_fold(prog->regstart) == utf_fold(c))) + || (c < 255 && prog->regstart < 255 && +#endif + TOLOWER_LOC(prog->regstart) == TOLOWER_LOC(c))))) + retval = regtry(prog, col); + else + retval = 0; + } + else + { + /* Messy cases: unanchored match. */ + while (!got_int && !out_of_stack) + { + if (prog->regstart != NUL) + { + /* Skip until the char we know it must start with. */ + s = cstrchr(regline + col, prog->regstart); + if (s == NULL) + { + retval = 0; + break; + } + col = (int)(s - regline); + } + + retval = regtry(prog, col); + if (retval > 0) + break; + + /* if not currently on the first line, get it again */ + if (reglnum != 0) + { + regline = reg_getline((linenr_T)0); + reglnum = 0; + } + if (regline[col] == NUL) + break; +#ifdef FEAT_MBYTE + if (has_mbyte) + col += (*mb_ptr2len_check)(regline + col); + else +#endif + ++col; + } + } + + if (out_of_stack) + EMSG(_("E363: pattern caused out-of-stack error")); + +#ifdef HAVE_TRY_EXCEPT + } + __except(EXCEPTION_EXECUTE_HANDLER) + { + if (GetExceptionCode() == EXCEPTION_STACK_OVERFLOW) + { + RESETSTKOFLW(); + EMSG(_("E363: pattern caused out-of-stack error")); + } + else + EMSG(_("E361: Crash intercepted; regexp too complex?")); + retval = 0L; + } +#endif + +theend: + /* Didn't find a match. */ + vim_free(reg_tofree); +#ifdef HAVE_SETJMP_H + mch_endjmp(); +#endif + return retval; +} + +#ifdef FEAT_SYN_HL +static reg_extmatch_T *make_extmatch __ARGS((void)); + +/* + * Create a new extmatch and mark it as referenced once. + */ + static reg_extmatch_T * +make_extmatch() +{ + reg_extmatch_T *em; + + em = (reg_extmatch_T *)alloc_clear((unsigned)sizeof(reg_extmatch_T)); + if (em != NULL) + em->refcnt = 1; + return em; +} + +/* + * Add a reference to an extmatch. + */ + reg_extmatch_T * +ref_extmatch(em) + reg_extmatch_T *em; +{ + if (em != NULL) + em->refcnt++; + return em; +} + +/* + * Remove a reference to an extmatch. If there are no references left, free + * the info. + */ + void +unref_extmatch(em) + reg_extmatch_T *em; +{ + int i; + + if (em != NULL && --em->refcnt <= 0) + { + for (i = 0; i < NSUBEXP; ++i) + vim_free(em->matches[i]); + vim_free(em); + } +} +#endif + +/* + * regtry - try match of "prog" with at regline["col"]. + * Returns 0 for failure, number of lines contained in the match otherwise. + */ + static long +regtry(prog, col) + regprog_T *prog; + colnr_T col; +{ + reginput = regline + col; + need_clear_subexpr = TRUE; +#ifdef FEAT_SYN_HL + /* Clear the external match subpointers if necessary. */ + if (prog->reghasz == REX_SET) + need_clear_zsubexpr = TRUE; +#endif + + if (regmatch(prog->program + 1)) + { + cleanup_subexpr(); + if (REG_MULTI) + { + if (reg_startpos[0].lnum < 0) + { + reg_startpos[0].lnum = 0; + reg_startpos[0].col = col; + } + if (reg_endpos[0].lnum < 0) + { + reg_endpos[0].lnum = reglnum; + reg_endpos[0].col = (int)(reginput - regline); + } + else + /* Use line number of "\ze". */ + reglnum = reg_endpos[0].lnum; + } + else + { + if (reg_startp[0] == NULL) + reg_startp[0] = regline + col; + if (reg_endp[0] == NULL) + reg_endp[0] = reginput; + } +#ifdef FEAT_SYN_HL + /* Package any found \z(...\) matches for export. Default is none. */ + unref_extmatch(re_extmatch_out); + re_extmatch_out = NULL; + + if (prog->reghasz == REX_SET) + { + int i; + + cleanup_zsubexpr(); + re_extmatch_out = make_extmatch(); + for (i = 0; i < NSUBEXP; i++) + { + if (REG_MULTI) + { + /* Only accept single line matches. */ + if (reg_startzpos[i].lnum >= 0 + && reg_endzpos[i].lnum == reg_startzpos[i].lnum) + re_extmatch_out->matches[i] = + vim_strnsave(reg_getline(reg_startzpos[i].lnum) + + reg_startzpos[i].col, + reg_endzpos[i].col - reg_startzpos[i].col); + } + else + { + if (reg_startzp[i] != NULL && reg_endzp[i] != NULL) + re_extmatch_out->matches[i] = + vim_strnsave(reg_startzp[i], + (int)(reg_endzp[i] - reg_startzp[i])); + } + } + } +#endif + return 1 + reglnum; + } + return 0; +} + +#ifdef FEAT_MBYTE +/* multi-byte: advance reginput with a function */ +# define ADVANCE_REGINPUT() advance_reginput() + +static void advance_reginput __ARGS((void)); +static int reg_prev_class __ARGS((void)); + + static void +advance_reginput() +{ + if (has_mbyte) + reginput += (*mb_ptr2len_check)(reginput); + else + ++reginput; +} + +/* + * Get class of previous character. + */ + static int +reg_prev_class() +{ + if (reginput > regline) + return mb_get_class(reginput - 1 + - (*mb_head_off)(regline, reginput - 1)); + return -1; +} + +#else +/* No multi-byte: It's too simple to make a function for. */ +# define ADVANCE_REGINPUT() ++reginput +#endif + +/* + * The arguments from BRACE_LIMITS are stored here. They are actually local + * to regmatch(), but they are here to reduce the amount of stack space used + * (it can be called recursively many times). + */ +static long bl_minval; +static long bl_maxval; + +/* + * regmatch - main matching routine + * + * Conceptually the strategy is simple: Check to see whether the current + * node matches, call self recursively to see whether the rest matches, + * and then act accordingly. In practice we make some effort to avoid + * recursion, in particular by going through "ordinary" nodes (that don't + * need to know whether the rest of the match failed) by a loop instead of + * by recursion. + * + * Returns TRUE when there is a match. Leaves reginput and reglnum just after + * the last matched character. + * Returns FALSE when there is no match. Leaves reginput and reglnum in an + * undefined state! + */ + static int +regmatch(scan) + char_u *scan; /* Current node. */ +{ + char_u *next; /* Next node. */ + int op; + int c; + +#ifdef HAVE_GETRLIMIT + /* Check if we are running out of stack space. Could be caused by + * recursively calling ourselves. */ + if (out_of_stack || mch_stackcheck((char *)&op) == FAIL) + { + out_of_stack = TRUE; + return FALSE; + } +#endif + + /* Some patterns my cause a long time to match, even though they are not + * illegal. E.g., "\([a-z]\+\)\+Q". Allow breaking them with CTRL-C. */ + fast_breakcheck(); + +#ifdef DEBUG + if (scan != NULL && regnarrate) + { + mch_errmsg(regprop(scan)); + mch_errmsg("(\n"); + } +#endif + while (scan != NULL) + { + if (got_int || out_of_stack) + return FALSE; +#ifdef DEBUG + if (regnarrate) + { + mch_errmsg(regprop(scan)); + mch_errmsg("...\n"); +# ifdef FEAT_SYN_HL + if (re_extmatch_in != NULL) + { + int i; + + mch_errmsg(_("External submatches:\n")); + for (i = 0; i < NSUBEXP; i++) + { + mch_errmsg(" \""); + if (re_extmatch_in->matches[i] != NULL) + mch_errmsg(re_extmatch_in->matches[i]); + mch_errmsg("\"\n"); + } + } +# endif + } +#endif + next = regnext(scan); + + op = OP(scan); + /* Check for character class with NL added. */ + if (WITH_NL(op) && *reginput == NUL && reglnum < reg_maxline) + { + reg_nextline(); + } + else if (reg_line_lbr && WITH_NL(op) && *reginput == '\n') + { + ADVANCE_REGINPUT(); + } + else + { + if (WITH_NL(op)) + op -= ADD_NL; +#ifdef FEAT_MBYTE + if (has_mbyte) + c = (*mb_ptr2char)(reginput); + else +#endif + c = *reginput; + switch (op) + { + case BOL: + if (reginput != regline) + return FALSE; + break; + + case EOL: + if (c != NUL) + return FALSE; + break; + + case RE_BOF: + /* Passing -1 to the getline() function provided for the search + * should always return NULL if the current line is the first + * line of the file. */ + if (reglnum != 0 || reginput != regline + || (REG_MULTI && reg_getline((linenr_T)-1) != NULL)) + return FALSE; + break; + + case RE_EOF: + if (reglnum != reg_maxline || c != NUL) + return FALSE; + break; + + case CURSOR: + /* Check if the buffer is in a window and compare the + * reg_win->w_cursor position to the match position. */ + if (reg_win == NULL + || (reglnum + reg_firstlnum != reg_win->w_cursor.lnum) + || ((colnr_T)(reginput - regline) != reg_win->w_cursor.col)) + return FALSE; + break; + + case RE_LNUM: + if (!REG_MULTI || !re_num_cmp((long_u)(reglnum + reg_firstlnum), + scan)) + return FALSE; + break; + + case RE_COL: + if (!re_num_cmp((long_u)(reginput - regline) + 1, scan)) + return FALSE; + break; + + case RE_VCOL: + if (!re_num_cmp((long_u)win_linetabsize( + reg_win == NULL ? curwin : reg_win, + regline, (colnr_T)(reginput - regline)) + 1, scan)) + return FALSE; + break; + + case BOW: /* \<word; reginput points to w */ + if (c == NUL) /* Can't match at end of line */ + return FALSE; +#ifdef FEAT_MBYTE + if (has_mbyte) + { + int this_class; + + /* Get class of current and previous char (if it exists). */ + this_class = mb_get_class(reginput); + if (this_class <= 1) + return FALSE; /* not on a word at all */ + if (reg_prev_class() == this_class) + return FALSE; /* previous char is in same word */ + } +#endif + else + { + if (!vim_iswordc(c) + || (reginput > regline && vim_iswordc(reginput[-1]))) + return FALSE; + } + break; + + case EOW: /* word\>; reginput points after d */ + if (reginput == regline) /* Can't match at start of line */ + return FALSE; +#ifdef FEAT_MBYTE + if (has_mbyte) + { + int this_class, prev_class; + + /* Get class of current and previous char (if it exists). */ + this_class = mb_get_class(reginput); + prev_class = reg_prev_class(); + if (this_class == prev_class) + return FALSE; + if (prev_class == 0 || prev_class == 1) + return FALSE; + } + else +#endif + { + if (!vim_iswordc(reginput[-1])) + return FALSE; + if (reginput[0] != NUL && vim_iswordc(c)) + return FALSE; + } + break; /* Matched with EOW */ + + case ANY: + if (c == NUL) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case IDENT: + if (!vim_isIDc(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case SIDENT: + if (VIM_ISDIGIT(*reginput) || !vim_isIDc(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case KWORD: + if (!vim_iswordp(reginput)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case SKWORD: + if (VIM_ISDIGIT(*reginput) || !vim_iswordp(reginput)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case FNAME: + if (!vim_isfilec(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case SFNAME: + if (VIM_ISDIGIT(*reginput) || !vim_isfilec(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case PRINT: + if (ptr2cells(reginput) != 1) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case SPRINT: + if (VIM_ISDIGIT(*reginput) || ptr2cells(reginput) != 1) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case WHITE: + if (!vim_iswhite(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case NWHITE: + if (c == NUL || vim_iswhite(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case DIGIT: + if (!ri_digit(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case NDIGIT: + if (c == NUL || ri_digit(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case HEX: + if (!ri_hex(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case NHEX: + if (c == NUL || ri_hex(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case OCTAL: + if (!ri_octal(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case NOCTAL: + if (c == NUL || ri_octal(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case WORD: + if (!ri_word(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case NWORD: + if (c == NUL || ri_word(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case HEAD: + if (!ri_head(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case NHEAD: + if (c == NUL || ri_head(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case ALPHA: + if (!ri_alpha(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case NALPHA: + if (c == NUL || ri_alpha(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case LOWER: + if (!ri_lower(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case NLOWER: + if (c == NUL || ri_lower(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case UPPER: + if (!ri_upper(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case NUPPER: + if (c == NUL || ri_upper(c)) + return FALSE; + ADVANCE_REGINPUT(); + break; + + case EXACTLY: + { + int len; + char_u *opnd; + + opnd = OPERAND(scan); + /* Inline the first byte, for speed. */ + if (*opnd != *reginput + && (!ireg_ic || ( +#ifdef FEAT_MBYTE + !enc_utf8 && +#endif + TOLOWER_LOC(*opnd) != TOLOWER_LOC(*reginput)))) + return FALSE; + if (*opnd == NUL) + { + /* match empty string always works; happens when "~" is + * empty. */ + } + else if (opnd[1] == NUL +#ifdef FEAT_MBYTE + && !(enc_utf8 && ireg_ic) +#endif + ) + ++reginput; /* matched a single char */ + else + { + len = (int)STRLEN(opnd); + /* Need to match first byte again for multi-byte. */ + if (cstrncmp(opnd, reginput, &len) != 0) + return FALSE; +#ifdef FEAT_MBYTE + /* Check for following composing character. */ + if (enc_utf8 && UTF_COMPOSINGLIKE(reginput, reginput + len)) + { + /* raaron: This code makes a composing character get + * ignored, which is the correct behavior (sometimes) + * for voweled Hebrew texts. */ + if (!ireg_icombine) + return FALSE; + } + else +#endif + reginput += len; + } + } + break; + + case ANYOF: + case ANYBUT: + if (c == NUL) + return FALSE; + if ((cstrchr(OPERAND(scan), c) == NULL) == (op == ANYOF)) + return FALSE; + ADVANCE_REGINPUT(); + break; + +#ifdef FEAT_MBYTE + case MULTIBYTECODE: + if (has_mbyte) + { + int i, len; + char_u *opnd; + + opnd = OPERAND(scan); + /* Safety check (just in case 'encoding' was changed since + * compiling the program). */ + if ((len = (*mb_ptr2len_check)(opnd)) < 2) + return FALSE; + for (i = 0; i < len; ++i) + if (opnd[i] != reginput[i]) + return FALSE; + reginput += len; + } + else + return FALSE; + break; +#endif + + case NOTHING: + break; + + case BACK: + break; + + case MOPEN + 0: /* Match start: \zs */ + case MOPEN + 1: /* \( */ + case MOPEN + 2: + case MOPEN + 3: + case MOPEN + 4: + case MOPEN + 5: + case MOPEN + 6: + case MOPEN + 7: + case MOPEN + 8: + case MOPEN + 9: + { + int no; + save_se_T save; + + no = op - MOPEN; + cleanup_subexpr(); + save_se(&save, ®_startpos[no], ®_startp[no]); + + if (regmatch(next)) + return TRUE; + + restore_se(&save, ®_startpos[no], ®_startp[no]); + return FALSE; + } + /* break; Not Reached */ + + case NOPEN: /* \%( */ + case NCLOSE: /* \) after \%( */ + if (regmatch(next)) + return TRUE; + return FALSE; + /* break; Not Reached */ + +#ifdef FEAT_SYN_HL + case ZOPEN + 1: + case ZOPEN + 2: + case ZOPEN + 3: + case ZOPEN + 4: + case ZOPEN + 5: + case ZOPEN + 6: + case ZOPEN + 7: + case ZOPEN + 8: + case ZOPEN + 9: + { + int no; + save_se_T save; + + no = op - ZOPEN; + cleanup_zsubexpr(); + save_se(&save, ®_startzpos[no], ®_startzp[no]); + + if (regmatch(next)) + return TRUE; + + restore_se(&save, ®_startzpos[no], ®_startzp[no]); + return FALSE; + } + /* break; Not Reached */ +#endif + + case MCLOSE + 0: /* Match end: \ze */ + case MCLOSE + 1: /* \) */ + case MCLOSE + 2: + case MCLOSE + 3: + case MCLOSE + 4: + case MCLOSE + 5: + case MCLOSE + 6: + case MCLOSE + 7: + case MCLOSE + 8: + case MCLOSE + 9: + { + int no; + save_se_T save; + + no = op - MCLOSE; + cleanup_subexpr(); + save_se(&save, ®_endpos[no], ®_endp[no]); + + if (regmatch(next)) + return TRUE; + + restore_se(&save, ®_endpos[no], ®_endp[no]); + return FALSE; + } + /* break; Not Reached */ + +#ifdef FEAT_SYN_HL + case ZCLOSE + 1: /* \) after \z( */ + case ZCLOSE + 2: + case ZCLOSE + 3: + case ZCLOSE + 4: + case ZCLOSE + 5: + case ZCLOSE + 6: + case ZCLOSE + 7: + case ZCLOSE + 8: + case ZCLOSE + 9: + { + int no; + save_se_T save; + + no = op - ZCLOSE; + cleanup_zsubexpr(); + save_se(&save, ®_endzpos[no], ®_endzp[no]); + + if (regmatch(next)) + return TRUE; + + restore_se(&save, ®_endzpos[no], ®_endzp[no]); + return FALSE; + } + /* break; Not Reached */ +#endif + + case BACKREF + 1: + case BACKREF + 2: + case BACKREF + 3: + case BACKREF + 4: + case BACKREF + 5: + case BACKREF + 6: + case BACKREF + 7: + case BACKREF + 8: + case BACKREF + 9: + { + int no; + int len; + linenr_T clnum; + colnr_T ccol; + char_u *p; + + no = op - BACKREF; + cleanup_subexpr(); + if (!REG_MULTI) /* Single-line regexp */ + { + if (reg_endp[no] == NULL) + { + /* Backref was not set: Match an empty string. */ + len = 0; + } + else + { + /* Compare current input with back-ref in the same + * line. */ + len = (int)(reg_endp[no] - reg_startp[no]); + if (cstrncmp(reg_startp[no], reginput, &len) != 0) + return FALSE; + } + } + else /* Multi-line regexp */ + { + if (reg_endpos[no].lnum < 0) + { + /* Backref was not set: Match an empty string. */ + len = 0; + } + else + { + if (reg_startpos[no].lnum == reglnum + && reg_endpos[no].lnum == reglnum) + { + /* Compare back-ref within the current line. */ + len = reg_endpos[no].col - reg_startpos[no].col; + if (cstrncmp(regline + reg_startpos[no].col, + reginput, &len) != 0) + return FALSE; + } + else + { + /* Messy situation: Need to compare between two + * lines. */ + ccol = reg_startpos[no].col; + clnum = reg_startpos[no].lnum; + for (;;) + { + /* Since getting one line may invalidate + * the other, need to make copy. Slow! */ + if (regline != reg_tofree) + { + len = (int)STRLEN(regline); + if (reg_tofree == NULL + || len >= (int)reg_tofreelen) + { + len += 50; /* get some extra */ + vim_free(reg_tofree); + reg_tofree = alloc(len); + if (reg_tofree == NULL) + return FALSE; /* out of memory! */ + reg_tofreelen = len; + } + STRCPY(reg_tofree, regline); + reginput = reg_tofree + + (reginput - regline); + regline = reg_tofree; + } + + /* Get the line to compare with. */ + p = reg_getline(clnum); + if (clnum == reg_endpos[no].lnum) + len = reg_endpos[no].col - ccol; + else + len = (int)STRLEN(p + ccol); + + if (cstrncmp(p + ccol, reginput, &len) != 0) + return FALSE; /* doesn't match */ + if (clnum == reg_endpos[no].lnum) + break; /* match and at end! */ + if (reglnum == reg_maxline) + return FALSE; /* text too short */ + + /* Advance to next line. */ + reg_nextline(); + ++clnum; + ccol = 0; + if (got_int || out_of_stack) + return FALSE; + } + + /* found a match! Note that regline may now point + * to a copy of the line, that should not matter. */ + } + } + } + + /* Matched the backref, skip over it. */ + reginput += len; + } + break; + +#ifdef FEAT_SYN_HL + case ZREF + 1: + case ZREF + 2: + case ZREF + 3: + case ZREF + 4: + case ZREF + 5: + case ZREF + 6: + case ZREF + 7: + case ZREF + 8: + case ZREF + 9: + { + int no; + int len; + + cleanup_zsubexpr(); + no = op - ZREF; + if (re_extmatch_in != NULL + && re_extmatch_in->matches[no] != NULL) + { + len = (int)STRLEN(re_extmatch_in->matches[no]); + if (cstrncmp(re_extmatch_in->matches[no], + reginput, &len) != 0) + return FALSE; + reginput += len; + } + else + { + /* Backref was not set: Match an empty string. */ + } + } + break; +#endif + + case BRANCH: + { + if (OP(next) != BRANCH) /* No choice. */ + next = OPERAND(scan); /* Avoid recursion. */ + else + { + regsave_T save; + + do + { + reg_save(&save); + if (regmatch(OPERAND(scan))) + return TRUE; + reg_restore(&save); + scan = regnext(scan); + } while (scan != NULL && OP(scan) == BRANCH); + return FALSE; + /* NOTREACHED */ + } + } + break; + + case BRACE_LIMITS: + { + int no; + + if (OP(next) == BRACE_SIMPLE) + { + bl_minval = OPERAND_MIN(scan); + bl_maxval = OPERAND_MAX(scan); + } + else if (OP(next) >= BRACE_COMPLEX + && OP(next) < BRACE_COMPLEX + 10) + { + no = OP(next) - BRACE_COMPLEX; + brace_min[no] = OPERAND_MIN(scan); + brace_max[no] = OPERAND_MAX(scan); + brace_count[no] = 0; + } + else + { + EMSG(_(e_internal)); /* Shouldn't happen */ + return FALSE; + } + } + break; + + case BRACE_COMPLEX + 0: + case BRACE_COMPLEX + 1: + case BRACE_COMPLEX + 2: + case BRACE_COMPLEX + 3: + case BRACE_COMPLEX + 4: + case BRACE_COMPLEX + 5: + case BRACE_COMPLEX + 6: + case BRACE_COMPLEX + 7: + case BRACE_COMPLEX + 8: + case BRACE_COMPLEX + 9: + { + int no; + regsave_T save; + + no = op - BRACE_COMPLEX; + ++brace_count[no]; + + /* If not matched enough times yet, try one more */ + if (brace_count[no] <= (brace_min[no] <= brace_max[no] + ? brace_min[no] : brace_max[no])) + { + reg_save(&save); + if (regmatch(OPERAND(scan))) + return TRUE; + reg_restore(&save); + --brace_count[no]; /* failed, decrement match count */ + return FALSE; + } + + /* If matched enough times, may try matching some more */ + if (brace_min[no] <= brace_max[no]) + { + /* Range is the normal way around, use longest match */ + if (brace_count[no] <= brace_max[no]) + { + reg_save(&save); + if (regmatch(OPERAND(scan))) + return TRUE; /* matched some more times */ + reg_restore(&save); + --brace_count[no]; /* matched just enough times */ + /* continue with the items after \{} */ + } + } + else + { + /* Range is backwards, use shortest match first */ + if (brace_count[no] <= brace_min[no]) + { + reg_save(&save); + if (regmatch(next)) + return TRUE; + reg_restore(&save); + next = OPERAND(scan); + /* must try to match one more item */ + } + } + } + break; + + case BRACE_SIMPLE: + case STAR: + case PLUS: + { + int nextb; /* next byte */ + int nextb_ic; /* next byte reverse case */ + long count; + regsave_T save; + long minval; + long maxval; + + /* + * Lookahead to avoid useless match attempts when we know + * what character comes next. + */ + if (OP(next) == EXACTLY) + { + nextb = *OPERAND(next); + if (ireg_ic) + { + if (isupper(nextb)) + nextb_ic = TOLOWER_LOC(nextb); + else + nextb_ic = TOUPPER_LOC(nextb); + } + else + nextb_ic = nextb; + } + else + { + nextb = NUL; + nextb_ic = NUL; + } + if (op != BRACE_SIMPLE) + { + minval = (op == STAR) ? 0 : 1; + maxval = MAX_LIMIT; + } + else + { + minval = bl_minval; + maxval = bl_maxval; + } + + /* + * When maxval > minval, try matching as much as possible, up + * to maxval. When maxval < minval, try matching at least the + * minimal number (since the range is backwards, that's also + * maxval!). + */ + count = regrepeat(OPERAND(scan), maxval); + if (got_int) + return FALSE; + if (minval <= maxval) + { + /* Range is the normal way around, use longest match */ + while (count >= minval) + { + /* If it could match, try it. */ + if (nextb == NUL || *reginput == nextb + || *reginput == nextb_ic) + { + reg_save(&save); + if (regmatch(next)) + return TRUE; + reg_restore(&save); + } + /* Couldn't or didn't match -- back up one char. */ + if (--count < minval) + break; + if (reginput == regline) + { + /* backup to last char of previous line */ + --reglnum; + regline = reg_getline(reglnum); + /* Just in case regrepeat() didn't count right. */ + if (regline == NULL) + return FALSE; + reginput = regline + STRLEN(regline); + fast_breakcheck(); + if (got_int || out_of_stack) + return FALSE; + } + else + { + --reginput; +#ifdef FEAT_MBYTE + if (has_mbyte) + reginput -= (*mb_head_off)(regline, reginput); +#endif + } + } + } + else + { + /* Range is backwards, use shortest match first. + * Careful: maxval and minval are exchanged! */ + if (count < maxval) + return FALSE; + for (;;) + { + /* If it could work, try it. */ + if (nextb == NUL || *reginput == nextb + || *reginput == nextb_ic) + { + reg_save(&save); + if (regmatch(next)) + return TRUE; + reg_restore(&save); + } + /* Couldn't or didn't match: try advancing one char. */ + if (count == minval + || regrepeat(OPERAND(scan), 1L) == 0) + break; + ++count; + if (got_int || out_of_stack) + return FALSE; + } + } + return FALSE; + } + /* break; Not Reached */ + + case NOMATCH: + { + regsave_T save; + + /* If the operand matches, we fail. Otherwise backup and + * continue with the next item. */ + reg_save(&save); + if (regmatch(OPERAND(scan))) + return FALSE; + reg_restore(&save); + } + break; + + case MATCH: + case SUBPAT: + { + regsave_T save; + + /* If the operand doesn't match, we fail. Otherwise backup + * and continue with the next item. */ + reg_save(&save); + if (!regmatch(OPERAND(scan))) + return FALSE; + if (op == MATCH) /* zero-width */ + reg_restore(&save); + } + break; + + case BEHIND: + case NOBEHIND: + { + regsave_T save_after, save_start; + regsave_T save_behind_pos; + int needmatch = (op == BEHIND); + + /* + * Look back in the input of the operand matches or not. This + * must be done at every position in the input and checking if + * the match ends at the current position. + * First check if the next item matches, that's probably + * faster. + */ + reg_save(&save_start); + if (regmatch(next)) + { + /* save the position after the found match for next */ + reg_save(&save_after); + + /* start looking for a match with operand at the current + * postion. Go back one character until we find the + * result, hitting the start of the line or the previous + * line (for multi-line matching). + * Set behind_pos to where the match should end, BHPOS + * will match it. */ + save_behind_pos = behind_pos; + behind_pos = save_start; + for (;;) + { + reg_restore(&save_start); + if (regmatch(OPERAND(scan)) + && reg_save_equal(&behind_pos)) + { + behind_pos = save_behind_pos; + /* found a match that ends where "next" started */ + if (needmatch) + { + reg_restore(&save_after); + return TRUE; + } + return FALSE; + } + /* + * No match: Go back one character. May go to + * previous line once. + */ + if (REG_MULTI) + { + if (save_start.rs_u.pos.col == 0) + { + if (save_start.rs_u.pos.lnum + < behind_pos.rs_u.pos.lnum + || reg_getline( + --save_start.rs_u.pos.lnum) == NULL) + break; + reg_restore(&save_start); + save_start.rs_u.pos.col = + (colnr_T)STRLEN(regline); + } + else + --save_start.rs_u.pos.col; + } + else + { + if (save_start.rs_u.ptr == regline) + break; + --save_start.rs_u.ptr; + } + } + + /* NOBEHIND succeeds when no match was found */ + behind_pos = save_behind_pos; + if (!needmatch) + { + reg_restore(&save_after); + return TRUE; + } + } + return FALSE; + } + + case BHPOS: + if (REG_MULTI) + { + if (behind_pos.rs_u.pos.col != (colnr_T)(reginput - regline) + || behind_pos.rs_u.pos.lnum != reglnum) + return FALSE; + } + else if (behind_pos.rs_u.ptr != reginput) + return FALSE; + break; + + case NEWL: + if ((c != NUL || reglnum == reg_maxline) + && (c != '\n' || !reg_line_lbr)) + return FALSE; + if (reg_line_lbr) + ADVANCE_REGINPUT(); + else + reg_nextline(); + break; + + case END: + return TRUE; /* Success! */ + + default: + EMSG(_(e_re_corr)); +#ifdef DEBUG + printf("Illegal op code %d\n", op); +#endif + return FALSE; + } + } + + scan = next; + } + + /* + * We get here only if there's trouble -- normally "case END" is the + * terminating point. + */ + EMSG(_(e_re_corr)); +#ifdef DEBUG + printf("Premature EOL\n"); +#endif + return FALSE; +} + +#ifdef FEAT_MBYTE +# define ADVANCE_P(x) if (has_mbyte) x += (*mb_ptr2len_check)(x); else ++x +#else +# define ADVANCE_P(x) ++x +#endif + +/* + * regrepeat - repeatedly match something simple, return how many. + * Advances reginput (and reglnum) to just after the matched chars. + */ + static int +regrepeat(p, maxcount) + char_u *p; + long maxcount; /* maximum number of matches allowed */ +{ + long count = 0; + char_u *scan; + char_u *opnd; + int mask; + int testval = 0; + + scan = reginput; /* Make local copy of reginput for speed. */ + opnd = OPERAND(p); + switch (OP(p)) + { + case ANY: + case ANY + ADD_NL: + while (count < maxcount) + { + /* Matching anything means we continue until end-of-line (or + * end-of-file for ANY + ADD_NL), only limited by maxcount. */ + while (*scan != NUL && count < maxcount) + { + ++count; + ADVANCE_P(scan); + } + if (!WITH_NL(OP(p)) || reglnum == reg_maxline || count == maxcount) + break; + ++count; /* count the line-break */ + reg_nextline(); + scan = reginput; + if (got_int) + break; + } + break; + + case IDENT: + case IDENT + ADD_NL: + testval = TRUE; + /*FALLTHROUGH*/ + case SIDENT: + case SIDENT + ADD_NL: + while (count < maxcount) + { + if (vim_isIDc(*scan) && (testval || !VIM_ISDIGIT(*scan))) + { + ADVANCE_P(scan); + } + else if (*scan == NUL) + { + if (!WITH_NL(OP(p)) || reglnum == reg_maxline) + break; + reg_nextline(); + scan = reginput; + if (got_int) + break; + } + else if (reg_line_lbr && *scan == '\n' && WITH_NL(OP(p))) + ++scan; + else + break; + ++count; + } + break; + + case KWORD: + case KWORD + ADD_NL: + testval = TRUE; + /*FALLTHROUGH*/ + case SKWORD: + case SKWORD + ADD_NL: + while (count < maxcount) + { + if (vim_iswordp(scan) && (testval || !VIM_ISDIGIT(*scan))) + { + ADVANCE_P(scan); + } + else if (*scan == NUL) + { + if (!WITH_NL(OP(p)) || reglnum == reg_maxline) + break; + reg_nextline(); + scan = reginput; + if (got_int) + break; + } + else if (reg_line_lbr && *scan == '\n' && WITH_NL(OP(p))) + ++scan; + else + break; + ++count; + } + break; + + case FNAME: + case FNAME + ADD_NL: + testval = TRUE; + /*FALLTHROUGH*/ + case SFNAME: + case SFNAME + ADD_NL: + while (count < maxcount) + { + if (vim_isfilec(*scan) && (testval || !VIM_ISDIGIT(*scan))) + { + ADVANCE_P(scan); + } + else if (*scan == NUL) + { + if (!WITH_NL(OP(p)) || reglnum == reg_maxline) + break; + reg_nextline(); + scan = reginput; + if (got_int) + break; + } + else if (reg_line_lbr && *scan == '\n' && WITH_NL(OP(p))) + ++scan; + else + break; + ++count; + } + break; + + case PRINT: + case PRINT + ADD_NL: + testval = TRUE; + /*FALLTHROUGH*/ + case SPRINT: + case SPRINT + ADD_NL: + while (count < maxcount) + { + if (*scan == NUL) + { + if (!WITH_NL(OP(p)) || reglnum == reg_maxline) + break; + reg_nextline(); + scan = reginput; + if (got_int) + break; + } + else if (ptr2cells(scan) == 1 && (testval || !VIM_ISDIGIT(*scan))) + { + ADVANCE_P(scan); + } + else if (reg_line_lbr && *scan == '\n' && WITH_NL(OP(p))) + ++scan; + else + break; + ++count; + } + break; + + case WHITE: + case WHITE + ADD_NL: + testval = mask = RI_WHITE; +do_class: + while (count < maxcount) + { +#ifdef FEAT_MBYTE + int l; +#endif + if (*scan == NUL) + { + if (!WITH_NL(OP(p)) || reglnum == reg_maxline) + break; + reg_nextline(); + scan = reginput; + if (got_int) + break; + } +#ifdef FEAT_MBYTE + else if (has_mbyte && (l = (*mb_ptr2len_check)(scan)) > 1) + { + if (testval != 0) + break; + scan += l; + } +#endif + else if ((class_tab[*scan] & mask) == testval) + ++scan; + else if (reg_line_lbr && *scan == '\n' && WITH_NL(OP(p))) + ++scan; + else + break; + ++count; + } + break; + + case NWHITE: + case NWHITE + ADD_NL: + mask = RI_WHITE; + goto do_class; + case DIGIT: + case DIGIT + ADD_NL: + testval = mask = RI_DIGIT; + goto do_class; + case NDIGIT: + case NDIGIT + ADD_NL: + mask = RI_DIGIT; + goto do_class; + case HEX: + case HEX + ADD_NL: + testval = mask = RI_HEX; + goto do_class; + case NHEX: + case NHEX + ADD_NL: + mask = RI_HEX; + goto do_class; + case OCTAL: + case OCTAL + ADD_NL: + testval = mask = RI_OCTAL; + goto do_class; + case NOCTAL: + case NOCTAL + ADD_NL: + mask = RI_OCTAL; + goto do_class; + case WORD: + case WORD + ADD_NL: + testval = mask = RI_WORD; + goto do_class; + case NWORD: + case NWORD + ADD_NL: + mask = RI_WORD; + goto do_class; + case HEAD: + case HEAD + ADD_NL: + testval = mask = RI_HEAD; + goto do_class; + case NHEAD: + case NHEAD + ADD_NL: + mask = RI_HEAD; + goto do_class; + case ALPHA: + case ALPHA + ADD_NL: + testval = mask = RI_ALPHA; + goto do_class; + case NALPHA: + case NALPHA + ADD_NL: + mask = RI_ALPHA; + goto do_class; + case LOWER: + case LOWER + ADD_NL: + testval = mask = RI_LOWER; + goto do_class; + case NLOWER: + case NLOWER + ADD_NL: + mask = RI_LOWER; + goto do_class; + case UPPER: + case UPPER + ADD_NL: + testval = mask = RI_UPPER; + goto do_class; + case NUPPER: + case NUPPER + ADD_NL: + mask = RI_UPPER; + goto do_class; + + case EXACTLY: + { + int cu, cl; + + /* This doesn't do a multi-byte character, because a MULTIBYTECODE + * would have been used for it. */ + if (ireg_ic) + { + cu = TOUPPER_LOC(*opnd); + cl = TOLOWER_LOC(*opnd); + while (count < maxcount && (*scan == cu || *scan == cl)) + { + count++; + scan++; + } + } + else + { + cu = *opnd; + while (count < maxcount && *scan == cu) + { + count++; + scan++; + } + } + break; + } + +#ifdef FEAT_MBYTE + case MULTIBYTECODE: + { + int i, len, cf = 0; + + /* Safety check (just in case 'encoding' was changed since + * compiling the program). */ + if ((len = (*mb_ptr2len_check)(opnd)) > 1) + { + if (ireg_ic && enc_utf8) + cf = utf_fold(utf_ptr2char(opnd)); + while (count < maxcount) + { + for (i = 0; i < len; ++i) + if (opnd[i] != scan[i]) + break; + if (i < len && (!ireg_ic || !enc_utf8 + || utf_fold(utf_ptr2char(scan)) != cf)) + break; + scan += len; + ++count; + } + } + } + break; +#endif + + case ANYOF: + case ANYOF + ADD_NL: + testval = TRUE; + /*FALLTHROUGH*/ + + case ANYBUT: + case ANYBUT + ADD_NL: + while (count < maxcount) + { +#ifdef FEAT_MBYTE + int len; +#endif + if (*scan == NUL) + { + if (!WITH_NL(OP(p)) || reglnum == reg_maxline) + break; + reg_nextline(); + scan = reginput; + if (got_int) + break; + } + else if (reg_line_lbr && *scan == '\n' && WITH_NL(OP(p))) + ++scan; +#ifdef FEAT_MBYTE + else if (has_mbyte && (len = (*mb_ptr2len_check)(scan)) > 1) + { + if ((cstrchr(opnd, (*mb_ptr2char)(scan)) == NULL) == testval) + break; + scan += len; + } +#endif + else + { + if ((cstrchr(opnd, *scan) == NULL) == testval) + break; + ++scan; + } + ++count; + } + break; + + case NEWL: + while (count < maxcount + && ((*scan == NUL && reglnum < reg_maxline) + || (*scan == '\n' && reg_line_lbr))) + { + count++; + if (reg_line_lbr) + ADVANCE_REGINPUT(); + else + reg_nextline(); + scan = reginput; + if (got_int) + break; + } + break; + + default: /* Oh dear. Called inappropriately. */ + EMSG(_(e_re_corr)); +#ifdef DEBUG + printf("Called regrepeat with op code %d\n", OP(p)); +#endif + break; + } + + reginput = scan; + + return (int)count; +} + +/* + * regnext - dig the "next" pointer out of a node + */ + static char_u * +regnext(p) + char_u *p; +{ + int offset; + + if (p == JUST_CALC_SIZE) + return NULL; + + offset = NEXT(p); + if (offset == 0) + return NULL; + + if (OP(p) == BACK) + return p - offset; + else + return p + offset; +} + +/* + * Check the regexp program for its magic number. + * Return TRUE if it's wrong. + */ + static int +prog_magic_wrong() +{ + if (UCHARAT(REG_MULTI + ? reg_mmatch->regprog->program + : reg_match->regprog->program) != REGMAGIC) + { + EMSG(_(e_re_corr)); + return TRUE; + } + return FALSE; +} + +/* + * Cleanup the subexpressions, if this wasn't done yet. + * This construction is used to clear the subexpressions only when they are + * used (to increase speed). + */ + static void +cleanup_subexpr() +{ + if (need_clear_subexpr) + { + if (REG_MULTI) + { + /* Use 0xff to set lnum to -1 */ + vim_memset(reg_startpos, 0xff, sizeof(lpos_T) * NSUBEXP); + vim_memset(reg_endpos, 0xff, sizeof(lpos_T) * NSUBEXP); + } + else + { + vim_memset(reg_startp, 0, sizeof(char_u *) * NSUBEXP); + vim_memset(reg_endp, 0, sizeof(char_u *) * NSUBEXP); + } + need_clear_subexpr = FALSE; + } +} + +#ifdef FEAT_SYN_HL + static void +cleanup_zsubexpr() +{ + if (need_clear_zsubexpr) + { + if (REG_MULTI) + { + /* Use 0xff to set lnum to -1 */ + vim_memset(reg_startzpos, 0xff, sizeof(lpos_T) * NSUBEXP); + vim_memset(reg_endzpos, 0xff, sizeof(lpos_T) * NSUBEXP); + } + else + { + vim_memset(reg_startzp, 0, sizeof(char_u *) * NSUBEXP); + vim_memset(reg_endzp, 0, sizeof(char_u *) * NSUBEXP); + } + need_clear_zsubexpr = FALSE; + } +} +#endif + +/* + * Advance reglnum, regline and reginput to the next line. + */ + static void +reg_nextline() +{ + regline = reg_getline(++reglnum); + reginput = regline; + fast_breakcheck(); +} + +/* + * Save the input line and position in a regsave_T. + */ + static void +reg_save(save) + regsave_T *save; +{ + if (REG_MULTI) + { + save->rs_u.pos.col = (colnr_T)(reginput - regline); + save->rs_u.pos.lnum = reglnum; + } + else + save->rs_u.ptr = reginput; +} + +/* + * Restore the input line and position from a regsave_T. + */ + static void +reg_restore(save) + regsave_T *save; +{ + if (REG_MULTI) + { + if (reglnum != save->rs_u.pos.lnum) + { + /* only call reg_getline() when the line number changed to save + * a bit of time */ + reglnum = save->rs_u.pos.lnum; + regline = reg_getline(reglnum); + } + reginput = regline + save->rs_u.pos.col; + } + else + reginput = save->rs_u.ptr; +} + +/* + * Return TRUE if current position is equal to saved position. + */ + static int +reg_save_equal(save) + regsave_T *save; +{ + if (REG_MULTI) + return reglnum == save->rs_u.pos.lnum + && reginput == regline + save->rs_u.pos.col; + return reginput == save->rs_u.ptr; +} + +/* + * Tentatively set the sub-expression start to the current position (after + * calling regmatch() they will have changed). Need to save the existing + * values for when there is no match. + * Use se_save() to use pointer (save_se_multi()) or position (save_se_one()), + * depending on REG_MULTI. + */ + static void +save_se_multi(savep, posp) + save_se_T *savep; + lpos_T *posp; +{ + savep->se_u.pos = *posp; + posp->lnum = reglnum; + posp->col = (colnr_T)(reginput - regline); +} + + static void +save_se_one(savep, pp) + save_se_T *savep; + char_u **pp; +{ + savep->se_u.ptr = *pp; + *pp = reginput; +} + +/* + * Compare a number with the operand of RE_LNUM, RE_COL or RE_VCOL. + */ + static int +re_num_cmp(val, scan) + long_u val; + char_u *scan; +{ + long_u n = OPERAND_MIN(scan); + + if (OPERAND_CMP(scan) == '>') + return val > n; + if (OPERAND_CMP(scan) == '<') + return val < n; + return val == n; +} + + +#ifdef DEBUG + +/* + * regdump - dump a regexp onto stdout in vaguely comprehensible form + */ + static void +regdump(pattern, r) + char_u *pattern; + regprog_T *r; +{ + char_u *s; + int op = EXACTLY; /* Arbitrary non-END op. */ + char_u *next; + char_u *end = NULL; + + printf("\r\nregcomp(%s):\r\n", pattern); + + s = r->program + 1; + /* + * Loop until we find the END that isn't before a referred next (an END + * can also appear in a NOMATCH operand). + */ + while (op != END || s <= end) + { + op = OP(s); + printf("%2d%s", (int)(s - r->program), regprop(s)); /* Where, what. */ + next = regnext(s); + if (next == NULL) /* Next ptr. */ + printf("(0)"); + else + printf("(%d)", (int)((s - r->program) + (next - s))); + if (end < next) + end = next; + if (op == BRACE_LIMITS) + { + /* Two short ints */ + printf(" minval %ld, maxval %ld", OPERAND_MIN(s), OPERAND_MAX(s)); + s += 8; + } + s += 3; + if (op == ANYOF || op == ANYOF + ADD_NL + || op == ANYBUT || op == ANYBUT + ADD_NL + || op == EXACTLY) + { + /* Literal string, where present. */ + while (*s != NUL) + printf("%c", *s++); + s++; + } + printf("\r\n"); + } + + /* Header fields of interest. */ + if (r->regstart != NUL) + printf("start `%s' 0x%x; ", r->regstart < 256 + ? (char *)transchar(r->regstart) + : "multibyte", r->regstart); + if (r->reganch) + printf("anchored; "); + if (r->regmust != NULL) + printf("must have \"%s\"", r->regmust); + printf("\r\n"); +} + +/* + * regprop - printable representation of opcode + */ + static char_u * +regprop(op) + char_u *op; +{ + char_u *p; + static char_u buf[50]; + + (void) strcpy(buf, ":"); + + switch (OP(op)) + { + case BOL: + p = "BOL"; + break; + case EOL: + p = "EOL"; + break; + case RE_BOF: + p = "BOF"; + break; + case RE_EOF: + p = "EOF"; + break; + case CURSOR: + p = "CURSOR"; + break; + case RE_LNUM: + p = "RE_LNUM"; + break; + case RE_COL: + p = "RE_COL"; + break; + case RE_VCOL: + p = "RE_VCOL"; + break; + case BOW: + p = "BOW"; + break; + case EOW: + p = "EOW"; + break; + case ANY: + p = "ANY"; + break; + case ANY + ADD_NL: + p = "ANY+NL"; + break; + case ANYOF: + p = "ANYOF"; + break; + case ANYOF + ADD_NL: + p = "ANYOF+NL"; + break; + case ANYBUT: + p = "ANYBUT"; + break; + case ANYBUT + ADD_NL: + p = "ANYBUT+NL"; + break; + case IDENT: + p = "IDENT"; + break; + case IDENT + ADD_NL: + p = "IDENT+NL"; + break; + case SIDENT: + p = "SIDENT"; + break; + case SIDENT + ADD_NL: + p = "SIDENT+NL"; + break; + case KWORD: + p = "KWORD"; + break; + case KWORD + ADD_NL: + p = "KWORD+NL"; + break; + case SKWORD: + p = "SKWORD"; + break; + case SKWORD + ADD_NL: + p = "SKWORD+NL"; + break; + case FNAME: + p = "FNAME"; + break; + case FNAME + ADD_NL: + p = "FNAME+NL"; + break; + case SFNAME: + p = "SFNAME"; + break; + case SFNAME + ADD_NL: + p = "SFNAME+NL"; + break; + case PRINT: + p = "PRINT"; + break; + case PRINT + ADD_NL: + p = "PRINT+NL"; + break; + case SPRINT: + p = "SPRINT"; + break; + case SPRINT + ADD_NL: + p = "SPRINT+NL"; + break; + case WHITE: + p = "WHITE"; + break; + case WHITE + ADD_NL: + p = "WHITE+NL"; + break; + case NWHITE: + p = "NWHITE"; + break; + case NWHITE + ADD_NL: + p = "NWHITE+NL"; + break; + case DIGIT: + p = "DIGIT"; + break; + case DIGIT + ADD_NL: + p = "DIGIT+NL"; + break; + case NDIGIT: + p = "NDIGIT"; + break; + case NDIGIT + ADD_NL: + p = "NDIGIT+NL"; + break; + case HEX: + p = "HEX"; + break; + case HEX + ADD_NL: + p = "HEX+NL"; + break; + case NHEX: + p = "NHEX"; + break; + case NHEX + ADD_NL: + p = "NHEX+NL"; + break; + case OCTAL: + p = "OCTAL"; + break; + case OCTAL + ADD_NL: + p = "OCTAL+NL"; + break; + case NOCTAL: + p = "NOCTAL"; + break; + case NOCTAL + ADD_NL: + p = "NOCTAL+NL"; + break; + case WORD: + p = "WORD"; + break; + case WORD + ADD_NL: + p = "WORD+NL"; + break; + case NWORD: + p = "NWORD"; + break; + case NWORD + ADD_NL: + p = "NWORD+NL"; + break; + case HEAD: + p = "HEAD"; + break; + case HEAD + ADD_NL: + p = "HEAD+NL"; + break; + case NHEAD: + p = "NHEAD"; + break; + case NHEAD + ADD_NL: + p = "NHEAD+NL"; + break; + case ALPHA: + p = "ALPHA"; + break; + case ALPHA + ADD_NL: + p = "ALPHA+NL"; + break; + case NALPHA: + p = "NALPHA"; + break; + case NALPHA + ADD_NL: + p = "NALPHA+NL"; + break; + case LOWER: + p = "LOWER"; + break; + case LOWER + ADD_NL: + p = "LOWER+NL"; + break; + case NLOWER: + p = "NLOWER"; + break; + case NLOWER + ADD_NL: + p = "NLOWER+NL"; + break; + case UPPER: + p = "UPPER"; + break; + case UPPER + ADD_NL: + p = "UPPER+NL"; + break; + case NUPPER: + p = "NUPPER"; + break; + case NUPPER + ADD_NL: + p = "NUPPER+NL"; + break; + case BRANCH: + p = "BRANCH"; + break; + case EXACTLY: + p = "EXACTLY"; + break; + case NOTHING: + p = "NOTHING"; + break; + case BACK: + p = "BACK"; + break; + case END: + p = "END"; + break; + case MOPEN + 0: + p = "MATCH START"; + break; + case MOPEN + 1: + case MOPEN + 2: + case MOPEN + 3: + case MOPEN + 4: + case MOPEN + 5: + case MOPEN + 6: + case MOPEN + 7: + case MOPEN + 8: + case MOPEN + 9: + sprintf(buf + STRLEN(buf), "MOPEN%d", OP(op) - MOPEN); + p = NULL; + break; + case MCLOSE + 0: + p = "MATCH END"; + break; + case MCLOSE + 1: + case MCLOSE + 2: + case MCLOSE + 3: + case MCLOSE + 4: + case MCLOSE + 5: + case MCLOSE + 6: + case MCLOSE + 7: + case MCLOSE + 8: + case MCLOSE + 9: + sprintf(buf + STRLEN(buf), "MCLOSE%d", OP(op) - MCLOSE); + p = NULL; + break; + case BACKREF + 1: + case BACKREF + 2: + case BACKREF + 3: + case BACKREF + 4: + case BACKREF + 5: + case BACKREF + 6: + case BACKREF + 7: + case BACKREF + 8: + case BACKREF + 9: + sprintf(buf + STRLEN(buf), "BACKREF%d", OP(op) - BACKREF); + p = NULL; + break; + case NOPEN: + p = "NOPEN"; + break; + case NCLOSE: + p = "NCLOSE"; + break; +#ifdef FEAT_SYN_HL + case ZOPEN + 1: + case ZOPEN + 2: + case ZOPEN + 3: + case ZOPEN + 4: + case ZOPEN + 5: + case ZOPEN + 6: + case ZOPEN + 7: + case ZOPEN + 8: + case ZOPEN + 9: + sprintf(buf + STRLEN(buf), "ZOPEN%d", OP(op) - ZOPEN); + p = NULL; + break; + case ZCLOSE + 1: + case ZCLOSE + 2: + case ZCLOSE + 3: + case ZCLOSE + 4: + case ZCLOSE + 5: + case ZCLOSE + 6: + case ZCLOSE + 7: + case ZCLOSE + 8: + case ZCLOSE + 9: + sprintf(buf + STRLEN(buf), "ZCLOSE%d", OP(op) - ZCLOSE); + p = NULL; + break; + case ZREF + 1: + case ZREF + 2: + case ZREF + 3: + case ZREF + 4: + case ZREF + 5: + case ZREF + 6: + case ZREF + 7: + case ZREF + 8: + case ZREF + 9: + sprintf(buf + STRLEN(buf), "ZREF%d", OP(op) - ZREF); + p = NULL; + break; +#endif + case STAR: + p = "STAR"; + break; + case PLUS: + p = "PLUS"; + break; + case NOMATCH: + p = "NOMATCH"; + break; + case MATCH: + p = "MATCH"; + break; + case BEHIND: + p = "BEHIND"; + break; + case NOBEHIND: + p = "NOBEHIND"; + break; + case SUBPAT: + p = "SUBPAT"; + break; + case BRACE_LIMITS: + p = "BRACE_LIMITS"; + break; + case BRACE_SIMPLE: + p = "BRACE_SIMPLE"; + break; + case BRACE_COMPLEX + 0: + case BRACE_COMPLEX + 1: + case BRACE_COMPLEX + 2: + case BRACE_COMPLEX + 3: + case BRACE_COMPLEX + 4: + case BRACE_COMPLEX + 5: + case BRACE_COMPLEX + 6: + case BRACE_COMPLEX + 7: + case BRACE_COMPLEX + 8: + case BRACE_COMPLEX + 9: + sprintf(buf + STRLEN(buf), "BRACE_COMPLEX%d", OP(op) - BRACE_COMPLEX); + p = NULL; + break; +#ifdef FEAT_MBYTE + case MULTIBYTECODE: + p = "MULTIBYTECODE"; + break; +#endif + case NEWL: + p = "NEWL"; + break; + default: + sprintf(buf + STRLEN(buf), "corrupt %d", OP(op)); + p = NULL; + break; + } + if (p != NULL) + (void) strcat(buf, p); + return buf; +} +#endif + +#ifdef FEAT_MBYTE +static void mb_decompose __ARGS((int c, int *c1, int *c2, int *c3)); + +typedef struct +{ + int a, b, c; +} decomp_T; + + +/* 0xfb20 - 0xfb4f */ +decomp_T decomp_table[0xfb4f-0xfb20+1] = +{ + {0x5e2,0,0}, /* 0xfb20 alt ayin */ + {0x5d0,0,0}, /* 0xfb21 alt alef */ + {0x5d3,0,0}, /* 0xfb22 alt dalet */ + {0x5d4,0,0}, /* 0xfb23 alt he */ + {0x5db,0,0}, /* 0xfb24 alt kaf */ + {0x5dc,0,0}, /* 0xfb25 alt lamed */ + {0x5dd,0,0}, /* 0xfb26 alt mem-sofit */ + {0x5e8,0,0}, /* 0xfb27 alt resh */ + {0x5ea,0,0}, /* 0xfb28 alt tav */ + {'+', 0, 0}, /* 0xfb29 alt plus */ + {0x5e9, 0x5c1, 0}, /* 0xfb2a shin+shin-dot */ + {0x5e9, 0x5c2, 0}, /* 0xfb2b shin+sin-dot */ + {0x5e9, 0x5c1, 0x5bc}, /* 0xfb2c shin+shin-dot+dagesh */ + {0x5e9, 0x5c2, 0x5bc}, /* 0xfb2d shin+sin-dot+dagesh */ + {0x5d0, 0x5b7, 0}, /* 0xfb2e alef+patah */ + {0x5d0, 0x5b8, 0}, /* 0xfb2f alef+qamats */ + {0x5d0, 0x5b4, 0}, /* 0xfb30 alef+hiriq */ + {0x5d1, 0x5bc, 0}, /* 0xfb31 bet+dagesh */ + {0x5d2, 0x5bc, 0}, /* 0xfb32 gimel+dagesh */ + {0x5d3, 0x5bc, 0}, /* 0xfb33 dalet+dagesh */ + {0x5d4, 0x5bc, 0}, /* 0xfb34 he+dagesh */ + {0x5d5, 0x5bc, 0}, /* 0xfb35 vav+dagesh */ + {0x5d6, 0x5bc, 0}, /* 0xfb36 zayin+dagesh */ + {0xfb37, 0, 0}, /* 0xfb37 -- UNUSED */ + {0x5d8, 0x5bc, 0}, /* 0xfb38 tet+dagesh */ + {0x5d9, 0x5bc, 0}, /* 0xfb39 yud+dagesh */ + {0x5da, 0x5bc, 0}, /* 0xfb3a kaf sofit+dagesh */ + {0x5db, 0x5bc, 0}, /* 0xfb3b kaf+dagesh */ + {0x5dc, 0x5bc, 0}, /* 0xfb3c lamed+dagesh */ + {0xfb3d, 0, 0}, /* 0xfb3d -- UNUSED */ + {0x5de, 0x5bc, 0}, /* 0xfb3e mem+dagesh */ + {0xfb3f, 0, 0}, /* 0xfb3f -- UNUSED */ + {0x5e0, 0x5bc, 0}, /* 0xfb40 nun+dagesh */ + {0x5e1, 0x5bc, 0}, /* 0xfb41 samech+dagesh */ + {0xfb42, 0, 0}, /* 0xfb42 -- UNUSED */ + {0x5e3, 0x5bc, 0}, /* 0xfb43 pe sofit+dagesh */ + {0x5e4, 0x5bc,0}, /* 0xfb44 pe+dagesh */ + {0xfb45, 0, 0}, /* 0xfb45 -- UNUSED */ + {0x5e6, 0x5bc, 0}, /* 0xfb46 tsadi+dagesh */ + {0x5e7, 0x5bc, 0}, /* 0xfb47 qof+dagesh */ + {0x5e8, 0x5bc, 0}, /* 0xfb48 resh+dagesh */ + {0x5e9, 0x5bc, 0}, /* 0xfb49 shin+dagesh */ + {0x5ea, 0x5bc, 0}, /* 0xfb4a tav+dagesh */ + {0x5d5, 0x5b9, 0}, /* 0xfb4b vav+holam */ + {0x5d1, 0x5bf, 0}, /* 0xfb4c bet+rafe */ + {0x5db, 0x5bf, 0}, /* 0xfb4d kaf+rafe */ + {0x5e4, 0x5bf, 0}, /* 0xfb4e pe+rafe */ + {0x5d0, 0x5dc, 0} /* 0xfb4f alef-lamed */ +}; + + static void +mb_decompose(c, c1, c2, c3) + int c, *c1, *c2, *c3; +{ + decomp_T d; + + if (c >= 0x4b20 && c <= 0xfb4f) + { + d = decomp_table[c - 0xfb20]; + *c1 = d.a; + *c2 = d.b; + *c3 = d.c; + } + else + { + *c1 = c; + *c2 = *c3 = 0; + } +} +#endif + +/* + * Compare two strings, ignore case if ireg_ic set. + * Return 0 if strings match, non-zero otherwise. + * Correct the length "*n" when composing characters are ignored. + */ + static int +cstrncmp(s1, s2, n) + char_u *s1, *s2; + int *n; +{ + int result; + + if (!ireg_ic) + result = STRNCMP(s1, s2, *n); + else + result = MB_STRNICMP(s1, s2, *n); + +#ifdef FEAT_MBYTE + /* if it failed and it's utf8 and we want to combineignore: */ + if (result != 0 && enc_utf8 && ireg_icombine) + { + char_u *str1, *str2; + int c1, c2, c11, c12; + int ix; + int junk; + + /* we have to handle the strcmp ourselves, since it is necessary to + * deal with the composing characters by ignoring them: */ + str1 = s1; + str2 = s2; + c1 = c2 = 0; + for (ix = 0; ix < *n; ) + { + c1 = mb_ptr2char_adv(&str1); + c2 = mb_ptr2char_adv(&str2); + ix += utf_char2len(c1); + + /* decompose the character if necessary, into 'base' characters + * because I don't care about Arabic, I will hard-code the Hebrew + * which I *do* care about! So sue me... */ + if (c1 != c2 && (!ireg_ic || utf_fold(c1) != utf_fold(c2))) + { + /* decomposition necessary? */ + mb_decompose(c1, &c11, &junk, &junk); + mb_decompose(c2, &c12, &junk, &junk); + c1 = c11; + c2 = c12; + if (c11 != c12 && (!ireg_ic || utf_fold(c11) != utf_fold(c12))) + break; + } + } + result = c2 - c1; + if (result == 0) + *n = (int)(str2 - s2); + } +#endif + + return result; +} + +/* + * cstrchr: This function is used a lot for simple searches, keep it fast! + */ + static char_u * +cstrchr(s, c) + char_u *s; + int c; +{ + char_u *p; + int cc; + + if (!ireg_ic +#ifdef FEAT_MBYTE + || (!enc_utf8 && mb_char2len(c) > 1) +#endif + ) + return vim_strchr(s, c); + + /* tolower() and toupper() can be slow, comparing twice should be a lot + * faster (esp. when using MS Visual C++!). + * For UTF-8 need to use folded case. */ +#ifdef FEAT_MBYTE + if (enc_utf8 && c > 0x80) + cc = utf_fold(c); + else +#endif + if (isupper(c)) + cc = TOLOWER_LOC(c); + else if (islower(c)) + cc = TOUPPER_LOC(c); + else + return vim_strchr(s, c); + +#ifdef FEAT_MBYTE + if (has_mbyte) + { + for (p = s; *p != NUL; p += (*mb_ptr2len_check)(p)) + { + if (enc_utf8 && c > 0x80) + { + if (utf_fold(utf_ptr2char(p)) == cc) + return p; + } + else if (*p == c || *p == cc) + return p; + } + } + else +#endif + /* Faster version for when there are no multi-byte characters. */ + for (p = s; *p != NUL; ++p) + if (*p == c || *p == cc) + return p; + + return NULL; +} + +/*************************************************************** + * regsub stuff * + ***************************************************************/ + +/* This stuff below really confuses cc on an SGI -- webb */ +#ifdef __sgi +# undef __ARGS +# define __ARGS(x) () +#endif + +/* + * We should define ftpr as a pointer to a function returning a pointer to + * a function returning a pointer to a function ... + * This is impossible, so we declare a pointer to a function returning a + * pointer to a function returning void. This should work for all compilers. + */ +typedef void (*(*fptr) __ARGS((char_u *, int)))(); + +static fptr do_upper __ARGS((char_u *, int)); +static fptr do_Upper __ARGS((char_u *, int)); +static fptr do_lower __ARGS((char_u *, int)); +static fptr do_Lower __ARGS((char_u *, int)); + +static int vim_regsub_both __ARGS((char_u *source, char_u *dest, int copy, int magic, int backslash)); + + static fptr +do_upper(d, c) + char_u *d; + int c; +{ + *d = TOUPPER_LOC(c); + + return (fptr)NULL; +} + + static fptr +do_Upper(d, c) + char_u *d; + int c; +{ + *d = TOUPPER_LOC(c); + + return (fptr)do_Upper; +} + + static fptr +do_lower(d, c) + char_u *d; + int c; +{ + *d = TOLOWER_LOC(c); + + return (fptr)NULL; +} + + static fptr +do_Lower(d, c) + char_u *d; + int c; +{ + *d = TOLOWER_LOC(c); + + return (fptr)do_Lower; +} + +/* + * regtilde(): Replace tildes in the pattern by the old pattern. + * + * Short explanation of the tilde: It stands for the previous replacement + * pattern. If that previous pattern also contains a ~ we should go back a + * step further... But we insert the previous pattern into the current one + * and remember that. + * This still does not handle the case where "magic" changes. TODO? + * + * The tildes are parsed once before the first call to vim_regsub(). + */ + char_u * +regtilde(source, magic) + char_u *source; + int magic; +{ + char_u *newsub = source; + char_u *tmpsub; + char_u *p; + int len; + int prevlen; + + for (p = newsub; *p; ++p) + { + if ((*p == '~' && magic) || (*p == '\\' && *(p + 1) == '~' && !magic)) + { + if (reg_prev_sub != NULL) + { + /* length = len(newsub) - 1 + len(prev_sub) + 1 */ + prevlen = (int)STRLEN(reg_prev_sub); + tmpsub = alloc((unsigned)(STRLEN(newsub) + prevlen)); + if (tmpsub != NULL) + { + /* copy prefix */ + len = (int)(p - newsub); /* not including ~ */ + mch_memmove(tmpsub, newsub, (size_t)len); + /* interpretate tilde */ + mch_memmove(tmpsub + len, reg_prev_sub, (size_t)prevlen); + /* copy postfix */ + if (!magic) + ++p; /* back off \ */ + STRCPY(tmpsub + len + prevlen, p + 1); + + if (newsub != source) /* already allocated newsub */ + vim_free(newsub); + newsub = tmpsub; + p = newsub + len + prevlen; + } + } + else if (magic) + STRCPY(p, p + 1); /* remove '~' */ + else + STRCPY(p, p + 2); /* remove '\~' */ + --p; + } + else + { + if (*p == '\\' && p[1]) /* skip escaped characters */ + ++p; +#ifdef FEAT_MBYTE + if (has_mbyte) + p += (*mb_ptr2len_check)(p) - 1; +#endif + } + } + + vim_free(reg_prev_sub); + if (newsub != source) /* newsub was allocated, just keep it */ + reg_prev_sub = newsub; + else /* no ~ found, need to save newsub */ + reg_prev_sub = vim_strsave(newsub); + return newsub; +} + +#ifdef FEAT_EVAL +static int can_f_submatch = FALSE; /* TRUE when submatch() can be used */ + +/* These pointers are used instead of reg_match and reg_mmatch for + * reg_submatch(). Needed for when the substitution string is an expression + * that contains a call to substitute() and submatch(). */ +static regmatch_T *submatch_match; +static regmmatch_T *submatch_mmatch; +#endif + +#if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO) +/* + * vim_regsub() - perform substitutions after a vim_regexec() or + * vim_regexec_multi() match. + * + * If "copy" is TRUE really copy into "dest". + * If "copy" is FALSE nothing is copied, this is just to find out the length + * of the result. + * + * If "backslash" is TRUE, a backslash will be removed later, need to double + * them to keep them, and insert a backslash before a CR to avoid it being + * replaced with a line break later. + * + * Note: The matched text must not change between the call of + * vim_regexec()/vim_regexec_multi() and vim_regsub()! It would make the back + * references invalid! + * + * Returns the size of the replacement, including terminating NUL. + */ + int +vim_regsub(rmp, source, dest, copy, magic, backslash) + regmatch_T *rmp; + char_u *source; + char_u *dest; + int copy; + int magic; + int backslash; +{ + reg_match = rmp; + reg_mmatch = NULL; + reg_maxline = 0; + return vim_regsub_both(source, dest, copy, magic, backslash); +} +#endif + + int +vim_regsub_multi(rmp, lnum, source, dest, copy, magic, backslash) + regmmatch_T *rmp; + linenr_T lnum; + char_u *source; + char_u *dest; + int copy; + int magic; + int backslash; +{ + reg_match = NULL; + reg_mmatch = rmp; + reg_buf = curbuf; /* always works on the current buffer! */ + reg_firstlnum = lnum; + reg_maxline = curbuf->b_ml.ml_line_count - lnum; + return vim_regsub_both(source, dest, copy, magic, backslash); +} + + static int +vim_regsub_both(source, dest, copy, magic, backslash) + char_u *source; + char_u *dest; + int copy; + int magic; + int backslash; +{ + char_u *src; + char_u *dst; + char_u *s; + int c; + int no = -1; + fptr func = (fptr)NULL; + linenr_T clnum = 0; /* init for GCC */ + int len = 0; /* init for GCC */ +#ifdef FEAT_EVAL + static char_u *eval_result = NULL; +#endif +#ifdef FEAT_MBYTE + int l; +#endif + + + /* Be paranoid... */ + if (source == NULL || dest == NULL) + { + EMSG(_(e_null)); + return 0; + } + if (prog_magic_wrong()) + return 0; + src = source; + dst = dest; + + /* + * When the substitute part starts with "\=" evaluate it as an expression. + */ + if (source[0] == '\\' && source[1] == '=' +#ifdef FEAT_EVAL + && !can_f_submatch /* can't do this recursively */ +#endif + ) + { +#ifdef FEAT_EVAL + /* To make sure that the length doesn't change between checking the + * length and copying the string, and to speed up things, the + * resulting string is saved from the call with "copy" == FALSE to the + * call with "copy" == TRUE. */ + if (copy) + { + if (eval_result != NULL) + { + STRCPY(dest, eval_result); + dst += STRLEN(eval_result); + vim_free(eval_result); + eval_result = NULL; + } + } + else + { + linenr_T save_reg_maxline; + win_T *save_reg_win; + int save_ireg_ic; + + vim_free(eval_result); + + /* The expression may contain substitute(), which calls us + * recursively. Make sure submatch() gets the text from the first + * level. Don't need to save "reg_buf", because + * vim_regexec_multi() can't be called recursively. */ + submatch_match = reg_match; + submatch_mmatch = reg_mmatch; + save_reg_maxline = reg_maxline; + save_reg_win = reg_win; + save_ireg_ic = ireg_ic; + can_f_submatch = TRUE; + + eval_result = eval_to_string(source + 2, NULL); + if (eval_result != NULL) + { + for (s = eval_result; *s != NUL; ++s) + { + /* Change NL to CR, so that it becomes a line break. + * Skip over a backslashed character. */ + if (*s == NL) + *s = CAR; + else if (*s == '\\' && s[1] != NUL) + ++s; +#ifdef FEAT_MBYTE + if (has_mbyte) + s += (*mb_ptr2len_check)(s) - 1; +#endif + } + + dst += STRLEN(eval_result); + } + + reg_match = submatch_match; + reg_mmatch = submatch_mmatch; + reg_maxline = save_reg_maxline; + reg_win = save_reg_win; + ireg_ic = save_ireg_ic; + can_f_submatch = FALSE; + } +#endif + } + else + while ((c = *src++) != NUL) + { + if (c == '&' && magic) + no = 0; + else if (c == '\\' && *src != NUL) + { + if (*src == '&' && !magic) + { + ++src; + no = 0; + } + else if ('0' <= *src && *src <= '9') + { + no = *src++ - '0'; + } + else if (vim_strchr((char_u *)"uUlLeE", *src)) + { + switch (*src++) + { + case 'u': func = (fptr)do_upper; + continue; + case 'U': func = (fptr)do_Upper; + continue; + case 'l': func = (fptr)do_lower; + continue; + case 'L': func = (fptr)do_Lower; + continue; + case 'e': + case 'E': func = (fptr)NULL; + continue; + } + } + } + if (no < 0) /* Ordinary character. */ + { + if (c == '\\' && *src != NUL) + { + /* Check for abbreviations -- webb */ + switch (*src) + { + case 'r': c = CAR; ++src; break; + case 'n': c = NL; ++src; break; + case 't': c = TAB; ++src; break; + /* Oh no! \e already has meaning in subst pat :-( */ + /* case 'e': c = ESC; ++src; break; */ + case 'b': c = Ctrl_H; ++src; break; + + /* If "backslash" is TRUE the backslash will be removed + * later. Used to insert a literal CR. */ + default: if (backslash) + { + if (copy) + *dst = '\\'; + ++dst; + } + c = *src++; + } + } + + /* Write to buffer, if copy is set. */ +#ifdef FEAT_MBYTE + if (has_mbyte && (l = (*mb_ptr2len_check)(src - 1)) > 1) + { + /* TODO: should use "func" here. */ + if (copy) + mch_memmove(dst, src - 1, l); + dst += l - 1; + src += l - 1; + } + else + { +#endif + if (copy) + { + if (func == (fptr)NULL) /* just copy */ + *dst = c; + else /* change case */ + func = (fptr)(func(dst, c)); + /* Turbo C complains without the typecast */ + } +#ifdef FEAT_MBYTE + } +#endif + dst++; + } + else + { + if (REG_MULTI) + { + clnum = reg_mmatch->startpos[no].lnum; + if (clnum < 0 || reg_mmatch->endpos[no].lnum < 0) + s = NULL; + else + { + s = reg_getline(clnum) + reg_mmatch->startpos[no].col; + if (reg_mmatch->endpos[no].lnum == clnum) + len = reg_mmatch->endpos[no].col + - reg_mmatch->startpos[no].col; + else + len = (int)STRLEN(s); + } + } + else + { + s = reg_match->startp[no]; + if (reg_match->endp[no] == NULL) + s = NULL; + else + len = (int)(reg_match->endp[no] - s); + } + if (s != NULL) + { + for (;;) + { + if (len == 0) + { + if (REG_MULTI) + { + if (reg_mmatch->endpos[no].lnum == clnum) + break; + if (copy) + *dst = CAR; + ++dst; + s = reg_getline(++clnum); + if (reg_mmatch->endpos[no].lnum == clnum) + len = reg_mmatch->endpos[no].col; + else + len = (int)STRLEN(s); + } + else + break; + } + else if (*s == NUL) /* we hit NUL. */ + { + if (copy) + EMSG(_(e_re_damg)); + goto exit; + } + else + { + if (backslash && (*s == CAR || *s == '\\')) + { + /* + * Insert a backslash in front of a CR, otherwise + * it will be replaced by a line break. + * Number of backslashes will be halved later, + * double them here. + */ + if (copy) + { + dst[0] = '\\'; + dst[1] = *s; + } + dst += 2; + } +#ifdef FEAT_MBYTE + else if (has_mbyte && (l = (*mb_ptr2len_check)(s)) > 1) + { + /* TODO: should use "func" here. */ + if (copy) + mch_memmove(dst, s, l); + dst += l; + s += l - 1; + len -= l - 1; + } +#endif + else + { + if (copy) + { + if (func == (fptr)NULL) /* just copy */ + *dst = *s; + else /* change case */ + func = (fptr)(func(dst, *s)); + /* Turbo C complains without the typecast */ + } + ++dst; + } + ++s; + --len; + } + } + } + no = -1; + } + } + if (copy) + *dst = NUL; + +exit: + return (int)((dst - dest) + 1); +} + +#ifdef FEAT_EVAL +/* + * Used for the submatch() function: get the string from tne n'th submatch in + * allocated memory. + * Returns NULL when not in a ":s" command and for a non-existing submatch. + */ + char_u * +reg_submatch(no) + int no; +{ + char_u *retval = NULL; + char_u *s; + int len; + int round; + linenr_T lnum; + + if (!can_f_submatch) + return NULL; + + if (submatch_match == NULL) + { + /* + * First round: compute the length and allocate memory. + * Second round: copy the text. + */ + for (round = 1; round <= 2; ++round) + { + lnum = submatch_mmatch->startpos[no].lnum; + if (lnum < 0 || submatch_mmatch->endpos[no].lnum < 0) + return NULL; + + s = reg_getline(lnum) + submatch_mmatch->startpos[no].col; + if (s == NULL) /* anti-crash check, cannot happen? */ + break; + if (submatch_mmatch->endpos[no].lnum == lnum) + { + /* Within one line: take form start to end col. */ + len = submatch_mmatch->endpos[no].col + - submatch_mmatch->startpos[no].col; + if (round == 2) + { + STRNCPY(retval, s, len); + retval[len] = NUL; + } + ++len; + } + else + { + /* Multiple lines: take start line from start col, middle + * lines completely and end line up to end col. */ + len = (int)STRLEN(s); + if (round == 2) + { + STRCPY(retval, s); + retval[len] = '\n'; + } + ++len; + ++lnum; + while (lnum < submatch_mmatch->endpos[no].lnum) + { + s = reg_getline(lnum++); + if (round == 2) + STRCPY(retval + len, s); + len += (int)STRLEN(s); + if (round == 2) + retval[len] = '\n'; + ++len; + } + if (round == 2) + STRNCPY(retval + len, reg_getline(lnum), + submatch_mmatch->endpos[no].col); + len += submatch_mmatch->endpos[no].col; + if (round == 2) + retval[len] = NUL; + ++len; + } + + if (round == 1) + { + retval = lalloc((long_u)len, TRUE); + if (s == NULL) + return NULL; + } + } + } + else + { + if (submatch_match->endp[no] == NULL) + retval = NULL; + else + { + s = submatch_match->startp[no]; + retval = vim_strnsave(s, (int)(submatch_match->endp[no] - s)); + } + } + + return retval; +} +#endif |