vim: src/syntax.c comparison

comparison src/syntax.c @ 7:3fc0f57ecb91 v7.0001

updated for version 7.0001

author	vimboss
date	Sun, 13 Jun 2004 20:20:40 +0000
parents
children	bdeee1504ac1

comparison

equal deleted inserted replaced

-:c2daee826b8f
+:3fc0f57ecb91
+/* vi:set ts=8 sts=4 sw=4:
+*
+* VIM - Vi IMproved	by Bram Moolenaar
+*
+* Do ":help uganda"  in Vim to read copying and usage conditions.
+* Do ":help credits" in Vim to see a list of people who contributed.
+* See README.txt for an overview of the Vim source code.
+*/
+/*
+* syntax.c: code for syntax highlighting
+*/
+#include "vim.h"
+/*
+* Structure that stores information about a highlight group.
+* The ID of a highlight group is also called group ID.  It is the index in
+* the highlight_ga array PLUS ONE.
+*/
+struct hl_group
+{
+char_u	*sg_name;	/* highlight group name */
+char_u	*sg_name_u;	/* uppercase of sg_name */
+/* for normal terminals */
+int		sg_term;	/* "term=" highlighting attributes */
+char_u	*sg_start;	/* terminal string for start highl */
+char_u	*sg_stop;	/* terminal string for stop highl */
+int		sg_term_attr;	/* Screen attr for term mode */
+/* for color terminals */
+int		sg_cterm;	/* "cterm=" highlighting attr */
+int		sg_cterm_bold;	/* bold attr was set for light color */
+int		sg_cterm_fg;	/* terminal fg color number + 1 */
+int		sg_cterm_bg;	/* terminal bg color number + 1 */
+int		sg_cterm_attr;	/* Screen attr for color term mode */
+#ifdef FEAT_GUI
+/* for when using the GUI */
+int		sg_gui;		/* "gui=" highlighting attributes */
+guicolor_T	sg_gui_fg;	/* GUI foreground color handle */
+char_u	*sg_gui_fg_name;/* GUI foreground color name */
+guicolor_T	sg_gui_bg;	/* GUI background color handle */
+char_u	*sg_gui_bg_name;/* GUI background color name */
+GuiFont	sg_font;	/* GUI font handle */
+#ifdef FEAT_XFONTSET
+GuiFontset	sg_fontset;	/* GUI fontset handle */
+#endif
+char_u	*sg_font_name;  /* GUI font or fontset name */
+int		sg_gui_attr;    /* Screen attr for GUI mode */
+#endif
+int		sg_link;	/* link to this highlight group ID */
+int		sg_set;		/* combination of SG_* flags */
+};
+#define SG_TERM		1	/* term has been set */
+#define SG_CTERM	2	/* cterm has been set */
+#define SG_GUI		4	/* gui has been set */
+#define SG_LINK		8	/* link has been set */
+static garray_T highlight_ga;	/* highlight groups for 'highlight' option */
+#define HL_TABLE() ((struct hl_group *)((highlight_ga.ga_data)))
+#ifdef FEAT_CMDL_COMPL
+static int include_default = FALSE;	/* include "default" for expansion */
+static int include_link = FALSE;	/* include "link" for expansion */
+#endif
+/*
+* The "term", "cterm" and "gui" arguments can be any combination of the
+* following names, separated by commas (but no spaces!).
+*/
+static char *(hl_name_table[]) =
+{"bold", "standout", "underline", "italic", "reverse", "inverse", "NONE"};
+static int hl_attr_table[] =
+{HL_BOLD, HL_STANDOUT, HL_UNDERLINE, HL_ITALIC, HL_INVERSE, HL_INVERSE, 0};
+static int get_attr_entry  __ARGS((garray_T *table, attrentry_T *aep));
+static void syn_unadd_group __ARGS((void));
+static void set_hl_attr __ARGS((int idx));
+static void highlight_list_one __ARGS((int id));
+static int highlight_list_arg __ARGS((int id, int didh, int type, int iarg, char_u *sarg, char *name));
+static int syn_add_group __ARGS((char_u *name));
+static int syn_list_header __ARGS((int did_header, int outlen, int id));
+static int hl_has_settings __ARGS((int idx, int check_link));
+static void highlight_clear __ARGS((int idx));
+#ifdef FEAT_GUI
+static void gui_do_one_color __ARGS((int idx, int do_menu, int do_tooltip));
+static int  set_group_colors __ARGS((char_u *name, guicolor_T *fgp, guicolor_T *bgp, int do_menu, int use_norm, int do_tooltip));
+static guicolor_T color_name2handle __ARGS((char_u *name));
+static GuiFont font_name2handle __ARGS((char_u *name));
+# ifdef FEAT_XFONTSET
+static GuiFontset fontset_name2handle __ARGS((char_u *name, int fixed_width));
+# endif
+static void hl_do_font __ARGS((int idx, char_u *arg, int do_normal, int do_menu, int do_tooltip));
+#endif
+/*
+* An attribute number is the index in attr_table plus ATTR_OFF.
+*/
+#define ATTR_OFF (HL_ALL + 1)
+#if defined(FEAT_SYN_HL) || defined(PROTO)
+#define SYN_NAMELEN	50		/* maximum length of a syntax name */
+/* different types of offsets that are possible */
+#define SPO_MS_OFF	0	/* match  start offset */
+#define SPO_ME_OFF	1	/* match  end	offset */
+#define SPO_HS_OFF	2	/* highl. start offset */
+#define SPO_HE_OFF	3	/* highl. end	offset */
+#define SPO_RS_OFF	4	/* region start offset */
+#define SPO_RE_OFF	5	/* region end	offset */
+#define SPO_LC_OFF	6	/* leading context offset */
+#define SPO_COUNT	7
+static char *(spo_name_tab[SPO_COUNT]) =
+	    {"ms=", "me=", "hs=", "he=", "rs=", "re=", "lc="};
+/*
+* The patterns that are being searched for are stored in a syn_pattern.
+* A match item consists of one pattern.
+* A start/end item consists of n start patterns and m end patterns.
+* A start/skip/end item consists of n start patterns, one skip pattern and m
+* end patterns.
+* For the latter two, the patterns are always consecutive: start-skip-end.
+*
+* A character offset can be given for the matched text (_m_start and _m_end)
+* and for the actually highlighted text (_h_start and _h_end).
+*/
+typedef struct syn_pattern
+{
+char	 sp_type;		/* see SPTYPE_ defines below */
+char	 sp_syncing;		/* this item used for syncing */
+short	 sp_flags;		/* see HL_ defines below */
+struct sp_syn sp_syn;		/* struct passed to in_id_list() */
+short	 sp_syn_match_id;	/* highlight group ID of pattern */
+char_u	*sp_pattern;		/* regexp to match, pattern */
+regprog_T	*sp_prog;		/* regexp to match, program */
+int		 sp_ic;			/* ignore-case flag for sp_prog */
+short	 sp_off_flags;		/* see below */
+int		 sp_offsets[SPO_COUNT];	/* offsets */
+short	*sp_cont_list;		/* cont. group IDs, if non-zero */
+short	*sp_next_list;		/* next group IDs, if non-zero */
+int		 sp_sync_idx;		/* sync item index (syncing only) */
+int		 sp_line_id;		/* ID of last line where tried */
+int		 sp_startcol;		/* next match in sp_line_id line */
+} synpat_T;
+/* The sp_off_flags are computed like this:
+* offset from the start of the matched text: (1 << SPO_XX_OFF)
+* offset from the end	 of the matched text: (1 << (SPO_XX_OFF + SPO_COUNT))
+* When both are present, only one is used.
+*/
+#define SPTYPE_MATCH	1	/* match keyword with this group ID */
+#define SPTYPE_START	2	/* match a regexp, start of item */
+#define SPTYPE_END	3	/* match a regexp, end of item */
+#define SPTYPE_SKIP	4	/* match a regexp, skip within item */
+#define HL_CONTAINED	0x01	/* not used on toplevel */
+#define HL_TRANSP	0x02	/* has no highlighting	*/
+#define HL_ONELINE	0x04	/* match within one line only */
+#define HL_HAS_EOL	0x08	/* end pattern that matches with $ */
+#define HL_SYNC_HERE	0x10	/* sync point after this item (syncing only) */
+#define HL_SYNC_THERE	0x20	/* sync point at current line (syncing only) */
+#define HL_MATCH	0x40	/* use match ID instead of item ID */
+#define HL_SKIPNL	0x80	/* nextgroup can skip newlines */
+#define HL_SKIPWHITE	0x100	/* nextgroup can skip white space */
+#define HL_SKIPEMPTY	0x200	/* nextgroup can skip empty lines */
+#define HL_KEEPEND	0x400	/* end match always kept */
+#define HL_EXCLUDENL	0x800	/* exclude NL from match */
+#define HL_DISPLAY	0x1000	/* only used for displaying, not syncing */
+#define HL_FOLD		0x2000	/* define fold */
+#define HL_EXTEND	0x4000	/* ignore a keepend */
+/* These don't fit in a short, thus can't be used for syntax items, only for
+* si_flags and bs_flags. */
+#define HL_MATCHCONT	0x8000	/* match continued from previous line */
+#define HL_TRANS_CONT	0x10000L /* transparent item without contains arg */
+#define SYN_ITEMS(buf)	((synpat_T *)((buf)->b_syn_patterns.ga_data))
+#define NONE_IDX	-2	/* value of sp_sync_idx for "NONE" */
+/*
+* Flags for b_syn_sync_flags:
+*/
+#define SF_CCOMMENT	0x01	/* sync on a C-style comment */
+#define SF_MATCH	0x02	/* sync by matching a pattern */
+#define SYN_STATE_P(ssp)    ((bufstate_T *)((ssp)->ga_data))
+/*
+* Settings for keyword hash table.  It uses a simplistic hash function: add
+* all characters together, modulo KHASH_SIZE.
+*/
+#define KHASH_SIZE	512
+#define KHASH_MASK	(KHASH_SIZE - 1)
+#define MAXKEYWLEN	80	    /* maximum length of a keyword */
+/*
+* The attributes of the syntax item that has been recognized.
+*/
+static int current_attr = 0;	    /* attr of current syntax word */
+#ifdef FEAT_EVAL
+static int current_id = 0;	    /* ID of current char for syn_get_id() */
+static int current_trans_id = 0;    /* idem, transparancy removed */
+#endif
+struct syn_cluster
+{
+char_u	    *scl_name;	    /* syntax cluster name */
+char_u	    *scl_name_u;    /* uppercase of scl_name */
+short	    *scl_list;	    /* IDs in this syntax cluster */
+};
+/*
+* Methods of combining two clusters
+*/
+#define CLUSTER_REPLACE	    1	/* replace first list with second */
+#define CLUSTER_ADD	    2	/* add second list to first */
+#define CLUSTER_SUBTRACT    3	/* subtract second list from first */
+#define SYN_CLSTR(buf)	((struct syn_cluster *)((buf)->b_syn_clusters.ga_data))
+/*
+* Syntax group IDs have different types:
+*     0 -  9999  normal syntax groups
+* 10000 - 14999  ALLBUT indicator (current_syn_inc_tag added)
+* 15000 - 19999  TOP indicator (current_syn_inc_tag added)
+* 20000 - 24999  CONTAINED indicator (current_syn_inc_tag added)
+* >= 25000	  cluster IDs (subtract SYNID_CLUSTER for the cluster ID)
+*/
+#define SYNID_ALLBUT	10000	    /* syntax group ID for contains=ALLBUT */
+#define SYNID_TOP	15000	    /* syntax group ID for contains=TOP */
+#define SYNID_CONTAINED	20000	    /* syntax group ID for contains=CONTAINED */
+#define SYNID_CLUSTER	25000	    /* first syntax group ID for clusters */
+/*
+* Annoying Hack(TM):  ":syn include" needs this pointer to pass to
+* expand_filename().  Most of the other syntax commands don't need it, so
+* instead of passing it to them, we stow it here.
+*/
+static char_u **syn_cmdlinep;
+/*
+* Another Annoying Hack(TM):  To prevent rules from other ":syn include"'d
+* files from from leaking into ALLBUT lists, we assign a unique ID to the
+* rules in each ":syn include"'d file.
+*/
+static int current_syn_inc_tag = 0;
+static int running_syn_inc_tag = 0;
+/*
+* To reduce the time spent in keepend(), remember at which level in the state
+* stack the first item with "keepend" is present.  When "-1", there is no
+* "keepend" on the stack.
+*/
+static int keepend_level = -1;
+/*
+* For the current state we need to remember more than just the idx.
+* When si_m_endpos.lnum is 0, the items other than si_idx are unknown.
+* (The end positions have the column number of the next char)
+*/
+typedef struct state_item
+{
+int		si_idx;			/* index of syntax pattern */
+int		si_id;			/* highlight group ID for keywords */
+int		si_trans_id;		/* idem, transparancy removed */
+int		si_m_lnum;		/* lnum of the match */
+int		si_m_startcol;		/* starting column of the match */
+lpos_T	si_m_endpos;		/* just after end posn of the match */
+lpos_T	si_h_startpos;		/* start position of the highlighting */
+lpos_T	si_h_endpos;		/* end position of the highlighting */
+lpos_T	si_eoe_pos;		/* end position of end pattern */
+int		si_end_idx;		/* group ID for end pattern or zero */
+int		si_ends;		/* if match ends before si_m_endpos */
+int		si_attr;		/* attributes in this state */
+long	si_flags;		/* HL_HAS_EOL flag in this state, and
+					 * HL_SKIP* for si_next_list */
+short	*si_cont_list;		/* list of contained groups */
+short	*si_next_list;		/* nextgroup IDs after this item ends */
+reg_extmatch_T *si_extmatch;	/* \z(...\) matches from start
+					 * pattern */
+} stateitem_T;
+#define KEYWORD_IDX	-1	    /* value of si_idx for keywords */
+#define ID_LIST_ALL	(short *)-1 /* valid of si_cont_list for containing all
+				       but contained groups */
+/*
+* The next possible match in the current line for any pattern is remembered,
+* to avoid having to try for a match in each column.
+* If next_match_idx == -1, not tried (in this line) yet.
+* If next_match_col == MAXCOL, no match found in this line.
+* (All end positions have the column of the char after the end)
+*/
+static int next_match_col;		/* column for start of next match */
+static lpos_T next_match_m_endpos;	/* position for end of next match */
+static lpos_T next_match_h_startpos;  /* pos. for highl. start of next match */
+static lpos_T next_match_h_endpos;	/* pos. for highl. end of next match */
+static int next_match_idx;		/* index of matched item */
+static long next_match_flags;		/* flags for next match */
+static lpos_T next_match_eos_pos;	/* end of start pattn (start region) */
+static lpos_T next_match_eoe_pos;	/* pos. for end of end pattern */
+static int next_match_end_idx;		/* ID of group for end pattn or zero */
+static reg_extmatch_T *next_match_extmatch = NULL;
+/*
+* A state stack is an array of integers or stateitem_T, stored in a
+* garray_T.  A state stack is invalid if it's itemsize entry is zero.
+*/
+#define INVALID_STATE(ssp)  ((ssp)->ga_itemsize == 0)
+#define VALID_STATE(ssp)    ((ssp)->ga_itemsize != 0)
+/*
+* The current state (within the line) of the recognition engine.
+* When current_state.ga_itemsize is 0 the current state is invalid.
+*/
+static win_T	*syn_win;		/* current window for highlighting */
+static buf_T	*syn_buf;		/* current buffer for highlighting */
+static linenr_T current_lnum = 0;	/* lnum of current state */
+static colnr_T	current_col = 0;	/* column of current state */
+static int	current_state_stored = 0; /* TRUE if stored current state
+					   * after setting current_finished */
+static int	current_finished = 0;	/* current line has been finished */
+static garray_T current_state		/* current stack of state_items */
+		= {0, 0, 0, 0, NULL};
+static short	*current_next_list = NULL; /* when non-zero, nextgroup list */
+static int	current_next_flags = 0; /* flags for current_next_list */
+static int	current_line_id = 0;	/* unique number for current line */
+#define CUR_STATE(idx)	((stateitem_T *)(current_state.ga_data))[idx]
+static void syn_sync __ARGS((win_T *wp, linenr_T lnum, synstate_T *last_valid));
+static int syn_match_linecont __ARGS((linenr_T lnum));
+static void syn_start_line __ARGS((void));
+static void syn_update_ends __ARGS((int startofline));
+static void syn_stack_alloc __ARGS((void));
+static int syn_stack_cleanup __ARGS((void));
+static void syn_stack_free_entry __ARGS((buf_T *buf, synstate_T *p));
+static synstate_T *syn_stack_find_entry __ARGS((linenr_T lnum));
+static synstate_T *store_current_state __ARGS((synstate_T *sp));
+static void load_current_state __ARGS((synstate_T *from));
+static void invalidate_current_state __ARGS((void));
+static int syn_stack_equal __ARGS((synstate_T *sp));
+static void validate_current_state __ARGS((void));
+static int syn_finish_line __ARGS((int syncing));
+static int syn_current_attr __ARGS((int syncing, int displaying));
+static int did_match_already __ARGS((int idx, garray_T *gap));
+static stateitem_T *push_next_match __ARGS((stateitem_T *cur_si));
+static void check_state_ends __ARGS((void));
+static void update_si_attr __ARGS((int idx));
+static void check_keepend __ARGS((void));
+static void update_si_end __ARGS((stateitem_T *sip, int startcol, int force));
+static short *copy_id_list __ARGS((short *list));
+static int in_id_list __ARGS((stateitem_T *item, short *cont_list, struct sp_syn *ssp, int contained));
+static int push_current_state __ARGS((int idx));
+static void pop_current_state __ARGS((void));
+static void find_endpos __ARGS((int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_endpos, long *flagsp, lpos_T *end_endpos, int *end_idx, reg_extmatch_T *start_ext));
+static void clear_syn_state __ARGS((synstate_T *p));
+static void clear_current_state __ARGS((void));
+static void limit_pos __ARGS((lpos_T *pos, lpos_T *limit));
+static void limit_pos_zero __ARGS((lpos_T *pos, lpos_T *limit));
+static void syn_add_end_off __ARGS((lpos_T *result, regmmatch_T *regmatch, synpat_T *spp, int idx, int extra));
+static void syn_add_start_off __ARGS((lpos_T *result, regmmatch_T *regmatch, synpat_T *spp, int idx, int extra));
+static char_u *syn_getcurline __ARGS((void));
+static int syn_regexec __ARGS((regmmatch_T *rmp, linenr_T lnum, colnr_T col));
+static int check_keyword_id __ARGS((char_u *line, int startcol, int *endcol, long *flags, short **next_list, stateitem_T *cur_si));
+static void syn_cmd_case __ARGS((exarg_T *eap, int syncing));
+static void syntax_sync_clear __ARGS((void));
+static void syn_remove_pattern __ARGS((buf_T *buf, int idx));
+static void syn_clear_pattern __ARGS((buf_T *buf, int i));
+static void syn_clear_cluster __ARGS((buf_T *buf, int i));
+static void syn_cmd_clear __ARGS((exarg_T *eap, int syncing));
+static void syn_clear_one __ARGS((int id, int syncing));
+static void syn_cmd_on __ARGS((exarg_T *eap, int syncing));
+static void syn_cmd_enable __ARGS((exarg_T *eap, int syncing));
+static void syn_cmd_reset __ARGS((exarg_T *eap, int syncing));
+static void syn_cmd_manual __ARGS((exarg_T *eap, int syncing));
+static void syn_cmd_off __ARGS((exarg_T *eap, int syncing));
+static void syn_cmd_onoff __ARGS((exarg_T *eap, char *name));
+static void syn_cmd_list __ARGS((exarg_T *eap, int syncing));
+static void syn_lines_msg __ARGS((void));
+static void syn_match_msg __ARGS((void));
+static void syn_list_one __ARGS((int id, int syncing, int link_only));
+static void syn_list_cluster __ARGS((int id));
+static void put_id_list __ARGS((char_u *name, short *list, int attr));
+static void put_pattern __ARGS((char *s, int c, synpat_T *spp, int attr));
+static int syn_list_keywords __ARGS((int id, keyentry_T **ktabp, int did_header, int attr));
+static void syn_clear_keyword __ARGS((int id, keyentry_T **ktabp));
+static void free_keywtab __ARGS((keyentry_T **ktabp));
+static void add_keyword __ARGS((char_u *name, int id, int flags, short *cont_in_list, short *next_list));
+static int syn_khash __ARGS((char_u *p));
+static char_u *get_group_name __ARGS((char_u *arg, char_u **name_end));
+static char_u *get_syn_options __ARGS((char_u *arg, int *flagsp, int keyword, int *sync_idx, short **cont_list, short **cont_in_list, short **next_list));
+static void syn_cmd_include __ARGS((exarg_T *eap, int syncing));
+static void syn_cmd_keyword __ARGS((exarg_T *eap, int syncing));
+static void syn_cmd_match __ARGS((exarg_T *eap, int syncing));
+static void syn_cmd_region __ARGS((exarg_T *eap, int syncing));
+#ifdef __BORLANDC__
+static int _RTLENTRYF syn_compare_stub __ARGS((const void *v1, const void *v2));
+#else
+static int syn_compare_stub __ARGS((const void *v1, const void *v2));
+#endif
+static void syn_cmd_cluster __ARGS((exarg_T *eap, int syncing));
+static int syn_scl_name2id __ARGS((char_u *name));
+static int syn_scl_namen2id __ARGS((char_u *linep, int len));
+static int syn_check_cluster __ARGS((char_u *pp, int len));
+static int syn_add_cluster __ARGS((char_u *name));
+static void init_syn_patterns __ARGS((void));
+static char_u *get_syn_pattern __ARGS((char_u *arg, synpat_T *ci));
+static void syn_cmd_sync __ARGS((exarg_T *eap, int syncing));
+static int get_id_list __ARGS((char_u **arg, int keylen, short **list));
+static void syn_combine_list __ARGS((short **clstr1, short **clstr2, int list_op));
+static void syn_incl_toplevel __ARGS((int id, int *flagsp));
+/*
+* Start the syntax recognition for a line.  This function is normally called
+* from the screen updating, once for each displayed line.
+* The buffer is remembered in syn_buf, because get_syntax_attr() doesn't get
+* it.	Careful: curbuf and curwin are likely to point to another buffer and
+* window.
+*/
+void
+syntax_start(wp, lnum)
+win_T	*wp;
+linenr_T	lnum;
+{
+synstate_T	*p;
+synstate_T	*last_valid = NULL;
+synstate_T	*last_min_valid = NULL;
+synstate_T	*sp, *prev;
+linenr_T	parsed_lnum;
+linenr_T	first_stored;
+int		dist;
+reg_syn = TRUE;	/* let vim_regexec() know we're using syntax */
+/*
+* After switching buffers, invalidate current_state.
+*/
+if (syn_buf != wp->w_buffer)
+{
+	invalidate_current_state();
+	syn_buf = wp->w_buffer;
+}
+syn_win = wp;
+/*
+* Allocate syntax stack when needed.
+*/
+syn_stack_alloc();
+if (syn_buf->b_sst_array == NULL)
+	goto theend;		/* out of memory */
+syn_buf->b_sst_lasttick = display_tick;
+/*
+* If the state of the end of the previous line is useful, store it.
+*/
+if (VALID_STATE(&current_state)
+	    && current_lnum < lnum
+	    && current_lnum < syn_buf->b_ml.ml_line_count)
+{
+	(void)syn_finish_line(FALSE);
+	if (!current_state_stored)
+	{
+	    ++current_lnum;
+	    (void)store_current_state(NULL);
+	}
+	/*
+	 * If the current_lnum is now the same as "lnum", keep the current
+	 * state (this happens very often!).  Otherwise invalidate
+	 * current_state and figure it out below.
+	 */
+	if (current_lnum != lnum)
+	    invalidate_current_state();
+}
+else
+	invalidate_current_state();
+/*
+* Try to synchronize from a saved state in b_sst_array[].
+* Only do this if lnum is not before and not to far beyond a saved state.
+*/
+if (INVALID_STATE(&current_state) && syn_buf->b_sst_array != NULL)
+{
+	/* Find last valid saved state before start_lnum. */
+	for (p = syn_buf->b_sst_first; p != NULL; p = p->sst_next)
+	{
+	    if (p->sst_lnum > lnum)
+		break;
+	    if (p->sst_lnum <= lnum && p->sst_change_lnum == 0)
+	    {
+		last_valid = p;
+		if (p->sst_lnum >= lnum - syn_buf->b_syn_sync_minlines)
+		    last_min_valid = p;
+	    }
+	}
+	if (last_min_valid != NULL)
+	    load_current_state(last_min_valid);
+}
+/*
+* If "lnum" is before or far beyond a line with a saved state, need to
+* re-synchronize.
+*/
+if (INVALID_STATE(&current_state))
+{
+	syn_sync(wp, lnum, last_valid);
+	first_stored = current_lnum + syn_buf->b_syn_sync_minlines;
+}
+else
+	first_stored = current_lnum;
+/*
+* Advance from the sync point or saved state until the current line.
+* Save some entries for syncing with later on.
+*/
+dist = syn_buf->b_ml.ml_line_count / (syn_buf->b_sst_len - Rows) + 1;
+prev = syn_stack_find_entry(current_lnum);
+while (current_lnum < lnum)
+{
+	syn_start_line();
+	(void)syn_finish_line(FALSE);
+	++current_lnum;
+	/* If we parsed at least "minlines" lines or started at a valid
+	 * state, the current state is considered valid. */
+	if (current_lnum >= first_stored)
+	{
+	    /* Check if the saved state entry is for the current line and is
+	     * equal to the current state.  If so, then validate all saved
+	     * states that depended on a change before the parsed line. */
+	    if (prev == NULL)
+		sp = syn_buf->b_sst_first;
+	    else
+		sp = prev->sst_next;
+	    if (sp != NULL
+		    && sp->sst_lnum == current_lnum
+		    && syn_stack_equal(sp))
+	    {
+		parsed_lnum = current_lnum;
+		prev = sp;
+		while (sp != NULL && sp->sst_change_lnum <= parsed_lnum)
+		{
+		    if (sp->sst_lnum <= lnum)
+			/* valid state before desired line, use this one */
+			prev = sp;
+		    else if (sp->sst_change_lnum == 0)
+			/* past saved states depending on change, break here. */
+			break;
+		    sp->sst_change_lnum = 0;
+		    sp = sp->sst_next;
+		}
+		load_current_state(prev);
+	    }
+	    /* Store the state at this line when it's the first one, the line
+	     * where we start parsing, or some distance from the previously
+	     * saved state.  But only when parsed at least 'minlines'. */
+	    else if (prev == NULL
+			|| current_lnum == lnum
+			|| current_lnum >= prev->sst_lnum + dist)
+		prev = store_current_state(prev);
+	}
+	/* This can take a long time: break when CTRL-C pressed.  The current
+	 * state will be wrong then. */
+	line_breakcheck();
+	if (got_int)
+	{
+	    current_lnum = lnum;
+	    break;
+	}
+}
+syn_start_line();
+theend:
+reg_syn = FALSE;
+}
+/*
+* We cannot simply discard growarrays full of state_items or buf_states; we
+* have to manually release their extmatch pointers first.
+*/
+static void
+clear_syn_state(p)
+synstate_T *p;
+{
+int		i;
+garray_T	*gap;
+if (p->sst_stacksize > SST_FIX_STATES)
+{
+	gap = &(p->sst_union.sst_ga);
+	for (i = 0; i < gap->ga_len; i++)
+	    unref_extmatch(SYN_STATE_P(gap)[i].bs_extmatch);
+	ga_clear(gap);
+}
+else
+{
+	for (i = 0; i < p->sst_stacksize; i++)
+	    unref_extmatch(p->sst_union.sst_stack[i].bs_extmatch);
+}
+}
+/*
+* Cleanup the current_state stack.
+*/
+static void
+clear_current_state()
+{
+int		i;
+stateitem_T	*sip;
+sip = (stateitem_T *)(current_state.ga_data);
+for (i = 0; i < current_state.ga_len; i++)
+	unref_extmatch(sip[i].si_extmatch);
+ga_clear(&current_state);
+}
+/*
+* Try to find a synchronisation point for line "lnum".
+*
+* This sets current_lnum and the current state.  One of three methods is
+* used:
+* 1. Search backwards for the end of a C-comment.
+* 2. Search backwards for given sync patterns.
+* 3. Simply start on a given number of lines above "lnum".
+*/
+static void
+syn_sync(wp, start_lnum, last_valid)
+win_T	*wp;
+linenr_T	start_lnum;
+synstate_T	*last_valid;
+{
+buf_T	*curbuf_save;
+win_T	*curwin_save;
+pos_T	cursor_save;
+int		idx;
+linenr_T	lnum;
+linenr_T	end_lnum;
+linenr_T	break_lnum;
+int		had_sync_point;
+stateitem_T	*cur_si;
+synpat_T	*spp;
+char_u	*line;
+int		found_flags = 0;
+int		found_match_idx = 0;
+linenr_T	found_current_lnum = 0;
+int		found_current_col= 0;
+lpos_T	found_m_endpos;
+/*
+* Clear any current state that might be hanging around.
+*/
+invalidate_current_state();
+/*
+* Start at least "minlines" back.  Default starting point for parsing is
+* there.
+* Start further back, to avoid that scrolling backwards will result in
+* resyncing for every line.  Now it resyncs only one out of N lines,
+* where N is minlines * 1.5, or minlines * 2 if minlines is small.
+* Watch out for overflow when minlines is MAXLNUM.
+*/
+if (syn_buf->b_syn_sync_minlines > start_lnum)
+	start_lnum = 1;
+else
+{
+	if (syn_buf->b_syn_sync_minlines == 1)
+	    lnum = 1;
+	else if (syn_buf->b_syn_sync_minlines < 10)
+	    lnum = syn_buf->b_syn_sync_minlines * 2;
+	else
+	    lnum = syn_buf->b_syn_sync_minlines * 3 / 2;
+	if (syn_buf->b_syn_sync_maxlines != 0
+				       && lnum > syn_buf->b_syn_sync_maxlines)
+	    lnum = syn_buf->b_syn_sync_maxlines;
+	if (lnum >= start_lnum)
+	    start_lnum = 1;
+	else
+	    start_lnum -= lnum;
+}
+current_lnum = start_lnum;
+/*
+* 1. Search backwards for the end of a C-style comment.
+*/
+if (syn_buf->b_syn_sync_flags & SF_CCOMMENT)
+{
+	/* Need to make syn_buf the current buffer for a moment, to be able to
+	 * use find_start_comment(). */
+	curwin_save = curwin;
+	curwin = wp;
+	curbuf_save = curbuf;
+	curbuf = syn_buf;
+	/*
+	 * Skip lines that end in a backslash.
+	 */
+	for ( ; start_lnum > 1; --start_lnum)
+	{
+	    line = ml_get(start_lnum - 1);
+	    if (*line == NUL || *(line + STRLEN(line) - 1) != '\\')
+		break;
+	}
+	current_lnum = start_lnum;
+	/* set cursor to start of search */
+	cursor_save = wp->w_cursor;
+	wp->w_cursor.lnum = start_lnum;
+	wp->w_cursor.col = 0;
+	/*
+	 * If the line is inside a comment, need to find the syntax item that
+	 * defines the comment.
+	 * Restrict the search for the end of a comment to b_syn_sync_maxlines.
+	 */
+	if (find_start_comment((int)syn_buf->b_syn_sync_maxlines) != NULL)
+	{
+	    for (idx = syn_buf->b_syn_patterns.ga_len; --idx >= 0; )
+		if (SYN_ITEMS(syn_buf)[idx].sp_syn.id == syn_buf->b_syn_sync_id
+			&& SYN_ITEMS(syn_buf)[idx].sp_type == SPTYPE_START)
+		{
+		    validate_current_state();
+		    if (push_current_state(idx) == OK)
+			update_si_attr(current_state.ga_len - 1);
+		    break;
+		}
+	}
+	/* restore cursor and buffer */
+	wp->w_cursor = cursor_save;
+	curwin = curwin_save;
+	curbuf = curbuf_save;
+}
+/*
+* 2. Search backwards for given sync patterns.
+*/
+else if (syn_buf->b_syn_sync_flags & SF_MATCH)
+{
+	if (syn_buf->b_syn_sync_maxlines != 0
+				 && start_lnum > syn_buf->b_syn_sync_maxlines)
+	    break_lnum = start_lnum - syn_buf->b_syn_sync_maxlines;
+	else
+	    break_lnum = 0;
+	end_lnum = start_lnum;
+	lnum = start_lnum;
+	while (--lnum > break_lnum)
+	{
+	    /* This can take a long time: break when CTRL-C pressed. */
+	    line_breakcheck();
+	    if (got_int)
+	    {
+		invalidate_current_state();
+		current_lnum = start_lnum;
+		break;
+	    }
+	    /* Check if we have run into a valid saved state stack now. */
+	    if (last_valid != NULL && lnum == last_valid->sst_lnum)
+	    {
+		load_current_state(last_valid);
+		break;
+	    }
+	    /*
+	     * Check if the previous line has the line-continuation pattern.
+	     */
+	    if (lnum > 1 && syn_match_linecont(lnum - 1))
+		continue;
+	    /*
+	     * Start with nothing on the state stack
+	     */
+	    validate_current_state();
+	    for (current_lnum = lnum; current_lnum < end_lnum; ++current_lnum)
+	    {
+		syn_start_line();
+		for (;;)
+		{
+		    had_sync_point = syn_finish_line(TRUE);
+		    /*
+		     * When a sync point has been found, remember where, and
+		     * continue to look for another one, further on in the line.
+		     */
+		    if (had_sync_point && current_state.ga_len)
+		    {
+			cur_si = &CUR_STATE(current_state.ga_len - 1);
+			if (cur_si->si_m_endpos.lnum > start_lnum)
+			{
+			    /* ignore match that goes to after where started */
+			    current_lnum = end_lnum;
+			    break;
+			}
+			spp = &(SYN_ITEMS(syn_buf)[cur_si->si_idx]);
+			found_flags = spp->sp_flags;
+			found_match_idx = spp->sp_sync_idx;
+			found_current_lnum = current_lnum;
+			found_current_col = current_col;
+			found_m_endpos = cur_si->si_m_endpos;
+			/*
+			 * Continue after the match (be aware of a zero-length
+			 * match).
+			 */
+			if (found_m_endpos.lnum > current_lnum)
+			{
+			    current_lnum = found_m_endpos.lnum;
+			    current_col = found_m_endpos.col;
+			    if (current_lnum >= end_lnum)
+				break;
+			}
+			else if (found_m_endpos.col > current_col)
+			    current_col = found_m_endpos.col;
+			else
+			    ++current_col;
+			/* syn_current_attr() will have skipped the check for
+			 * an item that ends here, need to do that now. */
+			++current_col;
+			check_state_ends();
+			--current_col;
+		    }
+		    else
+			break;
+		}
+	    }
+	    /*
+	     * If a sync point was encountered, break here.
+	     */
+	    if (found_flags)
+	    {
+		/*
+		 * Put the item that was specified by the sync point on the
+		 * state stack.  If there was no item specified, make the
+		 * state stack empty.
+		 */
+		clear_current_state();
+		if (found_match_idx >= 0
+			&& push_current_state(found_match_idx) == OK)
+		    update_si_attr(current_state.ga_len - 1);
+		/*
+		 * When using "grouphere", continue from the sync point
+		 * match, until the end of the line.  Parsing starts at
+		 * the next line.
+		 * For "groupthere" the parsing starts at start_lnum.
+		 */
+		if (found_flags & HL_SYNC_HERE)
+		{
+		    if (current_state.ga_len)
+		    {
+			cur_si = &CUR_STATE(current_state.ga_len - 1);
+			cur_si->si_h_startpos.lnum = found_current_lnum;
+			cur_si->si_h_startpos.col = found_current_col;
+			update_si_end(cur_si, (int)current_col, TRUE);
+			check_keepend();
+		    }
+		    current_col = found_m_endpos.col;
+		    current_lnum = found_m_endpos.lnum;
+		    (void)syn_finish_line(FALSE);
+		    ++current_lnum;
+		}
+		else
+		    current_lnum = start_lnum;
+		break;
+	    }
+	    end_lnum = lnum;
+	    invalidate_current_state();
+	}
+	/* Ran into start of the file or exceeded maximum number of lines */
+	if (lnum <= break_lnum)
+	{
+	    invalidate_current_state();
+	    current_lnum = break_lnum + 1;
+	}
+}
+validate_current_state();
+}
+/*
+* Return TRUE if the line-continuation pattern matches in line "lnum".
+*/
+static int
+syn_match_linecont(lnum)
+linenr_T	lnum;
+{
+regmmatch_T regmatch;
+if (syn_buf->b_syn_linecont_prog != NULL)
+{
+	regmatch.rmm_ic = syn_buf->b_syn_linecont_ic;
+	regmatch.regprog = syn_buf->b_syn_linecont_prog;
+	return syn_regexec(&regmatch, lnum, (colnr_T)0);
+}
+return FALSE;
+}
+/*
+* Prepare the current state for the start of a line.
+*/
+static void
+syn_start_line()
+{
+current_finished = FALSE;
+current_col = 0;
+/*
+* Need to update the end of a start/skip/end that continues from the
+* previous line and regions that have "keepend".
+*/
+if (current_state.ga_len > 0)
+	syn_update_ends(TRUE);
+next_match_idx = -1;
+++current_line_id;
+}
+/*
+* Check for items in the stack that need their end updated.
+* When "startofline" is TRUE the last item is always updated.
+* When "startofline" is FALSE the item with "keepend" is forcefully updated.
+*/
+static void
+syn_update_ends(startofline)
+int		startofline;
+{
+stateitem_T	*cur_si;
+int		i;
+if (startofline)
+{
+	/* Check for a match carried over from a previous line with a
+	 * contained region.  The match ends as soon as the region ends. */
+	for (i = 0; i < current_state.ga_len; ++i)
+	{
+	    cur_si = &CUR_STATE(i);
+	    if (cur_si->si_idx >= 0
+		    && (SYN_ITEMS(syn_buf)[cur_si->si_idx]).sp_type
+							       == SPTYPE_MATCH
+		    && cur_si->si_m_endpos.lnum < current_lnum)
+	    {
+		cur_si->si_flags |= HL_MATCHCONT;
+		cur_si->si_m_endpos.lnum = 0;
+		cur_si->si_m_endpos.col = 0;
+		cur_si->si_h_endpos = cur_si->si_m_endpos;
+		cur_si->si_ends = TRUE;
+	    }
+	}
+}
+/*
+* Need to update the end of a start/skip/end that continues from the
+* previous line.  And regions that have "keepend", because they may
+* influence contained items.
+* Then check for items ending in column 0.
+*/
+i = current_state.ga_len - 1;
+if (keepend_level >= 0)
+	for ( ; i > keepend_level; --i)
+	    if (CUR_STATE(i).si_flags & HL_EXTEND)
+		break;
+for ( ; i < current_state.ga_len; ++i)
+{
+	cur_si = &CUR_STATE(i);
+	if ((cur_si->si_flags & HL_KEEPEND)
+			    || (i == current_state.ga_len - 1 && startofline))
+	{
+	    cur_si->si_h_startpos.col = 0;	/* start highl. in col 0 */
+	    cur_si->si_h_startpos.lnum = current_lnum;
+	    if (!(cur_si->si_flags & HL_MATCHCONT))
+		update_si_end(cur_si, (int)current_col, !startofline);
+	}
+}
+check_keepend();
+check_state_ends();
+}
+/****************************************
+* Handling of the state stack cache.
+*/
+/*
+* EXPLANATION OF THE SYNTAX STATE STACK CACHE
+*
+* To speed up syntax highlighting, the state stack for the start of some
+* lines is cached.  These entries can be used to start parsing at that point.
+*
+* The stack is kept in b_sst_array[] for each buffer.  There is a list of
+* valid entries.  b_sst_first points to the first one, then follow sst_next.
+* The entries are sorted on line number.  The first entry is often for line 2
+* (line 1 always starts with an empty stack).
+* There is also a list for free entries.  This construction is used to avoid
+* having to allocate and free memory blocks too often.
+*
+* When making changes to the buffer, this is logged in b_mod_*.  When calling
+* update_screen() to update the display, it will call
+* syn_stack_apply_changes() for each displayed buffer to adjust the cached
+* entries.  The entries which are inside the changed area are removed,
+* because they must be recomputed.  Entries below the changed have their line
+* number adjusted for deleted/inserted lines, and have their sst_change_lnum
+* set to indicate that a check must be made if the changed lines would change
+* the cached entry.
+*
+* When later displaying lines, an entry is stored for each line.  Displayed
+* lines are likely to be displayed again, in which case the state at the
+* start of the line is needed.
+* For not displayed lines, an entry is stored for every so many lines.  These
+* entries will be used e.g., when scrolling backwards.  The distance between
+* entries depends on the number of lines in the buffer.  For small buffers
+* the distance is fixed at SST_DIST, for large buffers there is a fixed
+* number of entries SST_MAX_ENTRIES, and the distance is computed.
+*/
+/*
+* Free b_sst_array[] for buffer "buf".
+* Used when syntax items changed to force resyncing everywhere.
+*/
+void
+syn_stack_free_all(buf)
+buf_T	*buf;
+{
+synstate_T	*p;
+win_T	*wp;
+if (buf->b_sst_array != NULL)
+{
+	for (p = buf->b_sst_first; p != NULL; p = p->sst_next)
+	    clear_syn_state(p);
+	vim_free(buf->b_sst_array);
+	buf->b_sst_array = NULL;
+	buf->b_sst_len = 0;
+}
+#ifdef FEAT_FOLDING
+/* When using "syntax" fold method, must update all folds. */
+FOR_ALL_WINDOWS(wp)
+{
+	if (wp->w_buffer == buf && foldmethodIsSyntax(wp))
+	    foldUpdateAll(wp);
+}
+#endif
+}
+/*
+* Allocate the syntax state stack for syn_buf when needed.
+* If the number of entries in b_sst_array[] is much too big or a bit too
+* small, reallocate it.
+* Also used to allocate b_sst_array[] for the first time.
+*/
+static void
+syn_stack_alloc()
+{
+long	len;
+synstate_T	*to, *from;
+synstate_T	*sstp;
+len = syn_buf->b_ml.ml_line_count / SST_DIST + Rows * 2;
+if (len < SST_MIN_ENTRIES)
+	len = SST_MIN_ENTRIES;
+else if (len > SST_MAX_ENTRIES)
+	len = SST_MAX_ENTRIES;
+if (syn_buf->b_sst_len > len * 2 || syn_buf->b_sst_len < len)
+{
+	/* Allocate 50% too much, to avoid reallocating too often. */
+	len = syn_buf->b_ml.ml_line_count;
+	len = (len + len / 2) / SST_DIST + Rows * 2;
+	if (len < SST_MIN_ENTRIES)
+	    len = SST_MIN_ENTRIES;
+	else if (len > SST_MAX_ENTRIES)
+	    len = SST_MAX_ENTRIES;
+	if (syn_buf->b_sst_array != NULL)
+	{
+	    /* When shrinking the array, cleanup the existing stack.
+	     * Make sure that all valid entries fit in the new array. */
+	    while (syn_buf->b_sst_len - syn_buf->b_sst_freecount + 2 > len
+		    && syn_stack_cleanup())
+		;
+	    if (len < syn_buf->b_sst_len - syn_buf->b_sst_freecount + 2)
+		len = syn_buf->b_sst_len - syn_buf->b_sst_freecount + 2;
+	}
+	sstp = (synstate_T *)alloc_clear((unsigned)(len * sizeof(synstate_T)));
+	if (sstp == NULL)	/* out of memory! */
+	    return;
+	to = sstp - 1;
+	if (syn_buf->b_sst_array != NULL)
+	{
+	    /* Move the states from the old array to the new one. */
+	    for (from = syn_buf->b_sst_first; from != NULL;
+							from = from->sst_next)
+	    {
+		++to;
+		*to = *from;
+		to->sst_next = to + 1;
+	    }
+	}
+	if (to != sstp - 1)
+	{
+	    to->sst_next = NULL;
+	    syn_buf->b_sst_first = sstp;
+	    syn_buf->b_sst_freecount = len - (int)(to - sstp) - 1;
+	}
+	else
+	{
+	    syn_buf->b_sst_first = NULL;
+	    syn_buf->b_sst_freecount = len;
+	}
+	/* Create the list of free entries. */
+	syn_buf->b_sst_firstfree = to + 1;
+	while (++to < sstp + len)
+	    to->sst_next = to + 1;
+	(sstp + len - 1)->sst_next = NULL;
+	vim_free(syn_buf->b_sst_array);
+	syn_buf->b_sst_array = sstp;
+	syn_buf->b_sst_len = len;
+}
+}
+/*
+* Check for changes in a buffer to affect stored syntax states.  Uses the
+* b_mod_* fields.
+* Called from update_screen(), before screen is being updated, once for each
+* displayed buffer.
+*/
+void
+syn_stack_apply_changes(buf)
+buf_T	*buf;
+{
+synstate_T	*p, *prev, *np;
+linenr_T	n;
+if (buf->b_sst_array == NULL)	/* nothing to do */
+	return;
+prev = NULL;
+for (p = buf->b_sst_first; p != NULL; )
+{
+	if (p->sst_lnum + syn_buf->b_syn_sync_linebreaks > buf->b_mod_top)
+	{
+	    n = p->sst_lnum + buf->b_mod_xlines;
+	    if (n <= buf->b_mod_bot)
+	    {
+		/* this state is inside the changed area, remove it */
+		np = p->sst_next;
+		if (prev == NULL)
+		    buf->b_sst_first = np;
+		else
+		    prev->sst_next = np;
+		syn_stack_free_entry(buf, p);
+		p = np;
+		continue;
+	    }
+	    /* This state is below the changed area.  Remember the line
+	     * that needs to be parsed before this entry can be made valid
+	     * again. */
+	    if (p->sst_change_lnum != 0 && p->sst_change_lnum > buf->b_mod_top)
+	    {
+		if (p->sst_change_lnum + buf->b_mod_xlines > buf->b_mod_top)
+		    p->sst_change_lnum += buf->b_mod_xlines;
+		else
+		    p->sst_change_lnum = buf->b_mod_top;
+	    }
+	    if (p->sst_change_lnum == 0
+		    || p->sst_change_lnum < buf->b_mod_bot)
+		p->sst_change_lnum = buf->b_mod_bot;
+	    p->sst_lnum = n;
+	}
+	prev = p;
+	p = p->sst_next;
+}
+}
+/*
+* Reduce the number of entries in the state stack for syn_buf.
+* Returns TRUE if at least one entry was freed.
+*/
+static int
+syn_stack_cleanup()
+{
+synstate_T	*p, *prev;
+disptick_T	tick;
+int		above;
+int		dist;
+int		retval = FALSE;
+if (syn_buf->b_sst_array == NULL || syn_buf->b_sst_first == NULL)
+	return retval;
+/* Compute normal distance between non-displayed entries. */
+dist = syn_buf->b_ml.ml_line_count / (syn_buf->b_sst_len - Rows) + 1;
+/*
+* Go throught the list to find the "tick" for the oldest entry that can
+* be removed.  Set "above" when the "tick" for the oldest entry is above
+* "b_sst_lasttick" (the display tick wraps around).
+*/
+tick = syn_buf->b_sst_lasttick;
+above = FALSE;
+prev = syn_buf->b_sst_first;
+for (p = prev->sst_next; p != NULL; prev = p, p = p->sst_next)
+{
+	if (prev->sst_lnum + dist > p->sst_lnum)
+	{
+	    if (p->sst_tick > syn_buf->b_sst_lasttick)
+	    {
+		if (!above || p->sst_tick < tick)
+		    tick = p->sst_tick;
+		above = TRUE;
+	    }
+	    else if (!above && p->sst_tick < tick)
+		tick = p->sst_tick;
+	}
+}
+/*
+* Go through the list to make the entries for the oldest tick at an
+* interval of several lines.
+*/
+prev = syn_buf->b_sst_first;
+for (p = prev->sst_next; p != NULL; prev = p, p = p->sst_next)
+{
+	if (p->sst_tick == tick && prev->sst_lnum + dist > p->sst_lnum)
+	{
+	    /* Move this entry from used list to free list */
+	    prev->sst_next = p->sst_next;
+	    syn_stack_free_entry(syn_buf, p);
+	    p = prev;
+	    retval = TRUE;
+	}
+}
+return retval;
+}
+/*
+* Free the allocated memory for a syn_state item.
+* Move the entry into the free list.
+*/
+static void
+syn_stack_free_entry(buf, p)
+buf_T	*buf;
+synstate_T	*p;
+{
+clear_syn_state(p);
+p->sst_next = buf->b_sst_firstfree;
+buf->b_sst_firstfree = p;
+++buf->b_sst_freecount;
+}
+/*
+* Find an entry in the list of state stacks at or before "lnum".
+* Returns NULL when there is no entry or the first entry is after "lnum".
+*/
+static synstate_T *
+syn_stack_find_entry(lnum)
+linenr_T	lnum;
+{
+synstate_T	*p, *prev;
+prev = NULL;
+for (p = syn_buf->b_sst_first; p != NULL; prev = p, p = p->sst_next)
+{
+	if (p->sst_lnum == lnum)
+	    return p;
+	if (p->sst_lnum > lnum)
+	    break;
+}
+return prev;
+}
+/*
+* Try saving the current state in b_sst_array[].
+* The current state must be valid for the start of the current_lnum line!
+*/
+static synstate_T *
+store_current_state(sp)
+synstate_T	*sp;	/* at or before where state is to be saved or
+				   NULL */
+{
+int		i;
+synstate_T	*p;
+bufstate_T	*bp;
+stateitem_T	*cur_si;
+if (sp == NULL)
+	sp = syn_stack_find_entry(current_lnum);
+/*
+* If the current state contains a start or end pattern that continues
+* from the previous line, we can't use it.  Don't store it then.
+*/
+for (i = current_state.ga_len - 1; i >= 0; --i)
+{
+	cur_si = &CUR_STATE(i);
+	if (cur_si->si_h_startpos.lnum >= current_lnum
+		|| cur_si->si_m_endpos.lnum >= current_lnum
+		|| cur_si->si_h_endpos.lnum >= current_lnum
+		|| (cur_si->si_end_idx
+		    && cur_si->si_eoe_pos.lnum >= current_lnum))
+	    break;
+}
+if (i >= 0)
+{
+	if (sp != NULL)
+	{
+	    /* find "sp" in the list and remove it */
+	    if (syn_buf->b_sst_first == sp)
+		/* it's the first entry */
+		syn_buf->b_sst_first = sp->sst_next;
+	    else
+	    {
+		/* find the entry just before this one to adjust sst_next */
+		for (p = syn_buf->b_sst_first; p != NULL; p = p->sst_next)
+		    if (p->sst_next == sp)
+			break;
+		p->sst_next = sp->sst_next;
+	    }
+	    syn_stack_free_entry(syn_buf, sp);
+	    sp = NULL;
+	}
+}
+else if (sp == NULL || sp->sst_lnum != current_lnum)
+{
+	/*
+	 * Add a new entry
+	 */
+	/* If no free items, cleanup the array first. */
+	if (syn_buf->b_sst_freecount == 0)
+	{
+	    (void)syn_stack_cleanup();
+	    /* "sp" may have been moved to the freelist now */
+	    sp = syn_stack_find_entry(current_lnum);
+	}
+	/* Still no free items?  Must be a strange problem... */
+	if (syn_buf->b_sst_freecount == 0)
+	    sp = NULL;
+	else
+	{
+	    /* Take the first item from the free list and put it in the used
+	     * list, after *sp */
+	    p = syn_buf->b_sst_firstfree;
+	    syn_buf->b_sst_firstfree = p->sst_next;
+	    --syn_buf->b_sst_freecount;
+	    if (sp == NULL)
+	    {
+		/* Insert in front of the list */
+		p->sst_next = syn_buf->b_sst_first;
+		syn_buf->b_sst_first = p;
+	    }
+	    else
+	    {
+		/* insert in list after *sp */
+		p->sst_next = sp->sst_next;
+		sp->sst_next = p;
+	    }
+	    sp = p;
+	    sp->sst_stacksize = 0;
+	    sp->sst_lnum = current_lnum;
+	}
+}
+if (sp != NULL)
+{
+	/* When overwriting an existing state stack, clear it first */
+	clear_syn_state(sp);
+	sp->sst_stacksize = current_state.ga_len;
+	if (current_state.ga_len > SST_FIX_STATES)
+	{
+	    /* Need to clear it, might be something remaining from when the
+	     * length was less than SST_FIX_STATES. */
+	    ga_init2(&sp->sst_union.sst_ga, (int)sizeof(bufstate_T), 1);
+	    if (ga_grow(&sp->sst_union.sst_ga, current_state.ga_len) == FAIL)
+		sp->sst_stacksize = 0;
+	    else
+	    {
+		sp->sst_union.sst_ga.ga_len = current_state.ga_len;
+		sp->sst_union.sst_ga.ga_room -= current_state.ga_len;
+	    }
+	    bp = SYN_STATE_P(&(sp->sst_union.sst_ga));
+	}
+	else
+	    bp = sp->sst_union.sst_stack;
+	for (i = 0; i < sp->sst_stacksize; ++i)
+	{
+	    bp[i].bs_idx = CUR_STATE(i).si_idx;
+	    bp[i].bs_flags = CUR_STATE(i).si_flags;
+	    bp[i].bs_extmatch = ref_extmatch(CUR_STATE(i).si_extmatch);
+	}
+	sp->sst_next_flags = current_next_flags;
+	sp->sst_next_list = current_next_list;
+	sp->sst_tick = display_tick;
+	sp->sst_change_lnum = 0;
+}
+current_state_stored = TRUE;
+return sp;
+}
+/*
+* Copy a state stack from "from" in b_sst_array[] to current_state;
+*/
+static void
+load_current_state(from)
+synstate_T	*from;
+{
+int		i;
+bufstate_T	*bp;
+clear_current_state();
+validate_current_state();
+keepend_level = -1;
+if (from->sst_stacksize
+	    && ga_grow(&current_state, from->sst_stacksize) != FAIL)
+{
+	if (from->sst_stacksize > SST_FIX_STATES)
+	    bp = SYN_STATE_P(&(from->sst_union.sst_ga));
+	else
+	    bp = from->sst_union.sst_stack;
+	for (i = 0; i < from->sst_stacksize; ++i)
+	{
+	    CUR_STATE(i).si_idx = bp[i].bs_idx;
+	    CUR_STATE(i).si_flags = bp[i].bs_flags;
+	    CUR_STATE(i).si_extmatch = ref_extmatch(bp[i].bs_extmatch);
+	    if (keepend_level < 0 && (CUR_STATE(i).si_flags & HL_KEEPEND))
+		keepend_level = i;
+	    CUR_STATE(i).si_ends = FALSE;
+	    CUR_STATE(i).si_m_lnum = 0;
+	    if (CUR_STATE(i).si_idx >= 0)
+		CUR_STATE(i).si_next_list =
+		       (SYN_ITEMS(syn_buf)[CUR_STATE(i).si_idx]).sp_next_list;
+	    else
+		CUR_STATE(i).si_next_list = NULL;
+	    update_si_attr(i);
+	}
+	current_state.ga_len = from->sst_stacksize;
+	current_state.ga_room -= current_state.ga_len;
+}
+current_next_list = from->sst_next_list;
+current_next_flags = from->sst_next_flags;
+current_lnum = from->sst_lnum;
+}
+/*
+* Compare saved state stack "*sp" with the current state.
+* Return TRUE when they are equal.
+*/
+static int
+syn_stack_equal(sp)
+synstate_T *sp;
+{
+int		i, j;
+bufstate_T	*bp;
+reg_extmatch_T	*six, *bsx;
+/* First a quick check if the stacks have the same size end nextlist. */
+if (sp->sst_stacksize == current_state.ga_len
+	    && sp->sst_next_list == current_next_list)
+{
+	/* Need to compare all states on both stacks. */
+	if (sp->sst_stacksize > SST_FIX_STATES)
+	    bp = SYN_STATE_P(&(sp->sst_union.sst_ga));
+	else
+	    bp = sp->sst_union.sst_stack;
+	for (i = current_state.ga_len; --i >= 0; )
+	{
+	    /* If the item has another index the state is different. */
+	    if (bp[i].bs_idx != CUR_STATE(i).si_idx)
+		break;
+	    if (bp[i].bs_extmatch != CUR_STATE(i).si_extmatch)
+	    {
+		/* When the extmatch pointers are different, the strings in
+		 * them can still be the same.  Check if the extmatch
+		 * references are equal. */
+		bsx = bp[i].bs_extmatch;
+		six = CUR_STATE(i).si_extmatch;
+		/* If one of the extmatch pointers is NULL the states are
+		 * different. */
+		if (bsx == NULL || six == NULL)
+		    break;
+		for (j = 0; j < NSUBEXP; ++j)
+		{
+		    /* Check each referenced match string. They must all be
+		     * equal. */
+		    if (bsx->matches[j] != six->matches[j])
+		    {
+			/* If the pointer is different it can still be the
+			 * same text.  Compare the strings, ignore case when
+			 * the start item has the sp_ic flag set. */
+			if (bsx->matches[j] == NULL
+				|| six->matches[j] == NULL)
+			    break;
+			if ((SYN_ITEMS(syn_buf)[CUR_STATE(i).si_idx]).sp_ic
+				? MB_STRICMP(bsx->matches[j],
+							 six->matches[j]) != 0
+				: STRCMP(bsx->matches[j], six->matches[j]) != 0)
+			    break;
+		    }
+		}
+		if (j != NSUBEXP)
+		    break;
+	    }
+	}
+	if (i < 0)
+	    return TRUE;
+}
+return FALSE;
+}
+/*
+* We stop parsing syntax above line "lnum".  If the stored state at or below
+* this line depended on a change before it, it now depends on the line below
+* the last parsed line.
+* The window looks like this:
+*	    line which changed
+*	    displayed line
+*	    displayed line
+* lnum ->  line below window
+*/
+void
+syntax_end_parsing(lnum)
+linenr_T	lnum;
+{
+synstate_T	*sp;
+sp = syn_stack_find_entry(lnum);
+if (sp != NULL && sp->sst_lnum < lnum)
+	sp = sp->sst_next;
+if (sp != NULL && sp->sst_change_lnum != 0)
+	sp->sst_change_lnum = lnum;
+}
+/*
+* End of handling of the state stack.
+****************************************/
+static void
+invalidate_current_state()
+{
+clear_current_state();
+current_state.ga_itemsize = 0;	/* mark current_state invalid */
+current_next_list = NULL;
+keepend_level = -1;
+}
+static void
+validate_current_state()
+{
+current_state.ga_itemsize = sizeof(stateitem_T);
+current_state.ga_growsize = 3;
+}
+/*
+* Return TRUE if the syntax at start of lnum changed since last time.
+* This will only be called just after get_syntax_attr() for the previous
+* line, to check if the next line needs to be redrawn too.
+*/
+int
+syntax_check_changed(lnum)
+linenr_T	lnum;
+{
+int		retval = TRUE;
+synstate_T	*sp;
+reg_syn = TRUE;	/* let vim_regexec() know we're using syntax */
+/*
+* Check the state stack when:
+* - lnum is just below the previously syntaxed line.
+* - lnum is not before the lines with saved states.
+* - lnum is not past the lines with saved states.
+* - lnum is at or before the last changed line.
+*/
+if (VALID_STATE(&current_state) && lnum == current_lnum + 1)
+{
+	sp = syn_stack_find_entry(lnum);
+	if (sp != NULL && sp->sst_lnum == lnum)
+	{
+	    /*
+	     * finish the previous line (needed when not all of the line was
+	     * drawn)
+	     */
+	    (void)syn_finish_line(FALSE);
+	    /*
+	     * Compare the current state with the previously saved state of
+	     * the line.
+	     */
+	    if (syn_stack_equal(sp))
+		retval = FALSE;
+	    /*
+	     * Store the current state in b_sst_array[] for later use.
+	     */
+	    ++current_lnum;
+	    (void)store_current_state(NULL);
+	}
+}
+reg_syn = FALSE;
+return retval;
+}
+/*
+* Finish the current line.
+* This doesn't return any attributes, it only gets the state at the end of
+* the line.  It can start anywhere in the line, as long as the current state
+* is valid.
+*/
+static int
+syn_finish_line(syncing)
+int	    syncing;		/* called for syncing */
+{
+stateitem_T	*cur_si;
+if (!current_finished)
+{
+	while (!current_finished)
+	{
+	    (void)syn_current_attr(syncing, FALSE);
+	    /*
+	     * When syncing, and found some item, need to check the item.
+	     */
+	    if (syncing && current_state.ga_len)
+	    {
+		/*
+		 * Check for match with sync item.
+		 */
+		cur_si = &CUR_STATE(current_state.ga_len - 1);
+		if (cur_si->si_idx >= 0
+			&& (SYN_ITEMS(syn_buf)[cur_si->si_idx].sp_flags
+					      & (HL_SYNC_HERE|HL_SYNC_THERE)))
+		    return TRUE;
+		/* syn_current_attr() will have skipped the check for an item
+		 * that ends here, need to do that now. */
+		++current_col;
+		check_state_ends();
+		--current_col;
+	    }
+	    ++current_col;
+	}
+}
+return FALSE;
+}
+/*
+* Return highlight attributes for next character.
+* Must first call syntax_start() once for the line.
+* "col" is normally 0 for the first use in a line, and increments by one each
+* time.  It's allowed to skip characters and to stop before the end of the
+* line.  But only a "col" after a previously used column is allowed.
+*/
+int
+get_syntax_attr(col)
+colnr_T	col;
+{
+int	    attr = 0;
+/* check for out of memory situation */
+if (syn_buf->b_sst_array == NULL)
+	return 0;
+reg_syn = TRUE;	/* let vim_regexec() know we're using syntax */
+/* Make sure current_state is valid */
+if (INVALID_STATE(&current_state))
+	validate_current_state();
+/*
+* Skip from the current column to "col", get the attributes for "col".
+*/
+while (current_col <= col)
+{
+	attr = syn_current_attr(FALSE, TRUE);
+	++current_col;
+}
+reg_syn = FALSE;
+return attr;
+}
+/*
+* Get syntax attributes for current_lnum, current_col.
+*/
+static int
+syn_current_attr(syncing, displaying)
+int		syncing;		/* When 1: called for syncing */
+int		displaying;		/* result will be displayed */
+{
+int		syn_id;
+lpos_T	endpos;		/* was: char_u *endp; */
+lpos_T	hl_startpos;	/* was: int hl_startcol; */
+lpos_T	hl_endpos;
+lpos_T	eos_pos;	/* end-of-start match (start region) */
+lpos_T	eoe_pos;	/* end-of-end pattern */
+int		end_idx;	/* group ID for end pattern */
+int		idx;
+synpat_T	*spp;
+stateitem_T	*cur_si, *sip;
+int		startcol;
+int		endcol;
+long	flags;
+short	*next_list;
+int		found_match;		    /* found usable match */
+static int	try_next_column = FALSE;    /* must try in next col */
+int		do_keywords;
+regmmatch_T	regmatch;
+lpos_T	pos;
+int		lc_col;
+reg_extmatch_T *cur_extmatch = NULL;
+char_u	*line;		/* current line.  NOTE: becomes invalid after
+				   looking for a pattern match! */
+/* variables for zero-width matches that have a "nextgroup" argument */
+int		keep_next_list;
+int		zero_width_next_list = FALSE;
+garray_T	zero_width_next_ga;
+/*
+* No character, no attributes!  Past end of line?
+* Do try matching with an empty line (could be the start of a region).
+*/
+line = syn_getcurline();
+if (line[current_col] == NUL && current_col != 0)
+{
+	/*
+	 * If we found a match after the last column, use it.
+	 */
+	if (next_match_idx >= 0 && next_match_col >= (int)current_col
+						  && next_match_col != MAXCOL)
+	    (void)push_next_match(NULL);
+	current_finished = TRUE;
+	current_state_stored = FALSE;
+	return 0;
+}
+/* if the current or next character is NUL, we will finish the line now */
+if (line[current_col] == NUL || line[current_col + 1] == NUL)
+{
+	current_finished = TRUE;
+	current_state_stored = FALSE;
+}
+/*
+* When in the previous column there was a match but it could not be used
+* (empty match or already matched in this column) need to try again in
+* the next column.
+*/
+if (try_next_column)
+{
+	next_match_idx = -1;
+	try_next_column = FALSE;
+}
+/* Only check for keywords when not syncing and there are some. */
+do_keywords = !syncing
+		    && (syn_buf->b_keywtab != NULL
+			    || syn_buf->b_keywtab_ic != NULL);
+/* Init the list of zero-width matches with a nextlist.  This is used to
+* avoid matching the same item in the same position twice. */
+ga_init2(&zero_width_next_ga, (int)sizeof(int), 10);
+/*
+* Repeat matching keywords and patterns, to find contained items at the
+* same column.  This stops when there are no extra matches at the current
+* column.
+*/
+do
+{
+	found_match = FALSE;
+	keep_next_list = FALSE;
+	syn_id = 0;
+	/*
+	 * 1. Check for a current state.
+	 *    Only when there is no current state, or if the current state may
+	 *    contain other things, we need to check for keywords and patterns.
+	 *    Always need to check for contained items if some item has the
+	 *    "containedin" argument (takes extra time!).
+	 */
+	if (current_state.ga_len)
+	    cur_si = &CUR_STATE(current_state.ga_len - 1);
+	else
+	    cur_si = NULL;
+	if (syn_buf->b_syn_containedin || cur_si == NULL
+					      || cur_si->si_cont_list != NULL)
+	{
+	    /*
+	     * 2. Check for keywords, if on a keyword char after a non-keyword
+	     *	  char.  Don't do this when syncing.
+	     */
+	    if (do_keywords)
+	    {
+	      line = syn_getcurline();
+	      if (vim_iswordc_buf(line + current_col, syn_buf)
+		      && (current_col == 0
+			  || !vim_iswordc_buf(line + current_col - 1
+#ifdef FEAT_MBYTE
+			      - (has_mbyte
+				  ? (*mb_head_off)(line, line + current_col - 1)
+				  : 0)
+#endif
+			       , syn_buf)))
+	      {
+		syn_id = check_keyword_id(line, (int)current_col,
+					 &endcol, &flags, &next_list, cur_si);
+		if (syn_id)
+		{
+		    if (push_current_state(KEYWORD_IDX) == OK)
+		    {
+			cur_si = &CUR_STATE(current_state.ga_len - 1);
+			cur_si->si_m_startcol = current_col;
+			cur_si->si_h_startpos.lnum = current_lnum;
+			cur_si->si_h_startpos.col = 0;	/* starts right away */
+			cur_si->si_m_endpos.lnum = current_lnum;
+			cur_si->si_m_endpos.col = endcol;
+			cur_si->si_h_endpos.lnum = current_lnum;
+			cur_si->si_h_endpos.col = endcol;
+			cur_si->si_ends = TRUE;
+			cur_si->si_end_idx = 0;
+			cur_si->si_flags = flags;
+			cur_si->si_id = syn_id;
+			cur_si->si_trans_id = syn_id;
+			if (flags & HL_TRANSP)
+			{
+			    if (current_state.ga_len < 2)
+			    {
+				cur_si->si_attr = 0;
+				cur_si->si_trans_id = 0;
+			    }
+			    else
+			    {
+				cur_si->si_attr = CUR_STATE(
+					current_state.ga_len - 2).si_attr;
+				cur_si->si_trans_id = CUR_STATE(
+					current_state.ga_len - 2).si_trans_id;
+			    }
+			}
+			else
+			    cur_si->si_attr = syn_id2attr(syn_id);
+			cur_si->si_cont_list = NULL;
+			cur_si->si_next_list = next_list;
+			check_keepend();
+		    }
+		    else
+			vim_free(next_list);
+		}
+	      }
+	    }
+	    /*
+	     * 3. Check for patterns (only if not found a keyword).
+	     */
+	    if (syn_id == 0 && syn_buf->b_syn_patterns.ga_len)
+	    {
+		/*
+		 * If we didn't check for a match yet, or we are past it, check
+		 * for any match with a pattern.
+		 */
+		if (next_match_idx < 0 || next_match_col < (int)current_col)
+		{
+		    /*
+		     * Check all relevant patterns for a match at this
+		     * position.  This is complicated, because matching with a
+		     * pattern takes quite a bit of time, thus we want to
+		     * avoid doing it when it's not needed.
+		     */
+		    next_match_idx = 0;		/* no match in this line yet */
+		    next_match_col = MAXCOL;
+		    for (idx = syn_buf->b_syn_patterns.ga_len; --idx >= 0; )
+		    {
+			spp = &(SYN_ITEMS(syn_buf)[idx]);
+			if (	   spp->sp_syncing == syncing
+				&& (displaying || !(spp->sp_flags & HL_DISPLAY))
+				&& (spp->sp_type == SPTYPE_MATCH
+				    || spp->sp_type == SPTYPE_START)
+				&& (current_next_list != NULL
+				    ? in_id_list(NULL, current_next_list,
+							      &spp->sp_syn, 0)
+				    : (cur_si == NULL
+					? !(spp->sp_flags & HL_CONTAINED)
+					: in_id_list(cur_si,
+					    cur_si->si_cont_list, &spp->sp_syn,
+					    spp->sp_flags & HL_CONTAINED))))
+			{
+			    /* If we already tried matching in this line, and
+			     * there isn't a match before next_match_col, skip
+			     * this item. */
+			    if (spp->sp_line_id == current_line_id
+				    && spp->sp_startcol >= next_match_col)
+				continue;
+			    spp->sp_line_id = current_line_id;
+			    lc_col = current_col - spp->sp_offsets[SPO_LC_OFF];
+			    if (lc_col < 0)
+				lc_col = 0;
+			    regmatch.rmm_ic = spp->sp_ic;
+			    regmatch.regprog = spp->sp_prog;
+			    if (!syn_regexec(&regmatch, current_lnum,
+							     (colnr_T)lc_col))
+			    {
+				/* no match in this line, try another one */
+				spp->sp_startcol = MAXCOL;
+				continue;
+			    }
+			    /*
+			     * Compute the first column of the match.
+			     */
+			    syn_add_start_off(&pos, &regmatch,
+							 spp, SPO_MS_OFF, -1);
+			    if (pos.lnum > current_lnum)
+			    {
+				/* must have used end of match in a next line,
+				 * we can't handle that */
+				spp->sp_startcol = MAXCOL;
+				continue;
+			    }
+			    startcol = pos.col;
+			    /* remember the next column where this pattern
+			     * matches in the current line */
+			    spp->sp_startcol = startcol;
+			    /*
+			     * If a previously found match starts at a lower
+			     * column number, don't use this one.
+			     */
+			    if (startcol >= next_match_col)
+				continue;
+			    /*
+			     * If we matched this pattern at this position
+			     * before, skip it.  Must retry in the next
+			     * column, because it may match from there.
+			     */
+			    if (did_match_already(idx, &zero_width_next_ga))
+			    {
+				try_next_column = TRUE;
+				continue;
+			    }
+			    endpos.lnum = regmatch.endpos[0].lnum;
+			    endpos.col = regmatch.endpos[0].col;
+			    /* Compute the highlight start. */
+			    syn_add_start_off(&hl_startpos, &regmatch,
+							 spp, SPO_HS_OFF, -1);
+			    /* Compute the region start. */
+			    /* Default is to use the end of the match. */
+			    syn_add_end_off(&eos_pos, &regmatch,
+							 spp, SPO_RS_OFF, 0);
+			    /*
+			     * Grab the external submatches before they get
+			     * overwritten.  Reference count doesn't change.
+			     */
+			    unref_extmatch(cur_extmatch);
+			    cur_extmatch = re_extmatch_out;
+			    re_extmatch_out = NULL;
+			    flags = 0;
+			    eoe_pos.lnum = 0;	/* avoid warning */
+			    eoe_pos.col = 0;
+			    end_idx = 0;
+			    hl_endpos.lnum = 0;
+			    /*
+			     * For a "oneline" the end must be found in the
+			     * same line too.  Search for it after the end of
+			     * the match with the start pattern.  Set the
+			     * resulting end positions at the same time.
+			     */
+			    if (spp->sp_type == SPTYPE_START
+					      && (spp->sp_flags & HL_ONELINE))
+			    {
+				lpos_T	startpos;
+				startpos = endpos;
+				find_endpos(idx, &startpos, &endpos, &hl_endpos,
+				    &flags, &eoe_pos, &end_idx, cur_extmatch);
+				if (endpos.lnum == 0)
+				    continue;	    /* not found */
+			    }
+			    /*
+			     * For a "match" the size must be > 0 after the
+			     * end offset needs has been added.  Except when
+			     * syncing.
+			     */
+			    else if (spp->sp_type == SPTYPE_MATCH)
+			    {
+				syn_add_end_off(&hl_endpos, &regmatch, spp,
+							       SPO_HE_OFF, 0);
+				syn_add_end_off(&endpos, &regmatch, spp,
+							       SPO_ME_OFF, 0);
+				if (endpos.lnum == current_lnum
+				      && (int)endpos.col + syncing < startcol)
+				{
+				    /*
+				     * If an empty string is matched, may need
+				     * to try matching again at next column.
+				     */
+				    if (regmatch.startpos[0].col
+						    == regmatch.endpos[0].col)
+					try_next_column = TRUE;
+				    continue;
+				}
+			    }
+			    /*
+			     * keep the best match so far in next_match_*
+			     */
+			    /* Highlighting must start after startpos and end
+			     * before endpos. */
+			    if (hl_startpos.lnum == current_lnum
+					   && (int)hl_startpos.col < startcol)
+				hl_startpos.col = startcol;
+			    limit_pos_zero(&hl_endpos, &endpos);
+			    next_match_idx = idx;
+			    next_match_col = startcol;
+			    next_match_m_endpos = endpos;
+			    next_match_h_endpos = hl_endpos;
+			    next_match_h_startpos = hl_startpos;
+			    next_match_flags = flags;
+			    next_match_eos_pos = eos_pos;
+			    next_match_eoe_pos = eoe_pos;
+			    next_match_end_idx = end_idx;
+			    unref_extmatch(next_match_extmatch);
+			    next_match_extmatch = cur_extmatch;
+			    cur_extmatch = NULL;
+			}
+		    }
+		}
+		/*
+		 * If we found a match at the current column, use it.
+		 */
+		if (next_match_idx >= 0 && next_match_col == (int)current_col)
+		{
+		    synpat_T	*lspp;
+		    /* When a zero-width item matched which has a nextgroup,
+		     * don't push the item but set nextgroup. */
+		    lspp = &(SYN_ITEMS(syn_buf)[next_match_idx]);
+		    if (next_match_m_endpos.lnum == current_lnum
+			    && next_match_m_endpos.col == current_col
+			    && lspp->sp_next_list != NULL)
+		    {
+			current_next_list = lspp->sp_next_list;
+			current_next_flags = lspp->sp_flags;
+			keep_next_list = TRUE;
+			zero_width_next_list = TRUE;
+			/* Add the index to a list, so that we can check
+			 * later that we don't match it again (and cause an
+			 * endless loop). */
+			if (ga_grow(&zero_width_next_ga, 1) == OK)
+			{
+			    ((int *)(zero_width_next_ga.ga_data))
+				[zero_width_next_ga.ga_len++] = next_match_idx;
+			    --zero_width_next_ga.ga_room;
+			}
+			next_match_idx = -1;
+		    }
+		    else
+			cur_si = push_next_match(cur_si);
+		    found_match = TRUE;
+		}
+	    }
+	}
+	/*
+	 * Handle searching for nextgroup match.
+	 */
+	if (current_next_list != NULL && !keep_next_list)
+	{
+	    /*
+	     * If a nextgroup was not found, continue looking for one if:
+	     * - this is an empty line and the "skipempty" option was given
+	     * - we are on white space and the "skipwhite" option was given
+	     */
+	    if (!found_match)
+	    {
+		line = syn_getcurline();
+		if (((current_next_flags & HL_SKIPWHITE)
+			    && vim_iswhite(line[current_col]))
+			|| ((current_next_flags & HL_SKIPEMPTY)
+			    && *line == NUL))
+		    break;
+	    }
+	    /*
+	     * If a nextgroup was found: Use it, and continue looking for
+	     * contained matches.
+	     * If a nextgroup was not found: Continue looking for a normal
+	     * match.
+	     * When did set current_next_list for a zero-width item and no
+	     * match was found don't loop (would get stuck).
+	     */
+	    current_next_list = NULL;
+	    next_match_idx = -1;
+	    if (!zero_width_next_list)
+		found_match = TRUE;
+	}
+} while (found_match);
+/*
+* Use attributes from the current state, if within its highlighting.
+* If not, use attributes from the current-but-one state, etc.
+*/
+current_attr = 0;
+#ifdef FEAT_EVAL
+current_id = 0;
+current_trans_id = 0;
+#endif
+if (cur_si != NULL)
+{
+	for (idx = current_state.ga_len - 1; idx >= 0; --idx)
+	{
+	    sip = &CUR_STATE(idx);
+	    if ((current_lnum > sip->si_h_startpos.lnum
+			|| (current_lnum == sip->si_h_startpos.lnum
+			    && current_col >= sip->si_h_startpos.col))
+		    && (sip->si_h_endpos.lnum == 0
+			|| current_lnum < sip->si_h_endpos.lnum
+			|| (current_lnum == sip->si_h_endpos.lnum
+			    && current_col < sip->si_h_endpos.col)))
+	    {
+		current_attr = sip->si_attr;
+#ifdef FEAT_EVAL
+		current_id = sip->si_id;
+		current_trans_id = sip->si_trans_id;
+#endif
+		break;
+	    }
+	}
+	/*
+	 * Check for end of current state (and the states before it) at the
+	 * next column.  Don't do this for syncing, because we would miss a
+	 * single character match.
+	 * First check if the current state ends at the current column.  It
+	 * may be for an empty match and a containing item might end in the
+	 * current column.
+	 */
+	if (!syncing)
+	{
+	    check_state_ends();
+	    if (current_state.ga_len > 0)
+	    {
+		++current_col;
+		check_state_ends();
+		--current_col;
+	    }
+	}
+}
+/* nextgroup ends at end of line, unless "skipnl" or "skipemtpy" present */
+if (current_next_list != NULL
+	    && syn_getcurline()[current_col + 1] == NUL
+	    && !(current_next_flags & (HL_SKIPNL | HL_SKIPEMPTY)))
+	current_next_list = NULL;
+if (zero_width_next_ga.ga_len > 0)
+	ga_clear(&zero_width_next_ga);
+/* No longer need external matches.  But keep next_match_extmatch. */
+unref_extmatch(re_extmatch_out);
+re_extmatch_out = NULL;
+unref_extmatch(cur_extmatch);
+return current_attr;
+}
+/*
+* Check if we already matched pattern "idx" at the current column.
+*/
+static int
+did_match_already(idx, gap)
+int		idx;
+garray_T	*gap;
+{
+int		i;
+for (i = current_state.ga_len; --i >= 0; )
+	if (CUR_STATE(i).si_m_startcol == (int)current_col
+		&& CUR_STATE(i).si_m_lnum == (int)current_lnum
+		&& CUR_STATE(i).si_idx == idx)
+	    return TRUE;
+/* Zero-width matches with a nextgroup argument are not put on the syntax
+* stack, and can only be matched once anyway. */
+for (i = gap->ga_len; --i >= 0; )
+	if (((int *)(gap->ga_data))[i] == idx)
+	    return TRUE;
+return FALSE;
+}
+/*
+* Push the next match onto the stack.
+*/
+static stateitem_T *
+push_next_match(cur_si)
+stateitem_T	*cur_si;
+{
+synpat_T	*spp;
+spp = &(SYN_ITEMS(syn_buf)[next_match_idx]);
+/*
+* Push the item in current_state stack;
+*/
+if (push_current_state(next_match_idx) == OK)
+{
+	/*
+	 * If it's a start-skip-end type that crosses lines, figure out how
+	 * much it continues in this line.  Otherwise just fill in the length.
+	 */
+	cur_si = &CUR_STATE(current_state.ga_len - 1);
+	cur_si->si_h_startpos = next_match_h_startpos;
+	cur_si->si_m_startcol = current_col;
+	cur_si->si_m_lnum = current_lnum;
+	cur_si->si_flags = spp->sp_flags;
+	cur_si->si_next_list = spp->sp_next_list;
+	cur_si->si_extmatch = ref_extmatch(next_match_extmatch);
+	if (spp->sp_type == SPTYPE_START && !(spp->sp_flags & HL_ONELINE))
+	{
+	    /* Try to find the end pattern in the current line */
+	    update_si_end(cur_si, (int)(next_match_m_endpos.col), TRUE);
+	    check_keepend();
+	}
+	else
+	{
+	    cur_si->si_m_endpos = next_match_m_endpos;
+	    cur_si->si_h_endpos = next_match_h_endpos;
+	    cur_si->si_ends = TRUE;
+	    cur_si->si_flags |= next_match_flags;
+	    cur_si->si_eoe_pos = next_match_eoe_pos;
+	    cur_si->si_end_idx = next_match_end_idx;
+	}
+	if (keepend_level < 0 && (cur_si->si_flags & HL_KEEPEND))
+	    keepend_level = current_state.ga_len - 1;
+	check_keepend();
+	update_si_attr(current_state.ga_len - 1);
+	/*
+	 * If the start pattern has another highlight group, push another item
+	 * on the stack for the start pattern.
+	 */
+	if (	   spp->sp_type == SPTYPE_START
+		&& spp->sp_syn_match_id != 0
+		&& push_current_state(next_match_idx) == OK)
+	{
+	    cur_si = &CUR_STATE(current_state.ga_len - 1);
+	    cur_si->si_h_startpos = next_match_h_startpos;
+	    cur_si->si_m_startcol = current_col;
+	    cur_si->si_m_lnum = current_lnum;
+	    cur_si->si_m_endpos = next_match_eos_pos;
+	    cur_si->si_h_endpos = next_match_eos_pos;
+	    cur_si->si_ends = TRUE;
+	    cur_si->si_end_idx = 0;
+	    cur_si->si_flags = HL_MATCH;
+	    cur_si->si_next_list = NULL;
+	    check_keepend();
+	    update_si_attr(current_state.ga_len - 1);
+	}
+}
+next_match_idx = -1;	/* try other match next time */
+return cur_si;
+}
+/*
+* Check for end of current state (and the states before it).
+*/
+static void
+check_state_ends()
+{
+stateitem_T	*cur_si;
+int		had_extend = FALSE;
+cur_si = &CUR_STATE(current_state.ga_len - 1);
+for (;;)
+{
+	if (cur_si->si_ends
+		&& (cur_si->si_m_endpos.lnum < current_lnum
+		    || (cur_si->si_m_endpos.lnum == current_lnum
+			&& cur_si->si_m_endpos.col <= current_col)))
+	{
+	    /*
+	     * If there is an end pattern group ID, highlight the end pattern
+	     * now.  No need to pop the current item from the stack.
+	     * Only do this if the end pattern continues beyond the current
+	     * position.
+	     */
+	    if (cur_si->si_end_idx
+		    && (cur_si->si_eoe_pos.lnum > current_lnum
+			|| (cur_si->si_eoe_pos.lnum == current_lnum
+			    && cur_si->si_eoe_pos.col > current_col)))
+	    {
+		cur_si->si_idx = cur_si->si_end_idx;
+		cur_si->si_end_idx = 0;
+		cur_si->si_m_endpos = cur_si->si_eoe_pos;
+		cur_si->si_h_endpos = cur_si->si_eoe_pos;
+		cur_si->si_flags |= HL_MATCH;
+		update_si_attr(current_state.ga_len - 1);
+		break;
+	    }
+	    else
+	    {
+		/* handle next_list, unless at end of line and no "skipnl" or
+		 * "skipempty" */
+		current_next_list = cur_si->si_next_list;
+		current_next_flags = cur_si->si_flags;
+		if (!(current_next_flags & (HL_SKIPNL | HL_SKIPEMPTY))
+			&& syn_getcurline()[current_col] == NUL)
+		    current_next_list = NULL;
+		/* When the ended item has "extend", another item with
+		 * "keepend" now needs to check for its end. */
+		 if (cur_si->si_flags & HL_EXTEND)
+		     had_extend = TRUE;
+		pop_current_state();
+		if (current_state.ga_len == 0)
+		    break;
+		if (had_extend)
+		{
+		    syn_update_ends(FALSE);
+		    if (current_state.ga_len == 0)
+			break;
+		}
+		cur_si = &CUR_STATE(current_state.ga_len - 1);
+		/*
+		 * Only for a region the search for the end continues after
+		 * the end of the contained item.  If the contained match
+		 * included the end-of-line, break here, the region continues.
+		 * Don't do this when:
+		 * - "keepend" is used for the contained item
+		 * - not at the end of the line (could be end="x$"me=e-1).
+		 * - "excludenl" is used (HL_HAS_EOL won't be set)
+		 */
+		if (cur_si->si_idx >= 0
+			&& SYN_ITEMS(syn_buf)[cur_si->si_idx].sp_type
+							       == SPTYPE_START
+			&& !(cur_si->si_flags & (HL_MATCH | HL_KEEPEND)))
+		{
+		    update_si_end(cur_si, (int)current_col, TRUE);
+		    check_keepend();
+		    if ((current_next_flags & HL_HAS_EOL)
+			    && keepend_level < 0
+			    && syn_getcurline()[current_col] == NUL)
+			break;
+		}
+	    }
+	}
+	else
+	    break;
+}
+}
+/*
+* Update an entry in the current_state stack for a match or region.  This
+* fills in si_attr, si_next_list and si_cont_list.
+*/
+static void
+update_si_attr(idx)
+int	    idx;
+{
+stateitem_T	*sip = &CUR_STATE(idx);
+synpat_T	*spp;
+spp = &(SYN_ITEMS(syn_buf)[sip->si_idx]);
+if (sip->si_flags & HL_MATCH)
+	sip->si_id = spp->sp_syn_match_id;
+else
+	sip->si_id = spp->sp_syn.id;
+sip->si_attr = syn_id2attr(sip->si_id);
+sip->si_trans_id = sip->si_id;
+if (sip->si_flags & HL_MATCH)
+	sip->si_cont_list = NULL;
+else
+	sip->si_cont_list = spp->sp_cont_list;
+/*
+* For transparent items, take attr from outer item.
+* Also take cont_list, if there is none.
+* Don't do this for the matchgroup of a start or end pattern.
+*/
+if ((spp->sp_flags & HL_TRANSP) && !(sip->si_flags & HL_MATCH))
+{
+	if (idx == 0)
+	{
+	    sip->si_attr = 0;
+	    sip->si_trans_id = 0;
+	    if (sip->si_cont_list == NULL)
+		sip->si_cont_list = ID_LIST_ALL;
+	}
+	else
+	{
+	    sip->si_attr = CUR_STATE(idx - 1).si_attr;
+	    sip->si_trans_id = CUR_STATE(idx - 1).si_trans_id;
+	    if (sip->si_cont_list == NULL)
+	    {
+		sip->si_flags |= HL_TRANS_CONT;
+		sip->si_cont_list = CUR_STATE(idx - 1).si_cont_list;
+	    }
+	}
+}
+}
+/*
+* Check the current stack for patterns with "keepend" flag.
+* Propagate the match-end to contained items, until a "skipend" item is found.
+*/
+static void
+check_keepend()
+{
+int		i;
+lpos_T	maxpos;
+stateitem_T	*sip;
+/*
+* This check can consume a lot of time; only do it from the level where
+* there really is a keepend.
+*/
+if (keepend_level < 0)
+	return;
+/*
+* Find the last index of an "extend" item.  "keepend" items before that
+* won't do anything.  If there is no "extend" item "i" will be
+* "keepend_level" and all "keepend" items will work normally.
+*/
+for (i = current_state.ga_len - 1; i > keepend_level; --i)
+	if (CUR_STATE(i).si_flags & HL_EXTEND)
+	    break;
+maxpos.lnum = 0;
+for ( ; i < current_state.ga_len; ++i)
+{
+	sip = &CUR_STATE(i);
+	if (maxpos.lnum != 0)
+	{
+	    limit_pos_zero(&sip->si_m_endpos, &maxpos);
+	    limit_pos_zero(&sip->si_h_endpos, &maxpos);
+	    limit_pos_zero(&sip->si_eoe_pos, &maxpos);
+	    sip->si_ends = TRUE;
+	}
+	if (sip->si_ends
+		&& (sip->si_flags & HL_KEEPEND)
+		&& (maxpos.lnum == 0
+		    || maxpos.lnum > sip->si_m_endpos.lnum
+		    || (maxpos.lnum == sip->si_m_endpos.lnum
+			&& maxpos.col > sip->si_m_endpos.col)))
+	    maxpos = sip->si_m_endpos;
+}
+}
+/*
+* Update an entry in the current_state stack for a start-skip-end pattern.
+* This finds the end of the current item, if it's in the current line.
+*
+* Return the flags for the matched END.
+*/
+static void
+update_si_end(sip, startcol, force)
+stateitem_T	*sip;
+int		startcol;   /* where to start searching for the end */
+int		force;	    /* when TRUE overrule a previous end */
+{
+lpos_T	startpos;
+lpos_T	endpos;
+lpos_T	hl_endpos;
+lpos_T	end_endpos;
+int		end_idx;
+/* Don't update when it's already done.  Can be a match of an end pattern
+* that started in a previous line.  Watch out: can also be a "keepend"
+* from a containing item. */
+if (!force && sip->si_m_endpos.lnum >= current_lnum)
+	return;
+/*
+* We need to find the end of the region.  It may continue in the next
+* line.
+*/
+end_idx = 0;
+startpos.lnum = current_lnum;
+startpos.col = startcol;
+find_endpos(sip->si_idx, &startpos, &endpos, &hl_endpos,
+		   &(sip->si_flags), &end_endpos, &end_idx, sip->si_extmatch);
+if (endpos.lnum == 0)
+{
+	/* No end pattern matched. */
+	if (SYN_ITEMS(syn_buf)[sip->si_idx].sp_flags & HL_ONELINE)
+	{
+	    /* a "oneline" never continues in the next line */
+	    sip->si_ends = TRUE;
+	    sip->si_m_endpos.lnum = current_lnum;
+	    sip->si_m_endpos.col = (colnr_T)STRLEN(syn_getcurline());
+	}
+	else
+	{
+	    /* continues in the next line */
+	    sip->si_ends = FALSE;
+	    sip->si_m_endpos.lnum = 0;
+	}
+	sip->si_h_endpos = sip->si_m_endpos;
+}
+else
+{
+	/* match within this line */
+	sip->si_m_endpos = endpos;
+	sip->si_h_endpos = hl_endpos;
+	sip->si_eoe_pos = end_endpos;
+	sip->si_ends = TRUE;
+	sip->si_end_idx = end_idx;
+}
+}
+/*
+* Add a new state to the current state stack.
+* It is cleared and the index set to "idx".
+* Return FAIL if it's not possible (out of memory).
+*/
+static int
+push_current_state(idx)
+int	    idx;
+{
+if (ga_grow(&current_state, 1) == FAIL)
+	return FAIL;
+vim_memset(&CUR_STATE(current_state.ga_len), 0, sizeof(stateitem_T));
+CUR_STATE(current_state.ga_len).si_idx = idx;
+++current_state.ga_len;
+--current_state.ga_room;
+return OK;
+}
+/*
+* Remove a state from the current_state stack.
+*/
+static void
+pop_current_state()
+{
+if (current_state.ga_len)
+{
+	unref_extmatch(CUR_STATE(current_state.ga_len - 1).si_extmatch);
+	--current_state.ga_len;
+	++current_state.ga_room;
+}
+/* after the end of a pattern, try matching a keyword or pattern */
+next_match_idx = -1;
+/* if first state with "keepend" is popped, reset keepend_level */
+if (keepend_level >= current_state.ga_len)
+	keepend_level = -1;
+}
+/*
+* Find the end of a start/skip/end syntax region after "startpos".
+* Only checks one line.
+* Also handles a match item that continued from a previous line.
+* If not found, the syntax item continues in the next line.  m_endpos->lnum
+* will be 0.
+* If found, the end of the region and the end of the highlighting is
+* computed.
+*/
+static void
+find_endpos(idx, startpos, m_endpos, hl_endpos, flagsp, end_endpos,
+							   end_idx, start_ext)
+int		idx;		/* index of the pattern */
+lpos_T	*startpos;	/* where to start looking for an END match */
+lpos_T	*m_endpos;	/* return: end of match */
+lpos_T	*hl_endpos;	/* return: end of highlighting */
+long	*flagsp;	/* return: flags of matching END */
+lpos_T	*end_endpos;	/* return: end of end pattern match */
+int		*end_idx;	/* return: group ID for end pat. match, or 0 */
+reg_extmatch_T *start_ext;	/* submatches from the start pattern */
+{
+colnr_T	matchcol;
+synpat_T	*spp, *spp_skip;
+int		start_idx;
+int		best_idx;
+regmmatch_T	regmatch;
+regmmatch_T	best_regmatch;	    /* startpos/endpos of best match */
+lpos_T	pos;
+char_u	*line;
+int		had_match = FALSE;
+/*
+* Check for being called with a START pattern.
+* Can happen with a match that continues to the next line, because it
+* contained a region.
+*/
+spp = &(SYN_ITEMS(syn_buf)[idx]);
+if (spp->sp_type != SPTYPE_START)
+{
+	*hl_endpos = *startpos;
+	return;
+}
+/*
+* Find the SKIP or first END pattern after the last START pattern.
+*/
+for (;;)
+{
+	spp = &(SYN_ITEMS(syn_buf)[idx]);
+	if (spp->sp_type != SPTYPE_START)
+	    break;
+	++idx;
+}
+/*
+*	Lookup the SKIP pattern (if present)
+*/
+if (spp->sp_type == SPTYPE_SKIP)
+{
+	spp_skip = spp;
+	++idx;
+}
+else
+	spp_skip = NULL;
+/* Setup external matches for syn_regexec(). */
+unref_extmatch(re_extmatch_in);
+re_extmatch_in = ref_extmatch(start_ext);
+matchcol = startpos->col;	/* start looking for a match at sstart */
+start_idx = idx;		/* remember the first END pattern. */
+best_regmatch.startpos[0].col = 0;		/* avoid compiler warning */
+for (;;)
+{
+	/*
+	 * Find end pattern that matches first after "matchcol".
+	 */
+	best_idx = -1;
+	for (idx = start_idx; idx < syn_buf->b_syn_patterns.ga_len; ++idx)
+	{
+	    int lc_col = matchcol;
+	    spp = &(SYN_ITEMS(syn_buf)[idx]);
+	    if (spp->sp_type != SPTYPE_END)	/* past last END pattern */
+		break;
+	    lc_col -= spp->sp_offsets[SPO_LC_OFF];
+	    if (lc_col < 0)
+		lc_col = 0;
+	    regmatch.rmm_ic = spp->sp_ic;
+	    regmatch.regprog = spp->sp_prog;
+	    if (syn_regexec(&regmatch, startpos->lnum, lc_col))
+	    {
+		if (best_idx == -1 || regmatch.startpos[0].col
+					      < best_regmatch.startpos[0].col)
+		{
+		    best_idx = idx;
+		    best_regmatch.startpos[0] = regmatch.startpos[0];
+		    best_regmatch.endpos[0] = regmatch.endpos[0];
+		}
+	    }
+	}
+	/*
+	 * If all end patterns have been tried, and there is no match, the
+	 * item continues until end-of-line.
+	 */
+	if (best_idx == -1)
+	    break;
+	/*
+	 * If the skip pattern matches before the end pattern,
+	 * continue searching after the skip pattern.
+	 */
+	if (spp_skip != NULL)
+	{
+	    int lc_col = matchcol - spp_skip->sp_offsets[SPO_LC_OFF];
+	    if (lc_col < 0)
+		lc_col = 0;
+	    regmatch.rmm_ic = spp_skip->sp_ic;
+	    regmatch.regprog = spp_skip->sp_prog;
+	    if (syn_regexec(&regmatch, startpos->lnum, lc_col)
+		    && regmatch.startpos[0].col
+					     <= best_regmatch.startpos[0].col)
+	    {
+		/* Add offset to skip pattern match */
+		syn_add_end_off(&pos, &regmatch, spp_skip, SPO_ME_OFF, 1);
+		/* If the skip pattern goes on to the next line, there is no
+		 * match with an end pattern in this line. */
+		if (pos.lnum > startpos->lnum)
+		    break;
+		line = ml_get_buf(syn_buf, startpos->lnum, FALSE);
+		/* take care of an empty match or negative offset */
+		if (pos.col <= matchcol)
+		    ++matchcol;
+		else if (pos.col <= regmatch.endpos[0].col)
+		    matchcol = pos.col;
+		else
+		    /* Be careful not to jump over the NUL at the end-of-line */
+		    for (matchcol = regmatch.endpos[0].col;
+			    line[matchcol] != NUL && matchcol < pos.col;
+								   ++matchcol)
+			;
+		/* if the skip pattern includes end-of-line, break here */
+		if (line[matchcol] == NUL)
+		    break;
+		continue;	    /* start with first end pattern again */
+	    }
+	}
+	/*
+	 * Match from start pattern to end pattern.
+	 * Correct for match and highlight offset of end pattern.
+	 */
+	spp = &(SYN_ITEMS(syn_buf)[best_idx]);
+	syn_add_end_off(m_endpos, &best_regmatch, spp, SPO_ME_OFF, 1);
+	/* can't end before the start */
+	if (m_endpos->lnum == startpos->lnum && m_endpos->col < startpos->col)
+	    m_endpos->col = startpos->col;
+	syn_add_end_off(end_endpos, &best_regmatch, spp, SPO_HE_OFF, 1);
+	/* can't end before the start */
+	if (end_endpos->lnum == startpos->lnum
+					   && end_endpos->col < startpos->col)
+	    end_endpos->col = startpos->col;
+	/* can't end after the match */
+	limit_pos(end_endpos, m_endpos);
+	/*
+	 * If the end group is highlighted differently, adjust the pointers.
+	 */
+	if (spp->sp_syn_match_id != spp->sp_syn.id && spp->sp_syn_match_id != 0)
+	{
+	    *end_idx = best_idx;
+	    if (spp->sp_off_flags & (1 << (SPO_RE_OFF + SPO_COUNT)))
+	    {
+		hl_endpos->lnum = best_regmatch.endpos[0].lnum;
+		hl_endpos->col = best_regmatch.endpos[0].col;
+	    }
+	    else
+	    {
+		hl_endpos->lnum = best_regmatch.startpos[0].lnum;
+		hl_endpos->col = best_regmatch.startpos[0].col;
+	    }
+	    hl_endpos->col += spp->sp_offsets[SPO_RE_OFF];
+	    /* can't end before the start */
+	    if (hl_endpos->lnum == startpos->lnum
+					    && hl_endpos->col < startpos->col)
+		hl_endpos->col = startpos->col;
+	    limit_pos(hl_endpos, m_endpos);
+	    /* now the match ends where the highlighting ends, it is turned
+	     * into the matchgroup for the end */
+	    *m_endpos = *hl_endpos;
+	}
+	else
+	{
+	    *end_idx = 0;
+	    *hl_endpos = *end_endpos;
+	}
+	*flagsp = spp->sp_flags;
+	had_match = TRUE;
+	break;
+}
+/* no match for an END pattern in this line */
+if (!had_match)
+	m_endpos->lnum = 0;
+/* Remove external matches. */
+unref_extmatch(re_extmatch_in);
+re_extmatch_in = NULL;
+}
+/*
+* Limit "pos" not to be after "limit".
+*/
+static void
+limit_pos(pos, limit)
+lpos_T	*pos;
+lpos_T	*limit;
+{
+if (pos->lnum > limit->lnum)
+	*pos = *limit;
+else if (pos->lnum == limit->lnum && pos->col > limit->col)
+	pos->col = limit->col;
+}
+/*
+* Limit "pos" not to be after "limit", unless pos->lnum is zero.
+*/
+static void
+limit_pos_zero(pos, limit)
+lpos_T	*pos;
+lpos_T	*limit;
+{
+if (pos->lnum == 0)
+	*pos = *limit;
+else
+	limit_pos(pos, limit);
+}
+/*
+* Add offset to matched text for end of match or highlight.
+*/
+static void
+syn_add_end_off(result, regmatch, spp, idx, extra)
+lpos_T	*result;	/* returned position */
+regmmatch_T	*regmatch;	/* start/end of match */
+synpat_T	*spp;		/* matched pattern */
+int		idx;		/* index of offset */
+int		extra;		/* extra chars for offset to start */
+{
+int		col;
+if (spp->sp_off_flags & (1 << idx))
+{
+	result->lnum = regmatch->startpos[0].lnum;
+	col = regmatch->startpos[0].col + extra;
+}
+else
+{
+	result->lnum = regmatch->endpos[0].lnum;
+	col = regmatch->endpos[0].col;
+}
+col += spp->sp_offsets[idx];
+if (col < 0)
+	result->col = 0;
+else
+	result->col = col;
+}
+/*
+* Add offset to matched text for start of match or highlight.
+* Avoid resulting column to become negative.
+*/
+static void
+syn_add_start_off(result, regmatch, spp, idx, extra)
+lpos_T	*result;	/* returned position */
+regmmatch_T	*regmatch;	/* start/end of match */
+synpat_T	*spp;
+int		idx;
+int		extra;	    /* extra chars for offset to end */
+{
+int		col;
+if (spp->sp_off_flags & (1 << (idx + SPO_COUNT)))
+{
+	result->lnum = regmatch->endpos[0].lnum;
+	col = regmatch->endpos[0].col + extra;
+}
+else
+{
+	result->lnum = regmatch->startpos[0].lnum;
+	col = regmatch->startpos[0].col;
+}
+col += spp->sp_offsets[idx];
+if (col < 0)
+	result->col = 0;
+else
+	result->col = col;
+}
+/*
+* Get current line in syntax buffer.
+*/
+static char_u *
+syn_getcurline()
+{
+return ml_get_buf(syn_buf, current_lnum, FALSE);
+}
+/*
+* Call vim_regexec() to match in syn_buf.
+* Returns TRUE when there is a match.
+*/
+static int
+syn_regexec(rmp, lnum, col)
+regmmatch_T	*rmp;
+linenr_T	lnum;
+colnr_T	col;
+{
+if (vim_regexec_multi(rmp, syn_win, syn_buf, lnum, col) > 0)
+{
+	rmp->startpos[0].lnum += lnum;
+	rmp->endpos[0].lnum += lnum;
+	return TRUE;
+}
+return FALSE;
+}
+/*
+* Check one position in a line for a matching keyword.
+* The caller must check if a keyword can start at startcol.
+* Return it's ID if found, 0 otherwise.
+*/
+static int
+check_keyword_id(line, startcol, endcolp, flagsp, next_listp, cur_si)
+char_u	*line;
+int		startcol;	/* position in line to check for keyword */
+int		*endcolp;	/* return: character after found keyword */
+long	*flagsp;	/* return: flags of matching keyword */
+short	**next_listp;	/* return: next_list of matching keyword */
+stateitem_T	*cur_si;	/* item at the top of the stack */
+{
+keyentry_T	*ktab;
+char_u	*p;
+int		round;
+int		len;
+char_u	keyword[MAXKEYWLEN + 1]; /* assume max. keyword len is 80 */
+/* Find first character after the keyword.  First character was already
+* checked. */
+p = line + startcol;
+len = 0;
+do
+{
+#ifdef FEAT_MBYTE
+	if (has_mbyte)
+	    len += (*mb_ptr2len_check)(p + len);
+	else
+#endif
+	    ++len;
+}
+while (vim_iswordc_buf(p + len, syn_buf));
+if (len > MAXKEYWLEN)
+	return 0;
+/*
+* Must make a copy of the keyword, so we can add a NUL and make it
+* lowercase.
+*/
+STRNCPY(keyword, p, len);
+keyword[len] = NUL;
+/*
+* Try twice:
+* 1. matching case
+* 2. ignoring case
+*/
+for (round = 1; round <= 2; ++round)
+{
+	if ((round == 1 ? syn_buf->b_keywtab : syn_buf->b_keywtab_ic) == NULL)
+	    continue;
+	if (round == 1)	/* match case */
+	    ktab = syn_buf->b_keywtab[syn_khash(keyword)];
+	else /* round == 2, ignore case */
+	{
+	    p = str_foldcase(keyword, (int)STRLEN(keyword));
+	    if (p != NULL)
+	    {
+		STRNCPY(keyword, p, MAXKEYWLEN);
+		keyword[MAXKEYWLEN] = NUL;
+		vim_free(p);
+	    }
+	    ktab = syn_buf->b_keywtab_ic[syn_khash(keyword)];
+	}
+	/*
+	 * Find keywords that match.
+	 * When current_next_list is non-zero accept only that group, otherwise:
+	 *  Accept a not-contained keyword at toplevel.
+	 *  Accept a keyword at other levels only if it is in the contains list.
+	 */
+	for ( ; ktab != NULL; ktab = ktab->next)
+	    if (   STRCMP(keyword, ktab->keyword) == 0
+		&& (current_next_list != 0
+		    ? in_id_list(NULL, current_next_list, &ktab->k_syn, 0)
+		    : (cur_si == NULL
+			? !(ktab->flags & HL_CONTAINED)
+			: in_id_list(cur_si, cur_si->si_cont_list,
+				  &ktab->k_syn, ktab->flags & HL_CONTAINED))))
+	    {
+		*endcolp = startcol + len;
+		*flagsp = ktab->flags;
+		*next_listp = ktab->next_list;
+		return ktab->k_syn.id;
+	    }
+}
+return 0;
+}
+/*
+* Handle ":syntax case" command.
+*/
+/* ARGSUSED */
+static void
+syn_cmd_case(eap, syncing)
+exarg_T	*eap;
+int		syncing;	    /* not used */
+{
+char_u	*arg = eap->arg;
+char_u	*next;
+eap->nextcmd = find_nextcmd(arg);
+if (eap->skip)
+	return;
+next = skiptowhite(arg);
+if (STRNICMP(arg, "match", 5) == 0 && next - arg == 5)
+	curbuf->b_syn_ic = FALSE;
+else if (STRNICMP(arg, "ignore", 6) == 0 && next - arg == 6)
+	curbuf->b_syn_ic = TRUE;
+else
+	EMSG2(_("E390: Illegal argument: %s"), arg);
+}
+/*
+* Clear all syntax info for one buffer.
+*/
+void
+syntax_clear(buf)
+buf_T	*buf;
+{
+int i;
+curbuf->b_syn_ic = FALSE;	    /* Use case, by default */
+curbuf->b_syn_containedin = FALSE;
+/* free the keywords */
+free_keywtab(buf->b_keywtab);
+buf->b_keywtab = NULL;
+free_keywtab(buf->b_keywtab_ic);
+buf->b_keywtab_ic = NULL;
+/* free the syntax patterns */
+for (i = buf->b_syn_patterns.ga_len; --i >= 0; )
+	syn_clear_pattern(buf, i);
+ga_clear(&buf->b_syn_patterns);
+/* free the syntax clusters */
+for (i = buf->b_syn_clusters.ga_len; --i >= 0; )
+	syn_clear_cluster(buf, i);
+ga_clear(&buf->b_syn_clusters);
+buf->b_syn_sync_flags = 0;
+buf->b_syn_sync_minlines = 0;
+buf->b_syn_sync_maxlines = 0;
+buf->b_syn_sync_linebreaks = 0;
+vim_free(buf->b_syn_linecont_prog);
+buf->b_syn_linecont_prog = NULL;
+vim_free(buf->b_syn_linecont_pat);
+buf->b_syn_linecont_pat = NULL;
+#ifdef FEAT_FOLDING
+buf->b_syn_folditems = 0;
+#endif
+/* free the stored states */
+syn_stack_free_all(buf);
+invalidate_current_state();
+}
+/*
+* Clear syncing info for one buffer.
+*/
+static void
+syntax_sync_clear()
+{
+int i;
+/* free the syntax patterns */
+for (i = curbuf->b_syn_patterns.ga_len; --i >= 0; )
+	if (SYN_ITEMS(curbuf)[i].sp_syncing)
+	    syn_remove_pattern(curbuf, i);
+curbuf->b_syn_sync_flags = 0;
+curbuf->b_syn_sync_minlines = 0;
+curbuf->b_syn_sync_maxlines = 0;
+curbuf->b_syn_sync_linebreaks = 0;
+vim_free(curbuf->b_syn_linecont_prog);
+curbuf->b_syn_linecont_prog = NULL;
+vim_free(curbuf->b_syn_linecont_pat);
+curbuf->b_syn_linecont_pat = NULL;
+syn_stack_free_all(curbuf);		/* Need to recompute all syntax. */
+}
+/*
+* Remove one pattern from the buffer's pattern list.
+*/
+static void
+syn_remove_pattern(buf, idx)
+buf_T	*buf;
+int		idx;
+{
+synpat_T	*spp;
+spp = &(SYN_ITEMS(buf)[idx]);
+#ifdef FEAT_FOLDING
+if (spp->sp_flags & HL_FOLD)
+	--buf->b_syn_folditems;
+#endif
+syn_clear_pattern(buf, idx);
+mch_memmove(spp, spp + 1,
+		   sizeof(synpat_T) * (buf->b_syn_patterns.ga_len - idx - 1));
+--buf->b_syn_patterns.ga_len;
+--buf->b_syn_patterns.ga_room;
+}
+/*
+* Clear and free one syntax pattern.  When clearing all, must be called from
+* last to first!
+*/
+static void
+syn_clear_pattern(buf, i)
+buf_T	*buf;
+int		i;
+{
+vim_free(SYN_ITEMS(buf)[i].sp_pattern);
+vim_free(SYN_ITEMS(buf)[i].sp_prog);
+/* Only free sp_cont_list and sp_next_list of first start pattern */
+if (i == 0 || SYN_ITEMS(buf)[i - 1].sp_type != SPTYPE_START)
+{
+	vim_free(SYN_ITEMS(buf)[i].sp_cont_list);
+	vim_free(SYN_ITEMS(buf)[i].sp_next_list);
+}
+}
+/*
+* Clear and free one syntax cluster.
+*/
+static void
+syn_clear_cluster(buf, i)
+buf_T	*buf;
+int		i;
+{
+vim_free(SYN_CLSTR(buf)[i].scl_name);
+vim_free(SYN_CLSTR(buf)[i].scl_name_u);
+vim_free(SYN_CLSTR(buf)[i].scl_list);
+}
+/*
+* Handle ":syntax clear" command.
+*/
+static void
+syn_cmd_clear(eap, syncing)
+exarg_T	*eap;
+int		syncing;
+{
+char_u	*arg = eap->arg;
+char_u	*arg_end;
+int		id;
+eap->nextcmd = find_nextcmd(arg);
+if (eap->skip)
+	return;
+/*
+* We have to disable this within ":syn include @group filename",
+* because otherwise @group would get deleted.
+* Only required for Vim 5.x syntax files, 6.0 ones don't contain ":syn
+* clear".
+*/
+if (curbuf->b_syn_topgrp != 0)
+	return;
+if (ends_excmd(*arg))
+{
+	/*
+	 * No argument: Clear all syntax items.
+	 */
+	if (syncing)
+	    syntax_sync_clear();
+	else
+	{
+	    syntax_clear(curbuf);
+	    do_unlet((char_u *)"b:current_syntax");
+	}
+}
+else
+{
+	/*
+	 * Clear the group IDs that are in the argument.
+	 */
+	while (!ends_excmd(*arg))
+	{
+	    arg_end = skiptowhite(arg);
+	    if (*arg == '@')
+	    {
+		id = syn_scl_namen2id(arg + 1, (int)(arg_end - arg - 1));
+		if (id == 0)
+		{
+		    EMSG2(_("E391: No such syntax cluster: %s"), arg);
+		    break;
+		}
+		else
+		{
+		    /*
+		     * We can't physically delete a cluster without changing
+		     * the IDs of other clusters, so we do the next best thing
+		     * and make it empty.
+		     */
+		    short scl_id = id - SYNID_CLUSTER;
+		    vim_free(SYN_CLSTR(curbuf)[scl_id].scl_list);
+		    SYN_CLSTR(curbuf)[scl_id].scl_list = NULL;
+		}
+	    }
+	    else
+	    {
+		id = syn_namen2id(arg, (int)(arg_end - arg));
+		if (id == 0)
+		{
+		    EMSG2(_(e_nogroup), arg);
+		    break;
+		}
+		else
+		    syn_clear_one(id, syncing);
+	    }
+	    arg = skipwhite(arg_end);
+	}
+}
+redraw_curbuf_later(NOT_VALID);
+syn_stack_free_all(curbuf);		/* Need to recompute all syntax. */
+}
+/*
+* Clear one syntax group for the current buffer.
+*/
+static void
+syn_clear_one(id, syncing)
+int		id;
+int		syncing;
+{
+synpat_T	*spp;
+int		idx;
+/* Clear keywords only when not ":syn sync clear group-name" */
+if (!syncing)
+{
+	(void)syn_clear_keyword(id, curbuf->b_keywtab);
+	(void)syn_clear_keyword(id, curbuf->b_keywtab_ic);
+}
+/* clear the patterns for "id" */
+for (idx = curbuf->b_syn_patterns.ga_len; --idx >= 0; )
+{
+	spp = &(SYN_ITEMS(curbuf)[idx]);
+	if (spp->sp_syn.id != id || spp->sp_syncing != syncing)
+	    continue;
+	syn_remove_pattern(curbuf, idx);
+}
+}
+/*
+* Handle ":syntax on" command.
+*/
+/* ARGSUSED */
+static void
+syn_cmd_on(eap, syncing)
+exarg_T	*eap;
+int		syncing;	/* not used */
+{
+syn_cmd_onoff(eap, "syntax");
+}
+/*
+* Handle ":syntax enable" command.
+*/
+/* ARGSUSED */
+static void
+syn_cmd_enable(eap, syncing)
+exarg_T	*eap;
+int		syncing;	/* not used */
+{
+set_internal_string_var((char_u *)"syntax_cmd", (char_u *)"enable");
+syn_cmd_onoff(eap, "syntax");
+do_unlet((char_u *)"g:syntax_cmd");
+}
+/*
+* Handle ":syntax reset" command.
+*/
+/* ARGSUSED */
+static void
+syn_cmd_reset(eap, syncing)
+exarg_T	*eap;
+int		syncing;	/* not used */
+{
+eap->nextcmd = check_nextcmd(eap->arg);
+if (!eap->skip)
+{
+	set_internal_string_var((char_u *)"syntax_cmd", (char_u *)"reset");
+	do_cmdline_cmd((char_u *)"runtime! syntax/syncolor.vim");
+	do_unlet((char_u *)"g:syntax_cmd");
+}
+}
+/*
+* Handle ":syntax manual" command.
+*/
+/* ARGSUSED */
+static void
+syn_cmd_manual(eap, syncing)
+exarg_T	*eap;
+int		syncing;	/* not used */
+{
+syn_cmd_onoff(eap, "manual");
+}
+/*
+* Handle ":syntax off" command.
+*/
+/* ARGSUSED */
+static void
+syn_cmd_off(eap, syncing)
+exarg_T	*eap;
+int		syncing;	/* not used */
+{
+syn_cmd_onoff(eap, "nosyntax");
+}
+static void
+syn_cmd_onoff(eap, name)
+exarg_T	*eap;
+char	*name;
+{
+char_u	buf[100];
+eap->nextcmd = check_nextcmd(eap->arg);
+if (!eap->skip)
+{
+	STRCPY(buf, "so ");
+	sprintf((char *)buf + 3, SYNTAX_FNAME, name);
+	do_cmdline_cmd(buf);
+}
+}
+/*
+* Handle ":syntax [list]" command: list current syntax words.
+*/
+static void
+syn_cmd_list(eap, syncing)
+exarg_T	*eap;
+int		syncing;	    /* when TRUE: list syncing items */
+{
+char_u	*arg = eap->arg;
+int		id;
+char_u	*arg_end;
+eap->nextcmd = find_nextcmd(arg);
+if (eap->skip)
+	return;
+if (!syntax_present(curbuf))
+{
+	MSG(_("No Syntax items defined for this buffer"));
+	return;
+}
+if (syncing)
+{
+	if (curbuf->b_syn_sync_flags & SF_CCOMMENT)
+	{
+	    MSG_PUTS(_("syncing on C-style comments"));
+	    syn_lines_msg();
+	    syn_match_msg();
+	    return;
+	}
+	else if (!(curbuf->b_syn_sync_flags & SF_MATCH))
+	{
+	    if (curbuf->b_syn_sync_minlines == 0)
+		MSG_PUTS(_("no syncing"));
+	    else
+	    {
+		MSG_PUTS(_("syncing starts "));
+		msg_outnum(curbuf->b_syn_sync_minlines);
+		MSG_PUTS(_(" lines before top line"));
+		syn_match_msg();
+	    }
+	    return;
+	}
+	MSG_PUTS_TITLE(_("\n--- Syntax sync items ---"));
+	if (curbuf->b_syn_sync_minlines > 0
+		|| curbuf->b_syn_sync_maxlines > 0
+		|| curbuf->b_syn_sync_linebreaks > 0)
+	{
+	    MSG_PUTS(_("\nsyncing on items"));
+	    syn_lines_msg();
+	    syn_match_msg();
+	}
+}
+else
+	MSG_PUTS_TITLE(_("\n--- Syntax items ---"));
+if (ends_excmd(*arg))
+{
+	/*
+	 * No argument: List all group IDs and all syntax clusters.
+	 */
+	for (id = 1; id <= highlight_ga.ga_len && !got_int; ++id)
+	    syn_list_one(id, syncing, FALSE);
+	for (id = 0; id < curbuf->b_syn_clusters.ga_len && !got_int; ++id)
+	    syn_list_cluster(id);
+}
+else
+{
+	/*
+	 * List the group IDs and syntax clusters that are in the argument.
+	 */
+	while (!ends_excmd(*arg) && !got_int)
+	{
+	    arg_end = skiptowhite(arg);
+	    if (*arg == '@')
+	    {
+		id = syn_scl_namen2id(arg + 1, (int)(arg_end - arg - 1));
+		if (id == 0)
+		    EMSG2(_("E392: No such syntax cluster: %s"), arg);
+		else
+		    syn_list_cluster(id - SYNID_CLUSTER);
+	    }
+	    else
+	    {
+		id = syn_namen2id(arg, (int)(arg_end - arg));
+		if (id == 0)
+		    EMSG2(_(e_nogroup), arg);
+		else
+		    syn_list_one(id, syncing, TRUE);
+	    }
+	    arg = skipwhite(arg_end);
+	}
+}
+eap->nextcmd = check_nextcmd(arg);
+}
+static void
+syn_lines_msg()
+{
+if (curbuf->b_syn_sync_maxlines > 0 || curbuf->b_syn_sync_minlines > 0)
+{
+	MSG_PUTS("; ");
+	if (curbuf->b_syn_sync_minlines > 0)
+	{
+	    MSG_PUTS(_("minimal "));
+	    msg_outnum(curbuf->b_syn_sync_minlines);
+	    if (curbuf->b_syn_sync_maxlines)
+		MSG_PUTS(", ");
+	}
+	if (curbuf->b_syn_sync_maxlines > 0)
+	{
+	    MSG_PUTS(_("maximal "));
+	    msg_outnum(curbuf->b_syn_sync_maxlines);
+	}
+	MSG_PUTS(_(" lines before top line"));
+}
+}
+static void
+syn_match_msg()
+{
+if (curbuf->b_syn_sync_linebreaks > 0)
+{
+	MSG_PUTS(_("; match "));
+	msg_outnum(curbuf->b_syn_sync_linebreaks);
+	MSG_PUTS(_(" line breaks"));
+}
+}
+static int  last_matchgroup;
+struct name_list
+{
+int		flag;
+char	*name;
+};
+static void syn_list_flags __ARGS((struct name_list *nl, int flags, int attr));
+/*
+* List one syntax item, for ":syntax" or "syntax list syntax_name".
+*/
+static void
+syn_list_one(id, syncing, link_only)
+int		id;
+int		syncing;	    /* when TRUE: list syncing items */
+int		link_only;	    /* when TRUE; list link-only too */
+{
+int		attr;
+int		idx;
+int		did_header = FALSE;
+synpat_T	*spp;
+static struct name_list namelist1[] =
+		{
+		    {HL_DISPLAY, "display"},
+		    {HL_CONTAINED, "contained"},
+		    {HL_ONELINE, "oneline"},
+		    {HL_KEEPEND, "keepend"},
+		    {HL_EXTEND, "extend"},
+		    {HL_EXCLUDENL, "excludenl"},
+		    {HL_TRANSP, "transparent"},
+		    {HL_FOLD, "fold"},
+		    {0, NULL}
+		};
+static struct name_list namelist2[] =
+		{
+		    {HL_SKIPWHITE, "skipwhite"},
+		    {HL_SKIPNL, "skipnl"},
+		    {HL_SKIPEMPTY, "skipempty"},
+		    {0, NULL}
+		};
+attr = hl_attr(HLF_D);		/* highlight like directories */
+/* list the keywords for "id" */
+if (!syncing)
+{
+	did_header = syn_list_keywords(id, curbuf->b_keywtab, FALSE, attr);
+	did_header = syn_list_keywords(id, curbuf->b_keywtab_ic,
+							    did_header, attr);
+}
+/* list the patterns for "id" */
+for (idx = 0; idx < curbuf->b_syn_patterns.ga_len && !got_int; ++idx)
+{
+	spp = &(SYN_ITEMS(curbuf)[idx]);
+	if (spp->sp_syn.id != id || spp->sp_syncing != syncing)
+	    continue;
+	(void)syn_list_header(did_header, 999, id);
+	did_header = TRUE;
+	last_matchgroup = 0;
+	if (spp->sp_type == SPTYPE_MATCH)
+	{
+	    put_pattern("match", ' ', spp, attr);
+	    msg_putchar(' ');
+	}
+	else if (spp->sp_type == SPTYPE_START)
+	{
+	    while (SYN_ITEMS(curbuf)[idx].sp_type == SPTYPE_START)
+		put_pattern("start", '=', &SYN_ITEMS(curbuf)[idx++], attr);
+	    if (SYN_ITEMS(curbuf)[idx].sp_type == SPTYPE_SKIP)
+		put_pattern("skip", '=', &SYN_ITEMS(curbuf)[idx++], attr);
+	    while (idx < curbuf->b_syn_patterns.ga_len
+			      && SYN_ITEMS(curbuf)[idx].sp_type == SPTYPE_END)
+		put_pattern("end", '=', &SYN_ITEMS(curbuf)[idx++], attr);
+	    --idx;
+	    msg_putchar(' ');
+	}
+	syn_list_flags(namelist1, spp->sp_flags, attr);
+	if (spp->sp_cont_list != NULL)
+	    put_id_list((char_u *)"contains", spp->sp_cont_list, attr);
+	if (spp->sp_syn.cont_in_list != NULL)
+	    put_id_list((char_u *)"containedin",
+					      spp->sp_syn.cont_in_list, attr);
+	if (spp->sp_next_list != NULL)
+	{
+	    put_id_list((char_u *)"nextgroup", spp->sp_next_list, attr);
+	    syn_list_flags(namelist2, spp->sp_flags, attr);
+	}
+	if (spp->sp_flags & (HL_SYNC_HERE|HL_SYNC_THERE))
+	{
+	    if (spp->sp_flags & HL_SYNC_HERE)
+		msg_puts_attr((char_u *)"grouphere", attr);
+	    else
+		msg_puts_attr((char_u *)"groupthere", attr);
+	    msg_putchar(' ');
+	    if (spp->sp_sync_idx >= 0)
+		msg_outtrans(HL_TABLE()[SYN_ITEMS(curbuf)
+				   [spp->sp_sync_idx].sp_syn.id - 1].sg_name);
+	    else
+		MSG_PUTS("NONE");
+	    msg_putchar(' ');
+	}
+}
+/* list the link, if there is one */
+if (HL_TABLE()[id - 1].sg_link && (did_header || link_only) && !got_int)
+{
+	(void)syn_list_header(did_header, 999, id);
+	msg_puts_attr((char_u *)"links to", attr);
+	msg_putchar(' ');
+	msg_outtrans(HL_TABLE()[HL_TABLE()[id - 1].sg_link - 1].sg_name);
+}
+}
+static void
+syn_list_flags(nl, flags, attr)
+struct name_list	*nl;
+int			flags;
+int			attr;
+{
+int		i;
+for (i = 0; nl[i].flag != 0; ++i)
+	if (flags & nl[i].flag)
+	{
+	    msg_puts_attr((char_u *)nl[i].name, attr);
+	    msg_putchar(' ');
+	}
+}
+/*
+* List one syntax cluster, for ":syntax" or "syntax list syntax_name".
+*/
+static void
+syn_list_cluster(id)
+int id;
+{
+int	    endcol = 15;
+/* slight hack:  roughly duplicate the guts of syn_list_header() */
+msg_putchar('\n');
+msg_outtrans(SYN_CLSTR(curbuf)[id].scl_name);
+if (msg_col >= endcol)	/* output at least one space */
+	endcol = msg_col + 1;
+if (Columns <= endcol)	/* avoid hang for tiny window */
+	endcol = Columns - 1;
+msg_advance(endcol);
+if (SYN_CLSTR(curbuf)[id].scl_list != NULL)
+{
+	put_id_list((char_u *)"cluster", SYN_CLSTR(curbuf)[id].scl_list,
+		    hl_attr(HLF_D));
+}
+else
+{
+	msg_puts_attr((char_u *)"cluster", hl_attr(HLF_D));
+	msg_puts((char_u *)"=NONE");
+}
+}
+static void
+put_id_list(name, list, attr)
+char_u	*name;
+short	*list;
+int		attr;
+{
+short		*p;
+msg_puts_attr(name, attr);
+msg_putchar('=');
+for (p = list; *p; ++p)
+{
+	if (*p >= SYNID_ALLBUT && *p < SYNID_TOP)
+	{
+	    if (p[1])
+		MSG_PUTS("ALLBUT");
+	    else
+		MSG_PUTS("ALL");
+	}
+	else if (*p >= SYNID_TOP && *p < SYNID_CONTAINED)
+	{
+	    MSG_PUTS("TOP");
+	}
+	else if (*p >= SYNID_CONTAINED && *p < SYNID_CLUSTER)
+	{
+	    MSG_PUTS("CONTAINED");
+	}
+	else if (*p >= SYNID_CLUSTER)
+	{
+	    short scl_id = *p - SYNID_CLUSTER;
+	    msg_putchar('@');
+	    msg_outtrans(SYN_CLSTR(curbuf)[scl_id].scl_name);
+	}
+	else
+	    msg_outtrans(HL_TABLE()[*p - 1].sg_name);
+	if (p[1])
+	    msg_putchar(',');
+}
+msg_putchar(' ');
+}
+static void
+put_pattern(s, c, spp, attr)
+char	*s;
+int		c;
+synpat_T	*spp;
+int		attr;
+{
+long	n;
+int		mask;
+int		first;
+static char	*sepchars = "/+=-#@\"|'^&";
+int		i;
+/* May have to write "matchgroup=group" */
+if (last_matchgroup != spp->sp_syn_match_id)
+{
+	last_matchgroup = spp->sp_syn_match_id;
+	msg_puts_attr((char_u *)"matchgroup", attr);
+	msg_putchar('=');
+	if (last_matchgroup == 0)
+	    msg_outtrans((char_u *)"NONE");
+	else
+	    msg_outtrans(HL_TABLE()[last_matchgroup - 1].sg_name);
+	msg_putchar(' ');
+}
+/* output the name of the pattern and an '=' or ' ' */
+msg_puts_attr((char_u *)s, attr);
+msg_putchar(c);
+/* output the pattern, in between a char that is not in the pattern */
+for (i = 0; vim_strchr(spp->sp_pattern, sepchars[i]) != NULL; )
+	if (sepchars[++i] == NUL)
+	{
+	    i = 0;	/* no good char found, just use the first one */
+	    break;
+	}
+msg_putchar(sepchars[i]);
+msg_outtrans(spp->sp_pattern);
+msg_putchar(sepchars[i]);
+/* output any pattern options */
+first = TRUE;
+for (i = 0; i < SPO_COUNT; ++i)
+{
+	mask = (1 << i);
+	if (spp->sp_off_flags & (mask + (mask << SPO_COUNT)))
+	{
+	    if (!first)
+		msg_putchar(',');	/* separate with commas */
+	    msg_puts((char_u *)spo_name_tab[i]);
+	    n = spp->sp_offsets[i];
+	    if (i != SPO_LC_OFF)
+	    {
+		if (spp->sp_off_flags & mask)
+		    msg_putchar('s');
+		else
+		    msg_putchar('e');
+		if (n > 0)
+		    msg_putchar('+');
+	    }
+	    if (n || i == SPO_LC_OFF)
+		msg_outnum(n);
+	    first = FALSE;
+	}
+}
+msg_putchar(' ');
+}
+/*
+* List or clear the keywords for one syntax group.
+* Return TRUE if the header has been printed.
+*/
+static int
+syn_list_keywords(id, ktabp, did_header, attr)
+int		id;
+keyentry_T	**ktabp;
+int		did_header;		/* header has already been printed */
+int		attr;
+{
+int		i;
+int		outlen;
+keyentry_T	*ktab;
+int		prev_contained = 0;
+short	*prev_next_list = NULL;
+short	*prev_cont_in_list = NULL;
+int		prev_skipnl = 0;
+int		prev_skipwhite = 0;
+int		prev_skipempty = 0;
+if (ktabp == NULL)
+	return did_header;
+/*
+* Unfortunately, this list of keywords is not sorted on alphabet but on
+* hash value...
+*/
+for (i = 0; i < KHASH_SIZE; ++i)
+{
+	for (ktab = ktabp[i]; ktab != NULL && !got_int; ktab = ktab->next)
+	{
+	    if (ktab->k_syn.id == id)
+	    {
+		if (prev_contained != (ktab->flags & HL_CONTAINED)
+			|| prev_skipnl != (ktab->flags & HL_SKIPNL)
+			|| prev_skipwhite != (ktab->flags & HL_SKIPWHITE)
+			|| prev_skipempty != (ktab->flags & HL_SKIPEMPTY)
+			|| prev_cont_in_list != ktab->k_syn.cont_in_list
+			|| prev_next_list != ktab->next_list)
+		    outlen = 9999;
+		else
+		    outlen = (int)STRLEN(ktab->keyword);
+		/* output "contained" and "nextgroup" on each line */
+		if (syn_list_header(did_header, outlen, id))
+		{
+		    prev_contained = 0;
+		    prev_next_list = NULL;
+		    prev_cont_in_list = NULL;
+		    prev_skipnl = 0;
+		    prev_skipwhite = 0;
+		    prev_skipempty = 0;
+		}
+		did_header = TRUE;
+		if (prev_contained != (ktab->flags & HL_CONTAINED))
+		{
+		    msg_puts_attr((char_u *)"contained", attr);
+		    msg_putchar(' ');
+		    prev_contained = (ktab->flags & HL_CONTAINED);
+		}
+		if (ktab->k_syn.cont_in_list != prev_cont_in_list)
+		{
+		    put_id_list((char_u *)"containedin",
+					      ktab->k_syn.cont_in_list, attr);
+		    msg_putchar(' ');
+		    prev_cont_in_list = ktab->k_syn.cont_in_list;
+		}
+		if (ktab->next_list != prev_next_list)
+		{
+		    put_id_list((char_u *)"nextgroup", ktab->next_list, attr);
+		    msg_putchar(' ');
+		    prev_next_list = ktab->next_list;
+		    if (ktab->flags & HL_SKIPNL)
+		    {
+			msg_puts_attr((char_u *)"skipnl", attr);
+			msg_putchar(' ');
+			prev_skipnl = (ktab->flags & HL_SKIPNL);
+		    }
+		    if (ktab->flags & HL_SKIPWHITE)
+		    {
+			msg_puts_attr((char_u *)"skipwhite", attr);
+			msg_putchar(' ');
+			prev_skipwhite = (ktab->flags & HL_SKIPWHITE);
+		    }
+		    if (ktab->flags & HL_SKIPEMPTY)
+		    {
+			msg_puts_attr((char_u *)"skipempty", attr);
+			msg_putchar(' ');
+			prev_skipempty = (ktab->flags & HL_SKIPEMPTY);
+		    }
+		}
+		msg_outtrans(ktab->keyword);
+	    }
+	}
+}
+return did_header;
+}
+static void
+syn_clear_keyword(id, ktabp)
+int		id;
+keyentry_T	**ktabp;
+{
+int		i;
+keyentry_T	*ktab;
+keyentry_T	*ktab_prev;
+keyentry_T	*ktab_next;
+if (ktabp == NULL)	    /* no keywords present */
+	return;
+for (i = 0; i < KHASH_SIZE; ++i)
+{
+	ktab_prev = NULL;
+	for (ktab = ktabp[i]; ktab != NULL; )
+	{
+	    if (ktab->k_syn.id == id)
+	    {
+		ktab_next = ktab->next;
+		if (ktab_prev == NULL)
+		    ktabp[i] = ktab_next;
+		else
+		    ktab_prev->next = ktab_next;
+		vim_free(ktab);
+		ktab = ktab_next;
+	    }
+	    else
+	    {
+		ktab_prev = ktab;
+		ktab = ktab->next;
+	    }
+	}
+}
+}
+/*
+* Recursive function to free() a branch of a kwordtab.
+*/
+static void
+free_keywtab(ktabp)
+keyentry_T	**ktabp;
+{
+int		i;
+keyentry_T	*ktab;
+keyentry_T	*ktab_next;
+if (ktabp != NULL)
+{
+	for (i = 0; i < KHASH_SIZE; ++i)
+	    for (ktab = ktabp[i]; ktab != NULL; ktab = ktab_next)
+	    {
+		ktab_next = ktab->next;
+		vim_free(ktab->next_list);
+		vim_free(ktab->k_syn.cont_in_list);
+		vim_free(ktab);
+	    }
+	vim_free(ktabp);
+}
+}
+/*
+* Add a keyword to the list of keywords.
+*/
+static void
+add_keyword(name, id, flags, cont_in_list, next_list)
+char_u	*name;	    /* name of keyword */
+int		id;	    /* group ID for this keyword */
+int		flags;	    /* flags for this keyword */
+short	*cont_in_list; /* containedin for this keyword */
+short	*next_list; /* nextgroup for this keyword */
+{
+keyentry_T	*ktab;
+keyentry_T	***ktabpp;
+int		hash;
+char_u	*name_ic = name;
+if (curbuf->b_syn_ic)
+{
+	name_ic = str_foldcase(name, (int)STRLEN(name));
+	if (name_ic == NULL)
+	    name_ic = name;
+}
+ktab = (keyentry_T *)alloc((int)(sizeof(keyentry_T) + STRLEN(name_ic)));
+if (ktab == NULL)
+	return;
+STRCPY(ktab->keyword, name_ic);
+if (name_ic != name)
+	vim_free(name_ic);
+ktab->k_syn.id = id;
+ktab->k_syn.inc_tag = current_syn_inc_tag;
+ktab->flags = flags;
+ktab->k_syn.cont_in_list = copy_id_list(cont_in_list);
+if (cont_in_list != NULL)
+	curbuf->b_syn_containedin = TRUE;
+ktab->next_list = copy_id_list(next_list);
+if (curbuf->b_syn_ic)
+	ktabpp = &curbuf->b_keywtab_ic;
+else
+	ktabpp = &curbuf->b_keywtab;
+if (*ktabpp == NULL)
+{
+	*ktabpp = (keyentry_T **)alloc_clear(
+				    (int)(sizeof(keyentry_T *) * KHASH_SIZE));
+	if (*ktabpp == NULL)
+	    return;
+}
+hash = syn_khash(ktab->keyword);
+ktab->next = (*ktabpp)[hash];
+(*ktabpp)[hash] = ktab;
+}
+/*
+* Compute a hash value for a keyword.  Uses the ElfHash algorithm, which is
+* supposed to have an even distribution (suggested by Charles Campbell).
+*/
+static int
+syn_khash(p)
+char_u	*p;
+{
+long_u	hash = 0;
+long_u	g;
+while (*p != NUL)
+{
+	hash = (hash << 4) + *p++;	/* clear low 4 bits of hash, add char */
+	g = hash & 0xf0000000L;		/* g has high 4 bits of hash only */
+	if (g != 0)
+	    hash ^= g >> 24;		/* xor g's high 4 bits into hash */
+}
+return (int)(hash & KHASH_MASK);
+}
+/*
+* Get the start and end of the group name argument.
+* Return a pointer to the first argument.
+* Return NULL if the end of the command was found instead of further args.
+*/
+static char_u *
+get_group_name(arg, name_end)
+char_u	*arg;		/* start of the argument */
+char_u	**name_end;	/* pointer to end of the name */
+{
+char_u	*rest;
+*name_end = skiptowhite(arg);
+rest = skipwhite(*name_end);
+/*
+* Check if there are enough arguments.  The first argument may be a
+* pattern, where '|' is allowed, so only check for NUL.
+*/
+if (ends_excmd(*arg) || *rest == NUL)
+	return NULL;
+return rest;
+}
+/*
+* Check for syntax command option arguments.
+* This can be called at any place in the list of arguments, and just picks
+* out the arguments that are known.  Can be called several times in a row to
+* collect all options in between other arguments.
+* Return a pointer to the next argument (which isn't an option).
+* Return NULL for any error;
+*/
+static char_u *
+get_syn_options(arg, flagsp, keyword, sync_idx, cont_list,
+						      cont_in_list, next_list)
+char_u	*arg;		/* next argument */
+int		*flagsp;	/* flags for contained and transpartent */
+int		keyword;	/* TRUE for ":syn keyword" */
+int		*sync_idx;	/* syntax item for "grouphere" argument, NULL
+				   if not allowed */
+short	**cont_list;	/* group IDs for "contains" argument, NULL if
+				   not allowed */
+short	**cont_in_list;	/* group IDs for "containedin" argument, NULL
+				   if not allowed */
+short	**next_list;	/* group IDs for "nextgroup" argument */
+{
+int		flags;
+char_u	*gname_start, *gname;
+int		syn_id;
+int		len;
+int		i;
+int		fidx;
+static struct flag
+{
+	char	*name;
+	int	len;
+	int	val;
+} flagtab[] = { {"contained",   9,	HL_CONTAINED},
+		    {"oneline",	    7,	HL_ONELINE},
+		    {"keepend",	    7,	HL_KEEPEND},
+		    {"extend",	    6,	HL_EXTEND},
+		    {"excludenl",   9,	HL_EXCLUDENL},
+		    {"transparent", 11, HL_TRANSP},
+		    {"skipnl",	    6,	HL_SKIPNL},
+		    {"skipwhite",   9,	HL_SKIPWHITE},
+		    {"skipempty",   9,	HL_SKIPEMPTY},
+		    {"grouphere",   9,	HL_SYNC_HERE},
+		    {"groupthere",  10,	HL_SYNC_THERE},
+		    {"display",	    7,	HL_DISPLAY},
+		    {"fold",	    4,	HL_FOLD},
+		};
+#define MLEN 12
+char	lowname[MLEN];
+int		llen;
+if (arg == NULL)		/* already detected error */
+	return NULL;
+flags = *flagsp;
+for (;;)
+{
+	/* STRNICMP() is a bit slow, change arg to lowercase first and use
+	 * STRNCMP() */
+	for (llen = 0; llen < MLEN; ++llen)
+	{
+	    if (!isalpha(arg[llen]))
+		break;
+	    lowname[llen] = TOLOWER_ASC(arg[llen]);
+	}
+	for (fidx = sizeof(flagtab) / sizeof(struct flag); --fidx >= 0; )
+	{
+	    len = flagtab[fidx].len;
+	    if (len == llen
+		    && STRNCMP(lowname, flagtab[fidx].name, len) == 0
+		    && (ends_excmd(arg[len]) || vim_iswhite(arg[len])))
+	    {
+		if (keyword
+			&& (flagtab[fidx].val == HL_DISPLAY
+			    || flagtab[fidx].val == HL_FOLD
+			    || flagtab[fidx].val == HL_EXTEND))
+		{
+		    /* treat "display", "fold" and "extend" as a keyword */
+		    fidx = -1;
+		    break;
+		}
+		flags |= flagtab[fidx].val;
+		arg = skipwhite(arg + len);
+		if (flagtab[fidx].val == HL_SYNC_HERE
+			|| flagtab[fidx].val == HL_SYNC_THERE)
+		{
+		    if (sync_idx == NULL)
+		    {
+			EMSG(_("E393: group[t]here not accepted here"));
+			return NULL;
+		    }
+		    gname_start = arg;
+		    arg = skiptowhite(arg);
+		    if (gname_start == arg)
+			return NULL;
+		    gname = vim_strnsave(gname_start, (int)(arg - gname_start));
+		    if (gname == NULL)
+			return NULL;
+		    if (STRCMP(gname, "NONE") == 0)
+			*sync_idx = NONE_IDX;
+		    else
+		    {
+			syn_id = syn_name2id(gname);
+			for (i = curbuf->b_syn_patterns.ga_len; --i >= 0; )
+			    if (SYN_ITEMS(curbuf)[i].sp_syn.id == syn_id
+				&& SYN_ITEMS(curbuf)[i].sp_type == SPTYPE_START)
+			    {
+				*sync_idx = i;
+				break;
+			    }
+			if (i < 0)
+			{
+			    EMSG2(_("E394: Didn't find region item for %s"), gname);
+			    vim_free(gname);
+			    return NULL;
+			}
+		    }
+		    vim_free(gname);
+		    arg = skipwhite(arg);
+		}
+#ifdef FEAT_FOLDING
+		else if (flagtab[fidx].val == HL_FOLD
+						&& foldmethodIsSyntax(curwin))
+		{
+		    /* Need to update folds later. */
+		    foldUpdateAll(curwin);
+		}
+#endif
+		break;
+	    }
+	}
+	if (fidx >= 0)
+	    continue;
+	if (llen == 8 && STRNCMP(lowname, "contains", 8) == 0
+		&& (vim_iswhite(arg[8]) || arg[8] == '='))
+	{
+	    if (cont_list == NULL)
+	    {
+		EMSG(_("E395: contains argument not accepted here"));
+		return NULL;
+	    }
+	    if (get_id_list(&arg, 8, cont_list) == FAIL)
+		return NULL;
+	}
+	else if (llen == 11 && STRNCMP(lowname, "containedin", 11) == 0
+		&& (vim_iswhite(arg[11]) || arg[11] == '='))
+	{
+	    if (cont_in_list == NULL)
+	    {
+		EMSG(_("E396: containedin argument not accepted here"));
+		return NULL;
+	    }
+	    if (get_id_list(&arg, 11, cont_in_list) == FAIL)
+		return NULL;
+	}
+	else if (llen == 9 && STRNCMP(lowname, "nextgroup", 9) == 0
+		&& (vim_iswhite(arg[9]) || arg[9] == '='))
+	{
+	    if (get_id_list(&arg, 9, next_list) == FAIL)
+		return NULL;
+	}
+	else
+	    break;
+}
+*flagsp = flags;
+return arg;
+}
+/*
+* Adjustments to syntax item when declared in a ":syn include"'d file.
+* Set the contained flag, and if the item is not already contained, add it
+* to the specified top-level group, if any.
+*/
+static void
+syn_incl_toplevel(id, flagsp)
+int		id;
+int		*flagsp;
+{
+if ((*flagsp & HL_CONTAINED) || curbuf->b_syn_topgrp == 0)
+	return;
+*flagsp |= HL_CONTAINED;
+if (curbuf->b_syn_topgrp >= SYNID_CLUSTER)
+{
+	/* We have to alloc this, because syn_combine_list() will free it. */
+	short	    *grp_list = (short *)alloc((unsigned)(2 * sizeof(short)));
+	int	    tlg_id = curbuf->b_syn_topgrp - SYNID_CLUSTER;
+	if (grp_list != NULL)
+	{
+	    grp_list[0] = id;
+	    grp_list[1] = 0;
+	    syn_combine_list(&SYN_CLSTR(curbuf)[tlg_id].scl_list, &grp_list,
+			 CLUSTER_ADD);
+	}
+}
+}
+/*
+* Handle ":syntax include [@{group-name}] filename" command.
+*/
+/* ARGSUSED */
+static void
+syn_cmd_include(eap, syncing)
+exarg_T	*eap;
+int		syncing;	    /* not used */
+{
+char_u	*arg = eap->arg;
+int		sgl_id = 1;
+char_u	*group_name_end;
+char_u	*rest;
+char_u	*errormsg = NULL;
+int		prev_toplvl_grp;
+int		prev_syn_inc_tag;
+int		source = FALSE;
+eap->nextcmd = find_nextcmd(arg);
+if (eap->skip)
+	return;
+if (arg[0] == '@')
+{
+	++arg;
+	rest = get_group_name(arg, &group_name_end);
+	if (rest == NULL)
+	{
+	    EMSG((char_u *)_("E397: Filename required"));
+	    return;
+	}
+	sgl_id = syn_check_cluster(arg, (int)(group_name_end - arg));
+	/* separate_nextcmd() and expand_filename() depend on this */
+	eap->arg = rest;
+}
+/*
+* Everything that's left, up to the next command, should be the
+* filename to include.
+*/
+eap->argt |= (XFILE | NOSPC);
+separate_nextcmd(eap);
+if (*eap->arg == '<' || *eap->arg == '$' || mch_isFullName(eap->arg))
+{
+	/* For an absolute path, "$VIM/..." or "<sfile>.." we ":source" the
+	 * file.  Need to expand the file name first.  In other cases
+	 * ":runtime!" is used. */
+	source = TRUE;
+	if (expand_filename(eap, syn_cmdlinep, &errormsg) == FAIL)
+	{
+	    if (errormsg != NULL)
+		EMSG(errormsg);
+	    return;
+	}
+}
+/*
+* Save and restore the existing top-level grouplist id and ":syn
+* include" tag around the actual inclusion.
+*/
+prev_syn_inc_tag = current_syn_inc_tag;
+current_syn_inc_tag = ++running_syn_inc_tag;
+prev_toplvl_grp = curbuf->b_syn_topgrp;
+curbuf->b_syn_topgrp = sgl_id;
+if (source ? do_source(eap->arg, FALSE, FALSE) == FAIL
+					: cmd_runtime(eap->arg, TRUE) == FAIL)
+	EMSG2(_(e_notopen), eap->arg);
+curbuf->b_syn_topgrp = prev_toplvl_grp;
+current_syn_inc_tag = prev_syn_inc_tag;
+}
+/*
+* Handle ":syntax keyword {group-name} [{option}] keyword .." command.
+*/
+/* ARGSUSED */
+static void
+syn_cmd_keyword(eap, syncing)
+exarg_T	*eap;
+int		syncing;	    /* not used */
+{
+char_u	*arg = eap->arg;
+char_u	*group_name_end;
+int		syn_id;
+char_u	*rest;
+char_u	*keyword_copy;
+char_u	*p;
+char_u	*first_arg;
+int		round;
+int		flags = 0;
+short	*next_list = NULL;
+short	*cont_in_list = NULL;
+rest = get_group_name(arg, &group_name_end);
+if (rest != NULL)
+{
+	syn_id = syn_check_group(arg, (int)(group_name_end - arg));
+	/* allocate a buffer, for removing the backslashes in the keyword */
+	keyword_copy = alloc((unsigned)STRLEN(rest) + 1);
+	if (keyword_copy != NULL)
+	{
+	    /*
+	     * The options given apply to ALL keywords, so all options must be
+	     * found before keywords can be created.
+	     * round 1: collect the options.
+	     * round 2: create the keywords.
+	     */
+	    first_arg = rest;
+	    for (round = 1; round <= 2; ++round)
+	    {
+		/*
+		 * Isolate each keyword and add an entry for it.
+		 */
+		for (rest = first_arg; rest != NULL && !ends_excmd(*rest);
+						       rest = skipwhite(rest))
+		{
+		    rest = get_syn_options(rest, &flags, TRUE, NULL,
+					     NULL, &cont_in_list, &next_list);
+		    if (rest == NULL || ends_excmd(*rest))
+			break;
+		    p = keyword_copy;
+		    while (*rest != 0 && !vim_iswhite(*rest))
+		    {
+			if (*rest == '\\' && rest[1] != NUL)
+			    ++rest;
+			*p++ = *rest++;
+		    }
+		    *p = NUL;
+		    if (round == 2 && !eap->skip)
+		    {
+			for (p = vim_strchr(keyword_copy, '['); ; )
+			{
+			    if (p != NULL)
+				*p = NUL;
+			    add_keyword(keyword_copy, syn_id, flags,
+						     cont_in_list, next_list);
+			    if (p == NULL || p[1] == NUL || p[1] == ']')
+				break;
+#ifdef FEAT_MBYTE
+			    if (has_mbyte)
+			    {
+				int l = (*mb_ptr2len_check)(p + 1);
+				mch_memmove(p, p + 1, l);
+				p += l;
+			    }
+			    else
+#endif
+			    {
+				p[0] = p[1];
+				++p;
+			    }
+			}
+		    }
+		}
+		if (round == 1)
+		    syn_incl_toplevel(syn_id, &flags);
+	    }
+	    vim_free(keyword_copy);
+	}
+}
+if (rest != NULL)
+	eap->nextcmd = check_nextcmd(rest);
+else
+	EMSG2(_(e_invarg2), arg);
+vim_free(cont_in_list);
+vim_free(next_list);
+redraw_curbuf_later(NOT_VALID);
+syn_stack_free_all(curbuf);		/* Need to recompute all syntax. */
+}
+/*
+* Handle ":syntax match {name} [{options}] {pattern} [{options}]".
+*
+* Also ":syntax sync match {name} [[grouphere | groupthere] {group-name}] .."
+*/
+static void
+syn_cmd_match(eap, syncing)
+exarg_T	*eap;
+int		syncing;	    /* TRUE for ":syntax sync match .. " */
+{
+char_u	*arg = eap->arg;
+char_u	*group_name_end;
+char_u	*rest;
+synpat_T	item;		/* the item found in the line */
+int		syn_id;
+int		idx;
+int		flags = 0;
+int		sync_idx = 0;
+short	*cont_list = NULL;
+short	*cont_in_list = NULL;
+short	*next_list = NULL;
+/* Isolate the group name, check for validity */
+rest = get_group_name(arg, &group_name_end);
+/* Get options before the pattern */
+rest = get_syn_options(rest, &flags, FALSE,
+	   syncing ? &sync_idx : NULL, &cont_list, &cont_in_list, &next_list);
+/* get the pattern. */
+init_syn_patterns();
+vim_memset(&item, 0, sizeof(item));
+rest = get_syn_pattern(rest, &item);
+if (vim_regcomp_had_eol() && !(flags & HL_EXCLUDENL))
+	flags |= HL_HAS_EOL;
+/* Get options after the pattern */
+rest = get_syn_options(rest, &flags, FALSE,
+	   syncing ? &sync_idx : NULL, &cont_list, &cont_in_list, &next_list);
+if (rest != NULL)		/* all arguments are valid */
+{
+	/*
+	 * Check for trailing command and illegal trailing arguments.
+	 */
+	eap->nextcmd = check_nextcmd(rest);
+	if (!ends_excmd(*rest) || eap->skip)
+	    rest = NULL;
+	else if (ga_grow(&curbuf->b_syn_patterns, 1) != FAIL
+		&& (syn_id = syn_check_group(arg,
+					   (int)(group_name_end - arg))) != 0)
+	{
+	    syn_incl_toplevel(syn_id, &flags);
+	    /*
+	     * Store the pattern in the syn_items list
+	     */
+	    idx = curbuf->b_syn_patterns.ga_len;
+	    SYN_ITEMS(curbuf)[idx] = item;
+	    SYN_ITEMS(curbuf)[idx].sp_syncing = syncing;
+	    SYN_ITEMS(curbuf)[idx].sp_type = SPTYPE_MATCH;
+	    SYN_ITEMS(curbuf)[idx].sp_syn.id = syn_id;
+	    SYN_ITEMS(curbuf)[idx].sp_syn.inc_tag = current_syn_inc_tag;
+	    SYN_ITEMS(curbuf)[idx].sp_flags = flags;
+	    SYN_ITEMS(curbuf)[idx].sp_sync_idx = sync_idx;
+	    SYN_ITEMS(curbuf)[idx].sp_cont_list = cont_list;
+	    SYN_ITEMS(curbuf)[idx].sp_syn.cont_in_list = cont_in_list;
+	    if (cont_in_list != NULL)
+		curbuf->b_syn_containedin = TRUE;
+	    SYN_ITEMS(curbuf)[idx].sp_next_list = next_list;
+	    ++curbuf->b_syn_patterns.ga_len;
+	    --curbuf->b_syn_patterns.ga_room;
+	    /* remember that we found a match for syncing on */
+	    if (flags & (HL_SYNC_HERE|HL_SYNC_THERE))
+		curbuf->b_syn_sync_flags |= SF_MATCH;
+#ifdef FEAT_FOLDING
+	    if (flags & HL_FOLD)
+		++curbuf->b_syn_folditems;
+#endif
+	    redraw_curbuf_later(NOT_VALID);
+	    syn_stack_free_all(curbuf);	/* Need to recompute all syntax. */
+	    return;	/* don't free the progs and patterns now */
+	}
+}
+/*
+* Something failed, free the allocated memory.
+*/
+vim_free(item.sp_prog);
+vim_free(item.sp_pattern);
+vim_free(cont_list);
+vim_free(cont_in_list);
+vim_free(next_list);
+if (rest == NULL)
+	EMSG2(_(e_invarg2), arg);
+}
+/*
+* Handle ":syntax region {group-name} [matchgroup={group-name}]
+*		start {start} .. [skip {skip}] end {end} .. [{options}]".
+*/
+static void
+syn_cmd_region(eap, syncing)
+exarg_T	*eap;
+int		syncing;	    /* TRUE for ":syntax sync region .." */
+{
+char_u		*arg = eap->arg;
+char_u		*group_name_end;
+char_u		*rest;			/* next arg, NULL on error */
+char_u		*key_end;
+char_u		*key = NULL;
+char_u		*p;
+int			item;
+#define ITEM_START	    0
+#define ITEM_SKIP	    1
+#define ITEM_END	    2
+#define ITEM_MATCHGROUP	    3
+struct pat_ptr
+{
+	synpat_T	*pp_synp;		/* pointer to syn_pattern */
+	int		pp_matchgroup_id;	/* matchgroup ID */
+	struct pat_ptr	*pp_next;		/* pointer to next pat_ptr */
+}			*(pat_ptrs[3]);
+					/* patterns found in the line */
+struct pat_ptr	*ppp;
+struct pat_ptr	*ppp_next;
+int			pat_count = 0;		/* nr of syn_patterns found */
+int			syn_id;
+int			matchgroup_id = 0;
+int			not_enough = FALSE;	/* not enough arguments */
+int			illegal = FALSE;	/* illegal arguments */
+int			success = FALSE;
+int			idx;
+int			flags = 0;
+short		*cont_list = NULL;
+short		*cont_in_list = NULL;
+short		*next_list = NULL;
+/* Isolate the group name, check for validity */
+rest = get_group_name(arg, &group_name_end);
+pat_ptrs[0] = NULL;
+pat_ptrs[1] = NULL;
+pat_ptrs[2] = NULL;
+init_syn_patterns();
+/*
+* get the options, patterns and matchgroup.
+*/
+while (rest != NULL && !ends_excmd(*rest))
+{
+	/* Check for option arguments */
+	rest = get_syn_options(rest, &flags, FALSE, NULL,
+				       &cont_list, &cont_in_list, &next_list);
+	if (rest == NULL || ends_excmd(*rest))
+	    break;
+	/* must be a pattern or matchgroup then */
+	key_end = rest;
+	while (*key_end && !vim_iswhite(*key_end) && *key_end != '=')
+	    ++key_end;
+	vim_free(key);
+	key = vim_strnsave_up(rest, (int)(key_end - rest));
+	if (key == NULL)			/* out of memory */
+	{
+	    rest = NULL;
+	    break;
+	}
+	if (STRCMP(key, "MATCHGROUP") == 0)
+	    item = ITEM_MATCHGROUP;
+	else if (STRCMP(key, "START") == 0)
+	    item = ITEM_START;
+	else if (STRCMP(key, "END") == 0)
+	    item = ITEM_END;
+	else if (STRCMP(key, "SKIP") == 0)
+	{
+	    if (pat_ptrs[ITEM_SKIP] != NULL)	/* one skip pattern allowed */
+	    {
+		illegal = TRUE;
+		break;
+	    }
+	    item = ITEM_SKIP;
+	}
+	else
+	    break;
+	rest = skipwhite(key_end);
+	if (*rest != '=')
+	{
+	    rest = NULL;
+	    EMSG2(_("E398: Missing '=': %s"), arg);
+	    break;
+	}
+	rest = skipwhite(rest + 1);
+	if (*rest == NUL)
+	{
+	    not_enough = TRUE;
+	    break;
+	}
+	if (item == ITEM_MATCHGROUP)
+	{
+	    p = skiptowhite(rest);
+	    if ((p - rest == 4 && STRNCMP(rest, "NONE", 4) == 0) || eap->skip)
+		matchgroup_id = 0;
+	    else
+	    {
+		matchgroup_id = syn_check_group(rest, (int)(p - rest));
+		if (matchgroup_id == 0)
+		{
+		    illegal = TRUE;
+		    break;
+		}
+	    }
+	    rest = skipwhite(p);
+	}
+	else
+	{
+	    /*
+	     * Allocate room for a syn_pattern, and link it in the list of
+	     * syn_patterns for this item, at the start (because the list is
+	     * used from end to start).
+	     */
+	    ppp = (struct pat_ptr *)alloc((unsigned)sizeof(struct pat_ptr));
+	    if (ppp == NULL)
+	    {
+		rest = NULL;
+		break;
+	    }
+	    ppp->pp_next = pat_ptrs[item];
+	    pat_ptrs[item] = ppp;
+	    ppp->pp_synp = (synpat_T *)alloc_clear((unsigned)sizeof(synpat_T));
+	    if (ppp->pp_synp == NULL)
+	    {
+		rest = NULL;
+		break;
+	    }
+	    /*
+	     * Get the syntax pattern and the following offset(s).
+	     */
+	    /* Enable the appropriate \z specials. */
+	    if (item == ITEM_START)
+		reg_do_extmatch = REX_SET;
+	    else if (item == ITEM_SKIP || item == ITEM_END)
+		reg_do_extmatch = REX_USE;
+	    rest = get_syn_pattern(rest, ppp->pp_synp);
+	    reg_do_extmatch = 0;
+	    if (item == ITEM_END && vim_regcomp_had_eol()
+						   && !(flags & HL_EXCLUDENL))
+		ppp->pp_synp->sp_flags |= HL_HAS_EOL;
+	    ppp->pp_matchgroup_id = matchgroup_id;
+	    ++pat_count;
+	}
+}
+vim_free(key);
+if (illegal || not_enough)
+	rest = NULL;
+/*
+* Must have a "start" and "end" pattern.
+*/
+if (rest != NULL && (pat_ptrs[ITEM_START] == NULL ||
+						  pat_ptrs[ITEM_END] == NULL))
+{
+	not_enough = TRUE;
+	rest = NULL;
+}
+if (rest != NULL)
+{
+	/*
+	 * Check for trailing garbage or command.
+	 * If OK, add the item.
+	 */
+	eap->nextcmd = check_nextcmd(rest);
+	if (!ends_excmd(*rest) || eap->skip)
+	    rest = NULL;
+	else if (ga_grow(&(curbuf->b_syn_patterns), pat_count) != FAIL
+		&& (syn_id = syn_check_group(arg,
+					   (int)(group_name_end - arg))) != 0)
+	{
+	    syn_incl_toplevel(syn_id, &flags);
+	    /*
+	     * Store the start/skip/end in the syn_items list
+	     */
+	    idx = curbuf->b_syn_patterns.ga_len;
+	    for (item = ITEM_START; item <= ITEM_END; ++item)
+	    {
+		for (ppp = pat_ptrs[item]; ppp != NULL; ppp = ppp->pp_next)
+		{
+		    SYN_ITEMS(curbuf)[idx] = *(ppp->pp_synp);
+		    SYN_ITEMS(curbuf)[idx].sp_syncing = syncing;
+		    SYN_ITEMS(curbuf)[idx].sp_type =
+			    (item == ITEM_START) ? SPTYPE_START :
+			    (item == ITEM_SKIP) ? SPTYPE_SKIP : SPTYPE_END;
+		    SYN_ITEMS(curbuf)[idx].sp_flags |= flags;
+		    SYN_ITEMS(curbuf)[idx].sp_syn.id = syn_id;
+		    SYN_ITEMS(curbuf)[idx].sp_syn.inc_tag = current_syn_inc_tag;
+		    SYN_ITEMS(curbuf)[idx].sp_syn_match_id =
+							ppp->pp_matchgroup_id;
+		    if (item == ITEM_START)
+		    {
+			SYN_ITEMS(curbuf)[idx].sp_cont_list = cont_list;
+			SYN_ITEMS(curbuf)[idx].sp_syn.cont_in_list =
+								 cont_in_list;
+			if (cont_in_list != NULL)
+			    curbuf->b_syn_containedin = TRUE;
+			SYN_ITEMS(curbuf)[idx].sp_next_list = next_list;
+		    }
+		    ++curbuf->b_syn_patterns.ga_len;
+		    --curbuf->b_syn_patterns.ga_room;
+		    ++idx;
+#ifdef FEAT_FOLDING
+		    if (flags & HL_FOLD)
+			++curbuf->b_syn_folditems;
+#endif
+		}
+	    }
+	    redraw_curbuf_later(NOT_VALID);
+	    syn_stack_free_all(curbuf);	/* Need to recompute all syntax. */
+	    success = TRUE;	    /* don't free the progs and patterns now */
+	}
+}
+/*
+* Free the allocated memory.
+*/
+for (item = ITEM_START; item <= ITEM_END; ++item)
+	for (ppp = pat_ptrs[item]; ppp != NULL; ppp = ppp_next)
+	{
+	    if (!success)
+	    {
+		vim_free(ppp->pp_synp->sp_prog);
+		vim_free(ppp->pp_synp->sp_pattern);
+	    }
+	    vim_free(ppp->pp_synp);
+	    ppp_next = ppp->pp_next;
+	    vim_free(ppp);
+	}
+if (!success)
+{
+	vim_free(cont_list);
+	vim_free(cont_in_list);
+	vim_free(next_list);
+	if (not_enough)
+	    EMSG2(_("E399: Not enough arguments: syntax region %s"), arg);
+	else if (illegal || rest == NULL)
+	    EMSG2(_(e_invarg2), arg);
+}
+}
+/*
+* A simple syntax group ID comparison function suitable for use in qsort()
+*/
+static int
+#ifdef __BORLANDC__
+_RTLENTRYF
+#endif
+syn_compare_stub(v1, v2)
+const void	*v1;
+const void	*v2;
+{
+const short	*s1 = v1;
+const short	*s2 = v2;
+return (*s1 > *s2 ? 1 : *s1 < *s2 ? -1 : 0);
+}
+/*
+* Combines lists of syntax clusters.
+* *clstr1 and *clstr2 must both be allocated memory; they will be consumed.
+*/
+static void
+syn_combine_list(clstr1, clstr2, list_op)
+short	**clstr1;
+short	**clstr2;
+int		list_op;
+{
+int		count1 = 0;
+int		count2 = 0;
+short	*g1;
+short	*g2;
+short	*clstr = NULL;
+int		count;
+int		round;
+/*
+* Handle degenerate cases.
+*/
+if (*clstr2 == NULL)
+	return;
+if (*clstr1 == NULL || list_op == CLUSTER_REPLACE)
+{
+	if (list_op == CLUSTER_REPLACE)
+	    vim_free(*clstr1);
+	if (list_op == CLUSTER_REPLACE || list_op == CLUSTER_ADD)
+	    *clstr1 = *clstr2;
+	else
+	    vim_free(*clstr2);
+	return;
+}
+for (g1 = *clstr1; *g1; g1++)
+	++count1;
+for (g2 = *clstr2; *g2; g2++)
+	++count2;
+/*
+* For speed purposes, sort both lists.
+*/
+qsort(*clstr1, (size_t)count1, sizeof(short), syn_compare_stub);
+qsort(*clstr2, (size_t)count2, sizeof(short), syn_compare_stub);
+/*
+* We proceed in two passes; in round 1, we count the elements to place
+* in the new list, and in round 2, we allocate and populate the new
+* list.  For speed, we use a mergesort-like method, adding the smaller
+* of the current elements in each list to the new list.
+*/
+for (round = 1; round <= 2; round++)
+{
+	g1 = *clstr1;
+	g2 = *clstr2;
+	count = 0;
+	/*
+	 * First, loop through the lists until one of them is empty.
+	 */
+	while (*g1 && *g2)
+	{
+	    /*
+	     * We always want to add from the first list.
+	     */
+	    if (*g1 < *g2)
+	    {
+		if (round == 2)
+		    clstr[count] = *g1;
+		count++;
+		g1++;
+		continue;
+	    }
+	    /*
+	     * We only want to add from the second list if we're adding the
+	     * lists.
+	     */
+	    if (list_op == CLUSTER_ADD)
+	    {
+		if (round == 2)
+		    clstr[count] = *g2;
+		count++;
+	    }
+	    if (*g1 == *g2)
+		g1++;
+	    g2++;
+	}
+	/*
+	 * Now add the leftovers from whichever list didn't get finished
+	 * first.  As before, we only want to add from the second list if
+	 * we're adding the lists.
+	 */
+	for (; *g1; g1++, count++)
+	    if (round == 2)
+		clstr[count] = *g1;
+	if (list_op == CLUSTER_ADD)
+	    for (; *g2; g2++, count++)
+		if (round == 2)
+		    clstr[count] = *g2;
+	if (round == 1)
+	{
+	    /*
+	     * If the group ended up empty, we don't need to allocate any
+	     * space for it.
+	     */
+	    if (count == 0)
+	    {
+		clstr = NULL;
+		break;
+	    }
+	    clstr = (short *)alloc((unsigned)((count + 1) * sizeof(short)));
+	    if (clstr == NULL)
+		break;
+	    clstr[count] = 0;
+	}
+}
+/*
+* Finally, put the new list in place.
+*/
+vim_free(*clstr1);
+vim_free(*clstr2);
+*clstr1 = clstr;
+}
+/*
+* Lookup a syntax cluster name and return it's ID.
+* If it is not found, 0 is returned.
+*/
+static int
+syn_scl_name2id(name)
+char_u	*name;
+{
+int		i;
+char_u	*name_u;
+/* Avoid using stricmp() too much, it's slow on some systems */
+name_u = vim_strsave_up(name);
+if (name_u == NULL)
+	return 0;
+for (i = curbuf->b_syn_clusters.ga_len; --i >= 0; )
+	if (SYN_CLSTR(curbuf)[i].scl_name_u != NULL
+		&& STRCMP(name_u, SYN_CLSTR(curbuf)[i].scl_name_u) == 0)
+	    break;
+vim_free(name_u);
+return (i < 0 ? 0 : i + SYNID_CLUSTER);
+}
+/*
+* Like syn_scl_name2id(), but take a pointer + length argument.
+*/
+static int
+syn_scl_namen2id(linep, len)
+char_u  *linep;
+int	    len;
+{
+char_u  *name;
+int	    id = 0;
+name = vim_strnsave(linep, len);
+if (name != NULL)
+{
+	id = syn_scl_name2id(name);
+	vim_free(name);
+}
+return id;
+}
+/*
+* Find syntax cluster name in the table and return it's ID.
+* The argument is a pointer to the name and the length of the name.
+* If it doesn't exist yet, a new entry is created.
+* Return 0 for failure.
+*/
+static int
+syn_check_cluster(pp, len)
+char_u	*pp;
+int		len;
+{
+int		id;
+char_u	*name;
+name = vim_strnsave(pp, len);
+if (name == NULL)
+	return 0;
+id = syn_scl_name2id(name);
+if (id == 0)			/* doesn't exist yet */
+	id = syn_add_cluster(name);
+else
+	vim_free(name);
+return id;
+}
+/*
+* Add new syntax cluster and return it's ID.
+* "name" must be an allocated string, it will be consumed.
+* Return 0 for failure.
+*/
+static int
+syn_add_cluster(name)
+char_u		*name;
+{
+int len;
+/*
+* First call for this growarray: init growing array.
+*/
+if (curbuf->b_syn_clusters.ga_data == NULL)
+{
+	curbuf->b_syn_clusters.ga_itemsize = sizeof(struct syn_cluster);
+	curbuf->b_syn_clusters.ga_growsize = 10;
+}
+/*
+* Make room for at least one other cluster entry.
+*/
+if (ga_grow(&curbuf->b_syn_clusters, 1) == FAIL)
+{
+	vim_free(name);
+	return 0;
+}
+len = curbuf->b_syn_clusters.ga_len;
+vim_memset(&(SYN_CLSTR(curbuf)[len]), 0, sizeof(struct syn_cluster));
+SYN_CLSTR(curbuf)[len].scl_name = name;
+SYN_CLSTR(curbuf)[len].scl_name_u = vim_strsave_up(name);
+SYN_CLSTR(curbuf)[len].scl_list = NULL;
+++curbuf->b_syn_clusters.ga_len;
+--curbuf->b_syn_clusters.ga_room;
+return len + SYNID_CLUSTER;
+}
+/*
+* Handle ":syntax cluster {cluster-name} [contains={groupname},..]
+*		[add={groupname},..] [remove={groupname},..]".
+*/
+/* ARGSUSED */
+static void
+syn_cmd_cluster(eap, syncing)
+exarg_T	*eap;
+int		syncing;	    /* not used */
+{
+char_u	*arg = eap->arg;
+char_u	*group_name_end;
+char_u	*rest;
+int		scl_id;
+short	*clstr_list;
+int		got_clstr = FALSE;
+int		opt_len;
+int		list_op;
+eap->nextcmd = find_nextcmd(arg);
+if (eap->skip)
+	return;
+rest = get_group_name(arg, &group_name_end);
+if (rest != NULL)
+{
+	scl_id = syn_check_cluster(arg, (int)(group_name_end - arg))
+		    - SYNID_CLUSTER;
+	for (;;)
+	{
+	    if (STRNICMP(rest, "add", 3) == 0
+		    && (vim_iswhite(rest[3]) || rest[3] == '='))
+	    {
+		opt_len = 3;
+		list_op = CLUSTER_ADD;
+	    }
+	    else if (STRNICMP(rest, "remove", 6) == 0
+		    && (vim_iswhite(rest[6]) || rest[6] == '='))
+	    {
+		opt_len = 6;
+		list_op = CLUSTER_SUBTRACT;
+	    }
+	    else if (STRNICMP(rest, "contains", 8) == 0
+			&& (vim_iswhite(rest[8]) || rest[8] == '='))
+	    {
+		opt_len = 8;
+		list_op = CLUSTER_REPLACE;
+	    }
+	    else
+		break;
+	    clstr_list = NULL;
+	    if (get_id_list(&rest, opt_len, &clstr_list) == FAIL)
+	    {
+		EMSG2(_(e_invarg2), rest);
+		break;
+	    }
+	    syn_combine_list(&SYN_CLSTR(curbuf)[scl_id].scl_list,
+			     &clstr_list, list_op);
+	    got_clstr = TRUE;
+	}
+	if (got_clstr)
+	{
+	    redraw_curbuf_later(NOT_VALID);
+	    syn_stack_free_all(curbuf);	/* Need to recompute all syntax. */
+	}
+}
+if (!got_clstr)
+	EMSG(_("E400: No cluster specified"));
+if (rest == NULL || !ends_excmd(*rest))
+	EMSG2(_(e_invarg2), arg);
+}
+/*
+* On first call for current buffer: Init growing array.
+*/
+static void
+init_syn_patterns()
+{
+curbuf->b_syn_patterns.ga_itemsize = sizeof(synpat_T);
+curbuf->b_syn_patterns.ga_growsize = 10;
+}
+/*
+* Get one pattern for a ":syntax match" or ":syntax region" command.
+* Stores the pattern and program in a synpat_T.
+* Returns a pointer to the next argument, or NULL in case of an error.
+*/
+static char_u *
+get_syn_pattern(arg, ci)
+char_u	*arg;
+synpat_T	*ci;
+{
+char_u	*end;
+int		*p;
+int		idx;
+char_u	*cpo_save;
+/* need at least three chars */
+if (arg == NULL || arg[1] == NUL || arg[2] == NUL)
+	return NULL;
+end = skip_regexp(arg + 1, *arg, TRUE, NULL);
+if (*end != *arg)			    /* end delimiter not found */
+{
+	EMSG2(_("E401: Pattern delimiter not found: %s"), arg);
+	return NULL;
+}
+/* store the pattern and compiled regexp program */
+if ((ci->sp_pattern = vim_strnsave(arg + 1, (int)(end - arg - 1))) == NULL)
+	return NULL;
+/* Make 'cpoptions' empty, to avoid the 'l' flag */
+cpo_save = p_cpo;
+p_cpo = (char_u *)"";
+ci->sp_prog = vim_regcomp(ci->sp_pattern, RE_MAGIC);
+p_cpo = cpo_save;
+if (ci->sp_prog == NULL)
+	return NULL;
+ci->sp_ic = curbuf->b_syn_ic;
+/*
+* Check for a match, highlight or region offset.
+*/
+++end;
+do
+{
+	for (idx = SPO_COUNT; --idx >= 0; )
+	    if (STRNCMP(end, spo_name_tab[idx], 3) == 0)
+		break;
+	if (idx >= 0)
+	{
+	    p = &(ci->sp_offsets[idx]);
+	    if (idx != SPO_LC_OFF)
+		switch (end[3])
+		{
+		    case 's':   break;
+		    case 'b':   break;
+		    case 'e':   idx += SPO_COUNT; break;
+		    default:    idx = -1; break;
+		}
+	    if (idx >= 0)
+	    {
+		ci->sp_off_flags |= (1 << idx);
+		if (idx == SPO_LC_OFF)	    /* lc=99 */
+		{
+		    end += 3;
+		    *p = getdigits(&end);
+		    /* "lc=" offset automatically sets "ms=" offset */
+		    if (!(ci->sp_off_flags & (1 << SPO_MS_OFF)))
+		    {
+			ci->sp_off_flags |= (1 << SPO_MS_OFF);
+			ci->sp_offsets[SPO_MS_OFF] = *p;
+		    }
+		}
+		else			    /* yy=x+99 */
+		{
+		    end += 4;
+		    if (*end == '+')
+		    {
+			++end;
+			*p = getdigits(&end);		/* positive offset */
+		    }
+		    else if (*end == '-')
+		    {
+			++end;
+			*p = -getdigits(&end);		/* negative offset */
+		    }
+		}
+		if (*end != ',')
+		    break;
+		++end;
+	    }
+	}
+} while (idx >= 0);
+if (!ends_excmd(*end) && !vim_iswhite(*end))
+{
+	EMSG2(_("E402: Garbage after pattern: %s"), arg);
+	return NULL;
+}
+return skipwhite(end);
+}
+/*
+* Handle ":syntax sync .." command.
+*/
+/* ARGSUSED */
+static void
+syn_cmd_sync(eap, syncing)
+exarg_T	*eap;
+int		syncing;	    /* not used */
+{
+char_u	*arg_start = eap->arg;
+char_u	*arg_end;
+char_u	*key = NULL;
+char_u	*next_arg;
+int		illegal = FALSE;
+int		finished = FALSE;
+long	n;
+char_u	*cpo_save;
+if (ends_excmd(*arg_start))
+{
+	syn_cmd_list(eap, TRUE);
+	return;
+}
+while (!ends_excmd(*arg_start))
+{
+	arg_end = skiptowhite(arg_start);
+	next_arg = skipwhite(arg_end);
+	vim_free(key);
+	key = vim_strnsave_up(arg_start, (int)(arg_end - arg_start));
+	if (STRCMP(key, "CCOMMENT") == 0)
+	{
+	    if (!eap->skip)
+		curbuf->b_syn_sync_flags |= SF_CCOMMENT;
+	    if (!ends_excmd(*next_arg))
+	    {
+		arg_end = skiptowhite(next_arg);
+		if (!eap->skip)
+		    curbuf->b_syn_sync_id = syn_check_group(next_arg,
+						   (int)(arg_end - next_arg));
+		next_arg = skipwhite(arg_end);
+	    }
+	    else if (!eap->skip)
+		curbuf->b_syn_sync_id = syn_name2id((char_u *)"Comment");
+	}
+	else if (  STRNCMP(key, "LINES", 5) == 0
+		|| STRNCMP(key, "MINLINES", 8) == 0
+		|| STRNCMP(key, "MAXLINES", 8) == 0
+		|| STRNCMP(key, "LINEBREAKS", 10) == 0)
+	{
+	    if (key[4] == 'S')
+		arg_end = key + 6;
+	    else if (key[0] == 'L')
+		arg_end = key + 11;
+	    else
+		arg_end = key + 9;
+	    if (arg_end[-1] != '=' || !VIM_ISDIGIT(*arg_end))
+	    {
+		illegal = TRUE;
+		break;
+	    }
+	    n = getdigits(&arg_end);
+	    if (!eap->skip)
+	    {
+		if (key[4] == 'B')
+		    curbuf->b_syn_sync_linebreaks = n;
+		else if (key[1] == 'A')
+		    curbuf->b_syn_sync_maxlines = n;
+		else
+		    curbuf->b_syn_sync_minlines = n;
+	    }
+	}
+	else if (STRCMP(key, "FROMSTART") == 0)
+	{
+	    if (!eap->skip)
+	    {
+		curbuf->b_syn_sync_minlines = MAXLNUM;
+		curbuf->b_syn_sync_maxlines = 0;
+	    }
+	}
+	else if (STRCMP(key, "LINECONT") == 0)
+	{
+	    if (curbuf->b_syn_linecont_pat != NULL)
+	    {
+		EMSG(_("E403: syntax sync: line continuations pattern specified twice"));
+		finished = TRUE;
+		break;
+	    }
+	    arg_end = skip_regexp(next_arg + 1, *next_arg, TRUE, NULL);
+	    if (*arg_end != *next_arg)	    /* end delimiter not found */
+	    {
+		illegal = TRUE;
+		break;
+	    }
+	    if (!eap->skip)
+	    {
+		/* store the pattern and compiled regexp program */
+		if ((curbuf->b_syn_linecont_pat = vim_strnsave(next_arg + 1,
+				      (int)(arg_end - next_arg - 1))) == NULL)
+		{
+		    finished = TRUE;
+		    break;
+		}
+		curbuf->b_syn_linecont_ic = curbuf->b_syn_ic;
+		/* Make 'cpoptions' empty, to avoid the 'l' flag */
+		cpo_save = p_cpo;
+		p_cpo = (char_u *)"";
+		curbuf->b_syn_linecont_prog =
+			    vim_regcomp(curbuf->b_syn_linecont_pat, RE_MAGIC);
+		p_cpo = cpo_save;
+		if (curbuf->b_syn_linecont_prog == NULL)
+		{
+		    vim_free(curbuf->b_syn_linecont_pat);
+		    curbuf->b_syn_linecont_pat = NULL;
+		    finished = TRUE;
+		    break;
+		}
+	    }
+	    next_arg = skipwhite(arg_end + 1);
+	}
+	else
+	{
+	    eap->arg = next_arg;
+	    if (STRCMP(key, "MATCH") == 0)
+		syn_cmd_match(eap, TRUE);
+	    else if (STRCMP(key, "REGION") == 0)
+		syn_cmd_region(eap, TRUE);
+	    else if (STRCMP(key, "CLEAR") == 0)
+		syn_cmd_clear(eap, TRUE);
+	    else
+		illegal = TRUE;
+	    finished = TRUE;
+	    break;
+	}
+	arg_start = next_arg;
+}
+vim_free(key);
+if (illegal)
+	EMSG2(_("E404: Illegal arguments: %s"), arg_start);
+else if (!finished)
+{
+	eap->nextcmd = check_nextcmd(arg_start);
+	redraw_curbuf_later(NOT_VALID);
+	syn_stack_free_all(curbuf);	/* Need to recompute all syntax. */
+}
+}
+/*
+* Convert a line of highlight group names into a list of group ID numbers.
+* "arg" should point to the "contains" or "nextgroup" keyword.
+* "arg" is advanced to after the last group name.
+* Careful: the argument is modified (NULs added).
+* returns FAIL for some error, OK for success.
+*/
+static int
+get_id_list(arg, keylen, list)
+char_u	**arg;
+int		keylen;		/* length of keyword */
+short	**list;		/* where to store the resulting list, if not
+				   NULL, the list is silently skipped! */
+{
+char_u	*p = NULL;
+char_u	*end;
+int		round;
+int		count;
+int		total_count = 0;
+short	*retval = NULL;
+char_u	*name;
+regmatch_T	regmatch;
+int		id;
+int		i;
+int		failed = FALSE;
+/*
+* We parse the list twice:
+* round == 1: count the number of items, allocate the array.
+* round == 2: fill the array with the items.
+* In round 1 new groups may be added, causing the number of items to
+* grow when a regexp is used.  In that case round 1 is done once again.
+*/
+for (round = 1; round <= 2; ++round)
+{
+	/*
+	 * skip "contains"
+	 */
+	p = skipwhite(*arg + keylen);
+	if (*p != '=')
+	{
+	    EMSG2(_("E405: Missing equal sign: %s"), *arg);
+	    break;
+	}
+	p = skipwhite(p + 1);
+	if (ends_excmd(*p))
+	{
+	    EMSG2(_("E406: Empty argument: %s"), *arg);
+	    break;
+	}
+	/*
+	 * parse the arguments after "contains"
+	 */
+	count = 0;
+	while (!ends_excmd(*p))
+	{
+	    for (end = p; *end && !vim_iswhite(*end) && *end != ','; ++end)
+		;
+	    name = alloc((int)(end - p + 3));	    /* leave room for "^$" */
+	    if (name == NULL)
+	    {
+		failed = TRUE;
+		break;
+	    }
+	    STRNCPY(name + 1, p, end - p);
+	    name[end - p + 1] = NUL;
+	    if (       STRCMP(name + 1, "ALLBUT") == 0
+		    || STRCMP(name + 1, "ALL") == 0
+		    || STRCMP(name + 1, "TOP") == 0
+		    || STRCMP(name + 1, "CONTAINED") == 0)
+	    {
+		if (TOUPPER_ASC(**arg) != 'C')
+		{
+		    EMSG2(_("E407: %s not allowed here"), name + 1);
+		    failed = TRUE;
+		    vim_free(name);
+		    break;
+		}
+		if (count != 0)
+		{
+		    EMSG2(_("E408: %s must be first in contains list"), name + 1);
+		    failed = TRUE;
+		    vim_free(name);
+		    break;
+		}
+		if (name[1] == 'A')
+		    id = SYNID_ALLBUT;
+		else if (name[1] == 'T')
+		    id = SYNID_TOP;
+		else
+		    id = SYNID_CONTAINED;
+		id += current_syn_inc_tag;
+	    }
+	    else if (name[1] == '@')
+	    {
+		id = syn_check_cluster(name + 2, (int)(end - p - 1));
+	    }
+	    else
+	    {
+		/*
+		 * Handle full group name.
+		 */
+		if (vim_strpbrk(name + 1, (char_u *)"\\.*^$~[") == NULL)
+		    id = syn_check_group(name + 1, (int)(end - p));
+		else
+		{
+		    /*
+		     * Handle match of regexp with group names.
+		     */
+		    *name = '^';
+		    STRCAT(name, "$");
+		    regmatch.regprog = vim_regcomp(name, RE_MAGIC);
+		    if (regmatch.regprog == NULL)
+		    {
+			failed = TRUE;
+			vim_free(name);
+			break;
+		    }
+		    regmatch.rm_ic = TRUE;
+		    id = 0;
+		    for (i = highlight_ga.ga_len; --i >= 0; )
+		    {
+			if (vim_regexec(&regmatch, HL_TABLE()[i].sg_name,
+								  (colnr_T)0))
+			{
+			    if (round == 2)
+			    {
+				/* Got more items than expected; can happen
+				 * when adding items that match:
+				 * "contains=a.*b,axb".
+				 * Go back to first round */
+				if (count >= total_count)
+				{
+				    vim_free(retval);
+				    round = 1;
+				}
+				else
+				    retval[count] = i + 1;
+			    }
+			    ++count;
+			    id = -1;	    /* remember that we found one */
+			}
+		    }
+		    vim_free(regmatch.regprog);
+		}
+	    }
+	    vim_free(name);
+	    if (id == 0)
+	    {
+		EMSG2(_("E409: Unknown group name: %s"), p);
+		failed = TRUE;
+		break;
+	    }
+	    if (id > 0)
+	    {
+		if (round == 2)
+		{
+		    /* Got more items than expected, go back to first round */
+		    if (count >= total_count)
+		    {
+			vim_free(retval);
+			round = 1;
+		    }
+		    else
+			retval[count] = id;
+		}
+		++count;
+	    }
+	    p = skipwhite(end);
+	    if (*p != ',')
+		break;
+	    p = skipwhite(p + 1);	/* skip comma in between arguments */
+	}
+	if (failed)
+	    break;
+	if (round == 1)
+	{
+	    retval = (short *)alloc((unsigned)((count + 1) * sizeof(short)));
+	    if (retval == NULL)
+		break;
+	    retval[count] = 0;	    /* zero means end of the list */
+	    total_count = count;
+	}
+}
+*arg = p;
+if (failed || retval == NULL)
+{
+	vim_free(retval);
+	return FAIL;
+}
+if (*list == NULL)
+	*list = retval;
+else
+	vim_free(retval);	/* list already found, don't overwrite it */
+return OK;
+}
+/*
+* Make a copy of an ID list.
+*/
+static short *
+copy_id_list(list)
+short   *list;
+{
+int	    len;
+int	    count;
+short   *retval;
+if (list == NULL)
+	return NULL;
+for (count = 0; list[count]; ++count)
+	;
+len = (count + 1) * sizeof(short);
+retval = (short *)alloc((unsigned)len);
+if (retval != NULL)
+	mch_memmove(retval, list, (size_t)len);
+return retval;
+}
+/*
+* Check if syntax group "ssp" is in the ID list "list" of "cur_si".
+* "cur_si" can be NULL if not checking the "containedin" list.
+* Used to check if a syntax item is in the "contains" or "nextgroup" list of
+* the current item.
+* This function is called very often, keep it fast!!
+*/
+static int
+in_id_list(cur_si, list, ssp, contained)
+stateitem_T	*cur_si;	/* current item or NULL */
+short	*list;		/* id list */
+struct sp_syn *ssp;		/* group id and ":syn include" tag of group */
+int		contained;	/* group id is contained */
+{
+int		retval;
+short	*scl_list;
+short	item;
+short	id = ssp->id;
+static int	depth = 0;
+int		r;
+/* If spp has a "containedin" list and "cur_si" is in it, return TRUE. */
+if (cur_si != NULL && ssp->cont_in_list != NULL)
+{
+	/* Ignore transparent items without a contains argument.  Double check
+	 * that we don't go back past the first one. */
+	while ((cur_si->si_flags & HL_TRANS_CONT)
+		&& cur_si > (stateitem_T *)(current_state.ga_data))
+	    --cur_si;
+	/* cur_si->si_idx is -1 for keywords, these never contain anything. */
+	if (cur_si->si_idx >= 0 && in_id_list(NULL, ssp->cont_in_list,
+		&(SYN_ITEMS(syn_buf)[cur_si->si_idx].sp_syn),
+		  SYN_ITEMS(syn_buf)[cur_si->si_idx].sp_flags & HL_CONTAINED))
+	    return TRUE;
+}
+if (list == NULL)
+	return FALSE;
+/*
+* If list is ID_LIST_ALL, we are in a transparent item that isn't
+* inside anything.  Only allow not-contained groups.
+*/
+if (list == ID_LIST_ALL)
+	return !contained;
+/*
+* If the first item is "ALLBUT", return TRUE if "id" is NOT in the
+* contains list.  We also require that "id" is at the same ":syn include"
+* level as the list.
+*/
+item = *list;
+if (item >= SYNID_ALLBUT && item < SYNID_CLUSTER)
+{
+	if (item < SYNID_TOP)
+	{
+	    /* ALL or ALLBUT: accept all groups in the same file */
+	    if (item - SYNID_ALLBUT != ssp->inc_tag)
+		return FALSE;
+	}
+	else if (item < SYNID_CONTAINED)
+	{
+	    /* TOP: accept all not-contained groups in the same file */
+	    if (item - SYNID_TOP != ssp->inc_tag || contained)
+		return FALSE;
+	}
+	else
+	{
+	    /* CONTAINED: accept all contained groups in the same file */
+	    if (item - SYNID_CONTAINED != ssp->inc_tag || !contained)
+		return FALSE;
+	}
+	item = *++list;
+	retval = FALSE;
+}
+else
+	retval = TRUE;
+/*
+* Return "retval" if id is in the contains list.
+*/
+while (item != 0)
+{
+	if (item == id)
+	    return retval;
+	if (item >= SYNID_CLUSTER)
+	{
+	    scl_list = SYN_CLSTR(syn_buf)[item - SYNID_CLUSTER].scl_list;
+	    /* restrict recursiveness to 30 to avoid an endless loop for a
+	     * cluster that includes itself (indirectly) */
+	    if (scl_list != NULL && depth < 30)
+	    {
+		++depth;
+		r = in_id_list(NULL, scl_list, ssp, contained);
+		--depth;
+		if (r)
+		    return retval;
+	    }
+	}
+	item = *++list;
+}
+return !retval;
+}
+struct subcommand
+{
+char    *name;				/* subcommand name */
+void    (*func)__ARGS((exarg_T *, int));	/* function to call */
+};
+static struct subcommand subcommands[] =
+{
+{"case",		syn_cmd_case},
+{"clear",		syn_cmd_clear},
+{"cluster",		syn_cmd_cluster},
+{"enable",		syn_cmd_enable},
+{"include",		syn_cmd_include},
+{"keyword",		syn_cmd_keyword},
+{"list",		syn_cmd_list},
+{"manual",		syn_cmd_manual},
+{"match",		syn_cmd_match},
+{"on",		syn_cmd_on},
+{"off",		syn_cmd_off},
+{"region",		syn_cmd_region},
+{"reset",		syn_cmd_reset},
+{"sync",		syn_cmd_sync},
+{"",		syn_cmd_list},
+{NULL, NULL}
+};
+/*
+* ":syntax".
+* This searches the subcommands[] table for the subcommand name, and calls a
+* syntax_subcommand() function to do the rest.
+*/
+void
+ex_syntax(eap)
+exarg_T	*eap;
+{
+char_u	*arg = eap->arg;
+char_u	*subcmd_end;
+char_u	*subcmd_name;
+int		i;
+syn_cmdlinep = eap->cmdlinep;
+/* isolate subcommand name */
+for (subcmd_end = arg; ASCII_ISALPHA(*subcmd_end); ++subcmd_end)
+	;
+subcmd_name = vim_strnsave(arg, (int)(subcmd_end - arg));
+if (subcmd_name != NULL)
+{
+	if (eap->skip)		/* skip error messages for all subcommands */
+	    ++emsg_skip;
+	for (i = 0; ; ++i)
+	{
+	    if (subcommands[i].name == NULL)
+	    {
+		EMSG2(_("E410: Invalid :syntax subcommand: %s"), subcmd_name);
+		break;
+	    }
+	    if (STRCMP(subcmd_name, (char_u *)subcommands[i].name) == 0)
+	    {
+		eap->arg = skipwhite(subcmd_end);
+		(subcommands[i].func)(eap, FALSE);
+		break;
+	    }
+	}
+	vim_free(subcmd_name);
+	if (eap->skip)
+	    --emsg_skip;
+}
+}
+int
+syntax_present(buf)
+buf_T	*buf;
+{
+return (buf->b_syn_patterns.ga_len != 0
+	    || buf->b_syn_clusters.ga_len != 0
+	    || curbuf->b_keywtab != NULL
+	    || curbuf->b_keywtab_ic != NULL);
+}
+#if defined(FEAT_CMDL_COMPL) || defined(PROTO)
+static enum
+{
+EXP_SUBCMD,	    /* expand ":syn" sub-commands */
+EXP_CASE	    /* expand ":syn case" arguments */
+} expand_what;
+/*
+* Handle command line completion for :syntax command.
+*/
+void
+set_context_in_syntax_cmd(xp, arg)
+expand_T	*xp;
+char_u	*arg;
+{
+char_u	*p;
+/* Default: expand subcommands */
+xp->xp_context = EXPAND_SYNTAX;
+expand_what = EXP_SUBCMD;
+xp->xp_pattern = arg;
+include_link = FALSE;
+include_default = FALSE;
+/* (part of) subcommand already typed */
+if (*arg != NUL)
+{
+	p = skiptowhite(arg);
+	if (*p != NUL)		    /* past first word */
+	{
+	    xp->xp_pattern = skipwhite(p);
+	    if (*skiptowhite(xp->xp_pattern) != NUL)
+		xp->xp_context = EXPAND_NOTHING;
+	    else if (STRNICMP(arg, "case", p - arg) == 0)
+		expand_what = EXP_CASE;
+	    else if (  STRNICMP(arg, "keyword", p - arg) == 0
+		    || STRNICMP(arg, "region", p - arg) == 0
+		    || STRNICMP(arg, "match", p - arg) == 0
+		    || STRNICMP(arg, "list", p - arg) == 0)
+		xp->xp_context = EXPAND_HIGHLIGHT;
+	    else
+		xp->xp_context = EXPAND_NOTHING;
+	}
+}
+}
+static char *(case_args[]) = {"match", "ignore", NULL};
+/*
+* Function given to ExpandGeneric() to obtain the list syntax names for
+* expansion.
+*/
+/*ARGSUSED*/
+char_u *
+get_syntax_name(xp, idx)
+expand_T	*xp;
+int		idx;
+{
+if (expand_what == EXP_SUBCMD)
+	return (char_u *)subcommands[idx].name;
+return (char_u *)case_args[idx];
+}
+#endif /* FEAT_CMDL_COMPL */
+#if defined(FEAT_EVAL) || defined(FEAT_PRINTER) || defined(PROTO)
+/*
+* Function called for expression evaluation: get syntax ID at file position.
+*/
+int
+syn_get_id(lnum, col, trans)
+long	lnum;
+long	col;
+int		trans;	    /* remove transparancy */
+{
+/* When the position is not after the current position and in the same
+* line of the same buffer, need to restart parsing. */
+if (curwin->w_buffer != syn_buf
+	    || lnum != current_lnum
+	    || col < (long)current_col)
+	syntax_start(curwin, lnum);
+(void)get_syntax_attr((colnr_T)col);
+return (trans ? current_trans_id : current_id);
+}
+#endif
+#if defined(FEAT_FOLDING) || defined(PROTO)
+/*
+* Function called to get folding level for line "lnum" in window "wp".
+*/
+int
+syn_get_foldlevel(wp, lnum)
+win_T	*wp;
+long	lnum;
+{
+int		level = 0;
+int		i;
+/* Return quickly when there are no fold items at all. */
+if (wp->w_buffer->b_syn_folditems != 0)
+{
+	syntax_start(wp, lnum);
+	for (i = 0; i < current_state.ga_len; ++i)
+	    if (CUR_STATE(i).si_flags & HL_FOLD)
+		++level;
+}
+if (level > wp->w_p_fdn)
+	level = wp->w_p_fdn;
+return level;
+}
+#endif
+#endif /* FEAT_SYN_HL */
+/**************************************
+*  Highlighting stuff		      *
+**************************************/
+/*
+* The default highlight groups.  These are compiled-in for fast startup and
+* they still work when the runtime files can't be found.
+* When making changes here, also change runtime/colors/default.vim!
+*/
+static char *(highlight_init_both[]) =
+{
+#ifdef FEAT_GUI
+	"Cursor guibg=fg guifg=bg",
+	"lCursor guibg=fg guifg=bg",	/* should be different, but what? */
+#endif
+	"ErrorMsg term=standout ctermbg=DarkRed ctermfg=White guibg=Red guifg=White",
+	"IncSearch term=reverse cterm=reverse gui=reverse",
+	"ModeMsg term=bold cterm=bold gui=bold",
+	"NonText term=bold ctermfg=Blue gui=bold guifg=Blue",
+	"StatusLine term=reverse,bold cterm=reverse,bold gui=reverse,bold",
+	"StatusLineNC term=reverse cterm=reverse gui=reverse",
+	"VertSplit term=reverse cterm=reverse gui=reverse",
+	"Visual term=reverse cterm=reverse gui=reverse guifg=Grey guibg=fg",
+	"VisualNOS term=underline,bold cterm=underline,bold gui=underline,bold",
+	"DiffText term=reverse cterm=bold ctermbg=Red gui=bold guibg=Red",
+	NULL
+};
+static char *(highlight_init_light[]) =
+{
+	"Directory term=bold ctermfg=DarkBlue guifg=Blue",
+	"LineNr term=underline ctermfg=Brown guifg=Brown",
+	"MoreMsg term=bold ctermfg=DarkGreen gui=bold guifg=SeaGreen",
+	"Normal gui=NONE",
+	"Question term=standout ctermfg=DarkGreen gui=bold guifg=SeaGreen",
+	"Search term=reverse ctermbg=Yellow ctermfg=NONE guibg=Yellow guifg=NONE",
+	"SpecialKey term=bold ctermfg=DarkBlue guifg=Blue",
+	"Title term=bold ctermfg=DarkMagenta gui=bold guifg=Magenta",
+	"WarningMsg term=standout ctermfg=DarkRed guifg=Red",
+	"WildMenu term=standout ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black",
+	"Folded term=standout ctermbg=Grey ctermfg=DarkBlue guibg=LightGrey guifg=DarkBlue",
+	"FoldColumn term=standout ctermbg=Grey ctermfg=DarkBlue guibg=Grey guifg=DarkBlue",
+	"SignColumn term=standout ctermbg=Grey ctermfg=DarkBlue guibg=Grey guifg=DarkBlue",
+	"DiffAdd term=bold ctermbg=LightBlue guibg=LightBlue",
+	"DiffChange term=bold ctermbg=LightMagenta guibg=LightMagenta",
+	"DiffDelete term=bold ctermfg=Blue ctermbg=LightCyan gui=bold guifg=Blue guibg=LightCyan",
+	NULL
+};
+static char *(highlight_init_dark[]) =
+{
+	"Directory term=bold ctermfg=LightCyan guifg=Cyan",
+	"LineNr term=underline ctermfg=Yellow guifg=Yellow",
+	"MoreMsg term=bold ctermfg=LightGreen gui=bold guifg=SeaGreen",
+	"Normal gui=NONE",
+	"Question term=standout ctermfg=LightGreen gui=bold guifg=Green",
+	"Search term=reverse ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black",
+	"SpecialKey term=bold ctermfg=LightBlue guifg=Cyan",
+	"Title term=bold ctermfg=LightMagenta gui=bold guifg=Magenta",
+	"WarningMsg term=standout ctermfg=LightRed guifg=Red",
+	"WildMenu term=standout ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black",
+	"Folded term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=DarkGrey guifg=Cyan",
+	"FoldColumn term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=Grey guifg=Cyan",
+	"SignColumn term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=Grey guifg=Cyan",
+	"DiffAdd term=bold ctermbg=DarkBlue guibg=DarkBlue",
+	"DiffChange term=bold ctermbg=DarkMagenta guibg=DarkMagenta",
+	"DiffDelete term=bold ctermfg=Blue ctermbg=DarkCyan gui=bold guifg=Blue guibg=DarkCyan",
+	NULL
+};
+void
+init_highlight(both, reset)
+int		both;	    /* include groups where 'bg' doesn't matter */
+int		reset;	    /* clear group first */
+{
+int		i;
+char	**pp;
+static int	had_both = FALSE;
+#ifdef FEAT_EVAL
+char_u	*p;
+/*
+* Try finding the color scheme file.  Used when a color file was loaded
+* and 'background' or 't_Co' is changed.
+*/
+p = get_var_value((char_u *)"g:colors_name");
+if (p != NULL && load_colors(p) == OK)
+	return;
+#endif
+/*
+* Didn't use a color file, use the compiled-in colors.
+*/
+if (both)
+{
+	had_both = TRUE;
+	pp = highlight_init_both;
+	for (i = 0; pp[i] != NULL; ++i)
+	    do_highlight((char_u *)pp[i], reset, TRUE);
+}
+else if (!had_both)
+	/* Don't do anything before the call with both == TRUE from main().
+	 * Not everything has been setup then, and that call will overrule
+	 * everything anyway. */
+	return;
+if (*p_bg == 'l')
+	pp = highlight_init_light;
+else
+	pp = highlight_init_dark;
+for (i = 0; pp[i] != NULL; ++i)
+	do_highlight((char_u *)pp[i], reset, TRUE);
+#ifdef FEAT_SYN_HL
+/*
+* If syntax highlighting is enabled load the highlighting for it.
+*/
+if (get_var_value((char_u *)"g:syntax_on") != NULL)
+	(void)cmd_runtime((char_u *)"syntax/syncolor.vim", TRUE);
+#endif
+}
+/*
+* Load color file "p".
+* Return OK for success, FAIL for failure.
+*/
+int
+load_colors(p)
+char_u	*p;
+{
+char_u	*buf;
+int		retval = FAIL;
+static int	recursive = FALSE;
+/* When being called recursively, this is probably because setting
+* 'background' caused the highlighting to be reloaded.  This means it is
+* working, thus we should return OK. */
+if (recursive)
+	return OK;
+recursive = TRUE;
+buf = alloc((unsigned)(STRLEN(p) + 12));
+if (buf != NULL)
+{
+	sprintf((char *)buf, "colors/%s.vim", p);
+	retval = cmd_runtime(buf, FALSE);
+	vim_free(buf);
+}
+recursive = FALSE;
+return retval;
+}
+/*
+* Handle the ":highlight .." command.
+* When using ":hi clear" this is called recursively for each group with
+* "forceit" and "init" both TRUE.
+*/
+void
+do_highlight(line, forceit, init)
+char_u	*line;
+int		forceit;
+int		init;	    /* TRUE when called for initializing */
+{
+char_u	*name_end;
+char_u	*p;
+char_u	*linep;
+char_u	*key_start;
+char_u	*arg_start;
+char_u	*key = NULL, *arg = NULL;
+long	i;
+int		off;
+int		len;
+int		attr;
+int		id;
+int		idx;
+int		dodefault = FALSE;
+int		doclear = FALSE;
+int		dolink = FALSE;
+int		error = FALSE;
+int		color;
+int		is_normal_group = FALSE;	/* "Normal" group */
+#ifdef FEAT_GUI_X11
+int		is_menu_group = FALSE;		/* "Menu" group */
+int		is_scrollbar_group = FALSE;	/* "Scrollbar" group */
+int		is_tooltip_group = FALSE;	/* "Tooltip" group */
+int		do_colors = FALSE;		/* need to update colors? */
+#else
+# define is_menu_group 0
+# define is_tooltip_group 0
+#endif
+/*
+* If no argument, list current highlighting.
+*/
+if (ends_excmd(*line))
+{
+	for (i = 1; i <= highlight_ga.ga_len && !got_int; ++i)
+	    /* TODO: only call when the group has attributes set */
+	    highlight_list_one((int)i);
+	return;
+}
+/*
+* Isolate the name.
+*/
+name_end = skiptowhite(line);
+linep = skipwhite(name_end);
+/*
+* Check for "default" argument.
+*/
+if (STRNCMP(line, "default", name_end - line) == 0)
+{
+	dodefault = TRUE;
+	line = linep;
+	name_end = skiptowhite(line);
+	linep = skipwhite(name_end);
+}
+/*
+* Check for "clear" or "link" argument.
+*/
+if (STRNCMP(line, "clear", name_end - line) == 0)
+	doclear = TRUE;
+if (STRNCMP(line, "link", name_end - line) == 0)
+	dolink = TRUE;
+/*
+* ":highlight {group-name}": list highlighting for one group.
+*/
+if (!doclear && !dolink && ends_excmd(*linep))
+{
+	id = syn_namen2id(line, (int)(name_end - line));
+	if (id == 0)
+	    EMSG2(_("E411: highlight group not found: %s"), line);
+	else
+	    highlight_list_one(id);
+	return;
+}
+/*
+* Handle ":highlight link {from} {to}" command.
+*/
+if (dolink)
+{
+	char_u	    *from_start = linep;
+	char_u	    *from_end;
+	char_u	    *to_start;
+	char_u	    *to_end;
+	int	    from_id;
+	int	    to_id;
+	from_end = skiptowhite(from_start);
+	to_start = skipwhite(from_end);
+	to_end	 = skiptowhite(to_start);
+	if (ends_excmd(*from_start) || ends_excmd(*to_start))
+	{
+	    EMSG2(_("E412: Not enough arguments: \":highlight link %s\""),
+								  from_start);
+	    return;
+	}
+	if (!ends_excmd(*skipwhite(to_end)))
+	{
+	    EMSG2(_("E413: Too many arguments: \":highlight link %s\""), from_start);
+	    return;
+	}
+	from_id = syn_check_group(from_start, (int)(from_end - from_start));
+	if (STRNCMP(to_start, "NONE", 4) == 0)
+	    to_id = 0;
+	else
+	    to_id = syn_check_group(to_start, (int)(to_end - to_start));
+	if (from_id > 0 && (!init || HL_TABLE()[from_id - 1].sg_set == 0))
+	{
+	    /*
+	     * Don't allow a link when there already is some highlighting
+	     * for the group, unless '!' is used
+	     */
+	    if (to_id > 0 && !forceit && !init
+				   && hl_has_settings(from_id - 1, dodefault))
+	    {
+		if (sourcing_name == NULL && !dodefault)
+		    EMSG(_("E414: group has settings, highlight link ignored"));
+	    }
+	    else
+	    {
+		if (!init)
+		    HL_TABLE()[from_id - 1].sg_set |= SG_LINK;
+		HL_TABLE()[from_id - 1].sg_link = to_id;
+		redraw_all_later(NOT_VALID);
+	    }
+	}
+	/* Only call highlight_changed() once, after sourcing a syntax file */
+	need_highlight_changed = TRUE;
+	return;
+}
+if (doclear)
+{
+	/*
+	 * ":highlight clear [group]" command.
+	 */
+	line = linep;
+	if (ends_excmd(*line))
+	{
+#ifdef FEAT_GUI
+	    /* First, we do not destroy the old values, but allocate the new
+	     * ones and update the display. THEN we destroy the old values.
+	     * If we destroy the old values first, then the old values
+	     * (such as GuiFont's or GuiFontset's) will still be displayed but
+	     * invalid because they were free'd.
+	     */
+	    if (gui.in_use)
+	    {
+# ifdef FEAT_BEVAL_TIP
+		gui_init_tooltip_font();
+# endif
+# if defined(FEAT_MENU) && (defined(FEAT_GUI_ATHENA) || defined(FEAT_GUI_MOTIF))
+		gui_init_menu_font();
+# endif
+	    }
+# if defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_X11)
+	    gui_mch_def_colors();
+# endif
+# ifdef FEAT_GUI_X11
+#  ifdef FEAT_MENU
+	    /* This only needs to be done when there is no Menu highlight
+	     * group defined by default, which IS currently the case.
+	     */
+	    gui_mch_new_menu_colors();
+#  endif
+	    if (gui.in_use)
+	    {
+		gui_new_scrollbar_colors();
+#  ifdef FEAT_BEVAL
+		gui_mch_new_tooltip_colors();
+#  endif
+#  ifdef FEAT_MENU
+		gui_mch_new_menu_font();
+#  endif
+	    }
+# endif
+	    /* Ok, we're done allocating the new default graphics items.
+	     * The screen should already be refreshed at this point.
+	     * It is now Ok to clear out the old data.
+	     */
+#endif
+#ifdef FEAT_EVAL
+	    do_unlet((char_u *)"colors_name");
+#endif
+	    restore_cterm_colors();
+	    /*
+	     * Clear all default highlight groups and load the defaults.
+	     */
+	    for (idx = 0; idx < highlight_ga.ga_len; ++idx)
+		highlight_clear(idx);
+	    init_highlight(TRUE, TRUE);
+#ifdef FEAT_GUI
+	    if (gui.in_use)
+		highlight_gui_started();
+#endif
+	    highlight_changed();
+	    redraw_later_clear();
+	    return;
+	}
+	name_end = skiptowhite(line);
+	linep = skipwhite(name_end);
+}
+/*
+* Find the group name in the table.  If it does not exist yet, add it.
+*/
+id = syn_check_group(line, (int)(name_end - line));
+if (id == 0)			/* failed (out of memory) */
+	return;
+idx = id - 1;			/* index is ID minus one */
+/* Return if "default" was used and the group already has settings. */
+if (dodefault && hl_has_settings(idx, TRUE))
+	return;
+if (STRCMP(HL_TABLE()[idx].sg_name_u, "NORMAL") == 0)
+	is_normal_group = TRUE;
+#ifdef FEAT_GUI_X11
+else if (STRCMP(HL_TABLE()[idx].sg_name_u, "MENU") == 0)
+	is_menu_group = TRUE;
+else if (STRCMP(HL_TABLE()[idx].sg_name_u, "SCROLLBAR") == 0)
+	is_scrollbar_group = TRUE;
+else if (STRCMP(HL_TABLE()[idx].sg_name_u, "TOOLTIP") == 0)
+	is_tooltip_group = TRUE;
+#endif
+/* Clear the highlighting for ":hi clear {group}" and ":hi clear". */
+if (doclear || (forceit && init))
+{
+	highlight_clear(idx);
+	if (!doclear)
+	    HL_TABLE()[idx].sg_set = 0;
+}
+if (!doclear)
+while (!ends_excmd(*linep))
+{
+	key_start = linep;
+	if (*linep == '=')
+	{
+	    EMSG2(_("E415: unexpected equal sign: %s"), key_start);
+	    error = TRUE;
+	    break;
+	}
+	/*
+	 * Isolate the key ("term", "ctermfg", "ctermbg", "font", "guifg" or
+	 * "guibg").
+	 */
+	while (*linep && !vim_iswhite(*linep) && *linep != '=')
+	    ++linep;
+	vim_free(key);
+	key = vim_strnsave_up(key_start, (int)(linep - key_start));
+	if (key == NULL)
+	{
+	    error = TRUE;
+	    break;
+	}
+	linep = skipwhite(linep);
+	if (STRCMP(key, "NONE") == 0)
+	{
+	    if (!init || HL_TABLE()[idx].sg_set == 0)
+	    {
+		if (!init)
+		    HL_TABLE()[idx].sg_set |= SG_TERM+SG_CTERM+SG_GUI;
+		highlight_clear(idx);
+	    }
+	    continue;
+	}
+	/*
+	 * Check for the equal sign.
+	 */
+	if (*linep != '=')
+	{
+	    EMSG2(_("E416: missing equal sign: %s"), key_start);
+	    error = TRUE;
+	    break;
+	}
+	++linep;
+	/*
+	 * Isolate the argument.
+	 */
+	linep = skipwhite(linep);
+	if (*linep == '\'')		/* guifg='color name' */
+	{
+	    arg_start = ++linep;
+	    linep = vim_strchr(linep, '\'');
+	    if (linep == NULL)
+	    {
+		EMSG2(_(e_invarg2), key_start);
+		error = TRUE;
+		break;
+	    }
+	}
+	else
+	{
+	    arg_start = linep;
+	    linep = skiptowhite(linep);
+	}
+	if (linep == arg_start)
+	{
+	    EMSG2(_("E417: missing argument: %s"), key_start);
+	    error = TRUE;
+	    break;
+	}
+	vim_free(arg);
+	arg = vim_strnsave(arg_start, (int)(linep - arg_start));
+	if (arg == NULL)
+	{
+	    error = TRUE;
+	    break;
+	}
+	if (*linep == '\'')
+	    ++linep;
+	/*
+	 * Store the argument.
+	 */
+	if (  STRCMP(key, "TERM") == 0
+		|| STRCMP(key, "CTERM") == 0
+		|| STRCMP(key, "GUI") == 0)
+	{
+	    attr = 0;
+	    off = 0;
+	    while (arg[off] != NUL)
+	    {
+		for (i = sizeof(hl_attr_table) / sizeof(int); --i >= 0; )
+		{
+		    len = (int)STRLEN(hl_name_table[i]);
+		    if (STRNICMP(arg + off, hl_name_table[i], len) == 0)
+		    {
+			attr |= hl_attr_table[i];
+			off += len;
+			break;
+		    }
+		}
+		if (i < 0)
+		{
+		    EMSG2(_("E418: Illegal value: %s"), arg);
+		    error = TRUE;
+		    break;
+		}
+		if (arg[off] == ',')		/* another one follows */
+		    ++off;
+	    }
+	    if (error)
+		break;
+	    if (*key == 'T')
+	    {
+		if (!init || !(HL_TABLE()[idx].sg_set & SG_TERM))
+		{
+		    if (!init)
+			HL_TABLE()[idx].sg_set |= SG_TERM;
+		    HL_TABLE()[idx].sg_term = attr;
+		}
+	    }
+	    else if (*key == 'C')
+	    {
+		if (!init || !(HL_TABLE()[idx].sg_set & SG_CTERM))
+		{
+		    if (!init)
+			HL_TABLE()[idx].sg_set |= SG_CTERM;
+		    HL_TABLE()[idx].sg_cterm = attr;
+		    HL_TABLE()[idx].sg_cterm_bold = FALSE;
+		}
+	    }
+#ifdef FEAT_GUI
+	    else
+	    {
+		if (!init || !(HL_TABLE()[idx].sg_set & SG_GUI))
+		{
+		    if (!init)
+			HL_TABLE()[idx].sg_set |= SG_GUI;
+		    HL_TABLE()[idx].sg_gui = attr;
+		}
+	    }
+#endif
+	}
+	else if (STRCMP(key, "FONT") == 0)
+	{
+	    /* in non-GUI fonts are simply ignored */
+#ifdef FEAT_GUI
+	    if (!gui.shell_created)
+	    {
+		/* GUI not started yet, always accept the name. */
+		vim_free(HL_TABLE()[idx].sg_font_name);
+		HL_TABLE()[idx].sg_font_name = vim_strsave(arg);
+	    }
+	    else
+	    {
+		GuiFont temp_sg_font = HL_TABLE()[idx].sg_font;
+# ifdef FEAT_XFONTSET
+		GuiFontset temp_sg_fontset = HL_TABLE()[idx].sg_fontset;
+# endif
+		/* First, save the current font/fontset.
+		 * Then try to allocate the font/fontset.
+		 * If the allocation fails, HL_TABLE()[idx].sg_font OR
+		 * sg_fontset will be set to NOFONT or NOFONTSET respectively.
+		 */
+		HL_TABLE()[idx].sg_font = NOFONT;
+# ifdef FEAT_XFONTSET
+		HL_TABLE()[idx].sg_fontset = NOFONTSET;
+# endif
+		hl_do_font(idx, arg, is_normal_group, is_menu_group,
+							    is_tooltip_group);
+# ifdef FEAT_XFONTSET
+		if (HL_TABLE()[idx].sg_fontset != NOFONTSET)
+		{
+		    /* New fontset was accepted. Free the old one, if there was
+		     * one.
+		     */
+		    gui_mch_free_fontset(temp_sg_fontset);
+		    vim_free(HL_TABLE()[idx].sg_font_name);
+		    HL_TABLE()[idx].sg_font_name = vim_strsave(arg);
+		}
+		else
+		    HL_TABLE()[idx].sg_fontset = temp_sg_fontset;
+# endif
+		if (HL_TABLE()[idx].sg_font != NOFONT)
+		{
+		    /* New font was accepted. Free the old one, if there was
+		     * one.
+		     */
+		    gui_mch_free_font(temp_sg_font);
+		    vim_free(HL_TABLE()[idx].sg_font_name);
+		    HL_TABLE()[idx].sg_font_name = vim_strsave(arg);
+		}
+		else
+		    HL_TABLE()[idx].sg_font = temp_sg_font;
+	    }
+#endif
+	}
+	else if (STRCMP(key, "CTERMFG") == 0 || STRCMP(key, "CTERMBG") == 0)
+	{
+	  if (!init || !(HL_TABLE()[idx].sg_set & SG_CTERM))
+	  {
+	    if (!init)
+		HL_TABLE()[idx].sg_set |= SG_CTERM;
+	    /* When setting the foreground color, and previously the "bold"
+	     * flag was set for a light color, reset it now */
+	    if (key[5] == 'F' && HL_TABLE()[idx].sg_cterm_bold)
+	    {
+		HL_TABLE()[idx].sg_cterm &= ~HL_BOLD;
+		HL_TABLE()[idx].sg_cterm_bold = FALSE;
+	    }
+	    if (VIM_ISDIGIT(*arg))
+		color = atoi((char *)arg);
+	    else if (STRICMP(arg, "fg") == 0)
+	    {
+		if (cterm_normal_fg_color)
+		    color = cterm_normal_fg_color - 1;
+		else
+		{
+		    EMSG(_("E419: FG color unknown"));
+		    error = TRUE;
+		    break;
+		}
+	    }
+	    else if (STRICMP(arg, "bg") == 0)
+	    {
+		if (cterm_normal_bg_color > 0)
+		    color = cterm_normal_bg_color - 1;
+		else
+		{
+		    EMSG(_("E420: BG color unknown"));
+		    error = TRUE;
+		    break;
+		}
+	    }
+	    else
+	    {
+		static char *(color_names[28]) = {
+			    "Black", "DarkBlue", "DarkGreen", "DarkCyan",
+			    "DarkRed", "DarkMagenta", "Brown", "DarkYellow",
+			    "Gray", "Grey",
+			    "LightGray", "LightGrey", "DarkGray", "DarkGrey",
+			    "Blue", "LightBlue", "Green", "LightGreen",
+			    "Cyan", "LightCyan", "Red", "LightRed", "Magenta",
+			    "LightMagenta", "Yellow", "LightYellow", "White", "NONE"};
+		static int color_numbers_16[28] = {0, 1, 2, 3,
+						 4, 5, 6, 6,
+						 7, 7,
+						 7, 7, 8, 8,
+						 9, 9, 10, 10,
+						 11, 11, 12, 12, 13,
+						 13, 14, 14, 15, -1};
+		/* for xterm with 88 colors... */
+		static int color_numbers_88[28] = {0, 4, 2, 6,
+						 1, 5, 32, 72,
+						 84, 84,
+						 7, 7, 82, 82,
+						 12, 43, 10, 61,
+						 14, 63, 9, 74, 13,
+						 75, 11, 78, 15, -1};
+		/* for xterm with 256 colors... */
+		static int color_numbers_256[28] = {0, 4, 2, 6,
+						 1, 5, 130, 130,
+						 248, 248,
+						 7, 7, 242, 242,
+						 12, 81, 10, 121,
+						 14, 159, 9, 224, 13,
+						 225, 11, 229, 15, -1};
+		/* for terminals with less than 16 colors... */
+		static int color_numbers_8[28] = {0, 4, 2, 6,
+						 1, 5, 3, 3,
+						 7, 7,
+						 7, 7, 0+8, 0+8,
+						 4+8, 4+8, 2+8, 2+8,
+						 6+8, 6+8, 1+8, 1+8, 5+8,
+						 5+8, 3+8, 3+8, 7+8, -1};
+#if defined(__QNXNTO__)
+		static int *color_numbers_8_qansi = color_numbers_8;
+		/* On qnx, the 8 & 16 color arrays are the same */
+		if (STRNCMP(T_NAME, "qansi", 5) == 0)
+		    color_numbers_8_qansi = color_numbers_16;
+#endif
+		/* reduce calls to STRICMP a bit, it can be slow */
+		off = TOUPPER_ASC(*arg);
+		for (i = (sizeof(color_names) / sizeof(char *)); --i >= 0; )
+		    if (off == color_names[i][0]
+				 && STRICMP(arg + 1, color_names[i] + 1) == 0)
+			break;
+		if (i < 0)
+		{
+		    EMSG2(_("E421: Color name or number not recognized: %s"), key_start);
+		    error = TRUE;
+		    break;
+		}
+		/* Use the _16 table to check if its a valid color name. */
+		color = color_numbers_16[i];
+		if (color >= 0)
+		{
+		    if (t_colors == 8)
+		    {
+			/* t_Co is 8: use the 8 colors table */
+#if defined(__QNXNTO__)
+			color = color_numbers_8_qansi[i];
+#else
+			color = color_numbers_8[i];
+#endif
+			if (key[5] == 'F')
+			{
+			    /* set/reset bold attribute to get light foreground
+			     * colors (on some terminals, e.g. "linux") */
+			    if (color & 8)
+			    {
+				HL_TABLE()[idx].sg_cterm |= HL_BOLD;
+				HL_TABLE()[idx].sg_cterm_bold = TRUE;
+			    }
+			    else
+				HL_TABLE()[idx].sg_cterm &= ~HL_BOLD;
+			}
+			color &= 7;	/* truncate to 8 colors */
+		    }
+		    else if (t_colors == 16 || t_colors == 88
+							   || t_colors == 256)
+		    {
+			/*
+			 * Guess: if the termcap entry ends in 'm', it is
+			 * probably an xterm-like terminal.  Use the changed
+			 * order for colors.
+			 */
+			if (*T_CAF != NUL)
+			    p = T_CAF;
+			else
+			    p = T_CSF;
+			if (*p != NUL && *(p + STRLEN(p) - 1) == 'm')
+			    switch (t_colors)
+			    {
+				case 16:
+				    color = color_numbers_8[i];
+				    break;
+				case 88:
+				    color = color_numbers_88[i];
+				    break;
+				case 256:
+				    color = color_numbers_256[i];
+				    break;
+			    }
+		    }
+		}
+	    }
+	    /* Add one to the argument, to avoid zero */
+	    if (key[5] == 'F')
+	    {
+		HL_TABLE()[idx].sg_cterm_fg = color + 1;
+		if (is_normal_group)
+		{
+		    cterm_normal_fg_color = color + 1;
+		    cterm_normal_fg_bold = (HL_TABLE()[idx].sg_cterm & HL_BOLD);
+#ifdef FEAT_GUI
+		    /* Don't do this if the GUI is used. */
+		    if (!gui.in_use && !gui.starting)
+#endif
+		    {
+			must_redraw = CLEAR;
+			if (termcap_active)
+			    term_fg_color(color);
+		    }
+		}
+	    }
+	    else
+	    {
+		HL_TABLE()[idx].sg_cterm_bg = color + 1;
+		if (is_normal_group)
+		{
+		    cterm_normal_bg_color = color + 1;
+#ifdef FEAT_GUI
+		    /* Don't mess with 'background' if the GUI is used. */
+		    if (!gui.in_use && !gui.starting)
+#endif
+		    {
+			must_redraw = CLEAR;
+			if (termcap_active)
+			    term_bg_color(color);
+			if (t_colors < 16)
+			    i = (color == 0 || color == 4);
+			else
+			    i = (color < 7 || color == 8);
+			/* Set the 'background' option if the value is wrong. */
+			if (i != (*p_bg == 'd'))
+			    set_option_value((char_u *)"bg", 0L,
+				 i ? (char_u *)"dark" : (char_u *)"light", 0);
+		    }
+		}
+	    }
+	  }
+	}
+	else if (STRCMP(key, "GUIFG") == 0)
+	{
+#ifdef FEAT_GUI	    /* in non-GUI guifg colors are simply ignored */
+	  if (!init || !(HL_TABLE()[idx].sg_set & SG_GUI))
+	  {
+	    if (!init)
+		HL_TABLE()[idx].sg_set |= SG_GUI;
+	    i = color_name2handle(arg);
+	    if (i != INVALCOLOR || STRCMP(arg, "NONE") == 0 || !gui.in_use)
+	    {
+		HL_TABLE()[idx].sg_gui_fg = i;
+		vim_free(HL_TABLE()[idx].sg_gui_fg_name);
+		if (STRCMP(arg, "NONE"))
+		    HL_TABLE()[idx].sg_gui_fg_name = vim_strsave(arg);
+		else
+		    HL_TABLE()[idx].sg_gui_fg_name = NULL;
+# ifdef FEAT_GUI_X11
+		if (is_menu_group)
+		    gui.menu_fg_pixel = i;
+		if (is_scrollbar_group)
+		    gui.scroll_fg_pixel = i;
+#  ifdef FEAT_BEVAL
+		if (is_tooltip_group)
+		    gui.tooltip_fg_pixel = i;
+#  endif
+		do_colors = TRUE;
+# endif
+	    }
+	  }
+#endif
+	}
+	else if (STRCMP(key, "GUIBG") == 0)
+	{
+#ifdef FEAT_GUI	    /* in non-GUI guibg colors are simply ignored */
+	  if (!init || !(HL_TABLE()[idx].sg_set & SG_GUI))
+	  {
+	    if (!init)
+		HL_TABLE()[idx].sg_set |= SG_GUI;
+	    i = color_name2handle(arg);
+	    if (i != INVALCOLOR || STRCMP(arg, "NONE") == 0 || !gui.in_use)
+	    {
+		HL_TABLE()[idx].sg_gui_bg = i;
+		vim_free(HL_TABLE()[idx].sg_gui_bg_name);
+		if (STRCMP(arg, "NONE"))
+		    HL_TABLE()[idx].sg_gui_bg_name = vim_strsave(arg);
+		else
+		    HL_TABLE()[idx].sg_gui_bg_name = NULL;
+# ifdef FEAT_GUI_X11
+		if (is_menu_group)
+		    gui.menu_bg_pixel = i;
+		if (is_scrollbar_group)
+		    gui.scroll_bg_pixel = i;
+#  ifdef FEAT_BEVAL
+		if (is_tooltip_group)
+		    gui.tooltip_bg_pixel = i;
+#  endif
+		do_colors = TRUE;
+# endif
+	    }
+	  }
+#endif
+	}
+	else if (STRCMP(key, "START") == 0 || STRCMP(key, "STOP") == 0)
+	{
+	    char_u	buf[100];
+	    char_u	*tname;
+	    if (!init)
+		HL_TABLE()[idx].sg_set |= SG_TERM;
+	    /*
+	     * The "start" and "stop"  arguments can be a literal escape
+	     * sequence, or a comma seperated list of terminal codes.
+	     */
+	    if (STRNCMP(arg, "t_", 2) == 0)
+	    {
+		off = 0;
+		buf[0] = 0;
+		while (arg[off] != NUL)
+		{
+		    /* Isolate one termcap name */
+		    for (len = 0; arg[off + len] &&
+						 arg[off + len] != ','; ++len)
+			;
+		    tname = vim_strnsave(arg + off, len);
+		    if (tname == NULL)		/* out of memory */
+		    {
+			error = TRUE;
+			break;
+		    }
+		    /* lookup the escape sequence for the item */
+		    p = get_term_code(tname);
+		    vim_free(tname);
+		    if (p == NULL)	    /* ignore non-existing things */
+			p = (char_u *)"";
+		    /* Append it to the already found stuff */
+		    if ((int)(STRLEN(buf) + STRLEN(p)) >= 99)
+		    {
+			EMSG2(_("E422: terminal code too long: %s"), arg);
+			error = TRUE;
+			break;
+		    }
+		    STRCAT(buf, p);
+		    /* Advance to the next item */
+		    off += len;
+		    if (arg[off] == ',')	    /* another one follows */
+			++off;
+		}
+	    }
+	    else
+	    {
+		/*
+		 * Copy characters from arg[] to buf[], translating <> codes.
+		 */
+		for (p = arg, off = 0; off < 100 && *p; )
+		{
+		    len = trans_special(&p, buf + off, FALSE);
+		    if (len)		    /* recognized special char */
+			off += len;
+		    else		    /* copy as normal char */
+			buf[off++] = *p++;
+		}
+		buf[off] = NUL;
+	    }
+	    if (error)
+		break;
+	    if (STRCMP(buf, "NONE") == 0)	/* resetting the value */
+		p = NULL;
+	    else
+		p = vim_strsave(buf);
+	    if (key[2] == 'A')
+	    {
+		vim_free(HL_TABLE()[idx].sg_start);
+		HL_TABLE()[idx].sg_start = p;
+	    }
+	    else
+	    {
+		vim_free(HL_TABLE()[idx].sg_stop);
+		HL_TABLE()[idx].sg_stop = p;
+	    }
+	}
+	else
+	{
+	    EMSG2(_("E423: Illegal argument: %s"), key_start);
+	    error = TRUE;
+	    break;
+	}
+	/*
+	 * When highlighting has been given for a group, don't link it.
+	 */
+	if (!init || !(HL_TABLE()[idx].sg_set & SG_LINK))
+	    HL_TABLE()[idx].sg_link = 0;
+	/*
+	 * Continue with next argument.
+	 */
+	linep = skipwhite(linep);
+}
+/*
+* If there is an error, and it's a new entry, remove it from the table.
+*/
+if (error && idx == highlight_ga.ga_len)
+	syn_unadd_group();
+else
+{
+	if (is_normal_group)
+	{
+	    HL_TABLE()[idx].sg_term_attr = 0;
+	    HL_TABLE()[idx].sg_cterm_attr = 0;
+#ifdef FEAT_GUI
+	    HL_TABLE()[idx].sg_gui_attr = 0;
+	    /*
+	     * Need to update all groups, because they might be using "bg"
+	     * and/or "fg", which have been changed now.
+	     */
+	    if (gui.in_use)
+		highlight_gui_started();
+#endif
+	}
+#ifdef FEAT_GUI_X11
+# ifdef FEAT_MENU
+	else if (is_menu_group)
+	{
+	    if (gui.in_use && do_colors)
+		gui_mch_new_menu_colors();
+	}
+# endif
+	else if (is_scrollbar_group)
+	{
+	    if (gui.in_use && do_colors)
+		gui_new_scrollbar_colors();
+	}
+# ifdef FEAT_BEVAL
+	else if (is_tooltip_group)
+	{
+	    if (gui.in_use && do_colors)
+		gui_mch_new_tooltip_colors();
+	}
+# endif
+#endif
+	else
+	    set_hl_attr(idx);
+	redraw_all_later(NOT_VALID);
+}
+vim_free(key);
+vim_free(arg);
+/* Only call highlight_changed() once, after sourcing a syntax file */
+need_highlight_changed = TRUE;
+}
+/*
+* Reset the cterm colors to what they were before Vim was started, if
+* possible.  Otherwise reset them to zero.
+*/
+void
+restore_cterm_colors()
+{
+#if defined(MSDOS) || (defined(WIN3264) && !defined(FEAT_GUI_W32))
+/* Since t_me has been set, this probably means that the user
+* wants to use this as default colors.  Need to reset default
+* background/foreground colors. */
+mch_set_normal_colors();
+#else
+cterm_normal_fg_color = 0;
+cterm_normal_fg_bold = 0;
+cterm_normal_bg_color = 0;
+#endif
+}
+/*
+* Return TRUE if highlight group "idx" has any settings.
+* When "check_link" is TRUE also check for an existing link.
+*/
+static int
+hl_has_settings(idx, check_link)
+int		idx;
+int		check_link;
+{
+return (   HL_TABLE()[idx].sg_term_attr != 0
+	    || HL_TABLE()[idx].sg_cterm_attr != 0
+#ifdef FEAT_GUI
+	    || HL_TABLE()[idx].sg_gui_attr != 0
+#endif
+	    || (check_link && (HL_TABLE()[idx].sg_set & SG_LINK)));
+}
+/*
+* Clear highlighting for one group.
+*/
+static void
+highlight_clear(idx)
+int idx;
+{
+HL_TABLE()[idx].sg_term = 0;
+vim_free(HL_TABLE()[idx].sg_start);
+HL_TABLE()[idx].sg_start = NULL;
+vim_free(HL_TABLE()[idx].sg_stop);
+HL_TABLE()[idx].sg_stop = NULL;
+HL_TABLE()[idx].sg_term_attr = 0;
+HL_TABLE()[idx].sg_cterm = 0;
+HL_TABLE()[idx].sg_cterm_bold = FALSE;
+HL_TABLE()[idx].sg_cterm_fg = 0;
+HL_TABLE()[idx].sg_cterm_bg = 0;
+HL_TABLE()[idx].sg_cterm_attr = 0;
+#ifdef FEAT_GUI	    /* in non-GUI fonts are simply ignored */
+HL_TABLE()[idx].sg_gui = 0;
+HL_TABLE()[idx].sg_gui_fg = INVALCOLOR;
+vim_free(HL_TABLE()[idx].sg_gui_fg_name);
+HL_TABLE()[idx].sg_gui_fg_name = NULL;
+HL_TABLE()[idx].sg_gui_bg = INVALCOLOR;
+vim_free(HL_TABLE()[idx].sg_gui_bg_name);
+HL_TABLE()[idx].sg_gui_bg_name = NULL;
+gui_mch_free_font(HL_TABLE()[idx].sg_font);
+HL_TABLE()[idx].sg_font = NOFONT;
+# ifdef FEAT_XFONTSET
+gui_mch_free_fontset(HL_TABLE()[idx].sg_fontset);
+HL_TABLE()[idx].sg_fontset = NOFONTSET;
+# endif
+vim_free(HL_TABLE()[idx].sg_font_name);
+HL_TABLE()[idx].sg_font_name = NULL;
+HL_TABLE()[idx].sg_gui_attr = 0;
+#endif
+}
+#if defined(FEAT_GUI) || defined(PROTO)
+/*
+* Set the normal foreground and background colors according to the "Normal"
+* highlighighting group.  For X11 also set "Menu", "Scrollbar", and
+* "Tooltip" colors.
+*/
+void
+set_normal_colors()
+{
+if (set_group_colors((char_u *)"Normal",
+			       &gui.norm_pixel, &gui.back_pixel, FALSE, TRUE,
+			       FALSE))
+{
+	gui_mch_new_colors();
+	must_redraw = CLEAR;
+}
+#ifdef FEAT_GUI_X11
+if (set_group_colors((char_u *)"Menu",
+			 &gui.menu_fg_pixel, &gui.menu_bg_pixel, TRUE, FALSE,
+			 FALSE))
+{
+# ifdef FEAT_MENU
+	gui_mch_new_menu_colors();
+# endif
+	must_redraw = CLEAR;
+}
+# ifdef FEAT_BEVAL
+if (set_group_colors((char_u *)"Tooltip",
+			 &gui.tooltip_fg_pixel, &gui.tooltip_bg_pixel,
+			 FALSE, FALSE, TRUE))
+{
+# ifdef FEAT_TOOLBAR
+	gui_mch_new_tooltip_colors();
+# endif
+	must_redraw = CLEAR;
+}
+#endif
+if (set_group_colors((char_u *)"Scrollbar",
+		    &gui.scroll_fg_pixel, &gui.scroll_bg_pixel, FALSE, FALSE,
+		    FALSE))
+{
+	gui_new_scrollbar_colors();
+	must_redraw = CLEAR;
+}
+#endif
+}
+/*
+* Set the colors for "Normal", "Menu", "Tooltip" or "Scrollbar".
+*/
+static int
+set_group_colors(name, fgp, bgp, do_menu, use_norm, do_tooltip)
+char_u	*name;
+guicolor_T	*fgp;
+guicolor_T	*bgp;
+int		do_menu;
+int		use_norm;
+int		do_tooltip;
+{
+int		idx;
+idx = syn_name2id(name) - 1;
+if (idx >= 0)
+{
+	gui_do_one_color(idx, do_menu, do_tooltip);
+	if (HL_TABLE()[idx].sg_gui_fg != INVALCOLOR)
+	    *fgp = HL_TABLE()[idx].sg_gui_fg;
+	else if (use_norm)
+	    *fgp = gui.def_norm_pixel;
+	if (HL_TABLE()[idx].sg_gui_bg != INVALCOLOR)
+	    *bgp = HL_TABLE()[idx].sg_gui_bg;
+	else if (use_norm)
+	    *bgp = gui.def_back_pixel;
+	return TRUE;
+}
+return FALSE;
+}
+/*
+* Get the font of the "Normal" group.
+* Returns "" when it's not found or not set.
+*/
+char_u *
+hl_get_font_name()
+{
+int		id;
+char_u	*s;
+id = syn_name2id((char_u *)"Normal");
+if (id > 0)
+{
+	s = HL_TABLE()[id - 1].sg_font_name;
+	if (s != NULL)
+	    return s;
+}
+return (char_u *)"";
+}
+/*
+* Set font for "Normal" group.  Called by gui_mch_init_font() when a font has
+* actually chosen to be used.
+*/
+void
+hl_set_font_name(font_name)
+char_u	*font_name;
+{
+int	    id;
+id = syn_name2id((char_u *)"Normal");
+if (id > 0)
+{
+	vim_free(HL_TABLE()[id - 1].sg_font_name);
+	HL_TABLE()[id - 1].sg_font_name = vim_strsave(font_name);
+}
+}
+/*
+* Set background color for "Normal" group.  Called by gui_set_bg_color()
+* when the color is known.
+*/
+void
+hl_set_bg_color_name(name)
+char_u  *name;	    /* must have been allocated */
+{
+int	    id;
+if (name != NULL)
+{
+	id = syn_name2id((char_u *)"Normal");
+	if (id > 0)
+	{
+	    vim_free(HL_TABLE()[id - 1].sg_gui_bg_name);
+	    HL_TABLE()[id - 1].sg_gui_bg_name = name;
+	}
+}
+}
+/*
+* Set foreground color for "Normal" group.  Called by gui_set_fg_color()
+* when the color is known.
+*/
+void
+hl_set_fg_color_name(name)
+char_u  *name;	    /* must have been allocated */
+{
+int	    id;
+if (name != NULL)
+{
+	id = syn_name2id((char_u *)"Normal");
+	if (id > 0)
+	{
+	    vim_free(HL_TABLE()[id - 1].sg_gui_fg_name);
+	    HL_TABLE()[id - 1].sg_gui_fg_name = name;
+	}
+}
+}
+/*
+* Return the handle for a color name.
+* Returns INVALCOLOR when failed.
+*/
+static guicolor_T
+color_name2handle(name)
+char_u  *name;
+{
+if (STRCMP(name, "NONE") == 0)
+	return INVALCOLOR;
+if (STRICMP(name, "fg") == 0 || STRICMP(name, "foreground") == 0)
+	return gui.norm_pixel;
+if (STRICMP(name, "bg") == 0 || STRICMP(name, "background") == 0)
+	return gui.back_pixel;
+return gui_get_color(name);
+}
+/*
+* Return the handle for a font name.
+* Returns NOFONT when failed.
+*/
+static GuiFont
+font_name2handle(name)
+char_u  *name;
+{
+if (STRCMP(name, "NONE") == 0)
+	return NOFONT;
+return gui_mch_get_font(name, TRUE);
+}
+# ifdef FEAT_XFONTSET
+/*
+* Return the handle for a fontset name.
+* Returns NOFONTSET when failed.
+*/
+static GuiFontset
+fontset_name2handle(name, fixed_width)
+char_u	*name;
+int		fixed_width;
+{
+if (STRCMP(name, "NONE") == 0)
+	return NOFONTSET;
+return gui_mch_get_fontset(name, TRUE, fixed_width);
+}
+# endif
+/*
+* Get the font or fontset for one highlight group.
+*/
+/*ARGSUSED*/
+static void
+hl_do_font(idx, arg, do_normal, do_menu, do_tooltip)
+int		idx;
+char_u	*arg;
+int		do_normal;	/* set normal font */
+int		do_menu;	/* set menu font */
+int		do_tooltip;	/* set tooltip font */
+{
+# ifdef FEAT_XFONTSET
+/* If 'guifontset' is not empty, first try using the name as a
+* fontset.  If that doesn't work, use it as a font name. */
+if (*p_guifontset != NUL
+#  ifdef FONTSET_ALWAYS
+	|| do_menu
+#  endif
+#  ifdef FEAT_BEVAL_TIP
+	/* In Athena & Motif, the Tooltip highlight group is always a fontset */
+	|| do_tooltip
+#  endif
+	    )
+	HL_TABLE()[idx].sg_fontset = fontset_name2handle(arg, 0
+#  ifdef FONTSET_ALWAYS
+		|| do_menu
+#  endif
+#  ifdef FEAT_BEVAL_TIP
+		|| do_tooltip
+#  endif
+		);
+if (HL_TABLE()[idx].sg_fontset != NOFONTSET)
+{
+	/* If it worked and it's the Normal group, use it as the
+	 * normal fontset.  Same for the Menu group. */
+	if (do_normal)
+	    gui_init_font(arg, TRUE);
+#   if (defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_ATHENA)) && defined(FEAT_MENU)
+	if (do_menu)
+	{
+#    ifdef FONTSET_ALWAYS
+	    gui.menu_fontset = HL_TABLE()[idx].sg_fontset;
+#    else
+	    /* YIKES!  This is a bug waiting to crash the program */
+	    gui.menu_font = HL_TABLE()[idx].sg_fontset;
+#    endif
+	    gui_mch_new_menu_font();
+	}
+#    ifdef FEAT_BEVAL
+	if (do_tooltip)
+	{
+	    /* The Athena widget set cannot currently handle switching between
+	     * displaying a single font and a fontset.
+	     * If the XtNinternational resource is set to True at widget
+	     * creation, then a fontset is always used, othwise an
+	     * XFontStruct is used.
+	     */
+	    gui.tooltip_fontset = (XFontSet)HL_TABLE()[idx].sg_fontset;
+	    gui_mch_new_tooltip_font();
+	}
+#    endif
+#   endif
+}
+else
+# endif
+{
+	HL_TABLE()[idx].sg_font = font_name2handle(arg);
+	/* If it worked and it's the Normal group, use it as the
+	 * normal font.  Same for the Menu group. */
+	if (HL_TABLE()[idx].sg_font != NOFONT)
+	{
+	    if (do_normal)
+		gui_init_font(arg, FALSE);
+#ifndef FONTSET_ALWAYS
+# if (defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_ATHENA)) && defined(FEAT_MENU)
+	    if (do_menu)
+	    {
+		gui.menu_font = HL_TABLE()[idx].sg_font;
+		gui_mch_new_menu_font();
+	    }
+# endif
+#endif
+	}
+}
+}
+#endif /* FEAT_GUI */
+/*
+* Table with the specifications for an attribute number.
+* Note that this table is used by ALL buffers.  This is required because the
+* GUI can redraw at any time for any buffer.
+*/
+garray_T	term_attr_table = {0, 0, 0, 0, NULL};
+#define TERM_ATTR_ENTRY(idx) ((attrentry_T *)term_attr_table.ga_data)[idx]
+garray_T	cterm_attr_table = {0, 0, 0, 0, NULL};
+#define CTERM_ATTR_ENTRY(idx) ((attrentry_T *)cterm_attr_table.ga_data)[idx]
+#ifdef FEAT_GUI
+garray_T	gui_attr_table = {0, 0, 0, 0, NULL};
+#define GUI_ATTR_ENTRY(idx) ((attrentry_T *)gui_attr_table.ga_data)[idx]
+#endif
+/*
+* Return the attr number for a set of colors and font.
+* Add a new entry to the term_attr_table, cterm_attr_table or gui_attr_table
+* if the combination is new.
+* Return 0 for error (no more room).
+*/
+static int
+get_attr_entry(table, aep)
+garray_T	*table;
+attrentry_T	*aep;
+{
+int		i;
+attrentry_T	*gap;
+static int	recursive = FALSE;
+/*
+* Init the table, in case it wasn't done yet.
+*/
+table->ga_itemsize = sizeof(attrentry_T);
+table->ga_growsize = 7;
+/*
+* Try to find an entry with the same specifications.
+*/
+for (i = 0; i < table->ga_len; ++i)
+{
+	gap = &(((attrentry_T *)table->ga_data)[i]);
+	if (	   aep->ae_attr == gap->ae_attr
+		&& (
+#ifdef FEAT_GUI
+		       (table == &gui_attr_table
+			&& (aep->ae_u.gui.fg_color == gap->ae_u.gui.fg_color
+			    && aep->ae_u.gui.bg_color == gap->ae_u.gui.bg_color
+			    && aep->ae_u.gui.font == gap->ae_u.gui.font
+#  ifdef FEAT_XFONTSET
+			    && aep->ae_u.gui.fontset == gap->ae_u.gui.fontset
+#  endif
+			    ))
+		    ||
+#endif
+		       (table == &term_attr_table
+			&& (aep->ae_u.term.start == NULL) ==
+						(gap->ae_u.term.start == NULL)
+			&& (aep->ae_u.term.start == NULL
+			    || STRCMP(aep->ae_u.term.start,
+						   gap->ae_u.term.start) == 0)
+			&& (aep->ae_u.term.stop == NULL) ==
+						 (gap->ae_u.term.stop == NULL)
+			&& (aep->ae_u.term.stop == NULL
+			    || STRCMP(aep->ae_u.term.stop,
+						   gap->ae_u.term.stop) == 0))
+		    || (table == &cterm_attr_table
+			&& aep->ae_u.cterm.fg_color == gap->ae_u.cterm.fg_color
+			&& aep->ae_u.cterm.bg_color == gap->ae_u.cterm.bg_color)
+		     ))
+	return i + ATTR_OFF;
+}
+if (table->ga_len + ATTR_OFF == 256)
+{
+	/*
+	 * Running out of attribute entries!  remove all attributes, and
+	 * compute new ones for all groups.
+	 * When called recursively, we are really out of numbers.
+	 */
+	if (recursive)
+	{
+	    EMSG(_("E424: Too many different highlighting attributes in use"));
+	    return 0;
+	}
+	recursive = TRUE;
+#ifdef FEAT_GUI
+	ga_clear(&gui_attr_table);
+#endif
+	ga_clear(&term_attr_table);
+	ga_clear(&cterm_attr_table);
+	must_redraw = CLEAR;
+	for (i = 0; i < highlight_ga.ga_len; ++i)
+	    set_hl_attr(i);
+	recursive = FALSE;
+}
+/*
+* This is a new combination of colors and font, add an entry.
+*/
+if (ga_grow(table, 1) == FAIL)
+	return 0;
+gap = &(((attrentry_T *)table->ga_data)[table->ga_len]);
+vim_memset(gap, 0, sizeof(attrentry_T));
+gap->ae_attr = aep->ae_attr;
+#ifdef FEAT_GUI
+if (table == &gui_attr_table)
+{
+	gap->ae_u.gui.fg_color = aep->ae_u.gui.fg_color;
+	gap->ae_u.gui.bg_color = aep->ae_u.gui.bg_color;
+	gap->ae_u.gui.font = aep->ae_u.gui.font;
+# ifdef FEAT_XFONTSET
+	gap->ae_u.gui.fontset = aep->ae_u.gui.fontset;
+# endif
+}
+#endif
+if (table == &term_attr_table)
+{
+	if (aep->ae_u.term.start == NULL)
+	    gap->ae_u.term.start = NULL;
+	else
+	    gap->ae_u.term.start = vim_strsave(aep->ae_u.term.start);
+	if (aep->ae_u.term.stop == NULL)
+	    gap->ae_u.term.stop = NULL;
+	else
+	    gap->ae_u.term.stop = vim_strsave(aep->ae_u.term.stop);
+}
+else if (table == &cterm_attr_table)
+{
+	gap->ae_u.cterm.fg_color = aep->ae_u.cterm.fg_color;
+	gap->ae_u.cterm.bg_color = aep->ae_u.cterm.bg_color;
+}
+++table->ga_len;
+--table->ga_room;
+return (table->ga_len - 1 + ATTR_OFF);
+}
+#ifdef FEAT_GUI
+attrentry_T *
+syn_gui_attr2entry(attr)
+int		    attr;
+{
+attr -= ATTR_OFF;
+if (attr >= gui_attr_table.ga_len)	    /* did ":syntax clear" */
+	return NULL;
+return &(GUI_ATTR_ENTRY(attr));
+}
+#endif /* FEAT_GUI */
+attrentry_T *
+syn_term_attr2entry(attr)
+int		    attr;
+{
+attr -= ATTR_OFF;
+if (attr >= term_attr_table.ga_len)	    /* did ":syntax clear" */
+	return NULL;
+return &(TERM_ATTR_ENTRY(attr));
+}
+attrentry_T *
+syn_cterm_attr2entry(attr)
+int		    attr;
+{
+attr -= ATTR_OFF;
+if (attr >= cterm_attr_table.ga_len)	/* did ":syntax clear" */
+	return NULL;
+return &(CTERM_ATTR_ENTRY(attr));
+}
+#define LIST_ATTR   1
+#define LIST_STRING 2
+#define LIST_INT    3
+static void
+highlight_list_one(id)
+int		id;
+{
+struct hl_group	*sgp;
+int			didh = FALSE;
+sgp = &HL_TABLE()[id - 1];	    /* index is ID minus one */
+didh = highlight_list_arg(id, didh, LIST_ATTR,
+				    sgp->sg_term, NULL, "term");
+didh = highlight_list_arg(id, didh, LIST_STRING,
+				    0, sgp->sg_start, "start");
+didh = highlight_list_arg(id, didh, LIST_STRING,
+				    0, sgp->sg_stop, "stop");
+didh = highlight_list_arg(id, didh, LIST_ATTR,
+				    sgp->sg_cterm, NULL, "cterm");
+didh = highlight_list_arg(id, didh, LIST_INT,
+				    sgp->sg_cterm_fg, NULL, "ctermfg");
+didh = highlight_list_arg(id, didh, LIST_INT,
+				    sgp->sg_cterm_bg, NULL, "ctermbg");
+#ifdef FEAT_GUI
+didh = highlight_list_arg(id, didh, LIST_ATTR,
+				    sgp->sg_gui, NULL, "gui");
+didh = highlight_list_arg(id, didh, LIST_STRING,
+				    0, sgp->sg_gui_fg_name, "guifg");
+didh = highlight_list_arg(id, didh, LIST_STRING,
+				    0, sgp->sg_gui_bg_name, "guibg");
+didh = highlight_list_arg(id, didh, LIST_STRING,
+				    0, sgp->sg_font_name, "font");
+#endif
+if (sgp->sg_link)
+{
+	(void)syn_list_header(didh, 9999, id);
+	msg_puts_attr((char_u *)"links to", hl_attr(HLF_D));
+	msg_putchar(' ');
+	msg_outtrans(HL_TABLE()[HL_TABLE()[id - 1].sg_link - 1].sg_name);
+}
+}
+static int
+highlight_list_arg(id, didh, type, iarg, sarg, name)
+int		id;
+int		didh;
+int		type;
+int		iarg;
+char_u	*sarg;
+char	*name;
+{
+char_u	buf[100];
+char_u	*ts;
+int		i;
+if (type == LIST_STRING ? (sarg != NULL) : (iarg != 0))
+{
+	ts = buf;
+	if (type == LIST_INT)
+	    sprintf((char *)buf, "%d", iarg - 1);
+	else if (type == LIST_STRING)
+	    ts = sarg;
+	else /* type == LIST_ATTR */
+	{
+	    buf[0] = NUL;
+	    for (i = 0; hl_attr_table[i] != 0; ++i)
+	    {
+		if (iarg & hl_attr_table[i])
+		{
+		    if (buf[0] != NUL)
+			STRCAT(buf, ",");
+		    STRCAT(buf, hl_name_table[i]);
+		    iarg &= ~hl_attr_table[i];	    /* don't want "inverse" */
+		}
+	    }
+	}
+	(void)syn_list_header(didh,
+			       (int)(vim_strsize(ts) + STRLEN(name) + 1), id);
+	didh = TRUE;
+	MSG_PUTS_ATTR(name, hl_attr(HLF_D));
+	MSG_PUTS_ATTR("=", hl_attr(HLF_D));
+	msg_outtrans(ts);
+}
+return didh;
+}
+#if (((defined(FEAT_EVAL) || defined(FEAT_PRINTER))) && defined(FEAT_SYN_HL)) || defined(PROTO)
+/*
+* Return "1" if highlight group "id" has attribute "flag".
+* Return NULL otherwise.
+*/
+char_u *
+highlight_has_attr(id, flag, modec)
+int		id;
+int		flag;
+int		modec;	/* 'g' for GUI, 'c' for cterm, 't' for term */
+{
+int		attr;
+if (id <= 0 || id > highlight_ga.ga_len)
+	return NULL;
+#ifdef FEAT_GUI
+if (modec == 'g')
+	attr = HL_TABLE()[id - 1].sg_gui;
+else
+#endif
+	 if (modec == 'c')
+	attr = HL_TABLE()[id - 1].sg_cterm;
+else
+	attr = HL_TABLE()[id - 1].sg_term;
+if (attr & flag)
+	return (char_u *)"1";
+return NULL;
+}
+#endif
+#if (defined(FEAT_SYN_HL) && defined(FEAT_EVAL)) || defined(PROTO)
+/*
+* Return color name of highlight group "id".
+*/
+char_u *
+highlight_color(id, what, modec)
+int		id;
+char_u	*what;	/* "fg", "bg", "fg#" or "bg#" */
+int		modec;	/* 'g' for GUI, 'c' for cterm, 't' for term */
+{
+static char_u	name[20];
+int			n;
+int			fg;
+if (id <= 0 || id > highlight_ga.ga_len)
+	return NULL;
+if (TOLOWER_ASC(what[0]) == 'f')
+	fg = TRUE;
+else
+	fg = FALSE;
+#ifdef FEAT_GUI
+if (modec == 'g')
+{
+	/* return #RRGGBB form (only possible when GUI is running) */
+	if (gui.in_use && what[1] && what[2] == '#')
+	{
+	    guicolor_T		color;
+	    long_u		rgb;
+	    static char_u	buf[10];
+	    if (fg)
+		color = HL_TABLE()[id - 1].sg_gui_fg;
+	    else
+		color = HL_TABLE()[id - 1].sg_gui_bg;
+	    if (color == INVALCOLOR)
+		return NULL;
+	    rgb = gui_mch_get_rgb(color);
+	    sprintf((char *)buf, "#%02x%02x%02x",
+				      (unsigned)(rgb >> 16),
+				      (unsigned)(rgb >> 8) & 255,
+				      (unsigned)rgb & 255);
+	    return buf;
+	}
+	if (fg)
+	    return (HL_TABLE()[id - 1].sg_gui_fg_name);
+	return (HL_TABLE()[id - 1].sg_gui_bg_name);
+}
+#endif
+if (modec == 'c')
+{
+	if (fg)
+	    n = HL_TABLE()[id - 1].sg_cterm_fg - 1;
+	else
+	    n = HL_TABLE()[id - 1].sg_cterm_bg - 1;
+	sprintf((char *)name, "%d", n);
+	return name;
+}
+/* term doesn't have color */
+return NULL;
+}
+#endif
+#if (defined(FEAT_SYN_HL) && defined(FEAT_GUI) && defined(FEAT_PRINTER)) \
+	|| defined(PROTO)
+/*
+* Return color name of highlight group "id" as RGB value.
+*/
+long_u
+highlight_gui_color_rgb(id, fg)
+int		id;
+int		fg;	/* TRUE = fg, FALSE = bg */
+{
+guicolor_T	color;
+if (id <= 0 || id > highlight_ga.ga_len)
+	return 0L;
+if (fg)
+	color = HL_TABLE()[id - 1].sg_gui_fg;
+else
+	color = HL_TABLE()[id - 1].sg_gui_bg;
+if (color == INVALCOLOR)
+	return 0L;
+return gui_mch_get_rgb(color);
+}
+#endif
+/*
+* Output the syntax list header.
+* Return TRUE when started a new line.
+*/
+static int
+syn_list_header(did_header, outlen, id)
+int	    did_header;		/* did header already */
+int	    outlen;		/* length of string that comes */
+int	    id;			/* highlight group id */
+{
+int	    endcol = 19;
+int	    newline = TRUE;
+if (!did_header)
+{
+	msg_putchar('\n');
+	msg_outtrans(HL_TABLE()[id - 1].sg_name);
+	endcol = 15;
+}
+else if (msg_col + outlen + 1 >= Columns)
+	msg_putchar('\n');
+else
+{
+	if (msg_col >= endcol)	/* wrap around is like starting a new line */
+	    newline = FALSE;
+}
+if (msg_col >= endcol)	/* output at least one space */
+	endcol = msg_col + 1;
+if (Columns <= endcol)	/* avoid hang for tiny window */
+	endcol = Columns - 1;
+msg_advance(endcol);
+/* Show "xxx" with the attributes. */
+if (!did_header)
+{
+	msg_puts_attr((char_u *)"xxx", syn_id2attr(id));
+	msg_putchar(' ');
+}
+return newline;
+}
+/*
+* Set the attribute numbers for a highlight group.
+* Called after one of the attributes has changed.
+*/
+static void
+set_hl_attr(idx)
+int		idx;	    /* index in array */
+{
+attrentry_T		at_en;
+struct hl_group	*sgp = HL_TABLE() + idx;
+/* The "Normal" group doesn't need an attribute number */
+if (sgp->sg_name_u != NULL && STRCMP(sgp->sg_name_u, "NORMAL") == 0)
+	return;
+#ifdef FEAT_GUI
+/*
+* For the GUI mode: If there are other than "normal" highlighting
+* attributes, need to allocate an attr number.
+*/
+if (sgp->sg_gui_fg == INVALCOLOR
+	    && sgp->sg_gui_bg == INVALCOLOR
+	    && sgp->sg_font == NOFONT
+# ifdef FEAT_XFONTSET
+	    && sgp->sg_fontset == NOFONTSET
+# endif
+	    )
+{
+	sgp->sg_gui_attr = sgp->sg_gui;
+}
+else
+{
+	at_en.ae_attr = sgp->sg_gui;
+	at_en.ae_u.gui.fg_color = sgp->sg_gui_fg;
+	at_en.ae_u.gui.bg_color = sgp->sg_gui_bg;
+	at_en.ae_u.gui.font = sgp->sg_font;
+# ifdef FEAT_XFONTSET
+	at_en.ae_u.gui.fontset = sgp->sg_fontset;
+# endif
+	sgp->sg_gui_attr = get_attr_entry(&gui_attr_table, &at_en);
+}
+#endif
+/*
+* For the term mode: If there are other than "normal" highlighting
+* attributes, need to allocate an attr number.
+*/
+if (sgp->sg_start == NULL && sgp->sg_stop == NULL)
+	sgp->sg_term_attr = sgp->sg_term;
+else
+{
+	at_en.ae_attr = sgp->sg_term;
+	at_en.ae_u.term.start = sgp->sg_start;
+	at_en.ae_u.term.stop = sgp->sg_stop;
+	sgp->sg_term_attr = get_attr_entry(&term_attr_table, &at_en);
+}
+/*
+* For the color term mode: If there are other than "normal"
+* highlighting attributes, need to allocate an attr number.
+*/
+if (sgp->sg_cterm_fg == 0 && sgp->sg_cterm_bg == 0)
+	sgp->sg_cterm_attr = sgp->sg_cterm;
+else
+{
+	at_en.ae_attr = sgp->sg_cterm;
+	at_en.ae_u.cterm.fg_color = sgp->sg_cterm_fg;
+	at_en.ae_u.cterm.bg_color = sgp->sg_cterm_bg;
+	sgp->sg_cterm_attr = get_attr_entry(&cterm_attr_table, &at_en);
+}
+}
+/*
+* Lookup a highlight group name and return it's ID.
+* If it is not found, 0 is returned.
+*/
+int
+syn_name2id(name)
+char_u	*name;
+{
+int		i;
+char_u	name_u[200];
+/* Avoid using stricmp() too much, it's slow on some systems */
+/* Avoid alloc()/free(), these are slow too.  ID names over 200 chars
+* don't deserve to be found! */
+STRNCPY(name_u, name, 199);
+name_u[199] = NUL;
+vim_strup(name_u);
+for (i = highlight_ga.ga_len; --i >= 0; )
+	if (HL_TABLE()[i].sg_name_u != NULL
+		&& STRCMP(name_u, HL_TABLE()[i].sg_name_u) == 0)
+	    break;
+return i + 1;
+}
+#if defined(FEAT_EVAL) || defined(PROTO)
+/*
+* Return TRUE if highlight group "name" exists.
+*/
+int
+highlight_exists(name)
+char_u	*name;
+{
+return (syn_name2id(name) > 0);
+}
+#endif
+/*
+* Like syn_name2id(), but take a pointer + length argument.
+*/
+int
+syn_namen2id(linep, len)
+char_u  *linep;
+int	    len;
+{
+char_u  *name;
+int	    id = 0;
+name = vim_strnsave(linep, len);
+if (name != NULL)
+{
+	id = syn_name2id(name);
+	vim_free(name);
+}
+return id;
+}
+/*
+* Find highlight group name in the table and return it's ID.
+* The argument is a pointer to the name and the length of the name.
+* If it doesn't exist yet, a new entry is created.
+* Return 0 for failure.
+*/
+int
+syn_check_group(pp, len)
+char_u		*pp;
+int			len;
+{
+int	    id;
+char_u  *name;
+name = vim_strnsave(pp, len);
+if (name == NULL)
+	return 0;
+id = syn_name2id(name);
+if (id == 0)			/* doesn't exist yet */
+	id = syn_add_group(name);
+else
+	vim_free(name);
+return id;
+}
+/*
+* Add new highlight group and return it's ID.
+* "name" must be an allocated string, it will be consumed.
+* Return 0 for failure.
+*/
+static int
+syn_add_group(name)
+char_u	*name;
+{
+char_u	*p;
+/* Check that the name is ASCII letters, digits and underscore. */
+for (p = name; *p != NUL; ++p)
+{
+	if (!vim_isprintc(*p))
+	{
+	    EMSG(_("E669: Unprintable character in group name"));
+	    return 0;
+	}
+	else if (!ASCII_ISALNUM(*p) && *p != '_')
+	{
+	    /* This is an error, but since there previously was no check only
+	     * give a warning. */
+	    MSG(_("W18: Invalid character in group name"));
+	    break;
+	}
+}
+/*
+* First call for this growarray: init growing array.
+*/
+if (highlight_ga.ga_data == NULL)
+{
+	highlight_ga.ga_itemsize = sizeof(struct hl_group);
+	highlight_ga.ga_growsize = 10;
+}
+/*
+* Make room for at least one other syntax_highlight entry.
+*/
+if (ga_grow(&highlight_ga, 1) == FAIL)
+{
+	vim_free(name);
+	return 0;
+}
+vim_memset(&(HL_TABLE()[highlight_ga.ga_len]), 0, sizeof(struct hl_group));
+HL_TABLE()[highlight_ga.ga_len].sg_name = name;
+HL_TABLE()[highlight_ga.ga_len].sg_name_u = vim_strsave_up(name);
+#ifdef FEAT_GUI
+HL_TABLE()[highlight_ga.ga_len].sg_gui_bg = INVALCOLOR;
+HL_TABLE()[highlight_ga.ga_len].sg_gui_fg = INVALCOLOR;
+#endif
+++highlight_ga.ga_len;
+--highlight_ga.ga_room;
+return highlight_ga.ga_len;		    /* ID is index plus one */
+}
+/*
+* When, just after calling syn_add_group(), an error is discovered, this
+* function deletes the new name.
+*/
+static void
+syn_unadd_group()
+{
+--highlight_ga.ga_len;
+++highlight_ga.ga_room;
+vim_free(HL_TABLE()[highlight_ga.ga_len].sg_name);
+vim_free(HL_TABLE()[highlight_ga.ga_len].sg_name_u);
+}
+/*
+* Translate a group ID to highlight attributes.
+*/
+int
+syn_id2attr(hl_id)
+int			hl_id;
+{
+int			attr;
+struct hl_group	*sgp;
+hl_id = syn_get_final_id(hl_id);
+sgp = &HL_TABLE()[hl_id - 1];	    /* index is ID minus one */
+#ifdef FEAT_GUI
+/*
+* Only use GUI attr when the GUI is being used.
+*/
+if (gui.in_use)
+	attr = sgp->sg_gui_attr;
+else
+#endif
+	if (t_colors > 1)
+	    attr = sgp->sg_cterm_attr;
+	else
+	    attr = sgp->sg_term_attr;
+return attr;
+}
+#ifdef FEAT_GUI
+/*
+* Get the GUI colors and attributes for a group ID.
+* NOTE: the colors will be INVALCOLOR when not set, the color otherwise.
+*/
+int
+syn_id2colors(hl_id, fgp, bgp)
+int		hl_id;
+guicolor_T	*fgp;
+guicolor_T	*bgp;
+{
+struct hl_group	*sgp;
+hl_id = syn_get_final_id(hl_id);
+sgp = &HL_TABLE()[hl_id - 1];	    /* index is ID minus one */
+*fgp = sgp->sg_gui_fg;
+*bgp = sgp->sg_gui_bg;
+return sgp->sg_gui;
+}
+#endif
+/*
+* Translate a group ID to the final group ID (following links).
+*/
+int
+syn_get_final_id(hl_id)
+int			hl_id;
+{
+int			count;
+struct hl_group	*sgp;
+if (hl_id > highlight_ga.ga_len || hl_id < 1)
+	return 0;			/* Can be called from eval!! */
+/*
+* Follow links until there is no more.
+* Look out for loops!  Break after 100 links.
+*/
+for (count = 100; --count >= 0; )
+{
+	sgp = &HL_TABLE()[hl_id - 1];	    /* index is ID minus one */
+	if (sgp->sg_link == 0 || sgp->sg_link > highlight_ga.ga_len)
+	    break;
+	hl_id = sgp->sg_link;
+}
+return hl_id;
+}
+#ifdef FEAT_GUI
+/*
+* Call this function just after the GUI has started.
+* It finds the font and color handles for the highlighting groups.
+*/
+void
+highlight_gui_started()
+{
+int	    idx;
+/* First get the colors from the "Normal" and "Menu" group, if set */
+set_normal_colors();
+for (idx = 0; idx < highlight_ga.ga_len; ++idx)
+	gui_do_one_color(idx, FALSE, FALSE);
+highlight_changed();
+}
+static void
+gui_do_one_color(idx, do_menu, do_tooltip)
+int		idx;
+int		do_menu;	/* TRUE: might set the menu font */
+int		do_tooltip;	/* TRUE: might set the tooltip font */
+{
+int		didit = FALSE;
+if (HL_TABLE()[idx].sg_font_name != NULL)
+{
+	hl_do_font(idx, HL_TABLE()[idx].sg_font_name, FALSE, do_menu,
+		   do_tooltip);
+	didit = TRUE;
+}
+if (HL_TABLE()[idx].sg_gui_fg_name != NULL)
+{
+	HL_TABLE()[idx].sg_gui_fg =
+			    color_name2handle(HL_TABLE()[idx].sg_gui_fg_name);
+	didit = TRUE;
+}
+if (HL_TABLE()[idx].sg_gui_bg_name != NULL)
+{
+	HL_TABLE()[idx].sg_gui_bg =
+			    color_name2handle(HL_TABLE()[idx].sg_gui_bg_name);
+	didit = TRUE;
+}
+if (didit)	/* need to get a new attr number */
+	set_hl_attr(idx);
+}
+#endif
+/*
+* Translate the 'highlight' option into attributes in highlight_attr[] and
+* set up the user highlights User1..9.  If FEAT_STL_OPT is in use, a set of
+* corresponding highlights to use on top of HLF_SNC is computed.
+* Called only when the 'highlight' option has been changed and upon first
+* screen redraw after any :highlight command.
+* Return FAIL when an invalid flag is found in 'highlight'.  OK otherwise.
+*/
+int
+highlight_changed()
+{
+int		hlf;
+int		i;
+char_u	*p;
+int		attr;
+char_u	*end;
+int		id;
+#ifdef USER_HIGHLIGHT
+char_u      userhl[10];
+# ifdef FEAT_STL_OPT
+int		id_SNC = -1;
+int		id_S = -1;
+int		hlcnt;
+# endif
+#endif
+static int	hl_flags[HLF_COUNT] = HL_FLAGS;
+need_highlight_changed = FALSE;
+/*
+* Clear all attributes.
+*/
+for (hlf = 0; hlf < (int)HLF_COUNT; ++hlf)
+	highlight_attr[hlf] = 0;
+/*
+* First set all attributes to their default value.
+* Then use the attributes from the 'highlight' option.
+*/
+for (i = 0; i < 2; ++i)
+{
+	if (i)
+	    p = p_hl;
+	else
+	    p = get_highlight_default();
+	if (p == NULL)	    /* just in case */
+	    continue;
+	while (*p)
+	{
+	    for (hlf = 0; hlf < (int)HLF_COUNT; ++hlf)
+		if (hl_flags[hlf] == *p)
+		    break;
+	    ++p;
+	    if (hlf == (int)HLF_COUNT || *p == NUL)
+		return FAIL;
+	    /*
+	     * Allow several hl_flags to be combined, like "bu" for
+	     * bold-underlined.
+	     */
+	    attr = 0;
+	    for ( ; *p && *p != ','; ++p)	    /* parse upto comma */
+	    {
+		if (vim_iswhite(*p))		    /* ignore white space */
+		    continue;
+		if (attr > HL_ALL)  /* Combination with ':' is not allowed. */
+		    return FAIL;
+		switch (*p)
+		{
+		    case 'b':	attr |= HL_BOLD;
+				break;
+		    case 'i':	attr |= HL_ITALIC;
+				break;
+		    case '-':
+		    case 'n':			    /* no highlighting */
+				break;
+		    case 'r':	attr |= HL_INVERSE;
+				break;
+		    case 's':	attr |= HL_STANDOUT;
+				break;
+		    case 'u':	attr |= HL_UNDERLINE;
+				break;
+		    case ':':	++p;		    /* highlight group name */
+				if (attr || *p == NUL)	 /* no combinations */
+				    return FAIL;
+				end = vim_strchr(p, ',');
+				if (end == NULL)
+				    end = p + STRLEN(p);
+				id = syn_check_group(p, (int)(end - p));
+				if (id == 0)
+				    return FAIL;
+				attr = syn_id2attr(id);
+				p = end - 1;
+#if defined(FEAT_STL_OPT) && defined(USER_HIGHLIGHT)
+				if (hlf == (int)HLF_SNC)
+				    id_SNC = syn_get_final_id(id);
+				else if (hlf == (int)HLF_S)
+				    id_S = syn_get_final_id(id);
+#endif
+				break;
+		    default:	return FAIL;
+		}
+	    }
+	    highlight_attr[hlf] = attr;
+	    p = skip_to_option_part(p);	    /* skip comma and spaces */
+	}
+}
+#ifdef USER_HIGHLIGHT
+/* Setup the user highlights
+*
+* Temporarily  utilize 10 more hl entries.  Have to be in there
+* simultaneously in case of table overflows in get_attr_entry()
+*/
+# ifdef FEAT_STL_OPT
+if (ga_grow(&highlight_ga, 10) == FAIL)
+	return FAIL;
+hlcnt = highlight_ga.ga_len;
+if (id_S == 0)
+{		    /* Make sure id_S is always valid to simplify code below */
+	memset(&HL_TABLE()[hlcnt + 9], 0, sizeof(struct hl_group));
+	HL_TABLE()[hlcnt + 9].sg_term = highlight_attr[HLF_S];
+	id_S = hlcnt + 10;
+}
+# endif
+for (i = 0; i < 9; i++)
+{
+	sprintf((char *)userhl, "User%d", i + 1);
+	id = syn_name2id(userhl);
+	if (id == 0)
+	{
+	    highlight_user[i] = 0;
+# ifdef FEAT_STL_OPT
+	    highlight_stlnc[i] = 0;
+# endif
+	}
+	else
+	{
+# ifdef FEAT_STL_OPT
+	    struct hl_group *hlt = HL_TABLE();
+# endif
+	    highlight_user[i] = syn_id2attr(id);
+# ifdef FEAT_STL_OPT
+	    if (id_SNC == 0)
+	    {
+		memset(&hlt[hlcnt + i], 0, sizeof(struct hl_group));
+		hlt[hlcnt + i].sg_term = highlight_attr[HLF_SNC];
+		hlt[hlcnt + i].sg_cterm = highlight_attr[HLF_SNC];
+#  ifdef FEAT_GUI
+		hlt[hlcnt + i].sg_gui = highlight_attr[HLF_SNC];
+#  endif
+	    }
+	    else
+		mch_memmove(&hlt[hlcnt + i],
+			    &hlt[id_SNC - 1],
+			    sizeof(struct hl_group));
+	    hlt[hlcnt + i].sg_link = 0;
+	    /* Apply difference between UserX and HLF_S to HLF_SNC */
+	    hlt[hlcnt + i].sg_term ^=
+		hlt[id - 1].sg_term ^ hlt[id_S - 1].sg_term;
+	    if (hlt[id - 1].sg_start != hlt[id_S - 1].sg_start)
+		hlt[hlcnt + i].sg_start = hlt[id - 1].sg_start;
+	    if (hlt[id - 1].sg_stop != hlt[id_S - 1].sg_stop)
+		hlt[hlcnt + i].sg_stop = hlt[id - 1].sg_stop;
+	    hlt[hlcnt + i].sg_cterm ^=
+		hlt[id - 1].sg_cterm ^ hlt[id_S - 1].sg_cterm;
+	    if (hlt[id - 1].sg_cterm_fg != hlt[id_S - 1].sg_cterm_fg)
+		hlt[hlcnt + i].sg_cterm_fg = hlt[id - 1].sg_cterm_fg;
+	    if (hlt[id - 1].sg_cterm_bg != hlt[id_S - 1].sg_cterm_bg)
+		hlt[hlcnt + i].sg_cterm_bg = hlt[id - 1].sg_cterm_bg;
+#  ifdef FEAT_GUI
+	    hlt[hlcnt + i].sg_gui ^=
+		hlt[id - 1].sg_gui ^ hlt[id_S - 1].sg_gui;
+	    if (hlt[id - 1].sg_gui_fg != hlt[id_S - 1].sg_gui_fg)
+		hlt[hlcnt + i].sg_gui_fg = hlt[id - 1].sg_gui_fg;
+	    if (hlt[id - 1].sg_gui_bg != hlt[id_S - 1].sg_gui_bg)
+		hlt[hlcnt + i].sg_gui_bg = hlt[id - 1].sg_gui_bg;
+	    if (hlt[id - 1].sg_font != hlt[id_S - 1].sg_font)
+		hlt[hlcnt + i].sg_font = hlt[id - 1].sg_font;
+#   ifdef FEAT_XFONTSET
+	    if (hlt[id - 1].sg_fontset != hlt[id_S - 1].sg_fontset)
+		hlt[hlcnt + i].sg_fontset = hlt[id - 1].sg_fontset;
+#   endif
+#  endif
+	    highlight_ga.ga_len = hlcnt + i + 1;
+	    set_hl_attr(hlcnt + i);	/* At long last we can apply */
+	    highlight_stlnc[i] = syn_id2attr(hlcnt + i + 1);
+# endif
+	}
+}
+# ifdef FEAT_STL_OPT
+highlight_ga.ga_len = hlcnt;
+# endif
+#endif /* USER_HIGHLIGHT */
+return OK;
+}
+#ifdef FEAT_CMDL_COMPL
+static void highlight_list __ARGS((void));
+static void highlight_list_two __ARGS((int cnt, int attr));
+/*
+* Handle command line completion for :highlight command.
+*/
+void
+set_context_in_highlight_cmd(xp, arg)
+expand_T	*xp;
+char_u	*arg;
+{
+char_u	*p;
+/* Default: expand group names */
+xp->xp_context = EXPAND_HIGHLIGHT;
+xp->xp_pattern = arg;
+include_link = TRUE;
+include_default = TRUE;
+/* (part of) subcommand already typed */
+if (*arg != NUL)
+{
+	p = skiptowhite(arg);
+	if (*p != NUL)			/* past "default" or group name */
+	{
+	    include_default = FALSE;
+	    if (STRNCMP("default", arg, p - arg) == 0)
+	    {
+		arg = skipwhite(p);
+		xp->xp_pattern = arg;
+		p = skiptowhite(arg);
+	    }
+	    if (*p != NUL)			/* past group name */
+	    {
+		include_link = FALSE;
+		if (arg[1] == 'i' && arg[0] == 'N')
+		    highlight_list();
+		if (STRNCMP("link", arg, p - arg) == 0
+			|| STRNCMP("clear", arg, p - arg) == 0)
+		{
+		    xp->xp_pattern = skipwhite(p);
+		    p = skiptowhite(xp->xp_pattern);
+		    if (*p != NUL)		/* past first group name */
+		    {
+			xp->xp_pattern = skipwhite(p);
+			p = skiptowhite(xp->xp_pattern);
+		    }
+		}
+		if (*p != NUL)			/* past group name(s) */
+		    xp->xp_context = EXPAND_NOTHING;
+	    }
+	}
+}
+}
+/*
+* List highlighting matches in a nice way.
+*/
+static void
+highlight_list()
+{
+int		i;
+for (i = 10; --i >= 0; )
+	highlight_list_two(i, hl_attr(HLF_D));
+for (i = 40; --i >= 0; )
+	highlight_list_two(99, 0);
+}
+static void
+highlight_list_two(cnt, attr)
+int	    cnt;
+int	    attr;
+{
+msg_puts_attr((char_u *)("N \bI \b!  \b" + cnt / 11), attr);
+msg_clr_eos();
+out_flush();
+ui_delay(cnt == 99 ? 40L : (long)cnt * 50L, FALSE);
+}
+#endif /* FEAT_CMDL_COMPL */
+#if defined(FEAT_CMDL_COMPL) || (defined(FEAT_SYN_HL) && defined(FEAT_EVAL)) \
+|| defined(FEAT_SIGNS) || defined(PROTO)
+/*
+* Function given to ExpandGeneric() to obtain the list of group names.
+* Also used for synIDattr() function.
+*/
+/*ARGSUSED*/
+char_u *
+get_highlight_name(xp, idx)
+expand_T	*xp;
+int		idx;
+{
+if (idx == highlight_ga.ga_len
+#ifdef FEAT_CMDL_COMPL
+	    && include_link
+#endif
+	    )
+	return (char_u *)"link";
+if (idx == highlight_ga.ga_len + 1
+#ifdef FEAT_CMDL_COMPL
+	    && include_link
+#endif
+	    )
+	return (char_u *)"clear";
+if (idx == highlight_ga.ga_len + 2
+#ifdef FEAT_CMDL_COMPL
+	    && include_default
+#endif
+	    )
+	return (char_u *)"default";
+if (idx < 0 || idx >= highlight_ga.ga_len)
+	return NULL;
+return HL_TABLE()[idx].sg_name;
+}
+#endif
+#ifdef FEAT_GUI
+/*
+* Free all the highlight group fonts.
+* Used when quitting for systems which need it.
+*/
+void
+free_highlight_fonts()
+{
+int	    idx;
+for (idx = 0; idx < highlight_ga.ga_len; ++idx)
+{
+	gui_mch_free_font(HL_TABLE()[idx].sg_font);
+	HL_TABLE()[idx].sg_font = NOFONT;
+# ifdef FEAT_XFONTSET
+	gui_mch_free_fontset(HL_TABLE()[idx].sg_fontset);
+	HL_TABLE()[idx].sg_fontset = NOFONTSET;
+# endif
+}
+gui_mch_free_font(gui.norm_font);
+# ifdef FEAT_XFONTSET
+gui_mch_free_fontset(gui.fontset);
+# endif
+# ifndef HAVE_GTK2
+gui_mch_free_font(gui.bold_font);
+gui_mch_free_font(gui.ital_font);
+gui_mch_free_font(gui.boldital_font);
+# endif
+}
+#endif
+/**************************************
+*  End of Highlighting stuff	      *
+**************************************/

Mercurial > vim

comparison src/syntax.c @ 7:3fc0f57ecb91 v7.0001