开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编辑器/阅读器 > 查看源码
regexp.c
资源名称：vim53src.zip　[点击查看]
上传用户：gddssl
上传日期：2007-01-06
资源大小：1003k
文件大小：73k
源码类别：

编辑器/阅读器

开发平台：

DOS

regexp.c：源码内容
  1. /* vi:set ts=8 sts=4 sw=4:
  2.  *
  3.  * Handling of regular expressions: vim_regcomp(), vim_regexec(), vim_regsub()
  4.  *
  5.  * NOTICE:
  6.  *
  7.  * This is NOT the original regular expression code as written by Henry
  8.  * Spencer.  This code has been modified specifically for use with the VIM
  9.  * editor, and should not be used apart from compiling VIM.  If you want a
  10.  * good regular expression library, get the original code.  The copyright
  11.  * notice that follows is from the original.
  12.  *
  13.  * END NOTICE
  14.  *
  15.  * Copyright (c) 1986 by University of Toronto.
  16.  * Written by Henry Spencer.  Not derived from licensed software.
  17.  *
  18.  * Permission is granted to anyone to use this software for any
  19.  * purpose on any computer system, and to redistribute it freely,
  20.  * subject to the following restrictions:
  21.  *
  22.  * 1. The author is not responsible for the consequences of use of
  23.  * this software, no matter how awful, even if they arise
  24.  * from defects in it.
  25.  *
  26.  * 2. The origin of this software must not be misrepresented, either
  27.  * by explicit claim or by omission.
  28.  *
  29.  * 3. Altered versions must be plainly marked as such, and must not
  30.  * be misrepresented as being the original software.
  31.  *
  32.  * Beware that some of this code is subtly aware of the way operator
  33.  * precedence is structured in regular expressions.  Serious changes in
  34.  * regular-expression syntax might require a total rethink.
  35.  *
  36.  * Changes have been made by Tony Andrews, Olaf 'Rhialto' Seibert, Robert Webb
  37.  * and Bram Moolenaar.
  38.  * Named character class support added by Walter Briscoe (1998 Jul 01)
  39.  */
  41. #include "vim.h"
  43. #undef DEBUG
  45. #include <stdio.h>
  46. #include "option.h"
  48. /*
  49.  * Get around a problem with #defined char class functions.
  50.  */
  51. #ifdef isalnum
  52. static int myisalnum __ARGS((int c));
  53. static int myisalnum(c) int c; { return isalnum(c); }
  54. # undef isalnum
  55. # define isalnum myisalnum
  56. #endif
  57. #ifdef isalpha
  58. static int myisalpha __ARGS((int c));
  59. static int myisalpha(c) int c; { return isalpha(c); }
  60. # undef isalpha
  61. # define isalpha myisalpha
  62. #endif
  63. #ifdef iscntrl
  64. static int myiscntrl __ARGS((int c));
  65. static int myiscntrl(c) int c; { return iscntrl(c); }
  66. # undef iscntrl
  67. # define iscntrl myiscntrl
  68. #endif
  69. #ifdef isdigit
  70. static int myisdigit __ARGS((int c));
  71. static int myisdigit(c) int c; { return isdigit(c); }
  72. # undef isdigit
  73. # define isdigit myisdigit
  74. #endif
  75. # ifdef isgraph
  76. static int myisgraph __ARGS((int c));
  77. static int myisgraph(c) int c; { return isgraph(c); }
  78. # undef isgraph
  79. # define isgraph myisgraph
  80. #endif
  81. #ifdef islower
  82. static int myislower __ARGS((int c));
  83. static int myislower(c) int c; { return islower(c); }
  84. # undef islower
  85. # define islower myislower
  86. #endif
  87. #ifdef ispunct
  88. static int myispunct __ARGS((int c));
  89. static int myispunct(c) int c; { return ispunct(c); }
  90. # undef ispunct
  91. # define ispunct myispunct
  92. #endif
  93. #ifdef isupper
  94. static int myisupper __ARGS((int c));
  95. static int myisupper(c) int c; { return isupper(c); }
  96. # undef isupper
  97. # define isupper myisupper
  98. #endif
  99. #ifdef isxdigit
  100. static int myisxdigit __ARGS((int c));
  101. static int myisxdigit(c) int c; { return isxdigit(c); }
  102. # undef isxdigit
  103. # define isxdigit myisxdigit
  104. #endif
  106. /*
  107.  * The "internal use only" fields in regexp.h are present to pass info from
  108.  * compile to execute that permits the execute phase to run lots faster on
  109.  * simple cases.  They are:
  110.  *
  111.  * regstart char that must begin a match; '' if none obvious
  112.  * reganch is the match anchored (at beginning-of-line only)?
  113.  * regmust string (pointer into program) that match must include, or NULL
  114.  * regmlen length of regmust string
  115.  *
  116.  * Regstart and reganch permit very fast decisions on suitable starting points
  117.  * for a match, cutting down the work a lot.  Regmust permits fast rejection
  118.  * of lines that cannot possibly match.  The regmust tests are costly enough
  119.  * that vim_regcomp() supplies a regmust only if the r.e. contains something
  120.  * potentially expensive (at present, the only such thing detected is * or +
  121.  * at the start of the r.e., which can involve a lot of backup).  Regmlen is
  122.  * supplied because the test in vim_regexec() needs it and vim_regcomp() is
  123.  * computing it anyway.
  124.  */
  126. /*
  127.  * Structure for regexp "program".  This is essentially a linear encoding
  128.  * of a nondeterministic finite-state machine (aka syntax charts or
  129.  * "railroad normal form" in parsing technology).  Each node is an opcode
  130.  * plus a "next" pointer, possibly plus an operand.  "Next" pointers of
  131.  * all nodes except BRANCH and BRACES_COMPLEX implement concatenation; a "next"
  132.  * pointer with a BRANCH on both ends of it is connecting two alternatives.
  133.  * (Here we have one of the subtle syntax dependencies: an individual BRANCH
  134.  * (as opposed to a collection of them) is never concatenated with anything
  135.  * because of operator precedence).  The "next" pointer of a BRACES_COMPLEX
  136.  * node points to the node after the stuff to be repeated.  The operand of some
  137.  * types of node is a literal string; for others, it is a node leading into a
  138.  * sub-FSM.  In particular, the operand of a BRANCH node is the first node of
  139.  * the branch. (NB this is *not* a tree structure: the tail of the branch
  140.  * connects to the thing following the set of BRANCHes.)  The opcodes are:
  141.  */
  143. /* definition number    opnd?    meaning */
  144. #define END 0 /* no End of program. */
  145. #define BOL 1 /* no Match "" at beginning of line. */
  146. #define EOL 2 /* no Match "" at end of line. */
  147. #define ANY 3 /* no Match any one character. */
  148. #define ANYOF 4 /* str Match any character in this string. */
  149. #define ANYBUT 5 /* str Match any character not in this
  150.  * string. */
  151. #define BRANCH 6 /* node Match this alternative, or the
  152.  * next... */
  153. #define BACK 7 /* no Match "", "next" ptr points backward. */
  154. #define EXACTLY 8 /* str Match this string. */
  155. #define NOTHING 9 /* no Match empty string. */
  156. #define STAR 10 /* node Match this (simple) thing 0 or more
  157.  * times. */
  158. #define PLUS 11 /* node Match this (simple) thing 1 or more
  159.  * times. */
  160. #define BRACE_SIMPLE 12 /* node Match this (simple) thing between m and
  161.  * n times ({m,n}). */
  162. #define BOW 13 /* no Match "" after [^a-zA-Z0-9_] */
  163. #define EOW 14 /* no Match "" at    [^a-zA-Z0-9_] */
  164. #define IDENT 15 /* no Match identifier char */
  165. #define KWORD 16 /* no Match keyword char */
  166. #define FNAME 17 /* no Match file name char */
  167. #define PRINT 18 /* no Match printable char */
  168. #define SIDENT 19 /* no Match identifier char but no digit */
  169. #define SWORD 20 /* no Match word char but no digit */
  170. #define SFNAME 21 /* no Match file name char but no digit */
  171. #define SPRINT 22 /* no Match printable char but no digit */
  172. #define BRACE_LIMITS 23 /* 2int define the min & max for BRACE_SIMPLE
  173.  * and BRACE_COMPLEX. */
  174. #define WHITE 24 /* no Match whitespace char */
  175. #define NWHITE 25 /* no Match non-whitespace char */
  176. #define DIGIT 26 /* no Match digit char */
  177. #define NDIGIT 27 /* no Match non-digit char */
  178. #define HEX 28 /* no   Match hex char */
  179. #define NHEX 29 /* no   Match non-hex char */
  180. #define OCTAL 30 /* no Match octal char */
  181. #define NOCTAL 31 /* no Match non-octal char */
  182. #define WORD 32 /* no Match word char */
  183. #define NWORD 33 /* no Match non-word char */
  184. #define HEAD 34 /* no Match head char */
  185. #define NHEAD 35 /* no Match non-head char */
  186. #define ALPHA 36 /* no Match alpha char */
  187. #define NALPHA 37 /* no Match non-alpha char */
  188. #define LOWER 38 /* no Match lowercase char */
  189. #define NLOWER 39 /* no Match non-lowercase char */
  190. #define UPPER 40 /* no Match uppercase char */
  191. #define NUPPER 41 /* no Match non-uppercase char */
  192. #define MOPEN 60 /* -69  no Mark this point in input as start of
  193.  * ( subexpr. */
  194. #define MCLOSE 70 /* -79  no Analogous to MOPEN. */
  195. #define BACKREF 80 /* -89  node Match same string again 1-9 */
  196. #define BRACE_COMPLEX 90 /* -99  node Match nodes between m & n times */
  198. #define Magic(x)    ((x) | ('\' << 8))
  200. /*
  201.  * Opcode notes:
  202.  *
  203.  * BRANCH The set of branches constituting a single choice are hooked
  204.  * together with their "next" pointers, since precedence prevents
  205.  * anything being concatenated to any individual branch.  The
  206.  * "next" pointer of the last BRANCH in a choice points to the
  207.  * thing following the whole choice.  This is also where the
  208.  * final "next" pointer of each individual branch points; each
  209.  * branch starts with the operand node of a BRANCH node.
  210.  *
  211.  * BACK Normal "next" pointers all implicitly point forward; BACK
  212.  * exists to make loop structures possible.
  213.  *
  214.  * STAR,PLUS '=', and complex '*' and '+', are implemented as circular
  215.  * BRANCH structures using BACK.  Simple cases (one character
  216.  * per match) are implemented with STAR and PLUS for speed
  217.  * and to minimize recursive plunges.
  218.  * Note: We would like to use "?" instead of "=", but a "?"
  219.  * can be part of a pattern to escape the special meaning of '?'
  220.  * at the end of the pattern in "?pattern?e".
  221.  *
  222.  * BRACE_LIMITS This is always followed by a BRACE_SIMPLE or BRACE_COMPLEX
  223.  * node, and defines the min and max limits to be used for that
  224.  * node.
  225.  *
  226.  * MOPEN,MCLOSE ...are numbered at compile time.
  227.  */
  229. /*
  230.  * A node is one char of opcode followed by two chars of "next" pointer.
  231.  * "Next" pointers are stored as two 8-bit pieces, high order first.  The
  232.  * value is a positive offset from the opcode of the node containing it.
  233.  * An operand, if any, simply follows the node.  (Note that much of the
  234.  * code generation knows about this implicit relationship.)
  235.  *
  236.  * Using two bytes for the "next" pointer is vast overkill for most things,
  237.  * but allows patterns to get big without disasters.
  238.  */
  239. #define OP(p) ((int)*(p))
  240. #define NEXT(p) (((*((p)+1)&0377)<<8) + (*((p)+2)&0377))
  241. #define OPERAND(p) ((p) + 3)
  242. #define OPERAND_MIN(p) (((*((p)+3)&0377)<<8) + (*((p)+4)&0377))
  243. #define OPERAND_MAX(p) (((*((p)+5)&0377)<<8) + (*((p)+6)&0377))
  245. /*
  246.  * Utility definitions.
  247.  */
  248. #ifndef CHARBITS
  249. # define UCHARAT(p) ((int)*(unsigned char *)(p))
  250. #else
  251. # define UCHARAT(p) ((int)*(p)&CHARBITS)
  252. #endif
  254. #define EMSG_RETURN(m) { emsg(m); rc_did_emsg = TRUE; return NULL; }
  256. #define MAX_LIMIT 32767
  258. static int re_ismult __ARGS((int));
  259. static int cstrncmp __ARGS((char_u *s1, char_u *s2, int n));
  260. static char_u *cstrchr __ARGS((char_u *, int));
  262. #ifdef DEBUG
  263. static void regdump __ARGS((char_u *, vim_regexp *));
  264. static char_u *regprop __ARGS((char_u *));
  265. #endif
  267.     static int
  268. re_ismult(c)
  269.     int c;
  270. {
  271.     return (c == Magic('*') || c == Magic('+') || c == Magic('=') ||
  272.     c == Magic('{'));
  273. }
  275. /*
  276.  * Flags to be passed up and down.
  277.  */
  278. #define HASWIDTH 01 /* Known never to match null string. */
  279. #define SIMPLE 02 /* Simple enough to be STAR/PLUS operand. */
  280. #define SPSTART 04 /* Starts with * or +. */
  281. #define WORST 0 /* Worst case. */
  283. /*
  284.  * When regcode is set to this value, code is not emitted and size is computed
  285.  * instead.
  286.  */
  287. #define JUST_CALC_SIZE ((char_u *) -1)
  289. static char_u *reg_prev_sub;
  291. /*
  292.  * REGEXP_INRANGE contains all characters which are always special in a []
  293.  * range after ''.
  294.  * REGEXP_ABBR contains all characters which act as abbreviations after ''.
  295.  * These are:
  296.  *  r - New line (CR).
  297.  *  t - Tab (TAB).
  298.  *  e - Escape (ESC).
  299.  *  b - Backspace (Ctrl('H')).
  300.  */
  301. static char_u REGEXP_INRANGE[] = "]^-\";
  302. static char_u REGEXP_ABBR[] = "rteb";
  304. static int backslash_trans __ARGS((int c));
  305. static int my_isblank __ARGS((int c));
  306. static int (* skip_class_name __ARGS((char_u **pp)))__ARGS((int));
  307. static char_u * skip_range __ARGS((char_u *p));
  308. static void init_class_tab __ARGS((void));
  310.     static int
  311. backslash_trans(c)
  312.     int     c;
  313. {
  314.     switch (c)
  315.     {
  316. case 'r':   return CR;
  317. case 't':   return TAB;
  318. case 'e':   return ESC;
  319. case 'b':   return Ctrl('H');
  320.     }
  321.     return c;
  322. }
  324. /*
  325.  * Function version of the macro vim_iswhite().
  326.  */
  327.     static int
  328. my_isblank(c)
  329.     int c;
  330. {
  331.     return vim_iswhite(c);
  332. }
  334. /*
  335.  * Check for a character class name.  "pp" is at the '['.
  336.  * If not: NULL is returned; If so, a function of the sort is* is returned and
  337.  * the name is skipped.
  338.  */
  339.     static int (*
  340. skip_class_name(pp))__ARGS((int))
  341.     char_u **pp;
  342. {
  343.     typedef struct
  344.     {
  345. size_t     len;
  346. int     (*func)__ARGS((int));
  347. char_u     name[sizeof("xdigit:]")];
  348.     } namedata_t;
  350. #define t(n, func) { sizeof(n) - 1, func, n }
  351.     static const namedata_t class_names[] =
  352.     {
  353. t("alnum:]", isalnum), t("alpha:]", isalpha),
  354. t("blank:]", my_isblank), t("cntrl:]", iscntrl),
  355. t("digit:]", isdigit), t("graph:]", isgraph),
  356. t("lower:]", islower), t("print:]", vim_isprintc),
  357. t("punct:]", ispunct), t("space:]", vim_isspace),
  358. t("upper:]", isupper), t("xdigit:]", isxdigit)
  359.     };
  360. #undef t
  362.     const namedata_t *np;
  364.     if ((*pp)[1] != ':')
  365. return NULL;
  366.     for (   np = class_names;
  367.     np < class_names + sizeof(class_names) / sizeof(*class_names);
  368.     np++)
  369. if (STRNCMP(*pp+2, np->name, np->len) == 0)
  370. {
  371.     *pp += np->len + 2;
  372.     return np->func;
  373. }
  374.     return NULL;
  375. }
  377. /*
  378.  * Skip over a "[]" range.
  379.  * "p" must point to the character after the '['.
  380.  * The returned pointer is on the matching ']', or the terminating NUL.
  381.  */
  382.     static char_u *
  383. skip_range(p)
  384.     char_u *p;
  385. {
  386.     int     cpo_lit;     /* 'cpoptions' contains 'l' flag */
  388.     cpo_lit = (!reg_syn && vim_strchr(p_cpo, CPO_LITERAL) != NULL);
  390.     if (*p == '^') /* Complement of range. */
  391. ++p;
  392.     if (*p == ']' || *p == '-')
  393. ++p;
  394.     while (*p != NUL && *p != ']')
  395.     {
  396. if (*p == '-')
  397. {
  398.     ++p;
  399.     if (*p != ']' && *p != NUL)
  400. ++p;
  401. }
  402. else if (*p == '\'
  403. && (vim_strchr(REGEXP_INRANGE, p[1]) != NULL
  404.     || (!cpo_lit && vim_strchr(REGEXP_ABBR, p[1]) != NULL)))
  405.     p += 2;
  406. else if (*p == '[')
  407. {
  408.     if (skip_class_name(&p) == NULL)
  409. ++p; /* It was not a class name */
  410. }
  411. else
  412.     ++p;
  413.     }
  415.     return p;
  416. }
  418. /*
  419.  * Specific version of character class functions.
  420.  * Using a table to keep this fast.
  421.  */
  422. static char_u class_tab[256];
  424. #define     RI_DIGIT 0x01
  425. #define     RI_HEX 0x02
  426. #define     RI_OCTAL 0x04
  427. #define     RI_WORD 0x08
  428. #define     RI_HEAD 0x10
  429. #define     RI_ALPHA 0x20
  430. #define     RI_LOWER 0x40
  431. #define     RI_UPPER 0x80
  433.     static void
  434. init_class_tab()
  435. {
  436.     int i;
  437.     static int done = FALSE;
  439.     if (done)
  440. return;
  442.     for (i = 0; i < 256; ++i)
  443.     {
  444. if (i >= '0' && i <= '7')
  445.     class_tab[i] = RI_DIGIT + RI_HEX + RI_OCTAL + RI_WORD;
  446. else if (i >= '8' && i <= '9')
  447.     class_tab[i] = RI_DIGIT + RI_HEX + RI_WORD;
  448. else if (i >= 'a' && i <= 'f')
  449.     class_tab[i] = RI_HEX + RI_WORD + RI_HEAD + RI_ALPHA + RI_LOWER;
  450. else if (i >= 'g' && i <= 'z')
  451.     class_tab[i] = RI_WORD + RI_HEAD + RI_ALPHA + RI_LOWER;
  452. else if (i >= 'A' && i <= 'F')
  453.     class_tab[i] = RI_HEX + RI_WORD + RI_HEAD + RI_ALPHA + RI_UPPER;
  454. else if (i >= 'G' && i <= 'Z')
  455.     class_tab[i] = RI_WORD + RI_HEAD + RI_ALPHA + RI_UPPER;
  456. else if (i == '_')
  457.     class_tab[i] = RI_WORD + RI_HEAD;
  458.     }
  459.     done = TRUE;
  460. }
  462. #define ri_digit(c) (class_tab[c] & RI_DIGIT)
  463. #define ri_hex(c) (class_tab[c] & RI_HEX)
  464. #define ri_octal(c) (class_tab[c] & RI_OCTAL)
  465. #define ri_word(c) (class_tab[c] & RI_WORD)
  466. #define ri_head(c) (class_tab[c] & RI_HEAD)
  467. #define ri_alpha(c) (class_tab[c] & RI_ALPHA)
  468. #define ri_lower(c) (class_tab[c] & RI_LOWER)
  469. #define ri_upper(c) (class_tab[c] & RI_UPPER)
  471. /*
  472.  * Global work variables for vim_regcomp().
  473.  */
  475. static char_u *regparse;  /* Input-scan pointer. */
  476. static int num_complex_braces; /* Complex {...} count */
  477. static int regnpar; /* () count. */
  478. static char_u *regcode; /* Code-emit pointer, or JUST_CALC_SIZE */
  479. static long regsize; /* Code size. */
  480. static char_u **regendp; /* Pointer to endp array */
  481. static int brace_min[10]; /* Minimums for complex brace repeats */
  482. static int brace_max[10]; /* Maximums for complex brace repeats */
  483. static int brace_count[10]; /* Current counts for complex brace repeats */
  484. static int had_eol; /* TRUE when EOL found by vim_regcomp() */
  485. static int reg_magic; /* p_magic passed to vim_regexec() */
  487. /*
  488.  * META contains all characters that may be magic, except '^' and '$'.
  489.  */
  491. static char_u META[] = ".[()|=+*<>iIkKfFpPsSdDxXoOwWhHaAlLuU~123456789{";
  493. /*
  494.  * Forward declarations for vim_regcomp()'s friends.
  495.  */
  496. static void initchr __ARGS((char_u *));
  497. static int getchr __ARGS((void));
  498. static int peekchr __ARGS((void));
  499. #define PeekChr() curchr    /* shortcut only when last action was peekchr() */
  500. static int curchr;
  501. static void skipchr __ARGS((void));
  502. static void ungetchr __ARGS((void));
  503. static char_u *reg __ARGS((int, int *));
  504. static char_u *regbranch __ARGS((int *));
  505. static char_u *regpiece __ARGS((int *));
  506. static char_u *regatom __ARGS((int *));
  507. static char_u *regnode __ARGS((int));
  508. static char_u *regnext __ARGS((char_u *));
  509. static void regc __ARGS((int));
  510. static void unregc __ARGS((void));
  511. static void reginsert __ARGS((int, char_u *));
  512. static void reginsert_limits __ARGS((int, int, int, char_u *));
  513. static int read_limits __ARGS((int, int, int *, int *));
  514. static void regtail __ARGS((char_u *, char_u *));
  515. static void regoptail __ARGS((char_u *, char_u *));
  517. /*
  518.  * Skip past regular expression.
  519.  * Stop at end of 'p' of where 'dirc' is found ('/', '?', etc).
  520.  * Take care of characters with a backslash in front of it.
  521.  * Skip strings inside [ and ].
  522.  */
  523.     char_u *
  524. skip_regexp(p, dirc, magic)
  525.     char_u  *p;
  526.     int     dirc;
  527.     int     magic;
  528. {
  529.     for (; p[0] != NUL; ++p)
  530.     {
  531. if (p[0] == dirc) /* found end of regexp */
  532.     break;
  533. if ((p[0] == '[' && magic) || (p[0] == '\' && p[1] == '[' && !magic))
  534. {
  535.     p = skip_range(p + 1);
  536.     if (p[0] == NUL)
  537. break;
  538. }
  539. else if (p[0] == '\' && p[1] != NUL)
  540.     ++p;    /* skip next character */
  541.     }
  542.     return p;
  543. }
  545. /*
  546.  * vim_regcomp - compile a regular expression into internal code
  547.  *
  548.  * We can't allocate space until we know how big the compiled form will be,
  549.  * but we can't compile it (and thus know how big it is) until we've got a
  550.  * place to put the code.  So we cheat:  we compile it twice, once with code
  551.  * generation turned off and size counting turned on, and once "for real".
  552.  * This also means that we don't allocate space until we are sure that the
  553.  * thing really will compile successfully, and we never have to move the
  554.  * code and thus invalidate pointers into it.  (Note that it has to be in
  555.  * one piece because vim_free() must be able to free it all.)
  556.  *
  557.  * Does not use reg_ic, see vim_regexec() for that.
  558.  *
  559.  * Beware that the optimization-preparation code in here knows about some
  560.  * of the structure of the compiled regexp.
  561.  */
  562.     vim_regexp *
  563. vim_regcomp(exp, magic)
  564.     char_u *exp;
  565.     int magic;
  566. {
  567.     vim_regexp *r;
  568.     char_u *scan;
  569.     char_u *longest;
  570.     int len;
  571.     int flags;
  573.     if (exp == NULL)
  574. EMSG_RETURN(e_null);
  576.     reg_magic = magic;
  577.     init_class_tab();
  579.     /* First pass: determine size, legality. */
  580.     initchr((char_u *)exp);
  581.     num_complex_braces = 0;
  582.     regnpar = 1;
  583.     regsize = 0L;
  584.     regcode = JUST_CALC_SIZE;
  585.     regendp = NULL;
  586.     had_eol = FALSE;
  587.     regc(MAGIC);
  588.     if (reg(0, &flags) == NULL)
  589. return NULL;
  591.     /* Small enough for pointer-storage convention? */
  592. #ifdef SMALL_MALLOC /* 16 bit storage allocation */
  593.     if (regsize >= 65536L - 256L)
  594. EMSG_RETURN(e_toolong);
  595. #endif
  597.     /* Allocate space. */
  598.     r = (vim_regexp *)lalloc(sizeof(vim_regexp) + regsize, TRUE);
  599.     if (r == NULL)
  600. return NULL;
  602.     /* Second pass: emit code. */
  603.     initchr((char_u *)exp);
  604.     num_complex_braces = 0;
  605.     regnpar = 1;
  606.     regcode = r->program;
  607.     regendp = r->endp;
  608.     regc(MAGIC);
  609.     if (reg(0, &flags) == NULL)
  610.     {
  611. vim_free(r);
  612. return NULL;
  613.     }
  615.     /* Dig out information for optimizations. */
  616.     r->regstart = ''; /* Worst-case defaults. */
  617.     r->reganch = 0;
  618.     r->regmust = NULL;
  619.     r->regmlen = 0;
  620.     scan = r->program + 1; /* First BRANCH. */
  621.     if (OP(regnext(scan)) == END)   /* Only one top-level choice. */
  622.     {
  623. scan = OPERAND(scan);
  625. /* Starting-point info. */
  626. if (OP(scan) == BOL)
  627. {
  628.     r->reganch++;
  629.     scan = regnext(scan);
  630. }
  631. if (OP(scan) == EXACTLY)
  632.     r->regstart = *OPERAND(scan);
  633. else if ((OP(scan) == BOW || OP(scan) == EOW)
  634.  && OP(regnext(scan)) == EXACTLY)
  635.     r->regstart = *OPERAND(regnext(scan));
  637. /*
  638.  * If there's something expensive in the r.e., find the longest
  639.  * literal string that must appear and make it the regmust.  Resolve
  640.  * ties in favor of later strings, since the regstart check works
  641.  * with the beginning of the r.e. and avoiding duplication
  642.  * strengthens checking.  Not a strong reason, but sufficient in the
  643.  * absence of others.
  644.  */
  645. /*
  646.  * When the r.e. starts with BOW, it is faster to look for a regmust
  647.  * first. Used a lot for "#" and "*" commands. (Added by mool).
  648.  */
  649. if (flags & SPSTART || OP(scan) == BOW || OP(scan) == EOW)
  650. {
  651.     longest = NULL;
  652.     len = 0;
  653.     for (; scan != NULL; scan = regnext(scan))
  654. if (OP(scan) == EXACTLY && STRLEN(OPERAND(scan)) >= (size_t)len)
  655. {
  656.     longest = OPERAND(scan);
  657.     len = STRLEN(OPERAND(scan));
  658. }
  659.     r->regmust = longest;
  660.     r->regmlen = len;
  661. }
  662.     }
  663. #ifdef DEBUG
  664.     regdump(exp, r);
  665. #endif
  666.     return r;
  667. }
  669. /*
  670.  * Check if during the previous call to vim_regcomp the EOL item "$" has been
  671.  * found.  This is messy, but it works fine.
  672.  */
  673.     int
  674. vim_regcomp_had_eol()
  675. {
  676.     return had_eol;
  677. }
  679. /*
  680.  * reg - regular expression, i.e. main body or parenthesized thing
  681.  *
  682.  * Caller must absorb opening parenthesis.
  683.  *
  684.  * Combining parenthesis handling with the base level of regular expression
  685.  * is a trifle forced, but the need to tie the tails of the branches to what
  686.  * follows makes it hard to avoid.
  687.  */
  688.     static char_u *
  689. reg(paren, flagp)
  690.     int     paren; /* Parenthesized? */
  691.     int     *flagp;
  692. {
  693.     char_u *ret;
  694.     char_u *br;
  695.     char_u *ender;
  696.     int parno = 0;
  697.     int flags;
  699.     *flagp = HASWIDTH; /* Tentatively. */
  701.     /* Make an MOPEN node, if parenthesized. */
  702.     if (paren)
  703.     {
  704. if (regnpar >= NSUBEXP)
  705.     EMSG_RETURN(e_toombra);
  706. parno = regnpar;
  707. regnpar++;
  708. ret = regnode(MOPEN + parno);
  709. if (regendp)
  710.     regendp[parno] = NULL;  /* haven't seen the close paren yet */
  711.     }
  712.     else
  713. ret = NULL;
  715.     /* Pick up the branches, linking them together. */
  716.     br = regbranch(&flags);
  717.     if (br == NULL)
  718. return NULL;
  719.     if (ret != NULL)
  720. regtail(ret, br); /* MOPEN -> first. */
  721.     else
  722. ret = br;
  723.     if (!(flags & HASWIDTH))
  724. *flagp &= ~HASWIDTH;
  725.     *flagp |= flags & SPSTART;
  726.     while (peekchr() == Magic('|'))
  727.     {
  728. skipchr();
  729. br = regbranch(&flags);
  730. if (br == NULL)
  731.     return NULL;
  732. regtail(ret, br); /* BRANCH -> BRANCH. */
  733. if (!(flags & HASWIDTH))
  734.     *flagp &= ~HASWIDTH;
  735. *flagp |= flags & SPSTART;
  736.     }
  738.     /* Make a closing node, and hook it on the end. */
  739.     ender = regnode((paren) ? MCLOSE + parno : END);
  740.     regtail(ret, ender);
  742.     /* Hook the tails of the branches to the closing node. */
  743.     for (br = ret; br != NULL; br = regnext(br))
  744. regoptail(br, ender);
  746.     /* Check for proper termination. */
  747.     if (paren && getchr() != Magic(')'))
  748. EMSG_RETURN(e_toombra)
  749.     else if (!paren && peekchr() != '')
  750.     {
  751. if (PeekChr() == Magic(')'))
  752.     EMSG_RETURN(e_toomket)
  753. else
  754.     EMSG_RETURN(e_trailing) /* "Can't happen". */
  755. /* NOTREACHED */
  756.     }
  757.     /*
  758.      * Here we set the flag allowing back references to this set of
  759.      * parentheses.
  760.      */
  761.     if (paren && regendp)
  762. regendp[parno] = ender; /* have seen the close paren */
  763.     return ret;
  764. }
  766. /*
  767.  * regbranch - one alternative of an | operator
  768.  *
  769.  * Implements the concatenation operator.
  770.  */
  771.     static char_u    *
  772. regbranch(flagp)
  773.     int     *flagp;
  774. {
  775.     char_u     *ret;
  776.     char_u     *chain;
  777.     char_u     *latest;
  778.     int     flags;
  780.     *flagp = WORST; /* Tentatively. */
  782.     ret = regnode(BRANCH);
  783.     chain = NULL;
  784.     while (peekchr() != '' && PeekChr() != Magic('|') &&
  785.       PeekChr() != Magic(')'))
  786.     {
  787. latest = regpiece(&flags);
  788. if (latest == NULL)
  789.     return NULL;
  790. *flagp |= flags & HASWIDTH;
  791. if (chain == NULL) /* First piece. */
  792.     *flagp |= flags & SPSTART;
  793. else
  794.     regtail(chain, latest);
  795. chain = latest;
  796.     }
  797.     if (chain == NULL) /* Loop ran zero times. */
  798. (void) regnode(NOTHING);
  800.     return ret;
  801. }
  803. /*
  804.  * regpiece - something followed by possible [*+=]
  805.  *
  806.  * Note that the branching code sequences used for = and the general cases
  807.  * of * and + are somewhat optimized:  they use the same NOTHING node as
  808.  * both the endmarker for their branch list and the body of the last branch.
  809.  * It might seem that this node could be dispensed with entirely, but the
  810.  * endmarker role is not redundant.
  811.  */
  812.     static char_u *
  813. regpiece(flagp)
  814.     int     *flagp;
  815. {
  816.     char_u     *ret;
  817.     int     op;
  818.     char_u     *next;
  819.     int     flags;
  820.     int     minval;
  821.     int     maxval;
  823.     ret = regatom(&flags);
  824.     if (ret == NULL)
  825. return NULL;
  827.     op = peekchr();
  828.     if (!re_ismult(op))
  829.     {
  830. *flagp = flags;
  831. return ret;
  832.     }
  833.     if (!(flags & HASWIDTH) && op != Magic('='))
  834. EMSG_RETURN((char_u *)"*, \+, or \{ operand could be empty");
  835.     *flagp = (WORST | SPSTART);     /* default flags */
  837.     skipchr();
  838.     if (op == Magic('*') && (flags & SIMPLE))
  839. reginsert(STAR, ret);
  840.     else if (op == Magic('*'))
  841.     {
  842. /* Emit x* as (x&|), where & means "self". */
  843. reginsert(BRANCH, ret); /* Either x */
  844. regoptail(ret, regnode(BACK)); /* and loop */
  845. regoptail(ret, ret); /* back */
  846. regtail(ret, regnode(BRANCH)); /* or */
  847. regtail(ret, regnode(NOTHING)); /* null. */
  848.     }
  849.     else if (op == Magic('+') && (flags & SIMPLE))
  850.     {
  851. reginsert(PLUS, ret);
  852. *flagp = (WORST | HASWIDTH);
  853.     }
  854.     else if (op == Magic('+'))
  855.     {
  856. /* Emit x+ as x(&|), where & means "self". */
  857. next = regnode(BRANCH); /* Either */
  858. regtail(ret, next);
  859. regtail(regnode(BACK), ret); /* loop back */
  860. regtail(next, regnode(BRANCH)); /* or */
  861. regtail(ret, regnode(NOTHING)); /* null. */
  862. *flagp = (WORST | HASWIDTH);
  863.     }
  864.     else if (op == Magic('='))
  865.     {
  866. /* Emit x= as (x|) */
  867. reginsert(BRANCH, ret); /* Either x */
  868. regtail(ret, regnode(BRANCH)); /* or */
  869. next = regnode(NOTHING);/* null. */
  870. regtail(ret, next);
  871. regoptail(ret, next);
  872.     }
  873.     else if (op == Magic('{') && (flags & SIMPLE))
  874.     {
  875. if (!read_limits('{', '}', &minval, &maxval))
  876.     return NULL;
  877. reginsert(BRACE_SIMPLE, ret);
  878. reginsert_limits(BRACE_LIMITS, minval, maxval, ret);
  879. if (minval > 0)
  880.     *flagp = (WORST | HASWIDTH);
  881.     }
  882.     else if (op == Magic('{'))
  883.     {
  884. if (!read_limits('{', '}', &minval, &maxval))
  885.     return NULL;
  886. if (num_complex_braces >= 10)
  887.     EMSG_RETURN((char_u *)"Too many complex \{...}s");
  888. reginsert(BRACE_COMPLEX + num_complex_braces, ret);
  889. regoptail(ret, regnode(BACK));
  890. regoptail(ret, ret);
  891. reginsert_limits(BRACE_LIMITS, minval, maxval, ret);
  892. if (minval > 0)
  893.     *flagp = (WORST | HASWIDTH);
  894. ++num_complex_braces;
  895.     }
  896.     if (re_ismult(peekchr()))
  897. EMSG_RETURN((char_u *)"Nested *, \=, \+, or \{");
  899.     return ret;
  900. }
  902. /*
  903.  * regatom - the lowest level
  904.  *
  905.  * Optimization:  gobbles an entire sequence of ordinary characters so that
  906.  * it can turn them into a single node, which is smaller to store and
  907.  * faster to run.
  908.  */
  909.     static char_u *
  910. regatom(flagp)
  911.     int    *flagp;
  912. {
  913.     char_u     *ret;
  914.     int     flags;
  915.     int     cpo_lit;     /* 'cpoptions' contains 'l' flag */
  917.     *flagp = WORST; /* Tentatively. */
  918.     cpo_lit = (!reg_syn && vim_strchr(p_cpo, CPO_LITERAL) != NULL);
  920.     switch (getchr())
  921.     {
  922.       case Magic('^'):
  923. ret = regnode(BOL);
  924. break;
  925.       case Magic('$'):
  926. ret = regnode(EOL);
  927. had_eol = TRUE;
  928. break;
  929.       case Magic('<'):
  930. ret = regnode(BOW);
  931. break;
  932.       case Magic('>'):
  933. ret = regnode(EOW);
  934. break;
  935.       case Magic('.'):
  936. ret = regnode(ANY);
  937. *flagp |= HASWIDTH | SIMPLE;
  938. break;
  939.       case Magic('i'):
  940. ret = regnode(IDENT);
  941. *flagp |= HASWIDTH | SIMPLE;
  942. break;
  943.       case Magic('k'):
  944. ret = regnode(KWORD);
  945. *flagp |= HASWIDTH | SIMPLE;
  946. break;
  947.       case Magic('I'):
  948. ret = regnode(SIDENT);
  949. *flagp |= HASWIDTH | SIMPLE;
  950. break;
  951.       case Magic('K'):
  952. ret = regnode(SWORD);
  953. *flagp |= HASWIDTH | SIMPLE;
  954. break;
  955.       case Magic('f'):
  956. ret = regnode(FNAME);
  957. *flagp |= HASWIDTH | SIMPLE;
  958. break;
  959.       case Magic('F'):
  960. ret = regnode(SFNAME);
  961. *flagp |= HASWIDTH | SIMPLE;
  962. break;
  963.       case Magic('p'):
  964. ret = regnode(PRINT);
  965. *flagp |= HASWIDTH | SIMPLE;
  966. break;
  967.       case Magic('P'):
  968. ret = regnode(SPRINT);
  969. *flagp |= HASWIDTH | SIMPLE;
  970. break;
  971.       case Magic('s'):
  972. ret = regnode(WHITE);
  973. *flagp |= HASWIDTH | SIMPLE;
  974. break;
  975.       case Magic('S'):
  976. ret = regnode(NWHITE);
  977. *flagp |= HASWIDTH | SIMPLE;
  978. break;
  979.       case Magic('d'):
  980. ret = regnode(DIGIT);
  981. *flagp |= HASWIDTH | SIMPLE;
  982. break;
  983.       case Magic('D'):
  984. ret = regnode(NDIGIT);
  985. *flagp |= HASWIDTH | SIMPLE;
  986. break;
  987.       case Magic('x'):
  988. ret = regnode(HEX);
  989. *flagp |= HASWIDTH | SIMPLE;
  990. break;
  991.       case Magic('X'):
  992. ret = regnode(NHEX);
  993. *flagp |= HASWIDTH | SIMPLE;
  994. break;
  995.       case Magic('o'):
  996. ret = regnode(OCTAL);
  997. *flagp |= HASWIDTH | SIMPLE;
  998. break;
  999.       case Magic('O'):
  1000. ret = regnode(NOCTAL);
  1001. *flagp |= HASWIDTH | SIMPLE;
  1002. break;
  1003.       case Magic('w'):
  1004. ret = regnode(WORD);
  1005. *flagp |= HASWIDTH | SIMPLE;
  1006. break;
  1007.       case Magic('W'):
  1008. ret = regnode(NWORD);
  1009. *flagp |= HASWIDTH | SIMPLE;
  1010. break;
  1011.       case Magic('h'):
  1012. ret = regnode(HEAD);
  1013. *flagp |= HASWIDTH | SIMPLE;
  1014. break;
  1015.       case Magic('H'):
  1016. ret = regnode(NHEAD);
  1017. *flagp |= HASWIDTH | SIMPLE;
  1018. break;
  1019.       case Magic('a'):
  1020. ret = regnode(ALPHA);
  1021. *flagp |= HASWIDTH | SIMPLE;
  1022. break;
  1023.       case Magic('A'):
  1024. ret = regnode(NALPHA);
  1025. *flagp |= HASWIDTH | SIMPLE;
  1026. break;
  1027.       case Magic('l'):
  1028. ret = regnode(LOWER);
  1029. *flagp |= HASWIDTH | SIMPLE;
  1030. break;
  1031.       case Magic('L'):
  1032. ret = regnode(NLOWER);
  1033. *flagp |= HASWIDTH | SIMPLE;
  1034. break;
  1035.       case Magic('u'):
  1036. ret = regnode(UPPER);
  1037. *flagp |= HASWIDTH | SIMPLE;
  1038. break;
  1039.       case Magic('U'):
  1040. ret = regnode(NUPPER);
  1041. *flagp |= HASWIDTH | SIMPLE;
  1042. break;
  1043.       case Magic('('):
  1044. ret = reg(1, &flags);
  1045. if (ret == NULL)
  1046.     return NULL;
  1047. *flagp |= flags & (HASWIDTH | SPSTART);
  1048. break;
  1049.       case '':
  1050.       case Magic('|'):
  1051.       case Magic(')'):
  1052. EMSG_RETURN(e_internal)     /* Supposed to be caught earlier. */
  1053. /* NOTREACHED */
  1054.       case Magic('='):
  1055. EMSG_RETURN((char_u *)"\= follows nothing")
  1056. /* NOTREACHED */
  1057.       case Magic('+'):
  1058. EMSG_RETURN((char_u *)"\+ follows nothing")
  1059. /* NOTREACHED */
  1060.       case Magic('{'):
  1061. EMSG_RETURN((char_u *)"\{ follows nothing")
  1062. /* NOTREACHED */
  1063.       case Magic('*'):
  1064. if (reg_magic)
  1065.     EMSG_RETURN((char_u *)"* follows nothing")
  1066. else
  1067.     EMSG_RETURN((char_u *)"\* follows nothing")
  1068. /* break; Not Reached */
  1069.       case Magic('~'): /* previous substitute pattern */
  1070.     if (reg_prev_sub)
  1071.     {
  1072. char_u     *p;
  1074. ret = regnode(EXACTLY);
  1075. p = reg_prev_sub;
  1076. while (*p)
  1077. {
  1078.     regc(*p++);
  1079. }
  1080. regc('');
  1081. if (p - reg_prev_sub)
  1082. {
  1083.     *flagp |= HASWIDTH;
  1084.     if ((p - reg_prev_sub) == 1)
  1085. *flagp |= SIMPLE;
  1086. }
  1087.     }
  1088.     else
  1089. EMSG_RETURN(e_nopresub);
  1090.     break;
  1091.       case Magic('1'):
  1092.       case Magic('2'):
  1093.       case Magic('3'):
  1094.       case Magic('4'):
  1095.       case Magic('5'):
  1096.       case Magic('6'):
  1097.       case Magic('7'):
  1098.       case Magic('8'):
  1099.       case Magic('9'):
  1100.     {
  1101.     int     refnum;
  1103.     ungetchr();
  1104.     refnum = getchr() - Magic('0');
  1105.     /*
  1106.      * Check if the back reference is legal. We use the parentheses
  1107.      * pointers to mark encountered close parentheses, but this
  1108.      * is only available in the second pass. Checking opens is
  1109.      * always possible.
  1110.      * Should also check that we don't refer to something that
  1111.      * is repeated (+*=): what instance of the repetition should
  1112.      * we match? TODO.
  1113.      */
  1114.     if (refnum < regnpar &&
  1115. (regendp == NULL || regendp[refnum] != NULL))
  1116. ret = regnode(BACKREF + refnum);
  1117.     else
  1118. EMSG_RETURN((char_u *)"Illegal back reference");
  1119. }
  1120. break;
  1121.       case Magic('['):
  1122. {
  1123.     char_u *p;
  1125.     /*
  1126.      * If there is no matching ']', we assume the '[' is a normal
  1127.      * character. This makes ":help [" work.
  1128.      */
  1129.     p = skip_range(regparse);
  1130.     if (*p == ']') /* there is a matching ']' */
  1131.     {
  1132. /*
  1133.  * In a character class, different parsing rules apply.
  1134.  * Not even  is special anymore, nothing is.
  1135.  */
  1136. if (*regparse == '^') {     /* Complement of range. */
  1137.     ret = regnode(ANYBUT);
  1138.     regparse++;
  1139. }
  1140. else
  1141.     ret = regnode(ANYOF);
  1142. if (*regparse == ']' || *regparse == '-')
  1143.     regc(*regparse++);
  1144. while (*regparse != '' && *regparse != ']')
  1145. {
  1146.     if (*regparse == '-')
  1147.     {
  1148. regparse++;
  1149. if (*regparse == ']' || *regparse == '')
  1150.     regc('-');
  1151. else
  1152. {
  1153.     int cclass;
  1154.     int cclassend;
  1156.     cclass = UCHARAT(regparse - 2) + 1;
  1157.     cclassend = UCHARAT(regparse);
  1158.     if (cclass > cclassend + 1)
  1159. EMSG_RETURN(e_invrange);
  1160.     for (; cclass <= cclassend; cclass++)
  1161. regc(cclass);
  1162.     regparse++;
  1163. }
  1164.     }
  1165.     /*
  1166.      * Only "]", "^", "]" and "\" are special in Vi.  Vim
  1167.      * accepts "t", "e", etc., but only when the 'l' flag in
  1168.      * 'cpoptions' is not included.
  1169.      */
  1170.     else if (*regparse == '\' &&
  1171.     (vim_strchr(REGEXP_INRANGE, regparse[1]) != NULL ||
  1172.      (!cpo_lit &&
  1173.        vim_strchr(REGEXP_ABBR, regparse[1]) != NULL)))
  1174.     {
  1175. regparse++;
  1176. regc(backslash_trans(*regparse++));
  1177.     }
  1178.     else if (*regparse == '[')
  1179.     {
  1180. int (*func)__ARGS((int));
  1181. int cu;
  1183. if ((func = skip_class_name(&regparse)) == NULL)
  1184.     regc(*regparse++);
  1185. else
  1186.     /* Characters assumed to be 8 bits */
  1187.     for (cu = 0; cu <= 255; cu++)
  1188. if ((*func)(cu))
  1189.     regc(cu);
  1190.     }
  1191.     else
  1192. regc(*regparse++);
  1193. }
  1194. regc('');
  1195. if (*regparse != ']')
  1196.     EMSG_RETURN(e_toomsbra);
  1197. skipchr();     /* let's be friends with the lexer again */
  1198. *flagp |= HASWIDTH | SIMPLE;
  1199. break;
  1200.     }
  1201. }
  1202. /* FALLTHROUGH */
  1204.       default:
  1205. {
  1206.     int     len;
  1207.     int     chr;
  1209.     ungetchr();
  1210.     len = 0;
  1211.     ret = regnode(EXACTLY);
  1212.     /*
  1213.      * Always take at least one character, for '[' without matching
  1214.      * ']'.
  1215.      */
  1216.     while ((chr = peekchr()) != '' && (chr < Magic(0) || len == 0))
  1217.     {
  1218. regc(chr);
  1219. skipchr();
  1220. len++;
  1221.     }
  1222. #ifdef DEBUG
  1223.     if (len == 0)
  1224.  EMSG_RETURN((char_u *)"Unexpected magic character; check META.");
  1225. #endif
  1226.     /*
  1227.      * If there is a following *, + or = we need the character
  1228.      * in front of it as a single character operand
  1229.      */
  1230.     if (len > 1 && re_ismult(chr))
  1231.     {
  1232. unregc();     /* Back off of *+= operand */
  1233. ungetchr();     /* and put it back for next time */
  1234. --len;
  1235.     }
  1236.     regc('');
  1237.     *flagp |= HASWIDTH;
  1238.     if (len == 1)
  1239. *flagp |= SIMPLE;
  1240. }
  1241. break;
  1242.     }
  1244.     return ret;
  1245. }
  1247. /*
  1248.  * regnode - emit a node
  1249.  */
  1250.     static char_u * /* Location. */
  1251. regnode(op)
  1252.     int op;
  1253. {
  1254.     char_u  *ret;
  1255.     char_u  *ptr;
  1257.     ret = regcode;
  1258.     if (ret == JUST_CALC_SIZE)
  1259.     {
  1260. regsize += 3;
  1261. return ret;
  1262.     }
  1263.     ptr = ret;
  1264.     *ptr++ = op;
  1265.     *ptr++ = ''; /* Null "next" pointer. */
  1266.     *ptr++ = '';
  1267.     regcode = ptr;
  1269.     return ret;
  1270. }
  1272. /*
  1273.  * regc - emit (if appropriate) a byte of code
  1274.  */
  1275.     static void
  1276. regc(b)
  1277.     int b;
  1278. {
  1279.     if (regcode != JUST_CALC_SIZE)
  1280. *regcode++ = b;
  1281.     else
  1282. regsize++;
  1283. }
  1285. /*
  1286.  * unregc - take back (if appropriate) a byte of code
  1287.  */
  1288.     static void
  1289. unregc()
  1290. {
  1291.     if (regcode != JUST_CALC_SIZE)
  1292. regcode--;
  1293.     else
  1294. regsize--;
  1295. }
  1297. /*
  1298.  * reginsert - insert an operator in front of already-emitted operand
  1299.  *
  1300.  * Means relocating the operand.
  1301.  */
  1302.     static void
  1303. reginsert(op, opnd)
  1304.     int op;
  1305.     char_u     *opnd;
  1306. {
  1307.     char_u  *src;
  1308.     char_u  *dst;
  1309.     char_u  *place;
  1311.     if (regcode == JUST_CALC_SIZE)
  1312.     {
  1313. regsize += 3;
  1314. return;
  1315.     }
  1316.     src = regcode;
  1317.     regcode += 3;
  1318.     dst = regcode;
  1319.     while (src > opnd)
  1320. *--dst = *--src;
  1322.     place = opnd; /* Op node, where operand used to be. */
  1323.     *place++ = op;
  1324.     *place++ = '';
  1325.     *place = '';
  1326. }
  1328. /*
  1329.  * reginsert_limits - insert an operator in front of already-emitted operand.
  1330.  * The operator has the given limit values as operands.  Also set next pointer.
  1331.  *
  1332.  * Means relocating the operand.
  1333.  */
  1334.     static void
  1335. reginsert_limits(op, minval, maxval, opnd)
  1336.     int op;
  1337.     int minval;
  1338.     int maxval;
  1339.     char_u     *opnd;
  1340. {
  1341.     char_u  *src;
  1342.     char_u  *dst;
  1343.     char_u  *place;
  1345.     if (regcode == JUST_CALC_SIZE)
  1346.     {
  1347. regsize += 7;
  1348. return;
  1349.     }
  1350.     src = regcode;
  1351.     regcode += 7;
  1352.     dst = regcode;
  1353.     while (src > opnd)
  1354. *--dst = *--src;
  1356.     place = opnd; /* Op node, where operand used to be. */
  1357.     *place++ = op;
  1358.     *place++ = '';
  1359.     *place++ = '';
  1360.     *place++ = (char_u) (((unsigned)minval >> 8) & 0377);
  1361.     *place++ = (char_u) (minval & 0377);
  1362.     *place++ = (char_u) (((unsigned)maxval >> 8) & 0377);
  1363.     *place++ = (char_u) (maxval & 0377);
  1364.     regtail(opnd, place);
  1365. }
  1367. /*
  1368.  * regtail - set the next-pointer at the end of a node chain
  1369.  */
  1370.     static void
  1371. regtail(p, val)
  1372.     char_u    *p;
  1373.     char_u    *val;
  1374. {
  1375.     char_u  *scan;
  1376.     char_u  *temp;
  1377.     int     offset;
  1379.     if (p == JUST_CALC_SIZE)
  1380. return;
  1382.     /* Find last node. */
  1383.     scan = p;
  1384.     for (;;)
  1385.     {
  1386. temp = regnext(scan);
  1387. if (temp == NULL)
  1388.     break;
  1389. scan = temp;
  1390.     }
  1392.     if (OP(scan) == BACK)
  1393. offset = (int)(scan - val);
  1394.     else
  1395. offset = (int)(val - scan);
  1396.     *(scan + 1) = (char_u) (((unsigned)offset >> 8) & 0377);
  1397.     *(scan + 2) = (char_u) (offset & 0377);
  1398. }
  1400. /*
  1401.  * regoptail - regtail on operand of first argument; nop if operandless
  1402.  */
  1403.     static void
  1404. regoptail(p, val)
  1405.     char_u    *p;
  1406.     char_u    *val;
  1407. {
  1408.     /* When op is neither BRANCH nor BRACE_COMPLEX0-9, it is "operandless" */
  1409.     if (p == NULL || p == JUST_CALC_SIZE ||
  1410.     (OP(p) != BRANCH &&
  1411.      (OP(p) < BRACE_COMPLEX || OP(p) > BRACE_COMPLEX + 9)))
  1412. return;
  1413.     regtail(OPERAND(p), val);
  1414. }
  1416. /*
  1417.  * getchr() - get the next character from the pattern. We know about
  1418.  * magic and such, so therefore we need a lexical analyzer.
  1419.  */
  1421. /* static int     curchr; */
  1422. static int prevchr;
  1423. static int nextchr;    /* used for ungetchr() */
  1424. /*
  1425.  * Note: prevchr is sometimes -1 when we are not at the start,
  1426.  * eg in /[ ^I]^ the pattern was never found even if it existed, because ^ was
  1427.  * taken to be magic -- webb
  1428.  */
  1429. static int at_start; /* True when on the first character */
  1430. static int prev_at_start;  /* True when on the second character */
  1432.     static void
  1433. initchr(str)
  1434.     char_u *str;
  1435. {
  1436.     regparse = str;
  1437.     curchr = prevchr = nextchr = -1;
  1438.     at_start = TRUE;
  1439.     prev_at_start = FALSE;
  1440. }
  1442.     static int
  1443. peekchr()
  1444. {
  1445.     if (curchr < 0)
  1446.     {
  1447. switch (curchr = regparse[0])
  1448. {
  1449. case '.':
  1450.     /* case '+':*/
  1451.     /* case '=':*/
  1452. case '[':
  1453. case '~':
  1454.     if (reg_magic)
  1455. curchr = Magic(curchr);
  1456.     break;
  1457. case '*':
  1458.     /* * is not magic as the very first character, eg "?*ptr" and when
  1459.      * after '^', eg "/^*ptr" */
  1460.     if (reg_magic && !at_start
  1461.  && !(prev_at_start && prevchr == Magic('^')))
  1462. curchr = Magic('*');
  1463.     break;
  1464. case '^':
  1465.     /* ^ is only magic as the very first character */
  1466.     if (at_start)
  1467. curchr = Magic('^');
  1468.     break;
  1469. case '$':
  1470.     /* $ is only magic as the very last char and in front of '|' */
  1471.     if (regparse[1] == NUL
  1472.        || (regparse[1] == '\' && regparse[2] == '|'))
  1473. curchr = Magic('$');
  1474.     break;
  1475. case '\':
  1476.     regparse++;
  1477.     if (regparse[0] == NUL)
  1478.     {
  1479. curchr = '\'; /* trailing '' */
  1480. --regparse; /* there is no extra character to skip */
  1481.     }
  1482.     else if (vim_strchr(META, regparse[0]))
  1483.     {
  1484. /*
  1485.  * META contains everything that may be magic sometimes, except
  1486.  * ^ and $ ("^" and "$" are never magic).
  1487.  * We now fetch the next character and toggle its magicness.
  1488.  * Therefore,  is so meta-magic that it is not in META.
  1489.  */
  1490. curchr = -1;
  1491. prev_at_start = at_start;
  1492. at_start = FALSE; /* be able to say "/*ptr" */
  1493. peekchr();
  1494. curchr ^= Magic(0);
  1495.     }
  1496.     else if (vim_strchr(REGEXP_ABBR, regparse[0]))
  1497.     {
  1498. /*
  1499.  * Handle abbreviations, like "t" for TAB -- webb
  1500.  */
  1501. curchr = backslash_trans(regparse[0]);
  1502.     }
  1503.     else
  1504.     {
  1505. /*
  1506.  * Next character can never be (made) magic?
  1507.  * Then backslashing it won't do anything.
  1508.  */
  1509. curchr = regparse[0];
  1510.     }
  1511.     break;
  1512. }
  1513.     }
  1515.     return curchr;
  1516. }
  1518.     static void
  1519. skipchr()
  1520. {
  1521.     regparse++;
  1522.     prev_at_start = at_start;
  1523.     at_start = FALSE;
  1524.     prevchr = curchr;
  1525.     curchr = nextchr;     /* use previously unget char, or -1 */
  1526.     nextchr = -1;
  1527. }
  1529.     static int
  1530. getchr()
  1531. {
  1532.     int chr;
  1534.     chr = peekchr();
  1535.     skipchr();
  1537.     return chr;
  1538. }
  1540. /*
  1541.  * put character back. Works only once!
  1542.  */
  1543.     static void
  1544. ungetchr()
  1545. {
  1546.     nextchr = curchr;
  1547.     curchr = prevchr;
  1548.     at_start = prev_at_start;
  1549.     prev_at_start = FALSE;
  1550.     /*
  1551.      * Backup regparse as well; not because we will use what it points at,
  1552.      * but because skipchr() will bump it again.
  1553.      */
  1554.     regparse--;
  1555. }
  1557. /*
  1558.  * read_limits - Read two integers to be taken as a minimum and maximum.
  1559.  * If the first character is '-', then the range is reversed.
  1560.  * Should end with 'end'.  If minval is missing, zero is default, if maxval is
  1561.  * missing, a very big number is the default.
  1562.  */
  1563.     static int
  1564. read_limits(start, end, minval, maxval)
  1565.     int     start;
  1566.     int     end;
  1567.     int     *minval;
  1568.     int     *maxval;
  1569. {
  1570.     int     reverse = FALSE;
  1571.     char_u  *first_char;
  1573.     if (*regparse == '-')
  1574.     {
  1575. /* Starts with '-', so reverse the range later */
  1576. regparse++;
  1577. reverse = TRUE;
  1578.     }
  1579.     first_char = regparse;
  1580.     *minval = getdigits(&regparse);
  1581.     if (*regparse == ',')     /* There is a comma */
  1582.     {
  1583. if (isdigit(*++regparse))
  1584.     *maxval = getdigits(&regparse);
  1585. else
  1586.     *maxval = MAX_LIMIT;
  1587.     }
  1588.     else if (isdigit(*first_char))
  1589. *maxval = *minval;     /* It was {n} or {-n} */
  1590.     else
  1591. *maxval = MAX_LIMIT;     /* It was {} or {-} */
  1592.     if (*regparse == '\')
  1593. regparse++; /* Allow either {...} or {...} */
  1594.     if (       (*regparse != end && *regparse != NUL)
  1595.     || (*maxval == 0 && *minval == 0))
  1596.     {
  1597. sprintf((char *)IObuff, "Syntax error in \%c...%c", start, end);
  1598. emsg(IObuff);
  1599. rc_did_emsg = TRUE;
  1600. return FAIL;
  1601.     }
  1603.     /*
  1604.      * Reverse the range if there was a '-', or make sure it is in the right
  1605.      * order otherwise.
  1606.      */
  1607.     if ((!reverse && *minval > *maxval) || (reverse && *minval < *maxval))
  1608.     {
  1609. int tmp;
  1611. tmp = *minval;
  1612. *minval = *maxval;
  1613. *maxval = tmp;
  1614.     }
  1615.     skipchr(); /* let's be friends with the lexer again */
  1616.     return OK;
  1617. }
  1619. /*
  1620.  * vim_regexec and friends
  1621.  */
  1623. /*
  1624.  * Global work variables for vim_regexec().
  1625.  */
  1626. static char_u  *reginput; /* String-input pointer. */
  1627. static char_u  *regbol; /* Beginning of input, for ^ check. */
  1628. static char_u **regstartp; /* Pointer to startp array. */
  1629. static int   need_clear_subexpr; /* *regstartp end *regendp still need
  1630.    to be cleared */
  1632. static int regtry __ARGS((vim_regexp *, char_u *));
  1633. static void clear_subexpr __ARGS((void));
  1634. static int regmatch __ARGS((char_u *));
  1635. static int regrepeat __ARGS((char_u *));
  1637. #ifdef DEBUG
  1638. int regnarrate = 0;
  1639. #endif
  1641. /*
  1642.  * vim_regexec - match a regexp against a string
  1643.  * Uses current value of reg_ic.
  1644.  * Return non-zero if there is a match.
  1645.  */
  1646.     int
  1647. vim_regexec(prog, string, at_bol)
  1648.     vim_regexp *prog;
  1649.     char_u *string;
  1650.     int at_bol;
  1651. {
  1652.     char_u *s;
  1654.     /* Be paranoid... */
  1655.     if (prog == NULL || string == NULL)
  1656.     {
  1657. emsg(e_null);
  1658. rc_did_emsg = TRUE;
  1659. return 0;
  1660.     }
  1661.     /* Check validity of program. */
  1662.     if (UCHARAT(prog->program) != MAGIC)
  1663.     {
  1664. emsg(e_re_corr);
  1665. rc_did_emsg = TRUE;
  1666. return 0;
  1667.     }
  1668.     /* If there is a "must appear" string, look for it. */
  1669.     if (prog->regmust != NULL)
  1670.     {
  1671. s = string;
  1672. while ((s = cstrchr(s, prog->regmust[0])) != NULL)
  1673. {
  1674.     if (cstrncmp(s, prog->regmust, prog->regmlen) == 0)
  1675. break; /* Found it. */
  1676.     s++;
  1677. }
  1678. if (s == NULL) /* Not present. */
  1679.     return 0;
  1680.     }
  1681.     /* Mark beginning of line for ^ . */
  1682.     if (at_bol)
  1683. regbol = string; /* is possible to match bol */
  1684.     else
  1685. regbol = NULL; /* we aren't there, so don't match it */
  1687.     /* Simplest case:  anchored match need be tried only once. */
  1688.     if (prog->reganch)
  1689.     {
  1690. if (prog->regstart != '' && prog->regstart != string[0] &&
  1691.     (!reg_ic || TO_LOWER(prog->regstart) != TO_LOWER(string[0])))
  1692.     return 0;
  1693. return regtry(prog, string);
  1694.     }
  1696.     /* Messy cases:  unanchored match. */
  1697.     s = string;
  1698.     if (prog->regstart != '')
  1699. /* We know what char it must start with. */
  1700. while ((s = cstrchr(s, prog->regstart)) != NULL)
  1701. {
  1702.     if (regtry(prog, s))
  1703. return 1;
  1704.     s++;
  1705. }
  1706.     else
  1707. /* We don't -- general case. */
  1708. do
  1709. {
  1710.     if (regtry(prog, s))
  1711. return 1;
  1712. } while (*s++ != '');
  1714.     /* Failure. */
  1715.     return 0;
  1716. }
  1718. /*
  1719.  * regtry - try match at specific point
  1720.  */
  1721.     static int /* 0 failure, 1 success */
  1722. regtry(prog, string)
  1723.     vim_regexp    *prog;
  1724.     char_u    *string;
  1725. {
  1726.     reginput = string;
  1727.     regstartp = prog->startp;
  1728.     regendp = prog->endp;
  1729.     need_clear_subexpr = TRUE;
  1731.     if (regmatch(prog->program + 1))
  1732.     {
  1733. clear_subexpr();
  1734. prog->startp[0] = string;
  1735. prog->endp[0] = reginput;
  1736. return 1;
  1737.     }
  1738.     else
  1739. return 0;
  1740. }
  1742. /*
  1743.  * Clear the subexpressions, if this wasn't done yet.
  1744.  * This construction is used to clear the subexpressions only when they are
  1745.  * used (to increase speed).
  1746.  */
  1747.     static void
  1748. clear_subexpr()
  1749. {
  1750.     if (need_clear_subexpr)
  1751.     {
  1752. vim_memset(regstartp, 0, sizeof(char_u *) * NSUBEXP);
  1753. vim_memset(regendp, 0, sizeof(char_u *) * NSUBEXP);
  1754. need_clear_subexpr = FALSE;
  1755.     }
  1756. }
  1758. /*
  1759.  * regmatch - main matching routine
  1760.  *
  1761.  * Conceptually the strategy is simple: Check to see whether the current
  1762.  * node matches, call self recursively to see whether the rest matches,
  1763.  * and then act accordingly.  In practice we make some effort to avoid
  1764.  * recursion, in particular by going through "ordinary" nodes (that don't
  1765.  * need to know whether the rest of the match failed) by a loop instead of
  1766.  * by recursion.
  1767.  */
  1768.     static int /* 0 failure, 1 success */
  1769. regmatch(prog)
  1770.     char_u    *prog;
  1771. {
  1772.     char_u     *scan; /* Current node. */
  1773.     char_u     *next; /* Next node. */
  1774.     int     minval = -1;
  1775.     int     maxval = -1;
  1777.     scan = prog;
  1778. #ifdef DEBUG
  1779.     if (scan != NULL && regnarrate)
  1780.     {
  1781. mch_errmsg(regprop(scan));
  1782. mch_errmsg("(n");
  1783.     }
  1784. #endif
  1785.     while (scan != NULL)
  1786.     {
  1787. #ifdef DEBUG
  1788. if (regnarrate)
  1789. {
  1790.     mch_errmsg(regprop(scan));
  1791.     mch_errmsg("...n");
  1792. }
  1793. #endif
  1794. next = regnext(scan);
  1795. switch (OP(scan))
  1796. {
  1797.   case BOL:
  1798.     if (reginput != regbol)
  1799. return 0;
  1800.     break;
  1801.   case EOL:
  1802.     if (*reginput != '')
  1803. return 0;
  1804.     break;
  1805.   case BOW: /* <word; reginput points to w */
  1806.     if (reginput != regbol && vim_iswordc(reginput[-1]))
  1807. return 0;
  1808.     if (!reginput[0] || !vim_iswordc(reginput[0]))
  1809. return 0;
  1810.     break;
  1811.   case EOW: /* word>; reginput points after d */
  1812.     if (reginput == regbol || !vim_iswordc(reginput[-1]))
  1813. return 0;
  1814.     if (reginput[0] && vim_iswordc(reginput[0]))
  1815. return 0;
  1816.     break;
  1817.   case ANY:
  1818.     if (*reginput == '')
  1819. return 0;
  1820.     reginput++;
  1821.     break;
  1822.   case IDENT:
  1823.     if (!vim_isIDc(*reginput))
  1824. return 0;
  1825.     reginput++;
  1826.     break;
  1827.   case KWORD:
  1828.     if (!vim_iswordc(*reginput))
  1829. return 0;
  1830.     reginput++;
  1831.     break;
  1832.   case FNAME:
  1833.     if (!vim_isfilec(*reginput))
  1834. return 0;
  1835.     reginput++;
  1836.     break;
  1837.   case PRINT:
  1838.     if (charsize(*reginput) != 1)
  1839. return 0;
  1840.     reginput++;
  1841.     break;
  1842.   case SIDENT:
  1843.     if (isdigit(*reginput) || !vim_isIDc(*reginput))
  1844. return 0;
  1845.     reginput++;
  1846.     break;
  1847.   case SWORD:
  1848.     if (isdigit(*reginput) || !vim_iswordc(*reginput))
  1849. return 0;
  1850.     reginput++;
  1851.     break;
  1852.   case SFNAME:
  1853.     if (isdigit(*reginput) || !vim_isfilec(*reginput))
  1854. return 0;
  1855.     reginput++;
  1856.     break;
  1857.   case SPRINT:
  1858.     if (isdigit(*reginput) || charsize(*reginput) != 1)
  1859. return 0;
  1860.     reginput++;
  1861.     break;
  1862.   case WHITE:
  1863.     if (!vim_iswhite(*reginput))
  1864. return 0;
  1865.     reginput++;
  1866.     break;
  1867.   case NWHITE:
  1868.     if (*reginput == NUL || vim_iswhite(*reginput))
  1869. return 0;
  1870.     reginput++;
  1871.     break;
  1872.   case DIGIT:
  1873.     if (!ri_digit(*reginput))
  1874. return 0;
  1875.     reginput++;
  1876.     break;
  1877.   case NDIGIT:
  1878.     if (*reginput == NUL || ri_digit(*reginput))
  1879. return 0;
  1880.     reginput++;
  1881.     break;
  1882.   case HEX:
  1883.     if (!ri_hex(*reginput))
  1884. return 0;
  1885.     reginput++;
  1886.     break;
  1887.   case NHEX:
  1888.     if (*reginput == NUL || ri_hex(*reginput))
  1889. return 0;
  1890.     reginput++;
  1891.     break;
  1892.   case OCTAL:
  1893.     if (!ri_octal(*reginput))
  1894. return 0;
  1895.     reginput++;
  1896.     break;
  1897.   case NOCTAL:
  1898.     if (*reginput == NUL || ri_octal(*reginput))
  1899. return 0;
  1900.     reginput++;
  1901.     break;
  1902.   case WORD:
  1903.     if (!ri_word(*reginput))
  1904. return 0;
  1905.     reginput++;
  1906.     break;
  1907.   case NWORD:
  1908.     if (*reginput == NUL || ri_word(*reginput))
  1909. return 0;
  1910.     reginput++;
  1911.     break;
  1912.   case HEAD:
  1913.     if (!ri_head(*reginput))
  1914. return 0;
  1915.     reginput++;
  1916.     break;
  1917.   case NHEAD:
  1918.     if (*reginput == NUL || ri_head(*reginput))
  1919. return 0;
  1920.     reginput++;
  1921.     break;
  1922.   case ALPHA:
  1923.     if (!ri_alpha(*reginput))
  1924. return 0;
  1925.     reginput++;
  1926.     break;
  1927.   case NALPHA:
  1928.     if (*reginput == NUL || ri_alpha(*reginput))
  1929. return 0;
  1930.     reginput++;
  1931.     break;
  1932.   case LOWER:
  1933.     if (!ri_lower(*reginput))
  1934. return 0;
  1935.     reginput++;
  1936.     break;
  1937.   case NLOWER:
  1938.     if (*reginput == NUL || ri_lower(*reginput))
  1939. return 0;
  1940.     reginput++;
  1941.     break;
  1942.   case UPPER:
  1943.     if (!ri_upper(*reginput))
  1944. return 0;
  1945.     reginput++;
  1946.     break;
  1947.   case NUPPER:
  1948.     if (*reginput == NUL || ri_upper(*reginput))
  1949. return 0;
  1950.     reginput++;
  1951.     break;
  1952.   case EXACTLY:
  1953.     {
  1954. int     len;
  1955. char_u     *opnd;
  1957. opnd = OPERAND(scan);
  1958. /* Inline the first character, for speed. */
  1959. if (*opnd != *reginput
  1960. && (!reg_ic || TO_LOWER(*opnd) != TO_LOWER(*reginput)))
  1961.     return 0;
  1962. len = STRLEN(opnd);
  1963. if (len > 1 && cstrncmp(opnd, reginput, len) != 0)
  1964.     return 0;
  1965. reginput += len;
  1966.     }
  1967.     break;
  1968.   case ANYOF:
  1969.     if (*reginput == '' || cstrchr(OPERAND(scan), *reginput) == NULL)
  1970. return 0;
  1971.     reginput++;
  1972.     break;
  1973.   case ANYBUT:
  1974.     if (*reginput == '' || cstrchr(OPERAND(scan), *reginput) != NULL)
  1975. return 0;
  1976.     reginput++;
  1977.     break;
  1978.   case NOTHING:
  1979.     break;
  1980.   case BACK:
  1981.     break;
  1982.   case MOPEN + 1:
  1983.   case MOPEN + 2:
  1984.   case MOPEN + 3:
  1985.   case MOPEN + 4:
  1986.   case MOPEN + 5:
  1987.   case MOPEN + 6:
  1988.   case MOPEN + 7:
  1989.   case MOPEN + 8:
  1990.   case MOPEN + 9:
  1991.     {
  1992. int     no;
  1993. char_u     *save;
  1995. clear_subexpr();
  1996. no = OP(scan) - MOPEN;
  1997. save = regstartp[no];
  1998. regstartp[no] = reginput; /* Tentatively */
  1999. #ifdef DEBUG
  2000. if (regnarrate)
  2001.     printf("MOPEN  %d pre  @'%s' ('%s' )'%s'n",
  2002. no, save,
  2003. regstartp[no] ? (char *)regstartp[no] : "NULL",
  2004. regendp[no] ? (char *)regendp[no] : "NULL");
  2005. #endif
  2007. if (regmatch(next))
  2008. {
  2009. #ifdef DEBUG
  2010.     if (regnarrate)
  2011. printf("MOPEN  %d post @'%s' ('%s' )'%s'n",
  2012. no, save,
  2013. regstartp[no] ? (char *)regstartp[no] : "NULL",
  2014. regendp[no] ? (char *)regendp[no] : "NULL");
  2015. #endif
  2016.     return 1;
  2017. }
  2018. regstartp[no] = save;     /* We were wrong... */
  2019. return 0;
  2020.     }
  2021.     /* break; Not Reached */
  2022.   case MCLOSE + 1:
  2023.   case MCLOSE + 2:
  2024.   case MCLOSE + 3:
  2025.   case MCLOSE + 4:
  2026.   case MCLOSE + 5:
  2027.   case MCLOSE + 6:
  2028.   case MCLOSE + 7:
  2029.   case MCLOSE + 8:
  2030.   case MCLOSE + 9:
  2031.     {
  2032. int     no;
  2033. char_u     *save;
  2035. clear_subexpr();
  2036. no = OP(scan) - MCLOSE;
  2037. save = regendp[no];
  2038. regendp[no] = reginput; /* Tentatively */
  2039. #ifdef DEBUG
  2040. if (regnarrate)
  2041.     printf("MCLOSE %d pre  @'%s' ('%s' )'%s'n",
  2042. no, save,
  2043. regstartp[no] ? (char *)regstartp[no] : "NULL",
  2044. regendp[no] ? (char *)regendp[no] : "NULL");
  2045. #endif
  2047. if (regmatch(next))
  2048. {
  2049. #ifdef DEBUG
  2050.     if (regnarrate)
  2051. printf("MCLOSE %d post @'%s' ('%s' )'%s'n",
  2052. no, save,
  2053. regstartp[no] ? (char *)regstartp[no] : "NULL",
  2054. regendp[no] ? (char *)regendp[no] : "NULL");
  2055. #endif
  2056.     return 1;
  2057. }
  2058. regendp[no] = save; /* We were wrong... */
  2059. return 0;
  2060.     }
  2061.     /* break; Not Reached */
  2062.   case BACKREF + 1:
  2063.   case BACKREF + 2:
  2064.   case BACKREF + 3:
  2065.   case BACKREF + 4:
  2066.   case BACKREF + 5:
  2067.   case BACKREF + 6:
  2068.   case BACKREF + 7:
  2069.   case BACKREF + 8:
  2070.   case BACKREF + 9:
  2071.     {
  2072. int no;
  2073. int len;
  2075. clear_subexpr();
  2076. no = OP(scan) - BACKREF;
  2077. if (regendp[no] != NULL)
  2078. {
  2079.     len = (int)(regendp[no] - regstartp[no]);
  2080.     if (cstrncmp(regstartp[no], reginput, len) != 0)
  2081. return 0;
  2082.     reginput += len;
  2083. }
  2084. else
  2085. {
  2086.     /*emsg("backref to 0-repeat");*/
  2087.     /*return 0;*/
  2088. }
  2089.     }
  2090.     break;
  2091.   case BRANCH:
  2092.     {
  2093. char_u     *save;
  2095. if (OP(next) != BRANCH) /* No choice. */
  2096.     next = OPERAND(scan); /* Avoid recursion. */
  2097. else
  2098. {
  2099.     do
  2100.     {
  2101. save = reginput;
  2102. if (regmatch(OPERAND(scan)))
  2103.     return 1;
  2104. reginput = save;
  2105. scan = regnext(scan);
  2106.     } while (scan != NULL && OP(scan) == BRANCH);
  2107.     return 0;
  2108.     /* NOTREACHED */
  2109. }
  2110.     }
  2111.     break;
  2112.   case BRACE_LIMITS:
  2113.     {
  2114. int no;
  2116. if (OP(next) == BRACE_SIMPLE)
  2117. {
  2118.     minval = OPERAND_MIN(scan);
  2119.     maxval = OPERAND_MAX(scan);
  2120. }
  2121. else if (OP(next) >= BRACE_COMPLEX &&
  2122.  OP(next) < BRACE_COMPLEX + 10)
  2123. {
  2124.     no = OP(next) - BRACE_COMPLEX;
  2125.     brace_min[no] = OPERAND_MIN(scan);
  2126.     brace_max[no] = OPERAND_MAX(scan);
  2127.     brace_count[no] = 0;
  2128. }
  2129. else
  2130. {
  2131.     emsg(e_internal);     /* Shouldn't happen */
  2132.     return 0;
  2133. }
  2134.     }
  2135.     break;
  2136.   case BRACE_COMPLEX + 0:
  2137.   case BRACE_COMPLEX + 1:
  2138.   case BRACE_COMPLEX + 2:
  2139.   case BRACE_COMPLEX + 3:
  2140.   case BRACE_COMPLEX + 4:
  2141.   case BRACE_COMPLEX + 5:
  2142.   case BRACE_COMPLEX + 6:
  2143.   case BRACE_COMPLEX + 7:
  2144.   case BRACE_COMPLEX + 8:
  2145.   case BRACE_COMPLEX + 9:
  2146.     {
  2147. int     no;
  2148. char_u     *save;
  2150. no = OP(scan) - BRACE_COMPLEX;
  2151. ++brace_count[no];
  2153. /* If not matched enough times yet, try one more */
  2154. if (brace_count[no] <= (brace_min[no] <= brace_max[no]
  2155.     ? brace_min[no] : brace_max[no]))
  2156. {
  2157.     save = reginput;
  2158.     if (regmatch(OPERAND(scan)))
  2159. return 1;
  2160.     reginput = save;
  2161.     --brace_count[no]; /* failed, decrement match count */
  2162.     return 0;
  2163. }
  2165. /* If matched enough times, may try matching some more */
  2166. if (brace_min[no] <= brace_max[no])
  2167. {
  2168.     /* Range is the normal way around, use longest match */
  2169.     if (brace_count[no] <= brace_max[no])
  2170.     {
  2171. save = reginput;
  2172. if (regmatch(OPERAND(scan)))
  2173.     return 1;     /* matched some more times */
  2174. reginput = save;
  2175. --brace_count[no];  /* matched just enough times */
  2176. /* continue with the items after {} */
  2177.     }
  2178. }
  2179. else
  2180. {
  2181.     /* Range is backwards, use shortest match first */
  2182.     if (brace_count[no] <= brace_min[no])
  2183.     {
  2184. save = reginput;
  2185. if (regmatch(next))
  2186.     return 1;
  2187. reginput = save;
  2188. next = OPERAND(scan);
  2189. /* must try to match one more item */
  2190.     }
  2191. }
  2192.     }
  2193.     break;
  2195.   case BRACE_SIMPLE:
  2196.   case STAR:
  2197.   case PLUS:
  2198.     {
  2199. int nextch;
  2200. int nextch_ic;
  2201. int no;
  2202. char_u *save;
  2204. /*
  2205.  * Lookahead to avoid useless match attempts when we know
  2206.  * what character comes next.
  2207.  */
  2208. if (OP(next) == EXACTLY)
  2209. {
  2210.     nextch = *OPERAND(next);
  2211.     if (reg_ic)
  2212.     {
  2213. if (isupper(nextch))
  2214.     nextch_ic = TO_LOWER(nextch);
  2215. else
  2216.     nextch_ic = TO_UPPER(nextch);
  2217.     }
  2218.     else
  2219. nextch_ic = nextch;
  2220. }
  2221. else
  2222. {
  2223.     nextch = '';
  2224.     nextch_ic = '';
  2225. }
  2226. if (OP(scan) != BRACE_SIMPLE)
  2227. {
  2228.     minval = (OP(scan) == STAR) ? 0 : 1;
  2229.     maxval = MAX_LIMIT;
  2230. }
  2232. save = reginput;
  2233. no = regrepeat(OPERAND(scan));
  2234. if (minval <= maxval)
  2235. {
  2236.     /* Range is the normal way around, use longest match */
  2237.     if (no > maxval)
  2238.     {
  2239. no = maxval;
  2240. reginput = save + no;
  2241.     }
  2242.     while (no >= minval)
  2243.     {
  2244. /* If it could work, try it. */
  2245. if (nextch == '' || *reginput == nextch
  2246.     || *reginput == nextch_ic)
  2247.     if (regmatch(next))
  2248. return 1;
  2249. /* Couldn't or didn't -- back up. */
  2250. no--;
  2251. reginput = save + no;
  2252.     }
  2253. }
  2254. else
  2255. {
  2256.     /* Range is backwards, use shortest match first */
  2257.     if (no < maxval)
  2258. return 0;
  2259.     if (minval > no)
  2260. minval = no; /* Actually maximum value */
  2261.     no = maxval;
  2262.     reginput = save + no;
  2263.     while (no <= minval)
  2264.     {
  2265. /* If it could work, try it. */
  2266. if (nextch == '' || *reginput == nextch
  2267.     || *reginput == nextch_ic)
  2268.     if (regmatch(next))
  2269. return 1;
  2270. /* Couldn't or didn't -- try longer match. */
  2271. no++;
  2272. reginput = save + no;
  2273.     }
  2274. }
  2275. return 0;
  2276.     }
  2277.     /* break; Not Reached */
  2278.   case END:
  2279.     return 1;     /* Success! */
  2280.     /* break; Not Reached */
  2281.   default:
  2282.     emsg(e_re_corr);
  2283. #ifdef DEBUG
  2284.     printf("Illegal op code %dn", OP(scan));
  2285. #endif
  2286.     return 0;
  2287.     /* break; Not Reached */
  2288. }
  2290. scan = next;
  2291.     }
  2293.     /*
  2294.      * We get here only if there's trouble -- normally "case END" is the
  2295.      * terminating point.
  2296.      */
  2297.     emsg(e_re_corr);
  2298. #ifdef DEBUG
  2299.     printf("Premature EOLn");
  2300. #endif
  2301.     return 0;
  2302. }
  2304. /*
  2305.  * regrepeat - repeatedly match something simple, report how many
  2306.  */
  2307.     static int
  2308. regrepeat(p)
  2309.     char_u *p;
  2310. {
  2311.     int count = 0;
  2312.     char_u *scan;
  2313.     char_u *opnd;
  2314.     int mask;
  2316.     scan = reginput;
  2317.     opnd = OPERAND(p);
  2318.     switch (OP(p))
  2319.     {
  2320.       case ANY:
  2321. count = STRLEN(scan);
  2322. scan += count;
  2323. break;
  2324.       case IDENT:
  2325. for (count = 0; vim_isIDc(*scan); ++count)
  2326.     ++scan;
  2327. break;
  2328.       case KWORD:
  2329. for (count = 0; vim_iswordc(*scan); ++count)
  2330.     ++scan;
  2331. break;
  2332.       case FNAME:
  2333. for (count = 0; vim_isfilec(*scan); ++count)
  2334.     ++scan;
  2335. break;
  2336.       case PRINT:
  2337. for (count = 0; charsize(*scan) == 1; ++count)
  2338.     ++scan;
  2339. break;
  2340.       case SIDENT:
  2341. for (count = 0; !isdigit(*scan) && vim_isIDc(*scan); ++count)
  2342.     ++scan;
  2343. break;
  2344.       case SWORD:
  2345. for (count = 0; !isdigit(*scan) && vim_iswordc(*scan); ++count)
  2346.     ++scan;
  2347. break;
  2348.       case SFNAME:
  2349. for (count = 0; !isdigit(*scan) && vim_isfilec(*scan); ++count)
  2350.     ++scan;
  2351. break;
  2352.       case SPRINT:
  2353. for (count = 0; !isdigit(*scan) && charsize(*scan) == 1; ++count)
  2354.     ++scan;
  2355. break;
  2356.       case WHITE:
  2357. for (count = 0; vim_iswhite(*scan); ++count)
  2358.     ++scan;
  2359. break;
  2360.       case NWHITE:
  2361. for (count = 0; *scan != NUL && !vim_iswhite(*scan); ++count)
  2362.     ++scan;
  2363. break;
  2364.       case DIGIT:
  2365. mask = RI_DIGIT;
  2366. do_class:
  2367. for (count = 0; class_tab[*scan] & mask; ++count)
  2368.     ++scan;
  2369. break;
  2370.       case NDIGIT:
  2371. mask = RI_DIGIT;
  2372. do_nclass:
  2373. for (count = 0; *scan != NUL && !(class_tab[*scan] & mask); ++count)
  2374.     ++scan;
  2375. break;
  2376.       case HEX:
  2377. mask = RI_HEX;
  2378. goto do_class;
  2379.       case NHEX:
  2380. mask = RI_HEX;
  2381. goto do_nclass;
  2382.       case OCTAL:
  2383. mask = RI_OCTAL;
  2384. goto do_class;
  2385.       case NOCTAL:
  2386. mask = RI_OCTAL;
  2387. goto do_nclass;
  2388.       case WORD:
  2389. mask = RI_WORD;
  2390. goto do_class;
  2391.       case NWORD:
  2392. mask = RI_WORD;
  2393. goto do_nclass;
  2394.       case HEAD:
  2395. mask = RI_HEAD;
  2396. goto do_class;
  2397.       case NHEAD:
  2398. mask = RI_HEAD;
  2399. goto do_nclass;
  2400.       case ALPHA:
  2401. mask = RI_ALPHA;
  2402. goto do_class;
  2403.       case NALPHA:
  2404. mask = RI_ALPHA;
  2405. goto do_nclass;
  2406.       case LOWER:
  2407. mask = RI_LOWER;
  2408. goto do_class;
  2409.       case NLOWER:
  2410. mask = RI_LOWER;
  2411. goto do_nclass;
  2412.       case UPPER:
  2413. mask = RI_UPPER;
  2414. goto do_class;
  2415.       case NUPPER:
  2416. mask = RI_UPPER;
  2417. goto do_nclass;
  2418.       case EXACTLY:
  2419. {
  2420.     int     cu, cl;
  2422.     if (reg_ic)
  2423.     {
  2424. cu = TO_UPPER(*opnd);
  2425. cl = TO_LOWER(*opnd);
  2426. while (*scan == cu || *scan == cl)
  2427. {
  2428.     count++;
  2429.     scan++;
  2430. }
  2431.     }
  2432.     else
  2433.     {
  2434. cu = *opnd;
  2435. while (*scan == cu)
  2436. {
  2437.     count++;
  2438.     scan++;
  2439. }
  2440.     }
  2441.     break;
  2442. }
  2443.       case ANYOF:
  2444. while (*scan != '' && cstrchr(opnd, *scan) != NULL)
  2445. {
  2446.     count++;
  2447.     scan++;
  2448. }
  2449. break;
  2450.       case ANYBUT:
  2451. while (*scan != '' && cstrchr(opnd, *scan) == NULL)
  2452. {
  2453.     count++;
  2454.     scan++;
  2455. }
  2456. break;
  2457.       default: /* Oh dear.  Called inappropriately. */
  2458. emsg(e_re_corr);
  2459. #ifdef DEBUG
  2460. printf("Called regrepeat with op code %dn", OP(p));
  2461. #endif
  2462. count = 0; /* Best compromise. */
  2463. break;
  2464.     }
  2465.     reginput = scan;
  2467.     return count;
  2468. }
  2470. /*
  2471.  * regnext - dig the "next" pointer out of a node
  2472.  */
  2473.     static char_u *
  2474. regnext(p)
  2475.     char_u  *p;
  2476. {
  2477.     int     offset;
  2479.     if (p == JUST_CALC_SIZE)
  2480. return NULL;
  2482.     offset = NEXT(p);
  2483.     if (offset == 0)
  2484. return NULL;
  2486.     if (OP(p) == BACK)
  2487. return p - offset;
  2488.     else
  2489. return p + offset;
  2490. }
  2492. #ifdef DEBUG
  2494. /*
  2495.  * regdump - dump a regexp onto stdout in vaguely comprehensible form
  2496.  */
  2497.     static void
  2498. regdump(pattern, r)
  2499.     char_u *pattern;
  2500.     vim_regexp *r;
  2501. {
  2502.     char_u  *s;
  2503.     int     op = EXACTLY; /* Arbitrary non-END op. */
  2504.     char_u  *next;
  2506.     printf("nregcomp(%s):n", pattern);
  2508.     s = r->program + 1;
  2509.     while (op != END) /* While that wasn't END last time... */
  2510.     {
  2511. op = OP(s);
  2512. printf("%2d%s", (int)(s - r->program), regprop(s)); /* Where, what. */
  2513. next = regnext(s);
  2514. if (next == NULL) /* Next ptr. */
  2515.     printf("(0)");
  2516. else
  2517.     printf("(%d)", (int)((s - r->program) + (next - s)));
  2518. if (op == BRACE_LIMITS)
  2519. {
  2520.     /* Two short ints */
  2521.     printf(" minval %d, maxval %d", OPERAND_MIN(s), OPERAND_MAX(s));
  2522.     s += 4;
  2523. }
  2524. s += 3;
  2525. if (op == ANYOF || op == ANYBUT || op == EXACTLY)
  2526. {
  2527.     /* Literal string, where present. */
  2528.     while (*s != '')
  2529. printf("%c", *s++);
  2530.     s++;
  2531. }
  2532. printf("n");
  2533.     }
  2535.     /* Header fields of interest. */
  2536.     if (r->regstart != '')
  2537. printf("start `%c' ", r->regstart);
  2538.     if (r->reganch)
  2539. printf("anchored ");
  2540.     if (r->regmust != NULL)
  2541. printf("must have "%s"", r->regmust);
  2542.     printf("n");
  2543. }
  2545. /*
  2546.  * regprop - printable representation of opcode
  2547.  */
  2548.     static char_u *
  2549. regprop(op)
  2550.     char_u    *op;
  2551. {
  2552.     char_u     *p;
  2553.     static char_u   buf[50];
  2555.     (void) strcpy(buf, ":");
  2557.     switch (OP(op))
  2558.     {
  2559.       case BOL:
  2560. p = "BOL";
  2561. break;
  2562.       case EOL:
  2563. p = "EOL";
  2564. break;
  2565.       case BOW:
  2566. p = "BOW";
  2567. break;
  2568.       case EOW:
  2569. p = "EOW";
  2570. break;
  2571.       case ANY:
  2572. p = "ANY";
  2573. break;
  2574.       case IDENT:
  2575. p = "IDENT";
  2576. break;
  2577.       case KWORD:
  2578. p = "KWORD";
  2579. break;
  2580.       case FNAME:
  2581. p = "FNAME";
  2582. break;
  2583.       case PRINT:
  2584. p = "PRINT";
  2585. break;
  2586.       case SIDENT:
  2587. p = "SIDENT";
  2588. break;
  2589.       case SWORD:
  2590. p = "SWORD";
  2591. break;
  2592.       case SFNAME:
  2593. p = "SFNAME";
  2594. break;
  2595.       case SPRINT:
  2596. p = "SPRINT";
  2597. break;
  2598.       case WHITE:
  2599. p = "WHITE";
  2600. break;
  2601.       case NWHITE:
  2602. p = "NWHITE";
  2603. break;
  2604.       case DIGIT:
  2605. p = "DIGIT";
  2606. break;
  2607.       case NDIGIT:
  2608. p = "NDIGIT";
  2609. break;
  2610.       case HEX:
  2611. p = "HEX";
  2612. break;
  2613.       case NHEX:
  2614. p = "NHEX";
  2615. break;
  2616.       case OCTAL:
  2617. p = "OCTAL";
  2618. break;
  2619.       case NOCTAL:
  2620. p = "NOCTAL";
  2621. break;
  2622.       case WORD:
  2623. p = "WORD";
  2624. break;
  2625.       case NWORD:
  2626. p = "NWORD";
  2627. break;
  2628.       case HEAD:
  2629. p = "HEAD";
  2630. break;
  2631.       case NHEAD:
  2632. p = "NHEAD";
  2633. break;
  2634.       case ALPHA:
  2635. p = "ALPHA";
  2636. break;
  2637.       case NALPHA:
  2638. p = "NALPHA";
  2639. break;
  2640.       case LOWER:
  2641. p = "LOWER";
  2642. break;
  2643.       case NLOWER:
  2644. p = "NLOWER";
  2645. break;
  2646.       case UPPER:
  2647. p = "UPPER";
  2648. break;
  2649.       case NUPPER:
  2650. p = "NUPPER";
  2651. break;
  2652.       case ANYOF:
  2653. p = "ANYOF";
  2654. break;
  2655.       case ANYBUT:
  2656. p = "ANYBUT";
  2657. break;
  2658.       case BRANCH:
  2659. p = "BRANCH";
  2660. break;
  2661.       case EXACTLY:
  2662. p = "EXACTLY";
  2663. break;
  2664.       case NOTHING:
  2665. p = "NOTHING";
  2666. break;
  2667.       case BACK:
  2668. p = "BACK";
  2669. break;
  2670.       case END:
  2671. p = "END";
  2672. break;
  2673.       case MOPEN + 1:
  2674.       case MOPEN + 2:
  2675.       case MOPEN + 3:
  2676.       case MOPEN + 4:
  2677.       case MOPEN + 5:
  2678.       case MOPEN + 6:
  2679.       case MOPEN + 7:
  2680.       case MOPEN + 8:
  2681.       case MOPEN + 9:
  2682. sprintf(buf + STRLEN(buf), "MOPEN%d", OP(op) - MOPEN);
  2683. p = NULL;
  2684. break;
  2685.       case MCLOSE + 1:
  2686.       case MCLOSE + 2:
  2687.       case MCLOSE + 3:
  2688.       case MCLOSE + 4:
  2689.       case MCLOSE + 5:
  2690.       case MCLOSE + 6:
  2691.       case MCLOSE + 7:
  2692.       case MCLOSE + 8:
  2693.       case MCLOSE + 9:
  2694. sprintf(buf + STRLEN(buf), "MCLOSE%d", OP(op) - MCLOSE);
  2695. p = NULL;
  2696. break;
  2697.       case BACKREF + 1:
  2698.       case BACKREF + 2:
  2699.       case BACKREF + 3:
  2700.       case BACKREF + 4:
  2701.       case BACKREF + 5:
  2702.       case BACKREF + 6:
  2703.       case BACKREF + 7:
  2704.       case BACKREF + 8:
  2705.       case BACKREF + 9:
  2706. sprintf(buf + STRLEN(buf), "BACKREF%d", OP(op) - BACKREF);
  2707. p = NULL;
  2708. break;
  2709.       case STAR:
  2710. p = "STAR";
  2711. break;
  2712.       case PLUS:
  2713. p = "PLUS";
  2714. break;
  2715.       case BRACE_LIMITS:
  2716. p = "BRACE_LIMITS";
  2717. break;
  2718.       case BRACE_SIMPLE:
  2719. p = "BRACE_SIMPLE";
  2720. break;
  2721.       case BRACE_COMPLEX + 0:
  2722.       case BRACE_COMPLEX + 1:
  2723.       case BRACE_COMPLEX + 2:
  2724.       case BRACE_COMPLEX + 3:
  2725.       case BRACE_COMPLEX + 4:
  2726.       case BRACE_COMPLEX + 5:
  2727.       case BRACE_COMPLEX + 6:
  2728.       case BRACE_COMPLEX + 7:
  2729.       case BRACE_COMPLEX + 8:
  2730.       case BRACE_COMPLEX + 9:
  2731. sprintf(buf + STRLEN(buf), "BRACE_COMPLEX%d", OP(op) - BRACE_COMPLEX);
  2732. p = NULL;
  2733. break;
  2734.       default:
  2735. sprintf(buf + STRLEN(buf), "corrupt %d", OP(op));
  2736. p = NULL;
  2737. break;
  2738.     }
  2739.     if (p != NULL)
  2740. (void) strcat(buf, p);
  2741.     return buf;
  2742. }
  2743. #endif
  2745. /*
  2746.  * Compare two strings, ignore case if reg_ic set.
  2747.  * Return 0 if strings match, non-zero otherwise.
  2748.  */
  2749.     static int
  2750. cstrncmp(s1, s2, n)
  2751.     char_u *s1, *s2;
  2752.     int n;
  2753. {
  2754.     if (!reg_ic)
  2755. return STRNCMP(s1, s2, n);
  2756.     return STRNICMP(s1, s2, n);
  2757. }
  2759. /*
  2760.  * cstrchr: This function is used a lot for simple searches, keep it fast!
  2761.  */
  2762.     static char_u *
  2763. cstrchr(s, c)
  2764.     char_u *s;
  2765.     int c;
  2766. {
  2767.     char_u *p;
  2768.     int cc;
  2770.     if (!reg_ic)
  2771. return vim_strchr(s, c);
  2773.     /* tolower() and toupper() can be slow, comparing twice should be a lot
  2774.      * faster (esp. when using MS Visual C++!) */
  2775.     if (isupper(c))
  2776. cc = TO_LOWER(c);
  2777.     else if (islower(c))
  2778. cc = TO_UPPER(c);
  2779.     else
  2780. return vim_strchr(s, c);
  2782.     for (p = s; *p; ++p)
  2783. if (*p == c || *p == cc)
  2784.     return p;
  2785.     return NULL;
  2786. }
  2788. /***************************************************************
  2789.  *       regsub stuff        *
  2790.  ***************************************************************/
  2792. /* This stuff below really confuses cc on an SGI -- webb */
  2793. #ifdef __sgi
  2794. # undef __ARGS
  2795. # define __ARGS(x)  ()
  2796. #endif
  2798. /*
  2799.  * We should define ftpr as a pointer to a function returning a pointer to
  2800.  * a function returning a pointer to a function ...
  2801.  * This is impossible, so we declare a pointer to a function returning a
  2802.  * pointer to a function returning void. This should work for all compilers.
  2803.  */
  2804. typedef void (*(*fptr) __ARGS((char_u *, int)))();
  2806. static fptr do_upper __ARGS((char_u *, int));
  2807. static fptr do_Upper __ARGS((char_u *, int));
  2808. static fptr do_lower __ARGS((char_u *, int));
  2809. static fptr do_Lower __ARGS((char_u *, int));
  2811.     static fptr
  2812. do_upper(d, c)
  2813.     char_u *d;
  2814.     int c;
  2815. {
  2816.     *d = TO_UPPER(c);
  2818.     return (fptr)NULL;
  2819. }
  2821.     static fptr
  2822. do_Upper(d, c)
  2823.     char_u *d;
  2824.     int c;
  2825. {
  2826.     *d = TO_UPPER(c);
  2828.     return (fptr)do_Upper;
  2829. }
  2831.     static fptr
  2832. do_lower(d, c)
  2833.     char_u *d;
  2834.     int c;
  2835. {
  2836.     *d = TO_LOWER(c);
  2838.     return (fptr)NULL;
  2839. }
  2841.     static fptr
  2842. do_Lower(d, c)
  2843.     char_u *d;
  2844.     int c;
  2845. {
  2846.     *d = TO_LOWER(c);
  2848.     return (fptr)do_Lower;
  2849. }
  2851. /*
  2852.  * regtilde(): Replace tildes in the pattern by the old pattern.
  2853.  *
  2854.  * Short explanation of the tilde: It stands for the previous replacement
  2855.  * pattern.  If that previous pattern also contains a ~ we should go back a
  2856.  * step further...  But we insert the previous pattern into the current one
  2857.  * and remember that.
  2858.  * This still does not handle the case where "magic" changes. TODO?
  2859.  *
  2860.  * The tildes are parsed once before the first call to vim_regsub().
  2861.  */
  2862.     char_u *
  2863. regtilde(source, magic)
  2864.     char_u  *source;
  2865.     int     magic;
  2866. {
  2867.     char_u  *newsub = source;
  2868.     char_u  *tmpsub;
  2869.     char_u  *p;
  2870.     int     len;
  2871.     int     prevlen;
  2873.     for (p = newsub; *p; ++p)
  2874.     {
  2875. if ((*p == '~' && magic) || (*p == '\' && *(p + 1) == '~' && !magic))
  2876. {
  2877.     if (reg_prev_sub != NULL)
  2878.     {
  2879. /* length = len(newsub) - 1 + len(prev_sub) + 1 */
  2880. prevlen = STRLEN(reg_prev_sub);
  2881. tmpsub = alloc((unsigned)(STRLEN(newsub) + prevlen));
  2882. if (tmpsub != NULL)
  2883. {
  2884.     /* copy prefix */
  2885.     len = (int)(p - newsub); /* not including ~ */
  2886.     mch_memmove(tmpsub, newsub, (size_t)len);
  2887.     /* interpretate tilde */
  2888.     mch_memmove(tmpsub + len, reg_prev_sub, (size_t)prevlen);
  2889.     /* copy postfix */
  2890.     if (!magic)
  2891. ++p; /* back off  */
  2892.     STRCPY(tmpsub + len + prevlen, p + 1);
  2894.     if (newsub != source) /* already allocated newsub */
  2895. vim_free(newsub);
  2896.     newsub = tmpsub;
  2897.     p = newsub + len + prevlen;
  2898. }
  2899.     }
  2900.     else if (magic)
  2901. STRCPY(p, p + 1); /* remove '~' */
  2902.     else
  2903. STRCPY(p, p + 2); /* remove '~' */
  2904.     --p;
  2905. }
  2906. else if (*p == '\' && p[1]) /* skip escaped characters */
  2907.     ++p;
  2908.     }
  2910.     vim_free(reg_prev_sub);
  2911.     if (newsub != source) /* newsub was allocated, just keep it */
  2912. reg_prev_sub = newsub;
  2913.     else /* no ~ found, need to save newsub  */
  2914. reg_prev_sub = vim_strsave(newsub);
  2915.     return newsub;
  2916. }
  2918. /*
  2919.  * vim_regsub() - perform substitutions after a regexp match
  2920.  *
  2921.  * If copy is TRUE really copy into dest.
  2922.  * If copy is FALSE nothing is copied, this is just to find out the length of
  2923.  * the result.
  2924.  *
  2925.  * Returns the size of the replacement, including terminating NUL.
  2926.  */
  2927.     int
  2928. vim_regsub(prog, source, dest, copy, magic)
  2929.     vim_regexp    *prog;
  2930.     char_u    *source;
  2931.     char_u    *dest;
  2932.     int     copy;
  2933.     int     magic;
  2934. {
  2935.     char_u *src;
  2936.     char_u *dst;
  2937.     char_u *s;
  2938.     int c;
  2939.     int no;
  2940.     fptr func = (fptr)NULL;
  2942.     if (prog == NULL || source == NULL || dest == NULL)
  2943.     {
  2944. emsg(e_null);
  2945. return 0;
  2946.     }
  2947.     if (UCHARAT(prog->program) != MAGIC)
  2948.     {
  2949. emsg(e_re_corr);
  2950. return 0;
  2951.     }
  2952.     src = source;
  2953.     dst = dest;
  2955.     while ((c = *src++) != '')
  2956.     {
  2957. no = -1;
  2958. if (c == '&' && magic)
  2959.     no = 0;
  2960. else if (c == '\' && *src != NUL)
  2961. {
  2962.     if (*src == '&' && !magic)
  2963.     {
  2964. ++src;
  2965. no = 0;
  2966.     }
  2967.     else if ('0' <= *src && *src <= '9')
  2968.     {
  2969. no = *src++ - '0';
  2970.     }
  2971.     else if (vim_strchr((char_u *)"uUlLeE", *src))
  2972.     {
  2973. switch (*src++)
  2974. {
  2975. case 'u':   func = (fptr)do_upper;
  2976.     continue;
  2977. case 'U':   func = (fptr)do_Upper;
  2978.     continue;
  2979. case 'l':   func = (fptr)do_lower;
  2980.     continue;
  2981. case 'L':   func = (fptr)do_Lower;
  2982.     continue;
  2983. case 'e':
  2984. case 'E':   func = (fptr)NULL;
  2985.     continue;
  2986. }
  2987.     }
  2988. }
  2989. if (no < 0)       /* Ordinary character. */
  2990. {
  2991.     if (c == '\' && *src != NUL)
  2992.     {
  2993. /* Check for abbreviations -- webb */
  2994. switch (*src)
  2995. {
  2996.     case 'r': c = CR; break;
  2997.     case 'n': c = NL; break;
  2998.     case 't': c = TAB; break;
  2999.     /* Oh no!  e already has meaning in subst pat :-( */
  3000.     /* case 'e':    c = ESC;     break; */
  3001.     case 'b': c = Ctrl('H'); break;
  3002.     default:
  3003. /* Normal character, not abbreviation */
  3004. c = *src;
  3005. break;
  3006. }
  3007. src++;
  3008.     }
  3009.     if (copy)
  3010.     {
  3011. if (func == (fptr)NULL)     /* just copy */
  3012.     *dst = c;
  3013. else     /* change case */
  3014.     func = (fptr)(func(dst, c));
  3015.     /* Turbo C complains without the typecast */
  3016.     }
  3017.     dst++;
  3018. }
  3019. else if (prog->startp[no] != NULL && prog->endp[no] != NULL)
  3020. {
  3021.     for (s = prog->startp[no]; s < prog->endp[no]; ++s)
  3022.     {
  3023. if (copy && *s == '') /* we hit NUL. */
  3024. {
  3025.     emsg(e_re_damg);
  3026.     goto exit;
  3027. }
  3028. /*
  3029.  * Insert a CTRL-V in front of a CR, otherwise
  3030.  * it will be replaced by a line break.
  3031.  */
  3032. if (*s == CR)
  3033. {
  3034.     if (copy)
  3035.     {
  3036. dst[0] = Ctrl('V');
  3037. dst[1] = CR;
  3038.     }
  3039.     dst += 2;
  3040. }
  3041. else
  3042. {
  3043.     if (copy)
  3044.     {
  3045. if (func == (fptr)NULL)     /* just copy */
  3046.     *dst = *s;
  3047. else     /* change case */
  3048.     func = (fptr)(func(dst, *s));
  3049.     /* Turbo C complains without the typecast */
  3050.     }
  3051.     ++dst;
  3052. }
  3053.     }
  3054. }
  3055.     }
  3056.     if (copy)
  3057. *dst = '';
  3059. exit:
  3060.     return (int)((dst - dest) + 1);
  3061. }
  3063. /*
  3064.  * Return TRUE if "c" is a wildcard character.  Depends on 'magic'.
  3065.  */
  3066.     int
  3067. vim_iswildc(c)
  3068.     int c;
  3069. {
  3070.     return vim_strchr((char_u *)(p_magic ? ".*~[^$\" : "^$\"), c) != NULL;
  3071. }