diff --git a/src/regexp_nfa.c b/src/regexp_nfa.c
index 11c0119..c7c6598 100644
--- a/src/regexp_nfa.c
+++ b/src/regexp_nfa.c
@@ -604,7 +604,6 @@
     char_u	*endp;
 #ifdef FEAT_MBYTE
     char_u	*old_regparse = regparse;
-    int		i;
 #endif
     int		extra = 0;
     int		first;
@@ -827,24 +826,24 @@
 		case 'u':   /* %uabcd hex 4 */
 		case 'U':   /* %U1234abcd hex 8 */
 		    {
-			int i;
+			int nr;
 
 			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;
+			    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 (i < 0)
+			if (nr < 0)
 			    EMSG2_RET_FAIL(
 			       _("E678: Invalid character after %s%%[dxouU]"),
 				    reg_magic == MAGIC_ALL);
 			/* TODO: what if a composing character follows? */
-			EMIT(i);
+			EMIT(nr);
 		    }
 		    break;
 
@@ -1229,6 +1228,8 @@
 			    != (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,7 +1238,6 @@
 		     * 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);
@@ -2923,9 +2923,6 @@
     regsub_T		*submatch;
     regsub_T		*m;
 {
-    int		c;
-    int		n;
-    int		i = 0;
     int		result;
     int		size = 0;
     int		match = FALSE;
@@ -2939,6 +2936,7 @@
     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,7 +3002,7 @@
 #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);
+	addstate(ll, node->out , &t->sub, clen, listid + 1, &match);
 
 
     /*
@@ -3012,21 +3010,24 @@
      */
     for (;;)
     {
+	int	curc;
+	int	clen;
+
 #ifdef FEAT_MBYTE
 	if (has_mbyte)
 	{
-	    c = (*mb_ptr2char)(reginput);
-	    n = (*mb_ptr2len)(reginput);
+	    curc = (*mb_ptr2char)(reginput);
+	    clen = (*mb_ptr2len)(reginput);
 	}
 	else
 #endif
 	{
-	    c = *reginput;
-	    n = 1;
+	    curc = *reginput;
+	    clen = 1;
 	}
-	if (c == NUL)
+	if (curc == NUL)
 	{
-	    n = 0;
+	    clen = 0;
 	    go_to_nextline = FALSE;
 	}
 
@@ -3040,10 +3041,14 @@
 #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, ">>> Advanced one character ... Current char is %c (code %d) \n", curc, (int)curc);
 	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));
+	{
+	    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,16 +3062,16 @@
 	    break;
 
 	/* compute nextlist */
-	for (i = 0; i < thislist->n || neglist->n > 0; ++i)
+	for (listidx = 0; listidx < thislist->n || neglist->n > 0; ++listidx)
 	{
 	    if (neglist->n > 0)
 	    {
 		t = &neglist->t[0];
 		neglist->n--;
-		i--;
+		listidx--;
 	    }
 	    else
-		t = &thislist->t[i];
+		t = &thislist->t[listidx];
 
 #ifdef NFA_REGEXP_DEBUG_LOG
 	    nfa_set_code(t->state->c);
@@ -3116,7 +3121,7 @@
 		 * the parent call. */
 		if (start->c == NFA_MOPEN + 0)
 		    addstate_here(thislist, t->state->out, &t->sub, listid,
-								  &match, &i);
+							    &match, &listidx);
 		else
 		{
 		    *m = t->sub;
@@ -3190,7 +3195,7 @@
 			}
 		    /* t->state->out1 is the corresponding END_INVISIBLE node */
 		    addstate_here(thislist, t->state->out1->out, &t->sub,
-							  listid, &match, &i);
+						    listid, &match, &listidx);
 		}
 		else
 		{
@@ -3202,20 +3207,20 @@
 	    case NFA_BOL:
 		if (reginput == regline)
 		    addstate_here(thislist, t->state->out, &t->sub, listid,
-								  &match, &i);
+							    &match, &listidx);
 		break;
 
 	    case NFA_EOL:
-		if (c == NUL)
+		if (curc == NUL)
 		    addstate_here(thislist, t->state->out, &t->sub, listid,
-								  &match, &i);
+							    &match, &listidx);
 		break;
 
 	    case NFA_BOW:
 	    {
 		int bow = TRUE;
 
-		if (c == NUL)
+		if (curc == NUL)
 		    bow = FALSE;
 #ifdef FEAT_MBYTE
 		else if (has_mbyte)
@@ -3230,13 +3235,13 @@
 			bow = FALSE;
 		}
 #endif
-		else if (!vim_iswordc_buf(c, reg_buf)
+		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, &i);
+							    &match, &listidx);
 		break;
 	    }
 
@@ -3260,18 +3265,19 @@
 		}
 #endif
 		else if (!vim_iswordc_buf(reginput[-1], reg_buf)
-			|| (reginput[0] != NUL && vim_iswordc_buf(c, 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, &i);
+							    &match, &listidx);
 		break;
 	    }
 
 #ifdef FEAT_MBYTE
 	    case NFA_COMPOSING:
 	    {
-		int	    mc = c;
+		int	    mc = curc;
 		int	    len = 0;
 		nfa_state_T *end;
 		nfa_state_T *sta;
@@ -3286,14 +3292,14 @@
 		    /* Only match composing character(s), ignore base
 		     * character.  Used for ".{composing}" and "{composing}"
 		     * (no preceding character). */
-		    len += mb_char2len(c);
+		    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 != c)
+		    if (len == 0 && sta->c != curc)
 			result = FAIL;
 		    else
 			result = OK;
@@ -3312,7 +3318,7 @@
 
 		    /* We don't care about the order of composing characters.
 		     * Get them into cchars[] first. */
-		    while (len < n)
+		    while (len < clen)
 		    {
 			mc = mb_ptr2char(reginput + len);
 			cchars[ccount++] = mc;
@@ -3349,7 +3355,7 @@
 
 	    case NFA_NEWL:
 		if (!reg_line_lbr && REG_MULTI
-					&& c == NUL && reglnum <= reg_maxline)
+				     && curc == NUL && reglnum <= reg_maxline)
 		{
 		    go_to_nextline = TRUE;
 		    /* Pass -1 for the offset, which means taking the position
@@ -3375,35 +3381,35 @@
 	    case NFA_CLASS_RETURN:
 	    case NFA_CLASS_BACKSPACE:
 	    case NFA_CLASS_ESCAPE:
-		result = check_char_class(t->state->c, c);
+		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 (c > 0)
-		    addstate(nextlist, t->state->out, &t->sub, n, listid + 1,
-								    &match);
+		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 (c > 0)
-		    addstate(nextlist, t->state->out, &t->sub, n, listid + 1,
-								    &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(c);
+		result = vim_isIDc(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_SIDENT:	/*  \I	*/
-		result = !VIM_ISDIGIT(c) && vim_isIDc(c);
+		result = !VIM_ISDIGIT(curc) && vim_isIDc(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
@@ -3413,17 +3419,18 @@
 		break;
 
 	    case NFA_SKWORD:	/*  \K	*/
-		result = !VIM_ISDIGIT(c) && vim_iswordp_buf(reginput, reg_buf);
+		result = !VIM_ISDIGIT(curc)
+					&& vim_iswordp_buf(reginput, reg_buf);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_FNAME:	/*  \f	*/
-		result = vim_isfilec(c);
+		result = vim_isfilec(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_SFNAME:	/*  \F	*/
-		result = !VIM_ISDIGIT(c) && vim_isfilec(c);
+		result = !VIM_ISDIGIT(curc) && vim_isfilec(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
@@ -3433,97 +3440,97 @@
 		break;
 
 	    case NFA_SPRINT:	/*  \P	*/
-		result = !VIM_ISDIGIT(c) && ptr2cells(reginput) == 1;
+		result = !VIM_ISDIGIT(curc) && ptr2cells(reginput) == 1;
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_WHITE:	/*  \s	*/
-		result = vim_iswhite(c);
+		result = vim_iswhite(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_NWHITE:	/*  \S	*/
-		result = c != NUL && !vim_iswhite(c);
+		result = curc != NUL && !vim_iswhite(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_DIGIT:	/*  \d	*/
-		result = ri_digit(c);
+		result = ri_digit(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_NDIGIT:	/*  \D	*/
-		result = c != NUL && !ri_digit(c);
+		result = curc != NUL && !ri_digit(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_HEX:	/*  \x	*/
-		result = ri_hex(c);
+		result = ri_hex(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_NHEX:	/*  \X	*/
-		result = c != NUL && !ri_hex(c);
+		result = curc != NUL && !ri_hex(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_OCTAL:	/*  \o	*/
-		result = ri_octal(c);
+		result = ri_octal(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_NOCTAL:	/*  \O	*/
-		result = c != NUL && !ri_octal(c);
+		result = curc != NUL && !ri_octal(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_WORD:	/*  \w	*/
-		result = ri_word(c);
+		result = ri_word(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_NWORD:	/*  \W	*/
-		result = c != NUL && !ri_word(c);
+		result = curc != NUL && !ri_word(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_HEAD:	/*  \h	*/
-		result = ri_head(c);
+		result = ri_head(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_NHEAD:	/*  \H	*/
-		result = c != NUL && !ri_head(c);
+		result = curc != NUL && !ri_head(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_ALPHA:	/*  \a	*/
-		result = ri_alpha(c);
+		result = ri_alpha(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_NALPHA:	/*  \A	*/
-		result = c != NUL && !ri_alpha(c);
+		result = curc != NUL && !ri_alpha(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_LOWER:	/*  \l	*/
-		result = ri_lower(c);
+		result = ri_lower(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_NLOWER:	/*  \L	*/
-		result = c != NUL && !ri_lower(c);
+		result = curc != NUL && !ri_lower(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_UPPER:	/*  \u	*/
-		result = ri_upper(c);
+		result = ri_upper(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
 	    case NFA_NUPPER:	/* \U	*/
-		result = c != NUL && !ri_upper(c);
+		result = curc != NUL && !ri_upper(curc);
 		ADD_POS_NEG_STATE(t->state);
 		break;
 
@@ -3549,17 +3556,17 @@
 		/* 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);
+		result = (no_Magic(t->state->c) == curc);
 
 		if (!result)
 		    result = ireg_ic == TRUE
-				&& MB_TOLOWER(t->state->c) == MB_TOLOWER(c);
+			       && 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
-						      && n != utf_char2len(c))
+						&& clen != utf_char2len(curc))
 		    result = FALSE;
 #endif
 		ADD_POS_NEG_STATE(t->state);
@@ -3578,21 +3585,25 @@
 #ifdef ENABLE_LOG
 	    fprintf(log_fd, "(---) STARTSTATE\n");
 #endif
-	    addstate(nextlist, start, m, n, listid + 1, &match);
+	    addstate(nextlist, start, m, clen, 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));
+	{
+	    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 (n != 0)
-	    reginput += n;
+	if (clen != 0)
+	    reginput += clen;
 	else if (go_to_nextline)
 	    reg_nextline();
 	else