diff --git a/7.3.1022 b/7.3.1022
new file mode 100644
index 0000000..557f0bb
--- /dev/null
+++ b/7.3.1022
@@ -0,0 +1,873 @@
+To: vim_dev@googlegroups.com
+Subject: Patch 7.3.1022
+Fcc: outbox
+From: Bram Moolenaar <Bram@moolenaar.net>
+Mime-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+------------
+
+Patch 7.3.1022
+Problem:    Compiler warning for shadowed variable. (John Little)
+Solution:   Move declaration, rename variables.
+Files:	    src/regexp_nfa.c
+
+
+*** ../vim-7.3.1021/src/regexp_nfa.c	2013-05-26 14:32:01.000000000 +0200
+--- src/regexp_nfa.c	2013-05-26 14:50:27.000000000 +0200
+***************
+*** 604,610 ****
+      char_u	*endp;
+  #ifdef FEAT_MBYTE
+      char_u	*old_regparse = regparse;
+-     int		i;
+  #endif
+      int		extra = 0;
+      int		first;
+--- 604,609 ----
+***************
+*** 827,850 ****
+  		case 'u':   /* %uabcd hex 4 */
+  		case 'U':   /* %U1234abcd hex 8 */
+  		    {
+! 			int i;
+  
+  			switch (c)
+  			{
+! 			    case 'd': i = getdecchrs(); break;
+! 			    case 'o': i = getoctchrs(); break;
+! 			    case 'x': i = gethexchrs(2); break;
+! 			    case 'u': i = gethexchrs(4); break;
+! 			    case 'U': i = gethexchrs(8); break;
+! 			    default:  i = -1; break;
+  			}
+  
+! 			if (i < 0)
+  			    EMSG2_RET_FAIL(
+  			       _("E678: Invalid character after %s%%[dxouU]"),
+  				    reg_magic == MAGIC_ALL);
+  			/* TODO: what if a composing character follows? */
+! 			EMIT(i);
+  		    }
+  		    break;
+  
+--- 826,849 ----
+  		case 'u':   /* %uabcd hex 4 */
+  		case 'U':   /* %U1234abcd hex 8 */
+  		    {
+! 			int nr;
+  
+  			switch (c)
+  			{
+! 			    case 'd': nr = getdecchrs(); break;
+! 			    case 'o': nr = getoctchrs(); break;
+! 			    case 'x': nr = gethexchrs(2); break;
+! 			    case 'u': nr = gethexchrs(4); break;
+! 			    case 'U': nr = gethexchrs(8); break;
+! 			    default:  nr = -1; break;
+  			}
+  
+! 			if (nr < 0)
+  			    EMSG2_RET_FAIL(
+  			       _("E678: Invalid character after %s%%[dxouU]"),
+  				    reg_magic == MAGIC_ALL);
+  			/* TODO: what if a composing character follows? */
+! 			EMIT(nr);
+  		    }
+  		    break;
+  
+***************
+*** 1229,1234 ****
+--- 1228,1235 ----
+  			    != (plen = (*mb_ptr2len)(old_regparse))
+  						       || utf_iscomposing(c)))
+  		{
++ 		    int i = 0;
++ 
+  		    /* A base character plus composing characters, or just one
+  		     * or more composing characters.
+  		     * This requires creating a separate atom as if enclosing
+***************
+*** 1237,1243 ****
+  		     * building the postfix form, not the NFA itself;
+  		     * a composing char could be: a, b, c, NFA_COMPOSING
+  		     * where 'b' and 'c' are chars with codes > 256. */
+- 		    i = 0;
+  		    for (;;)
+  		    {
+  			EMIT(c);
+--- 1238,1243 ----
+***************
+*** 2923,2931 ****
+      regsub_T		*submatch;
+      regsub_T		*m;
+  {
+-     int		c;
+-     int		n;
+-     int		i = 0;
+      int		result;
+      int		size = 0;
+      int		match = FALSE;
+--- 2923,2928 ----
+***************
+*** 2939,2944 ****
+--- 2936,2942 ----
+      nfa_list_T	*listtbl[2][2];
+      nfa_list_T	*ll;
+      int		listid = 1;
++     int		listidx;
+      nfa_list_T	*thislist;
+      nfa_list_T	*nextlist;
+      nfa_list_T	*neglist;
+***************
+*** 3004,3010 ****
+  #define	ADD_POS_NEG_STATE(node)						    \
+      ll = listtbl[result ? 1 : 0][node->negated];			    \
+      if (ll != NULL)							    \
+! 	addstate(ll, node->out , &t->sub, n, listid + 1, &match);
+  
+  
+      /*
+--- 3002,3008 ----
+  #define	ADD_POS_NEG_STATE(node)						    \
+      ll = listtbl[result ? 1 : 0][node->negated];			    \
+      if (ll != NULL)							    \
+! 	addstate(ll, node->out , &t->sub, clen, listid + 1, &match);
+  
+  
+      /*
+***************
+*** 3012,3032 ****
+       */
+      for (;;)
+      {
+  #ifdef FEAT_MBYTE
+  	if (has_mbyte)
+  	{
+! 	    c = (*mb_ptr2char)(reginput);
+! 	    n = (*mb_ptr2len)(reginput);
+  	}
+  	else
+  #endif
+  	{
+! 	    c = *reginput;
+! 	    n = 1;
+  	}
+! 	if (c == NUL)
+  	{
+! 	    n = 0;
+  	    go_to_nextline = FALSE;
+  	}
+  
+--- 3010,3033 ----
+       */
+      for (;;)
+      {
++ 	int	curc;
++ 	int	clen;
++ 
+  #ifdef FEAT_MBYTE
+  	if (has_mbyte)
+  	{
+! 	    curc = (*mb_ptr2char)(reginput);
+! 	    clen = (*mb_ptr2len)(reginput);
+  	}
+  	else
+  #endif
+  	{
+! 	    curc = *reginput;
+! 	    clen = 1;
+  	}
+! 	if (curc == NUL)
+  	{
+! 	    clen = 0;
+  	    go_to_nextline = FALSE;
+  	}
+  
+***************
+*** 3040,3049 ****
+  #ifdef ENABLE_LOG
+  	fprintf(log_fd, "------------------------------------------\n");
+  	fprintf(log_fd, ">>> Reginput is \"%s\"\n", reginput);
+! 	fprintf(log_fd, ">>> Advanced one character ... Current char is %c (code %d) \n", c, (int)c);
+  	fprintf(log_fd, ">>> Thislist has %d states available: ", thislist->n);
+! 	for (i = 0; i < thislist->n; i++)
+! 	    fprintf(log_fd, "%d  ", abs(thislist->t[i].state->id));
+  	fprintf(log_fd, "\n");
+  #endif
+  
+--- 3041,3054 ----
+  #ifdef ENABLE_LOG
+  	fprintf(log_fd, "------------------------------------------\n");
+  	fprintf(log_fd, ">>> Reginput is \"%s\"\n", reginput);
+! 	fprintf(log_fd, ">>> Advanced one character ... Current char is %c (code %d) \n", curc, (int)curc);
+  	fprintf(log_fd, ">>> Thislist has %d states available: ", thislist->n);
+! 	{
+! 	    int i;
+! 
+! 	    for (i = 0; i < thislist->n; i++)
+! 		fprintf(log_fd, "%d  ", abs(thislist->t[i].state->id));
+! 	}
+  	fprintf(log_fd, "\n");
+  #endif
+  
+***************
+*** 3057,3072 ****
+  	    break;
+  
+  	/* compute nextlist */
+! 	for (i = 0; i < thislist->n || neglist->n > 0; ++i)
+  	{
+  	    if (neglist->n > 0)
+  	    {
+  		t = &neglist->t[0];
+  		neglist->n--;
+! 		i--;
+  	    }
+  	    else
+! 		t = &thislist->t[i];
+  
+  #ifdef NFA_REGEXP_DEBUG_LOG
+  	    nfa_set_code(t->state->c);
+--- 3062,3077 ----
+  	    break;
+  
+  	/* compute nextlist */
+! 	for (listidx = 0; listidx < thislist->n || neglist->n > 0; ++listidx)
+  	{
+  	    if (neglist->n > 0)
+  	    {
+  		t = &neglist->t[0];
+  		neglist->n--;
+! 		listidx--;
+  	    }
+  	    else
+! 		t = &thislist->t[listidx];
+  
+  #ifdef NFA_REGEXP_DEBUG_LOG
+  	    nfa_set_code(t->state->c);
+***************
+*** 3116,3122 ****
+  		 * the parent call. */
+  		if (start->c == NFA_MOPEN + 0)
+  		    addstate_here(thislist, t->state->out, &t->sub, listid,
+! 								  &match, &i);
+  		else
+  		{
+  		    *m = t->sub;
+--- 3121,3127 ----
+  		 * the parent call. */
+  		if (start->c == NFA_MOPEN + 0)
+  		    addstate_here(thislist, t->state->out, &t->sub, listid,
+! 							    &match, &listidx);
+  		else
+  		{
+  		    *m = t->sub;
+***************
+*** 3190,3196 ****
+  			}
+  		    /* t->state->out1 is the corresponding END_INVISIBLE node */
+  		    addstate_here(thislist, t->state->out1->out, &t->sub,
+! 							  listid, &match, &i);
+  		}
+  		else
+  		{
+--- 3195,3201 ----
+  			}
+  		    /* t->state->out1 is the corresponding END_INVISIBLE node */
+  		    addstate_here(thislist, t->state->out1->out, &t->sub,
+! 						    listid, &match, &listidx);
+  		}
+  		else
+  		{
+***************
+*** 3202,3221 ****
+  	    case NFA_BOL:
+  		if (reginput == regline)
+  		    addstate_here(thislist, t->state->out, &t->sub, listid,
+! 								  &match, &i);
+  		break;
+  
+  	    case NFA_EOL:
+! 		if (c == NUL)
+  		    addstate_here(thislist, t->state->out, &t->sub, listid,
+! 								  &match, &i);
+  		break;
+  
+  	    case NFA_BOW:
+  	    {
+  		int bow = TRUE;
+  
+! 		if (c == NUL)
+  		    bow = FALSE;
+  #ifdef FEAT_MBYTE
+  		else if (has_mbyte)
+--- 3207,3226 ----
+  	    case NFA_BOL:
+  		if (reginput == regline)
+  		    addstate_here(thislist, t->state->out, &t->sub, listid,
+! 							    &match, &listidx);
+  		break;
+  
+  	    case NFA_EOL:
+! 		if (curc == NUL)
+  		    addstate_here(thislist, t->state->out, &t->sub, listid,
+! 							    &match, &listidx);
+  		break;
+  
+  	    case NFA_BOW:
+  	    {
+  		int bow = TRUE;
+  
+! 		if (curc == NUL)
+  		    bow = FALSE;
+  #ifdef FEAT_MBYTE
+  		else if (has_mbyte)
+***************
+*** 3230,3242 ****
+  			bow = FALSE;
+  		}
+  #endif
+! 		else if (!vim_iswordc_buf(c, reg_buf)
+  			   || (reginput > regline
+  				   && vim_iswordc_buf(reginput[-1], reg_buf)))
+  		    bow = FALSE;
+  		if (bow)
+  		    addstate_here(thislist, t->state->out, &t->sub, listid,
+! 								  &match, &i);
+  		break;
+  	    }
+  
+--- 3235,3247 ----
+  			bow = FALSE;
+  		}
+  #endif
+! 		else if (!vim_iswordc_buf(curc, reg_buf)
+  			   || (reginput > regline
+  				   && vim_iswordc_buf(reginput[-1], reg_buf)))
+  		    bow = FALSE;
+  		if (bow)
+  		    addstate_here(thislist, t->state->out, &t->sub, listid,
+! 							    &match, &listidx);
+  		break;
+  	    }
+  
+***************
+*** 3260,3277 ****
+  		}
+  #endif
+  		else if (!vim_iswordc_buf(reginput[-1], reg_buf)
+! 			|| (reginput[0] != NUL && vim_iswordc_buf(c, reg_buf)))
+  		    eow = FALSE;
+  		if (eow)
+  		    addstate_here(thislist, t->state->out, &t->sub, listid,
+! 								  &match, &i);
+  		break;
+  	    }
+  
+  #ifdef FEAT_MBYTE
+  	    case NFA_COMPOSING:
+  	    {
+! 		int	    mc = c;
+  		int	    len = 0;
+  		nfa_state_T *end;
+  		nfa_state_T *sta;
+--- 3265,3283 ----
+  		}
+  #endif
+  		else if (!vim_iswordc_buf(reginput[-1], reg_buf)
+! 			|| (reginput[0] != NUL
+! 					   && vim_iswordc_buf(curc, reg_buf)))
+  		    eow = FALSE;
+  		if (eow)
+  		    addstate_here(thislist, t->state->out, &t->sub, listid,
+! 							    &match, &listidx);
+  		break;
+  	    }
+  
+  #ifdef FEAT_MBYTE
+  	    case NFA_COMPOSING:
+  	    {
+! 		int	    mc = curc;
+  		int	    len = 0;
+  		nfa_state_T *end;
+  		nfa_state_T *sta;
+***************
+*** 3286,3299 ****
+  		    /* Only match composing character(s), ignore base
+  		     * character.  Used for ".{composing}" and "{composing}"
+  		     * (no preceding character). */
+! 		    len += mb_char2len(c);
+  		}
+  		if (ireg_icombine)
+  		{
+  		    /* If \Z was present, then ignore composing characters.
+  		     * When ignoring the base character this always matches. */
+  		    /* TODO: How about negated? */
+! 		    if (len == 0 && sta->c != c)
+  			result = FAIL;
+  		    else
+  			result = OK;
+--- 3292,3305 ----
+  		    /* Only match composing character(s), ignore base
+  		     * character.  Used for ".{composing}" and "{composing}"
+  		     * (no preceding character). */
+! 		    len += mb_char2len(mc);
+  		}
+  		if (ireg_icombine)
+  		{
+  		    /* If \Z was present, then ignore composing characters.
+  		     * When ignoring the base character this always matches. */
+  		    /* TODO: How about negated? */
+! 		    if (len == 0 && sta->c != curc)
+  			result = FAIL;
+  		    else
+  			result = OK;
+***************
+*** 3312,3318 ****
+  
+  		    /* We don't care about the order of composing characters.
+  		     * Get them into cchars[] first. */
+! 		    while (len < n)
+  		    {
+  			mc = mb_ptr2char(reginput + len);
+  			cchars[ccount++] = mc;
+--- 3318,3324 ----
+  
+  		    /* We don't care about the order of composing characters.
+  		     * Get them into cchars[] first. */
+! 		    while (len < clen)
+  		    {
+  			mc = mb_ptr2char(reginput + len);
+  			cchars[ccount++] = mc;
+***************
+*** 3349,3355 ****
+  
+  	    case NFA_NEWL:
+  		if (!reg_line_lbr && REG_MULTI
+! 					&& c == NUL && reglnum <= reg_maxline)
+  		{
+  		    go_to_nextline = TRUE;
+  		    /* Pass -1 for the offset, which means taking the position
+--- 3355,3361 ----
+  
+  	    case NFA_NEWL:
+  		if (!reg_line_lbr && REG_MULTI
+! 				     && curc == NUL && reglnum <= reg_maxline)
+  		{
+  		    go_to_nextline = TRUE;
+  		    /* Pass -1 for the offset, which means taking the position
+***************
+*** 3375,3409 ****
+  	    case NFA_CLASS_RETURN:
+  	    case NFA_CLASS_BACKSPACE:
+  	    case NFA_CLASS_ESCAPE:
+! 		result = check_char_class(t->state->c, c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_END_NEG_RANGE:
+  		/* This follows a series of negated nodes, like:
+  		 * CHAR(x), NFA_NOT, CHAR(y), NFA_NOT etc. */
+! 		if (c > 0)
+! 		    addstate(nextlist, t->state->out, &t->sub, n, listid + 1,
+! 								    &match);
+  		break;
+  
+  	    case NFA_ANY:
+  		/* Any char except '\0', (end of input) does not match. */
+! 		if (c > 0)
+! 		    addstate(nextlist, t->state->out, &t->sub, n, listid + 1,
+! 								    &match);
+  		break;
+  
+  	    /*
+  	     * Character classes like \a for alpha, \d for digit etc.
+  	     */
+  	    case NFA_IDENT:	/*  \i	*/
+! 		result = vim_isIDc(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_SIDENT:	/*  \I	*/
+! 		result = !VIM_ISDIGIT(c) && vim_isIDc(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+--- 3381,3415 ----
+  	    case NFA_CLASS_RETURN:
+  	    case NFA_CLASS_BACKSPACE:
+  	    case NFA_CLASS_ESCAPE:
+! 		result = check_char_class(t->state->c, curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_END_NEG_RANGE:
+  		/* This follows a series of negated nodes, like:
+  		 * CHAR(x), NFA_NOT, CHAR(y), NFA_NOT etc. */
+! 		if (curc > 0)
+! 		    addstate(nextlist, t->state->out, &t->sub, clen,
+! 							  listid + 1, &match);
+  		break;
+  
+  	    case NFA_ANY:
+  		/* Any char except '\0', (end of input) does not match. */
+! 		if (curc > 0)
+! 		    addstate(nextlist, t->state->out, &t->sub, clen,
+! 							  listid + 1, &match);
+  		break;
+  
+  	    /*
+  	     * Character classes like \a for alpha, \d for digit etc.
+  	     */
+  	    case NFA_IDENT:	/*  \i	*/
+! 		result = vim_isIDc(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_SIDENT:	/*  \I	*/
+! 		result = !VIM_ISDIGIT(curc) && vim_isIDc(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+***************
+*** 3413,3429 ****
+  		break;
+  
+  	    case NFA_SKWORD:	/*  \K	*/
+! 		result = !VIM_ISDIGIT(c) && vim_iswordp_buf(reginput, reg_buf);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_FNAME:	/*  \f	*/
+! 		result = vim_isfilec(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_SFNAME:	/*  \F	*/
+! 		result = !VIM_ISDIGIT(c) && vim_isfilec(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+--- 3419,3436 ----
+  		break;
+  
+  	    case NFA_SKWORD:	/*  \K	*/
+! 		result = !VIM_ISDIGIT(curc)
+! 					&& vim_iswordp_buf(reginput, reg_buf);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_FNAME:	/*  \f	*/
+! 		result = vim_isfilec(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_SFNAME:	/*  \F	*/
+! 		result = !VIM_ISDIGIT(curc) && vim_isfilec(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+***************
+*** 3433,3529 ****
+  		break;
+  
+  	    case NFA_SPRINT:	/*  \P	*/
+! 		result = !VIM_ISDIGIT(c) && ptr2cells(reginput) == 1;
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_WHITE:	/*  \s	*/
+! 		result = vim_iswhite(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NWHITE:	/*  \S	*/
+! 		result = c != NUL && !vim_iswhite(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_DIGIT:	/*  \d	*/
+! 		result = ri_digit(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NDIGIT:	/*  \D	*/
+! 		result = c != NUL && !ri_digit(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_HEX:	/*  \x	*/
+! 		result = ri_hex(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NHEX:	/*  \X	*/
+! 		result = c != NUL && !ri_hex(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_OCTAL:	/*  \o	*/
+! 		result = ri_octal(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NOCTAL:	/*  \O	*/
+! 		result = c != NUL && !ri_octal(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_WORD:	/*  \w	*/
+! 		result = ri_word(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NWORD:	/*  \W	*/
+! 		result = c != NUL && !ri_word(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_HEAD:	/*  \h	*/
+! 		result = ri_head(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NHEAD:	/*  \H	*/
+! 		result = c != NUL && !ri_head(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_ALPHA:	/*  \a	*/
+! 		result = ri_alpha(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NALPHA:	/*  \A	*/
+! 		result = c != NUL && !ri_alpha(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_LOWER:	/*  \l	*/
+! 		result = ri_lower(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NLOWER:	/*  \L	*/
+! 		result = c != NUL && !ri_lower(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_UPPER:	/*  \u	*/
+! 		result = ri_upper(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NUPPER:	/* \U	*/
+! 		result = c != NUL && !ri_upper(c);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+--- 3440,3536 ----
+  		break;
+  
+  	    case NFA_SPRINT:	/*  \P	*/
+! 		result = !VIM_ISDIGIT(curc) && ptr2cells(reginput) == 1;
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_WHITE:	/*  \s	*/
+! 		result = vim_iswhite(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NWHITE:	/*  \S	*/
+! 		result = curc != NUL && !vim_iswhite(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_DIGIT:	/*  \d	*/
+! 		result = ri_digit(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NDIGIT:	/*  \D	*/
+! 		result = curc != NUL && !ri_digit(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_HEX:	/*  \x	*/
+! 		result = ri_hex(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NHEX:	/*  \X	*/
+! 		result = curc != NUL && !ri_hex(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_OCTAL:	/*  \o	*/
+! 		result = ri_octal(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NOCTAL:	/*  \O	*/
+! 		result = curc != NUL && !ri_octal(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_WORD:	/*  \w	*/
+! 		result = ri_word(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NWORD:	/*  \W	*/
+! 		result = curc != NUL && !ri_word(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_HEAD:	/*  \h	*/
+! 		result = ri_head(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NHEAD:	/*  \H	*/
+! 		result = curc != NUL && !ri_head(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_ALPHA:	/*  \a	*/
+! 		result = ri_alpha(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NALPHA:	/*  \A	*/
+! 		result = curc != NUL && !ri_alpha(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_LOWER:	/*  \l	*/
+! 		result = ri_lower(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NLOWER:	/*  \L	*/
+! 		result = curc != NUL && !ri_lower(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_UPPER:	/*  \u	*/
+! 		result = ri_upper(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+  	    case NFA_NUPPER:	/* \U	*/
+! 		result = curc != NUL && !ri_upper(curc);
+  		ADD_POS_NEG_STATE(t->state);
+  		break;
+  
+***************
+*** 3549,3565 ****
+  		/* TODO: put this in #ifdef later */
+  		if (t->state->c < -256)
+  		    EMSGN("INTERNAL: Negative state char: %ld", t->state->c);
+! 		result = (no_Magic(t->state->c) == c);
+  
+  		if (!result)
+  		    result = ireg_ic == TRUE
+! 				&& MB_TOLOWER(t->state->c) == MB_TOLOWER(c);
+  #ifdef FEAT_MBYTE
+  		/* If there is a composing character which is not being
+  		 * ignored there can be no match. Match with composing
+  		 * character uses NFA_COMPOSING above. */
+  		if (result && enc_utf8 && !ireg_icombine
+! 						      && n != utf_char2len(c))
+  		    result = FALSE;
+  #endif
+  		ADD_POS_NEG_STATE(t->state);
+--- 3556,3572 ----
+  		/* TODO: put this in #ifdef later */
+  		if (t->state->c < -256)
+  		    EMSGN("INTERNAL: Negative state char: %ld", t->state->c);
+! 		result = (no_Magic(t->state->c) == curc);
+  
+  		if (!result)
+  		    result = ireg_ic == TRUE
+! 			       && MB_TOLOWER(t->state->c) == MB_TOLOWER(curc);
+  #ifdef FEAT_MBYTE
+  		/* If there is a composing character which is not being
+  		 * ignored there can be no match. Match with composing
+  		 * character uses NFA_COMPOSING above. */
+  		if (result && enc_utf8 && !ireg_icombine
+! 						&& clen != utf_char2len(curc))
+  		    result = FALSE;
+  #endif
+  		ADD_POS_NEG_STATE(t->state);
+***************
+*** 3578,3598 ****
+  #ifdef ENABLE_LOG
+  	    fprintf(log_fd, "(---) STARTSTATE\n");
+  #endif
+! 	    addstate(nextlist, start, m, n, listid + 1, &match);
+  	}
+  
+  #ifdef ENABLE_LOG
+  	fprintf(log_fd, ">>> Thislist had %d states available: ", thislist->n);
+! 	for (i = 0; i< thislist->n; i++)
+! 	    fprintf(log_fd, "%d  ", abs(thislist->t[i].state->id));
+  	fprintf(log_fd, "\n");
+  #endif
+  
+  nextchar:
+  	/* Advance to the next character, or advance to the next line, or
+  	 * finish. */
+! 	if (n != 0)
+! 	    reginput += n;
+  	else if (go_to_nextline)
+  	    reg_nextline();
+  	else
+--- 3585,3609 ----
+  #ifdef ENABLE_LOG
+  	    fprintf(log_fd, "(---) STARTSTATE\n");
+  #endif
+! 	    addstate(nextlist, start, m, clen, listid + 1, &match);
+  	}
+  
+  #ifdef ENABLE_LOG
+  	fprintf(log_fd, ">>> Thislist had %d states available: ", thislist->n);
+! 	{
+! 	    int i;
+! 
+! 	    for (i = 0; i < thislist->n; i++)
+! 		fprintf(log_fd, "%d  ", abs(thislist->t[i].state->id));
+! 	}
+  	fprintf(log_fd, "\n");
+  #endif
+  
+  nextchar:
+  	/* Advance to the next character, or advance to the next line, or
+  	 * finish. */
+! 	if (clen != 0)
+! 	    reginput += clen;
+  	else if (go_to_nextline)
+  	    reg_nextline();
+  	else
+*** ../vim-7.3.1021/src/version.c	2013-05-26 14:32:01.000000000 +0200
+--- src/version.c	2013-05-26 14:39:12.000000000 +0200
+***************
+*** 730,731 ****
+--- 730,733 ----
+  {   /* Add new patch number below this line */
++ /**/
++     1022,
+  /**/
+
+-- 
+Female engineers become irresistible at the age of consent and remain that
+way until about thirty minutes after their clinical death.  Longer if it's a
+warm day.
+				(Scott Adams - The Dilbert principle)
+
+ /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\
+///        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
+\\\  an exciting new programming language -- http://www.Zimbu.org        ///
+ \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///