vim: src/spell.c comparison

comparison src/spell.c @ 11127:506f5d8b7d8b v8.0.0451

patch 8.0.0451: some macros are in lower case commit https://github.com/vim/vim/commit/91acfffc1e6c0d8c2abfb186a0e79a5bf19c3f3f Author: Bram Moolenaar <Bram@vim.org> Date: Sun Mar 12 19:22:36 2017 +0100 patch 8.0.0451: some macros are in lower case Problem: Some macros are in lower case. Solution: Make a few more macros upper case. Avoid lower case macros use an argument twice.

author	Christian Brabandt <cb@256bit.org>
date	Sun, 12 Mar 2017 19:30:05 +0100
parents	778c10516955
children	f4ea50924c6d

comparison

equal deleted inserted replaced

-:48599a3eae0b
+:506f5d8b7d8b
 mi.mi_fend = ptr;
 if (spell_iswordp(mi.mi_fend, wp))
 {
 	do
 	{
-	    mb_ptr_adv(mi.mi_fend);
+	    MB_PTR_ADV(mi.mi_fend);
 	} while (*mi.mi_fend != NUL && spell_iswordp(mi.mi_fend, wp));
 	if (capcol != NULL && *capcol == 0 && wp->w_s->b_cap_prog != NULL)
 	{
 	    /* Check word starting with capital letter. */
 mi.mi_win = wp;
 /* case-fold the word with one non-word character, so that we can check
 * for the word end. */
 if (*mi.mi_fend != NUL)
-	mb_ptr_adv(mi.mi_fend);
+	MB_PTR_ADV(mi.mi_fend);
 (void)spell_casefold(ptr, (int)(mi.mi_fend - ptr), mi.mi_fword,
 							     MAXWLEN + 1);
 mi.mi_fwordlen = (int)STRLEN(mi.mi_fword);
 	    return 1;
 	}
 	else if (mi.mi_end == ptr)
 	    /* Always include at least one character.  Required for when there
 	     * is a mixup in "midword". */
-	    mb_ptr_adv(mi.mi_end);
+	    MB_PTR_ADV(mi.mi_end);
 	else if (mi.mi_result == SP_BAD
 		&& LANGP_ENTRY(wp->w_s->b_langp, 0)->lp_slang->sl_nobreak)
 	{
 	    char_u	*p, *fp;
 	    int		save_result = mi.mi_result;
 	    {
 		p = mi.mi_word;
 		fp = mi.mi_fword;
 		for (;;)
 		{
-		    mb_ptr_adv(p);
+		    MB_PTR_ADV(p);
-		    mb_ptr_adv(fp);
+		    MB_PTR_ADV(fp);
 		    if (p >= mi.mi_end)
 			break;
 		    mi.mi_compoff = (int)(fp - mi.mi_fword);
 		    find_word(&mi, FIND_COMPOUND);
 		    if (mi.mi_result != SP_BAD)
 	     * when folding case.  This can be slow, take a shortcut when the
 	     * case-folded word is equal to the keep-case word. */
 	    p = mip->mi_word;
 	    if (STRNCMP(ptr, p, wlen) != 0)
 	    {
-		for (s = ptr; s < ptr + wlen; mb_ptr_adv(s))
+		for (s = ptr; s < ptr + wlen; MB_PTR_ADV(s))
-		    mb_ptr_adv(p);
+		    MB_PTR_ADV(p);
 		wlen = (int)(p - mip->mi_word);
 	    }
 	}
 #endif
 		    if (has_mbyte && STRNCMP(ptr, mip->mi_word,
 							mip->mi_compoff) != 0)
 		    {
 			/* case folding may have changed the length */
 			p = mip->mi_word;
-			for (s = ptr; s < ptr + mip->mi_compoff; mb_ptr_adv(s))
+			for (s = ptr; s < ptr + mip->mi_compoff; MB_PTR_ADV(s))
-			    mb_ptr_adv(p);
+			    MB_PTR_ADV(p);
 		    }
 		    else
 #endif
 			p = mip->mi_word + mip->mi_compoff;
 		    capflags = captype(p, mip->mi_word + wlen);
 		    {
 			/* When the character before the word is a word
 			 * character we do not accept a Onecap word.  We do
 			 * accept a no-caps word, even when the dictionary
 			 * word specifies ONECAP. */
-			mb_ptr_back(mip->mi_word, p);
+			MB_PTR_BACK(mip->mi_word, p);
 			if (spell_iswordp_nmw(p, mip->mi_win)
 				? capflags == WF_ONECAP
 				: (flags & WF_ONECAP) != 0
 						     && capflags != WF_ONECAP)
 			    continue;
 		     * folding case.  This can be slow, take a shortcut when
 		     * the case-folded word is equal to the keep-case word. */
 		    p = mip->mi_fword;
 		    if (STRNCMP(ptr, p, wlen) != 0)
 		    {
-			for (s = ptr; s < ptr + wlen; mb_ptr_adv(s))
+			for (s = ptr; s < ptr + wlen; MB_PTR_ADV(s))
-			    mb_ptr_adv(p);
+			    MB_PTR_ADV(p);
 			mip->mi_compoff = (int)(p - mip->mi_fword);
 		    }
 		}
 #endif
 #if 0 /* Disabled, see below */
 char_u	*p;
 p = mip->mi_fend;
 do
 {
-	mb_ptr_adv(mip->mi_fend);
+	MB_PTR_ADV(mip->mi_fend);
 } while (*mip->mi_fend != NUL && spell_iswordp(mip->mi_fend, mip->mi_win));
 /* Include the non-word character so that we can check for the word end. */
 if (*mip->mi_fend != NUL)
-	mb_ptr_adv(mip->mi_fend);
+	MB_PTR_ADV(mip->mi_fend);
 (void)spell_casefold(p, (int)(mip->mi_fend - p),
 			     mip->mi_fword + mip->mi_fwordlen,
 			     MAXWLEN - mip->mi_fwordlen);
 flen = (int)STRLEN(mip->mi_fword + mip->mi_fwordlen);
 int		firstcap;
 int		allcap;
 int		past_second = FALSE;	/* past second word char */
 /* find first letter */
-for (p = word; !spell_iswordp_nmw(p, curwin); mb_ptr_adv(p))
+for (p = word; !spell_iswordp_nmw(p, curwin); MB_PTR_ADV(p))
 	if (end == NULL ? *p == NUL : p >= end)
 	    return 0;	    /* only non-word characters, illegal word */
 #ifdef FEAT_MBYTE
 if (has_mbyte)
 	c = mb_ptr2char_adv(&p);
 /*
 * Need to check all letters to find a word with mixed upper/lower.
 * But a word with an upper char only at start is a ONECAP.
 */
-for ( ; end == NULL ? *p != NUL : p < end; mb_ptr_adv(p))
+for ( ; end == NULL ? *p != NUL : p < end; MB_PTR_ADV(p))
 	if (spell_iswordp_nmw(p, curwin))
 	{
 	    c = PTR2CHAR(p);
 	    if (!SPELL_ISUPPER(c))
 	    {
 if (flags & WF_KEEPCAP)
 {
 	/* Count the number of UPPER and lower case letters. */
 	l = u = 0;
 	first = FALSE;
-	for (p = word; p < end; mb_ptr_adv(p))
+	for (p = word; p < end; MB_PTR_ADV(p))
 	{
 	    c = PTR2CHAR(p);
 	    if (SPELL_ISUPPER(c))
 	    {
 		++u;
 	curwin->w_cursor = prev_cursor;
 	line = ml_get_curline();
 	p = line + curwin->w_cursor.col;
 	/* Backup to before start of word. */
 	while (p > line && spell_iswordp_nmw(p, curwin))
-	    mb_ptr_back(line, p);
+	    MB_PTR_BACK(line, p);
 	/* Forward to start of word. */
 	while (*p != NUL && !spell_iswordp_nmw(p, curwin))
-	    mb_ptr_adv(p);
+	    MB_PTR_ADV(p);
 	if (!spell_iswordp_nmw(p, curwin))		/* No word found. */
 	{
 	    beep_flush();
 	    return;
 	regmatch.regprog = curwin->w_s->b_cap_prog;
 	regmatch.rm_ic = FALSE;
 	p = line + endcol;
 	for (;;)
 	{
-	    mb_ptr_back(line, p);
+	    MB_PTR_BACK(line, p);
 	    if (p == line || spell_iswordp_nmw(p, curwin))
 		break;
 	    if (vim_regexec(&regmatch, p, 0)
 					 && regmatch.endp[0] == line + endcol)
 	    {
 			    compound_ok = FALSE;
 		    }
 		    /* Get pointer to last char of previous word. */
 		    p = preword + sp->ts_prewordlen;
-		    mb_ptr_back(preword, p);
+		    MB_PTR_BACK(preword, p);
 		}
 	    }
 	    /*
 	     * Form the word with proper case in preword.
 		else if (sp->ts_fidx > 0)
 		{
 		    /* Give a penalty when changing non-word char to word
 		     * char, e.g., "thes," -> "these". */
 		    p = fword + sp->ts_fidx;
-		    mb_ptr_back(fword, p);
+		    MB_PTR_BACK(fword, p);
 		    if (!spell_iswordp(p, curwin))
 		    {
 			p = preword + STRLEN(preword);
-			mb_ptr_back(preword, p);
+			MB_PTR_BACK(preword, p);
 			if (spell_iswordp(p, curwin))
 			    newscore += SCORE_NONWORD;
 		    }
 		    /* Give a bonus to words seen before. */
 				    /* If the previous character was the same,
 				     * thus doubling a character, give a bonus
 				     * to the score.  Also for the soundfold
 				     * tree (might seem illogical but does
 				     * give better scores). */
-				    mb_ptr_back(tword, p);
+				    MB_PTR_BACK(tword, p);
 				    if (c == mb_ptr2char(p))
 					sp->ts_score -= SCORE_INS
 							       - SCORE_INSDUP;
 				}
 			    }
 nofold_len(char_u *fword, int flen, char_u *word)
 {
 char_u	*p;
 int		i = 0;
-for (p = fword; p < fword + flen; mb_ptr_adv(p))
+for (p = fword; p < fword + flen; MB_PTR_ADV(p))
 	++i;
-for (p = word; i > 0; mb_ptr_adv(p))
+for (p = word; i > 0; MB_PTR_ADV(p))
 	--i;
 return (int)(p - word);
 }
 #endif
 {
 	goodlen = (int)(pgood - goodword);
 	badlen = (int)(pbad - su->su_badptr);
 	if (goodlen <= 0 || badlen <= 0)
 	    break;
-	mb_ptr_back(goodword, pgood);
+	MB_PTR_BACK(goodword, pgood);
-	mb_ptr_back(su->su_badptr, pbad);
+	MB_PTR_BACK(su->su_badptr, pbad);
 #ifdef FEAT_MBYTE
 	if (has_mbyte)
 	{
 	    if (mb_ptr2char(pgood) != mb_ptr2char(pbad))
 		break;
 spell_to_word_end(char_u *start, win_T *win)
 {
 char_u  *p = start;
 while (*p != NUL && spell_iswordp(p, win))
-	mb_ptr_adv(p);
+	MB_PTR_ADV(p);
 return p;
 }
 #if defined(FEAT_INS_EXPAND) || defined(PROTO)
 /*
 /* Find a word character before "startcol". */
 line = ml_get_curline();
 for (p = line + startcol; p > line; )
 {
-	mb_ptr_back(line, p);
+	MB_PTR_BACK(line, p);
 	if (spell_iswordp_nmw(p, curwin))
 	    break;
 }
 /* Go back to start of the word. */
 while (p > line)
 {
 	col = (int)(p - line);
-	mb_ptr_back(line, p);
+	MB_PTR_BACK(line, p);
 	if (!spell_iswordp(p, curwin))
 	    break;
 	col = 0;
 }

Mercurial > vim

comparison src/spell.c @ 11127:506f5d8b7d8b v8.0.0451