diff --git a/src/regexp.c b/src/regexp.c
new file mode 100644
index 0000000..9715a1e
--- /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(&regparse);
+			    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(&regparse);
+			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(&regparse);
+    if (*regparse == ',')	    /* There is a comma */
+    {
+	if (vim_isdigit(*++regparse))
+	    *maxval = getdigits(&regparse);
+	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		&regmatch_T		NULL
+ * reg_mmatch		NULL			&regmmatch_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, &reg_startpos[no], &reg_startp[no]);
+
+		if (regmatch(next))
+		    return TRUE;
+
+		restore_se(&save, &reg_startpos[no], &reg_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, &reg_startzpos[no], &reg_startzp[no]);
+
+		if (regmatch(next))
+		    return TRUE;
+
+		restore_se(&save, &reg_startzpos[no], &reg_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, &reg_endpos[no], &reg_endp[no]);
+
+		if (regmatch(next))
+		    return TRUE;
+
+		restore_se(&save, &reg_endpos[no], &reg_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, &reg_endzpos[no], &reg_endzp[no]);
+
+		if (regmatch(next))
+		    return TRUE;
+
+		restore_se(&save, &reg_endzpos[no], &reg_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