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    ///