diff --git a/src/eval.c b/src/eval.c
index cd706b4..2dbbb22 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -11959,18 +11959,24 @@
 	char_u	*s;
 	int	saved_did_emsg = did_emsg;
 	char	*fmt;
+	va_list	ap; /* dummy */
+
+# ifdef LINT
+	/* avoid warning for "ap" used before set; it is unused. */
+	va_start(ap, rettv);
+# endif
 
 	/* Get the required length, allocate the buffer and do it for real. */
 	did_emsg = FALSE;
 	fmt = (char *)get_tv_string_buf(&argvars[0], buf);
-	len = vim_vsnprintf(NULL, 0, fmt, NULL, argvars + 1);
+	len = vim_vsnprintf(NULL, 0, fmt, ap, argvars + 1);
 	if (!did_emsg)
 	{
 	    s = alloc(len + 1);
 	    if (s != NULL)
 	    {
 		rettv->vval.v_string = s;
-		(void)vim_vsnprintf((char *)s, len + 1, fmt, NULL, argvars + 1);
+		(void)vim_vsnprintf((char *)s, len + 1, fmt, ap, argvars + 1);
 	    }
 	}
 	did_emsg |= saved_did_emsg;
@@ -17482,6 +17488,10 @@
 	MSG_PUTS("...");
     }
     msg_putchar(')');
+#ifdef FEAT_EVAL
+    if (p_verbose > 0)
+	last_set_msg(fp->uf_script_ID);
+#endif
 }
 
 /*
diff --git a/src/ex_docmd.c b/src/ex_docmd.c
index 0f5360f..6e6e297 100644
--- a/src/ex_docmd.c
+++ b/src/ex_docmd.c
@@ -5117,6 +5117,10 @@
 	    msg_outtrans(IObuff);
 
 	    msg_outtrans_special(cmd->uc_rep, FALSE);
+#ifdef FEAT_EVAL
+	    if (p_verbose > 0)
+		last_set_msg(cmd->uc_scriptID);
+#endif
 	    out_flush();
 	    ui_breakcheck();
 	    if (got_int)
diff --git a/src/gui.c b/src/gui.c
index f0d65ee..c7f872e 100644
--- a/src/gui.c
+++ b/src/gui.c
@@ -4590,6 +4590,7 @@
     int		type = (flags & FRD_TYPE_MASK);
     char_u	*p;
     regmatch_T	regmatch;
+    int		save_did_emsg = did_emsg;
 
     ga_init2(&ga, 1, 100);
     if (type == FRD_REPLACEALL)
@@ -4666,6 +4667,10 @@
 	msg_scroll = i;	    /* don't let an error message set msg_scroll */
     }
 
+    /* Don't want to pass did_emsg to other code, it may cause disabling
+     * syntax HL if we were busy redrawing. */
+    did_emsg = save_did_emsg;
+
     if (State & (NORMAL | INSERT))
     {
 	gui_update_screen();		/* update the screen */
diff --git a/src/message.c b/src/message.c
index 2b3adcf..cca8a52 100644
--- a/src/message.c
+++ b/src/message.c
@@ -3800,7 +3800,7 @@
  * When va_list is not supported we only define vim_snprintf().
  *
  * vim_vsnprintf() can be invoked with either "va_list" or a list of
- * "typval_T".  The other must be NULL.
+ * "typval_T".  When the latter is not used it must be NULL.
  */
 
 /* When generating prototypes all of this is skipped, cproto doesn't
@@ -3937,7 +3937,7 @@
 		    get_a_arg(arg_idx);
 #else
 # if defined(FEAT_EVAL)
-		    ap == NULL ? tv_nr(tvs, &arg_idx) :
+		    tvs != NULL ? tv_nr(tvs, &arg_idx) :
 # endif
 			va_arg(ap, int);
 #endif
@@ -3974,7 +3974,7 @@
 			get_a_arg(arg_idx);
 #else
 # if defined(FEAT_EVAL)
-			ap == NULL ? tv_nr(tvs, &arg_idx) :
+			tvs != NULL ? tv_nr(tvs, &arg_idx) :
 # endif
 			    va_arg(ap, int);
 #endif
@@ -4050,7 +4050,7 @@
 			    get_a_arg(arg_idx);
 #else
 # if defined(FEAT_EVAL)
-			    ap == NULL ? tv_nr(tvs, &arg_idx) :
+			    tvs != NULL ? tv_nr(tvs, &arg_idx) :
 # endif
 				va_arg(ap, int);
 #endif
@@ -4066,7 +4066,7 @@
 				(char *)get_a_arg(arg_idx);
 #else
 # if defined(FEAT_EVAL)
-				ap == NULL ? tv_str(tvs, &arg_idx) :
+				tvs != NULL ? tv_str(tvs, &arg_idx) :
 # endif
 				    va_arg(ap, char *);
 #endif
@@ -4127,10 +4127,10 @@
 			length_modifier = '\0';
 			ptr_arg =
 #ifndef HAVE_STDARG_H
-				    (void *)get_a_arg(arg_idx);
+				 (void *)get_a_arg(arg_idx);
 #else
 # if defined(FEAT_EVAL)
-				    ap == NULL ? (void *)tv_str(tvs, &arg_idx) :
+				 tvs != NULL ? (void *)tv_str(tvs, &arg_idx) :
 # endif
 					va_arg(ap, void *);
 #endif
@@ -4150,7 +4150,7 @@
 					get_a_arg(arg_idx);
 #else
 # if defined(FEAT_EVAL)
-					ap == NULL ? tv_nr(tvs, &arg_idx) :
+					tvs != NULL ? tv_nr(tvs, &arg_idx) :
 # endif
 					    va_arg(ap, int);
 #endif
@@ -4165,7 +4165,7 @@
 					get_a_arg(arg_idx);
 #else
 # if defined(FEAT_EVAL)
-					ap == NULL ? tv_nr(tvs, &arg_idx) :
+					tvs != NULL ? tv_nr(tvs, &arg_idx) :
 # endif
 					    va_arg(ap, long int);
 #endif
@@ -4188,7 +4188,7 @@
 					    get_a_arg(arg_idx);
 #else
 # if defined(FEAT_EVAL)
-					    ap == NULL ? tv_nr(tvs, &arg_idx) :
+					    tvs != NULL ? tv_nr(tvs, &arg_idx) :
 # endif
 						va_arg(ap, unsigned int);
 #endif
@@ -4201,7 +4201,7 @@
 					    get_a_arg(arg_idx);
 #else
 # if defined(FEAT_EVAL)
-					    ap == NULL ? tv_nr(tvs, &arg_idx) :
+					    tvs != NULL ? tv_nr(tvs, &arg_idx) :
 # endif
 						va_arg(ap, unsigned long int);
 #endif
@@ -4484,7 +4484,7 @@
     }
 
 #ifdef HAVE_STDARG_H
-    if (ap == NULL && tvs[arg_idx - 1].v_type != VAR_UNKNOWN)
+    if (tvs != NULL && tvs[arg_idx - 1].v_type != VAR_UNKNOWN)
 	EMSG(_("E767: Too many arguments to printf()"));
 #endif
 
diff --git a/src/regexp.c b/src/regexp.c
index 1ff5a06..f8b8616 100644
--- a/src/regexp.c
+++ b/src/regexp.c
@@ -3177,7 +3177,7 @@
      * can't go before line 1 */
     if (reg_firstlnum + lnum < 1)
 	return NULL;
-    if (reg_firstlnum + lnum > reg_buf->b_ml.ml_line_count)
+    if (lnum > reg_maxline)
 	/* Must have matched the "\n" in the last line. */
 	return (char_u *)"";
     return ml_get_buf(reg_buf, reg_firstlnum + lnum, FALSE);
diff --git a/src/screen.c b/src/screen.c
index 6562d65..b3dbe01 100644
--- a/src/screen.c
+++ b/src/screen.c
@@ -2594,7 +2594,7 @@
     extra_check = 0;
 #endif
 #ifdef FEAT_SYN_HL
-    if (syntax_present(wp->w_buffer))
+    if (syntax_present(wp->w_buffer) && !wp->w_buffer->b_syn_error)
     {
 	/* Prepare for syntax highlighting in this line.  When there is an
 	 * error, stop syntax highlighting. */
@@ -2602,7 +2602,7 @@
 	did_emsg = FALSE;
 	syntax_start(wp, lnum);
 	if (did_emsg)
-	    syntax_clear(wp->w_buffer);
+	    wp->w_buffer->b_syn_error = TRUE;
 	else
 	{
 	    did_emsg = save_did_emsg;
@@ -3643,7 +3643,10 @@
 					       has_spell ? &can_spell : NULL);
 
 		    if (did_emsg)
-			syntax_clear(wp->w_buffer);
+		    {
+			wp->w_buffer->b_syn_error = TRUE;
+			has_syntax = FALSE;
+		    }
 		    else
 			did_emsg = save_did_emsg;
 
diff --git a/src/spell.c b/src/spell.c
index 114e3f2..a3fc24f 100644
--- a/src/spell.c
+++ b/src/spell.c
@@ -51,16 +51,21 @@
  */
 
 /* Use SPELL_PRINTTREE for debugging: dump the word tree after adding a word.
- * Only use it for small word lists!
- * SPELL_COMPRESS_CNT is in how many words we compress the tree to limit the
- * amount of memory used (esp. for Italian). */
+ * Only use it for small word lists! */
 #if 0
 # define SPELL_PRINTTREE
-# define SPELL_COMPRESS_CNT 1
-#else
-# define SPELL_COMPRESS_CNT 1000000
 #endif
 
+/* SPELL_COMPRESS_CNT is after how many allocated blocks we compress the tree
+ * to limit the amount of memory used (esp. for Italian and Hungarian).  The
+ * amount of memory used for nodes then is SPELL_COMPRESS_CNT times
+ * SBLOCKSIZE.
+ * Then compress again after allocating SPELL_COMPRESS_INC more blocks or
+ * adding SPELL_COMPRESS_ADDED words and running out of memory again.  */
+#define SPELL_COMPRESS_CNT 30000
+#define SPELL_COMPRESS_INC 100
+#define SPELL_COMPRESS_ADDED 500000
+
 /*
  * Use this to adjust the score after finding suggestions, based on the
  * suggested word sounding like the bad word.  This is much faster than doing
@@ -594,8 +599,9 @@
     char_u	ts_fidx;	/* index in fword[], case-folded bad word */
     char_u	ts_fidxtry;	/* ts_fidx at which bytes may be changed */
     char_u	ts_twordlen;	/* valid length of tword[] */
-    char_u	ts_prefixdepth;	/* stack depth for end of prefix or PREFIXTREE
-				 * or NOPREFIX */
+    char_u	ts_prefixdepth;	/* stack depth for end of prefix or
+				 * PFD_PREFIXTREE or PFD_NOPREFIX or
+				 * PFD_COMPOUND */
 #ifdef FEAT_MBYTE
     char_u	ts_tcharlen;	/* number of bytes in tword character */
     char_u	ts_tcharidx;	/* current byte index in tword character */
@@ -613,8 +619,9 @@
 #define DIFF_INSERT	2	/* inserting character */
 
 /* special values ts_prefixdepth */
-#define PREFIXTREE	0xfe	/* walking through the prefix tree */
-#define NOPREFIX	0xff	/* not using prefixes */
+#define PFD_COMPOUND	0xfd	/* prefixed is a compound word */
+#define PFD_PREFIXTREE	0xfe	/* walking through the prefix tree */
+#define PFD_NOPREFIX	0xff	/* not using prefixes */
 
 /* mode values for find_word */
 #define FIND_FOLDWORD	    0	/* find word case-folded */
@@ -627,6 +634,7 @@
 static void slang_free __ARGS((slang_T *lp));
 static void slang_clear __ARGS((slang_T *lp));
 static void find_word __ARGS((matchinf_T *mip, int mode));
+static int can_compound __ARGS((slang_T *slang, int flags));
 static int valid_word_prefix __ARGS((int totprefcnt, int arridx, int flags, char_u *word, slang_T *slang, int cond_req));
 static void find_prefix __ARGS((matchinf_T *mip));
 static int fold_more __ARGS((matchinf_T *mip));
@@ -740,6 +748,7 @@
 
 static char *e_format = N_("E759: Format error in spell file");
 static char *e_spell_trunc = N_("E758: Truncated spell file");
+static char *e_afftrailing = N_("Trailing text in %s line %d: %s");
 static char *msg_compressing = N_("Compressing word tree...");
 
 /*
@@ -1156,8 +1165,7 @@
 
 		/* The word doesn't end or it comes after another: it must
 		 * have a compound flag. */
-		/* TODO: check more flags */
-		if (*slang->sl_compflags != ((unsigned)flags >> 24))
+		if (!can_compound(slang, flags))
 		    continue;
 	    }
 
@@ -1231,6 +1239,19 @@
 }
 
 /*
+ * Return TRUE if "flags" has a valid compound flag.
+ * TODO: check flags in a more advanced way.
+ */
+    static int
+can_compound(slang, flags)
+    slang_T	*slang;
+    int		flags;
+{
+    return slang->sl_compflags != NULL
+			   && *slang->sl_compflags == ((unsigned)flags >> 24);
+}
+
+/*
  * Return non-zero if the prefix indicated by "arridx" matches with the prefix
  * ID in "flags" for the word "word".
  * The WF_RAREPFX flag is included in the return value for a rare prefix.
@@ -3324,17 +3345,19 @@
 {
     wordnode_T	*si_foldroot;	/* tree with case-folded words */
     long	si_foldwcount;	/* nr of words in si_foldroot */
-    int		si_fold_added;	/* nr of words added since compressing */
 
     wordnode_T	*si_keeproot;	/* tree with keep-case words */
     long	si_keepwcount;	/* nr of words in si_keeproot */
-    int		si_keep_added;	/* nr of words added since compressing */
 
     wordnode_T	*si_prefroot;	/* tree with postponed prefixes */
 
     sblock_T	*si_blocks;	/* memory blocks used */
+    long	si_blocks_cnt;	/* memory blocks allocated */
+    long	si_compress_cnt;    /* words to add before lowering
+				       compression limit */
     wordnode_T	*si_first_free; /* List of nodes that have been freed during
 				   compression, linked by "wn_child" field. */
+    long	si_free_count;	/* number of nodes in si_first_free */
 #ifdef SPELL_PRINTTREE
     int		si_wordnode_nr;	/* sequence nr for nodes */
 #endif
@@ -3801,8 +3824,7 @@
 		/* Myspell allows extra text after the item, but that might
 		 * mean mistakes go unnoticed.  Require a comment-starter. */
 		if (itemcnt > lasti && *items[lasti] != '#')
-		    smsg((char_u *)_("Trailing text in %s line %d: %s"),
-						   fname, lnum, items[lasti]);
+		    smsg((char_u *)_(e_afftrailing), fname, lnum, items[lasti]);
 
 		/* New item for an affix letter. */
 		--aff_todo;
@@ -3983,9 +4005,13 @@
 		    smsg((char_u *)_("Expected REP count in %s line %d"),
 								 fname, lnum);
 	    }
-	    else if (STRCMP(items[0], "REP") == 0 && itemcnt == 3)
+	    else if (STRCMP(items[0], "REP") == 0 && itemcnt >= 3)
 	    {
 		/* REP item */
+		/* Myspell ignores extra arguments, we require it starts with
+		 * # to detect mistakes. */
+		if (itemcnt > 3 && items[3][0] != '#')
+		    smsg((char_u *)_(e_afftrailing), fname, lnum, items[3]);
 		if (do_rep)
 		    add_fromto(spin, &spin->si_rep, items[1], items[2]);
 	    }
@@ -4119,9 +4145,6 @@
 	    smsg((char_u *)_("COMPOUNDFLAG(S) value differs from what is used in another .aff file"));
 	else
 	    spin->si_compflags = aff->af_compflags;
-
-	if (aff->af_pfxpostpone)
-	    smsg((char_u *)_("Cannot use both PFXPOSTPONE and COMPOUNDFLAG(S)"));
     }
 
     vim_free(pc);
@@ -4412,10 +4435,32 @@
 	    if (affile->af_pfxpostpone)
 		/* Need to store the list of prefix IDs with the word. */
 		store_afflist = get_pfxlist(spin, affile, afflist);
-	    else if (spin->si_compflags)
-		/* Need to store the list of affix IDs for compounding with
-		 * the word. */
-		store_afflist = get_compflags(spin, afflist);
+
+	    if (spin->si_compflags)
+	    {
+		/* Need to store the list of compound flags with the word. */
+		p = get_compflags(spin, afflist);
+		if (p != NULL)
+		{
+		    if (store_afflist != NULL)
+		    {
+			char_u *s;
+
+			/* Concatenate the prefix IDs with the compound flags.
+			 */
+			s = getroom(spin, STRLEN(store_afflist)
+						      + STRLEN(p) + 1, FALSE);
+			if (s != NULL)
+			{
+			    STRCPY(s, store_afflist);
+			    STRCAT(s, p);
+			    store_afflist = s;
+			}
+		    }
+		    else
+			store_afflist = p;
+		}
+	    }
 	}
 
 	/* Add the word to the word tree(s). */
@@ -4938,6 +4983,7 @@
 	bl->sb_next = spin->si_blocks;
 	spin->si_blocks = bl;
 	bl->sb_used = 0;
+	++spin->si_blocks_cnt;
     }
 
     p = bl->sb_data + bl->sb_used;
@@ -4996,7 +5042,8 @@
  * useful when the word can also be used with all caps (no WF_FIXCAP flag) and
  * used to find suggestions.
  * For a keep-case word also store it in the keep-case tree.
- * When "pfxlist" is not NULL store the word for each postponed prefix ID.
+ * When "pfxlist" is not NULL store the word for each postponed prefix ID and
+ * compound flag.
  */
     static int
 store_word(spin, word, flags, region, pfxlist)
@@ -5158,29 +5205,38 @@
     /* count nr of words added since last message */
     ++spin->si_msg_count;
 
+    if (spin->si_compress_cnt > 1)
+    {
+	if (--spin->si_compress_cnt == 1)
+	    /* Did enough words to lower the block count limit. */
+	    spin->si_blocks_cnt += SPELL_COMPRESS_INC;
+    }
+
     /*
-     * Every so many words compress the tree, so that we don't use too much
-     * memory.
+     * When we have allocated lots of memory we need to compress the word tree
+     * to free up some room.  But compression is slow, and we might actually
+     * need that room, thus only compress in the following situations:
+     * 1. When not compressed before (si_compress_cnt == 0): when using
+     *    SPELL_COMPRESS_CNT blocks.
+     * 2. When compressed before and used SPELL_COMPRESS_INC blocks before
+     *    adding SPELL_COMPRESS_ADDED words (si_compress_cnt > 1).
+     * 3. When compressed before, added SPELL_COMPRESS_ADDED words
+     *    (si_compress_cnt == 1) and the number of free nodes drops below the
+     *    maximum word length.
      */
-    i = FALSE;
-    if (root == spin->si_foldroot)
+#ifndef SPELL_PRINTTREE
+    if (spin->si_compress_cnt == 1
+	    ? spin->si_free_count < MAXWLEN
+	    : spin->si_blocks_cnt >= SPELL_COMPRESS_CNT)
+#endif
     {
-	if (++spin->si_fold_added >= SPELL_COMPRESS_CNT)
-	{
-	    i = TRUE;
-	    spin->si_fold_added = 0;
-	}
-    }
-    else if (root == spin->si_keeproot)
-    {
-	if (++spin->si_keep_added >= SPELL_COMPRESS_CNT)
-	{
-	    i = TRUE;
-	    spin->si_keep_added = 0;
-	}
-    }
-    if (i)
-    {
+	/* Decrement the block counter.  The effect is that we compress again
+	 * when the freed up room has been used and another SPELL_COMPRESS_INC
+	 * blocks have been allocated.  Unless SPELL_COMPRESS_ADDED words have
+	 * been added, then the limit is put back again. */
+	spin->si_blocks_cnt -= SPELL_COMPRESS_INC;
+	spin->si_compress_cnt = SPELL_COMPRESS_ADDED;
+
 	if (spin->si_verbose)
 	{
 	    msg_start();
@@ -5190,7 +5246,12 @@
 	    msg_col = 0;
 	    out_flush();
 	}
-	wordtree_compress(spin, root);
+
+	/* Compress both trees.  Either they both have many nodes, which makes
+	 * compression useful, or one of them is small, which means
+	 * compression goes fast. */
+	wordtree_compress(spin, spin->si_foldroot);
+	wordtree_compress(spin, spin->si_keeproot);
     }
 
     return OK;
@@ -5213,6 +5274,7 @@
 	n = spin->si_first_free;
 	spin->si_first_free = n->wn_child;
 	vim_memset(n, 0, sizeof(wordnode_T));
+	--spin->si_free_count;
     }
 #ifdef SPELL_PRINTTREE
     n->wn_nr = ++spin->si_wordnode_nr;
@@ -5252,6 +5314,7 @@
 {
     n->wn_child = spin->si_first_free;
     spin->si_first_free = n;
+    ++spin->si_free_count;
 }
 
 /*
@@ -5282,6 +5345,8 @@
 		verbose_enter();
 	    if (tot > 1000000)
 		perc = (tot - n) / (tot / 100);
+	    else if (tot == 0)
+		perc = 0;
 	    else
 		perc = (tot - n) * 100 / tot;
 	    smsg((char_u *)_("Compressed %d of %d nodes; %d%% remaining"),
@@ -5323,7 +5388,7 @@
      * Note that with "child" we mean not just the node that is pointed to,
      * but the whole list of siblings, of which the node is the first.
      */
-    for (np = node; np != NULL; np = np->wn_sibling)
+    for (np = node; np != NULL && !got_int; np = np->wn_sibling)
     {
 	++len;
 	if ((child = np->wn_child) != NULL)
@@ -5398,6 +5463,9 @@
     node->wn_u1.hashkey[4] = n == 0 ? 1 : n;
     node->wn_u1.hashkey[5] = NUL;
 
+    /* Check for CTRL-C pressed now and then. */
+    fast_breakcheck();
+
     return compressed;
 }
 
@@ -7604,6 +7672,8 @@
     fromto_T	*ftp;
     int		fl = 0, tl;
     int		repextra = 0;	    /* extra bytes in fword[] from REP item */
+    slang_T	*slang;
+    int		fword_ends;
 
     /* We make a copy of the case-folded bad word, so that we can modify it
      * to find matches (esp. REP items).  Append some more text, changing
@@ -7616,6 +7686,8 @@
     for (lp = LANGP_ENTRY(curwin->w_buffer->b_langp, 0);
 						   lp->lp_slang != NULL; ++lp)
     {
+	slang = lp->lp_slang;
+
 	/*
 	 * Go through the whole case-fold tree, try changes at each node.
 	 * "tword[]" contains the word collected from nodes in the tree.
@@ -7639,22 +7711,22 @@
 	 * When there are postponed prefixes we need to use these first.  At
 	 * the end of the prefix we continue in the case-fold tree.
 	 */
-	fbyts = lp->lp_slang->sl_fbyts;
-	fidxs = lp->lp_slang->sl_fidxs;
-	pbyts = lp->lp_slang->sl_pbyts;
-	pidxs = lp->lp_slang->sl_pidxs;
+	fbyts = slang->sl_fbyts;
+	fidxs = slang->sl_fidxs;
+	pbyts = slang->sl_pbyts;
+	pidxs = slang->sl_pidxs;
 	if (pbyts != NULL)
 	{
 	    byts = pbyts;
 	    idxs = pidxs;
-	    sp->ts_prefixdepth = PREFIXTREE;
+	    sp->ts_prefixdepth = PFD_PREFIXTREE;
 	    sp->ts_state = STATE_NOPREFIX;	/* try without prefix first */
 	}
 	else
 	{
 	    byts = fbyts;
 	    idxs = fidxs;
-	    sp->ts_prefixdepth = NOPREFIX;
+	    sp->ts_prefixdepth = PFD_NOPREFIX;
 	}
 
 	/*
@@ -7679,7 +7751,7 @@
 		len = byts[arridx];	    /* bytes in this node */
 		arridx += sp->ts_curi;	    /* index of current byte */
 
-		if (sp->ts_prefixdepth == PREFIXTREE)
+		if (sp->ts_prefixdepth == PFD_PREFIXTREE)
 		{
 		    /* Skip over the NUL bytes, we use them later. */
 		    for (n = 0; n < len && byts[arridx + n] == 0; ++n)
@@ -7743,7 +7815,17 @@
 
 		flags = (int)idxs[arridx];
 
-		if (sp->ts_prefixdepth < MAXWLEN)
+		if (sp->ts_prefixdepth == PFD_COMPOUND)
+		{
+		    /* There was a compound word before this word.  If this
+		     * word does not support compounding then give up
+		     * (splitting is tried for the word without compound
+		     * flag). */
+		    if (sp->ts_twordlen - splitoff < slang->sl_compminlen
+					       || !can_compound(slang, flags))
+			break;
+		}
+		else if (sp->ts_prefixdepth < MAXWLEN)
 		{
 		    /* There was a prefix before the word.  Check that the
 		     * prefix can be used with this word. */
@@ -7756,10 +7838,8 @@
 			;
 		    if (c > 0)
 		    {
-			/* The prefix ID is stored three bytes above the
-			 * flags. */
 			c = valid_word_prefix(c, n, flags,
-				       tword + splitoff, lp->lp_slang, FALSE);
+					      tword + splitoff, slang, FALSE);
 			if (c == 0)
 			    break;
 
@@ -7776,7 +7856,7 @@
 		tword[sp->ts_twordlen] = NUL;
 		if (flags & WF_KEEPCAP)
 		    /* Must find the word in the keep-case tree. */
-		    find_keepcap_word(lp->lp_slang, tword + splitoff,
+		    find_keepcap_word(slang, tword + splitoff,
 							preword + prewordlen);
 		else
 		{
@@ -7818,9 +7898,9 @@
 					 captype(preword + prewordlen, NULL)))
 		    newscore += SCORE_ICASE;
 
-		if ((fword[sp->ts_fidx] == NUL
-			       || !spell_iswordp(fword + sp->ts_fidx, curbuf))
-			&& sp->ts_fidx >= sp->ts_fidxtry)
+		fword_ends = (fword[sp->ts_fidx] == NUL
+			       || !spell_iswordp(fword + sp->ts_fidx, curbuf));
+		if (fword_ends && sp->ts_fidx >= sp->ts_fidxtry)
 		{
 		    /* The badword also ends: add suggestions.  Give a penalty
 		     * when changing non-word char to word char, e.g., "thes,"
@@ -7849,17 +7929,38 @@
 			    sp->ts_fidx - repextra,
 					   sp->ts_score + newscore, 0, FALSE);
 		}
-		else if (sp->ts_fidx >= sp->ts_fidxtry
+		else if ((sp->ts_fidx >= sp->ts_fidxtry || fword_ends)
 #ifdef FEAT_MBYTE
 			/* Don't split halfway a character. */
 			&& (!has_mbyte || sp->ts_tcharlen == 0)
 #endif
 			)
 		{
-		    /* The word in the tree ends but the badword
-		     * continues: try inserting a space and check that a valid
-		     * words starts at fword[sp->ts_fidx]. */
-		    if (try_deeper(su, stack, depth, newscore + SCORE_SPLIT))
+		    int	    try_compound;
+
+		    /* Get here in two situations:
+		     * 1. The word in the tree ends but the badword continues:
+		     *    If the word allows compounding try that.  Otherwise
+		     *    try a split by inserting a space.  For both check
+		     *    that a valid words starts at fword[sp->ts_fidx].
+		     * 2. The badword does end, but it was due to a change
+		     *    (e.g., a swap).  No need to split, but do check that
+		     *    the following word is valid.
+		     */
+		    if (!fword_ends
+			    && spell_iswordp(fword + sp->ts_fidx, curbuf)
+			    && sp->ts_twordlen - splitoff
+						      >= slang->sl_compminlen
+			    && can_compound(slang, flags))
+			try_compound = TRUE;
+		    else
+		    {
+			try_compound = FALSE;
+			if (!fword_ends)
+			    newscore += SCORE_SPLIT;
+		    }
+
+		    if (try_deeper(su, stack, depth, newscore))
 		    {
 			/* Save things to be restored at STATE_SPLITUNDO. */
 			sp->ts_save_prewordlen = prewordlen;
@@ -7870,28 +7971,49 @@
 			++depth;
 			sp = &stack[depth];
 
-			/* Append a space to preword. */
-			STRCAT(preword, " ");
+			/* Append a space to preword when splitting. */
+			if (!try_compound && !fword_ends)
+			    STRCAT(preword, " ");
 			prewordlen = STRLEN(preword);
 			splitoff = sp->ts_twordlen;
 
 			/* If the badword has a non-word character at this
 			 * position skip it.  That means replacing the
-			 * non-word character with a space. */
-			if (!spell_iswordp_nmw(fword + sp->ts_fidx))
+			 * non-word character with a space.  Always skip a
+			 * character when the word ends. */
+			if ((!try_compound
+				   && !spell_iswordp_nmw(fword + sp->ts_fidx))
+				|| fword_ends)
 			{
-			    sp->ts_score -= SCORE_SPLIT - SCORE_SUBST;
+			    int	    l;
+
 #ifdef FEAT_MBYTE
 			    if (has_mbyte)
-				sp->ts_fidx += MB_BYTE2LEN(fword[sp->ts_fidx]);
+				l = MB_BYTE2LEN(fword[sp->ts_fidx]);
 			    else
 #endif
-				++sp->ts_fidx;
+				l = 1;
+			    if (fword_ends)
+			    {
+				/* Copy the skipped character to preword. */
+				mch_memmove(preword + prewordlen,
+						      fword + sp->ts_fidx, l);
+				prewordlen += l;
+				preword[prewordlen] = NUL;
+			    }
+			    else
+				sp->ts_score -= SCORE_SPLIT - SCORE_SUBST;
+			    sp->ts_fidx += l;
 			}
 
+			/* set flag to check compound flag on following word */
+			if (try_compound)
+			    sp->ts_prefixdepth = PFD_COMPOUND;
+			else
+			    sp->ts_prefixdepth = PFD_NOPREFIX;
+
 			/* set su->su_badflags to the caps type at this
 			 * position */
-
 #ifdef FEAT_MBYTE
 			if (has_mbyte)
 			    n = nofold_len(fword, sp->ts_fidx, su->su_badptr);
@@ -7908,10 +8030,10 @@
 		break;
 
 	    case STATE_SPLITUNDO:
-		/* Undo the changes done for word split. */
+		/* Undo the changes done for word split or compound word. */
 		su->su_badflags = sp->ts_save_badflags;
 		splitoff = sp->ts_save_splitoff;
-		prewordlen =  sp->ts_save_prewordlen;
+		prewordlen = sp->ts_save_prewordlen;
 
 		/* Continue looking for NUL bytes. */
 		sp->ts_state = STATE_START;
@@ -8018,8 +8140,8 @@
 
 				    /* For a similar character adjust score
 				     * from SCORE_SUBST to SCORE_SIMILAR. */
-				    else if (lp->lp_slang->sl_has_map
-					    && similar_chars(lp->lp_slang,
+				    else if (slang->sl_has_map
+					    && similar_chars(slang,
 						mb_ptr2char(tword
 						    + sp->ts_twordlen
 							   - sp->ts_tcharlen),
@@ -8064,8 +8186,8 @@
 			     * We do this after calling try_deeper() because
 			     * it's slow. */
 			    if (newscore != 0
-				    && lp->lp_slang->sl_has_map
-				    && similar_chars(lp->lp_slang,
+				    && slang->sl_has_map
+				    && similar_chars(slang,
 						   c, fword[sp->ts_fidx - 1]))
 				sp->ts_score -= SCORE_SUBST - SCORE_SIMILAR;
 			}
@@ -8432,7 +8554,7 @@
 		/* Check if matching with REP items from the .aff file would
 		 * work.  Quickly skip if there are no REP items or the score
 		 * is going to be too high anyway. */
-		gap = &lp->lp_slang->sl_rep;
+		gap = &slang->sl_rep;
 		if (gap->ga_len == 0
 			       || sp->ts_score + SCORE_REP >= su->su_maxscore)
 		{
@@ -8442,7 +8564,7 @@
 
 		/* Use the first byte to quickly find the first entry that
 		 * may match.  If the index is -1 there is none. */
-		sp->ts_curi = lp->lp_slang->sl_rep_first[fword[sp->ts_fidx]];
+		sp->ts_curi = slang->sl_rep_first[fword[sp->ts_fidx]];
 		if (sp->ts_curi < 0)
 		{
 		    sp->ts_state = STATE_FINAL;
@@ -8458,7 +8580,7 @@
 		 * word is valid. */
 		p = fword + sp->ts_fidx;
 
-		gap = &lp->lp_slang->sl_rep;
+		gap = &slang->sl_rep;
 		while (sp->ts_curi < gap->ga_len)
 		{
 		    ftp = (fromto_T *)gap->ga_data + sp->ts_curi++;
@@ -8500,8 +8622,7 @@
 
 	    case STATE_REP_UNDO:
 		/* Undo a REP replacement and continue with the next one. */
-		ftp = (fromto_T *)lp->lp_slang->sl_rep.ga_data
-							    + sp->ts_curi - 1;
+		ftp = (fromto_T *)slang->sl_rep.ga_data + sp->ts_curi - 1;
 		fl = STRLEN(ftp->ft_from);
 		tl = STRLEN(ftp->ft_to);
 		p = fword + sp->ts_fidx;
@@ -8518,7 +8639,7 @@
 		/* Did all possible states at this level, go up one level. */
 		--depth;
 
-		if (depth >= 0 && stack[depth].ts_prefixdepth == PREFIXTREE)
+		if (depth >= 0 && stack[depth].ts_prefixdepth == PFD_PREFIXTREE)
 		{
 		    /* Continue in or go back to the prefix tree. */
 		    byts = pbyts;
diff --git a/src/structs.h b/src/structs.h
index af859bf..5473510 100644
--- a/src/structs.h
+++ b/src/structs.h
@@ -1432,6 +1432,7 @@
 #ifdef FEAT_SYN_HL
     hashtab_T	b_keywtab;		/* syntax keywords hash table */
     hashtab_T	b_keywtab_ic;		/* idem, ignore case */
+    int		b_syn_error;		/* TRUE when error occured in HL */
     int		b_syn_ic;		/* ignore case for :syn cmds */
     int		b_syn_spell;		/* SYNSPL_ values */
     garray_T	b_syn_patterns;		/* table for syntax patterns */
diff --git a/src/syntax.c b/src/syntax.c
index 4c4cbad..aa393d7 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -3182,6 +3182,7 @@
 {
     int i;
 
+    buf->b_syn_error = FALSE;	    /* clear previous error */
     buf->b_syn_ic = FALSE;	    /* Use case, by default */
     buf->b_syn_spell = SYNSPL_DEFAULT; /* default spell checking */
     buf->b_syn_containedin = FALSE;
diff --git a/src/version.h b/src/version.h
index 4b69735..94726c6 100644
--- a/src/version.h
+++ b/src/version.h
@@ -36,5 +36,5 @@
 #define VIM_VERSION_NODOT	"vim70aa"
 #define VIM_VERSION_SHORT	"7.0aa"
 #define VIM_VERSION_MEDIUM	"7.0aa ALPHA"
-#define VIM_VERSION_LONG	"VIM - Vi IMproved 7.0aa ALPHA (2005 Aug 15)"
-#define VIM_VERSION_LONG_DATE	"VIM - Vi IMproved 7.0aa ALPHA (2005 Aug 15, compiled "
+#define VIM_VERSION_LONG	"VIM - Vi IMproved 7.0aa ALPHA (2005 Aug 16)"
+#define VIM_VERSION_LONG_DATE	"VIM - Vi IMproved 7.0aa ALPHA (2005 Aug 16, compiled "