vim: src/spell.c comparison

comparison src/spell.c @ 376:d2bc505a6d91

updated for version 7.0098

author	vimboss
date	Thu, 30 Jun 2005 21:52:39 +0000
parents	f14cbd913415
children	997a094e44d2

comparison

equal deleted inserted replaced

-:f14cbd913415
+:d2bc505a6d91
 char_u	*sl_pbyts;	/* prefix tree word bytes */
 idx_T	*sl_pidxs;	/* prefix tree word indexes */
 char_u	sl_regions[17];	/* table with up to 8 region names plus NUL */
+char_u	*sl_midword;	/* MIDWORD string or NULL */
 int		sl_prefixcnt;	/* number of items in "sl_prefprog" */
 regprog_T	**sl_prefprog;	/* table with regprogs for prefixes */
 garray_T	sl_rep;		/* list of fromto_T entries from REP lines */
 short	sl_rep_first[256];  /* indexes where byte first appears, -1 if
 int		mi_prefixlen;		/* byte length of prefix */
 /* others */
 int		mi_result;		/* result so far: SP_BAD, SP_OK, etc. */
 int		mi_capflags;		/* WF_ONECAP WF_ALLCAP WF_KEEPCAP */
+buf_T	*mi_buf;		/* buffer being checked */
 } matchinf_T;
 /*
 * The tables used for recognizing word characters according to spelling.
 * These are only used for the first 256 characters of 'encoding'.
 char_u  st_upper[256];	/* chars: upper case */
 } spelltab_T;
 static spelltab_T   spelltab;
 static int	    did_set_spelltab;
-static char_u	    spell_ismw[256];		/* flags: is midword char */
-#ifdef FEAT_MBYTE
-static char_u	    *spell_ismw_mb = NULL;	/* multi-byte midword chars */
-#endif
 #define CF_WORD		0x01
 #define CF_UPPER	0x02
 static void clear_spell_chartab __ARGS((spelltab_T *sp));
 static int set_spell_finish __ARGS((spelltab_T	*new_st));
-static int spell_iswordp __ARGS((char_u *p));
+static int spell_iswordp __ARGS((char_u *p, buf_T *buf));
+static int spell_iswordp_nmw __ARGS((char_u *p));
+#ifdef FEAT_MBYTE
+static int spell_iswordp_w __ARGS((int *p, buf_T *buf));
+#endif
 static void write_spell_prefcond __ARGS((FILE *fd, garray_T *gap));
 /*
 * Return TRUE if "p" points to a word character.  Like spell_iswordp() but
 * without the special handling of a single quote.
 /* mode values for find_word */
 #define FIND_FOLDWORD	0	/* find word case-folded */
 #define FIND_KEEPWORD	1	/* find keep-case word */
 #define FIND_PREFIX	2	/* find word after prefix */
+/* values for read_cnt_string() */
+#define ERR_NOMEM	-1
+#define ERR_TRUNC	-2
 static slang_T *slang_alloc __ARGS((char_u *lang));
 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 valid_word_prefix __ARGS((int totprefcnt, int arridx, int prefid, char_u *word, slang_T *slang));
 static int no_spell_checking __ARGS((void));
 static void spell_load_lang __ARGS((char_u *lang));
 static char_u *spell_enc __ARGS((void));
 static void spell_load_cb __ARGS((char_u *fname, void *cookie));
 static slang_T *spell_load_file __ARGS((char_u *fname, char_u *lang, slang_T *old_lp, int silent));
+static char_u *read_cnt_string __ARGS((FILE *fd, int cnt_bytes, int *errp));
 #ifdef FEAT_MBYTE
 static int *mb_str2wide __ARGS((char_u *s));
 #endif
 static idx_T read_tree __ARGS((FILE *fd, char_u *byts, idx_T *idxs, int maxidx, int startidx, int prefixtree, int maxprefcondnr));
+static void clear_midword __ARGS((buf_T *buf));
+static void use_midword __ARGS((slang_T *lp, buf_T *buf));
 static int find_region __ARGS((char_u *rp, char_u *region));
 static int captype __ARGS((char_u *word, char_u *end));
 static void spell_reload_one __ARGS((char_u *fname, int added_word));
 static int set_spell_charflags __ARGS((char_u *flags, int cnt, char_u *upp));
 static int set_spell_chartab __ARGS((char_u *fol, char_u *low, char_u *upp));
 	else
 	{
 	    mi.mi_end = skipdigits(ptr);
 	    nrlen = mi.mi_end - ptr;
 	}
-	if (!spell_iswordp(mi.mi_end))
+	if (!spell_iswordp(mi.mi_end, wp->w_buffer))
 	    return (int)(mi.mi_end - ptr);
 	/* Try including the digits in the word. */
 	mi.mi_fend = ptr + nrlen;
 }
 else
 	mi.mi_fend = ptr;
 /* Find the normal end of the word (until the next non-word character). */
 mi.mi_word = ptr;
-if (spell_iswordp(mi.mi_fend))
+if (spell_iswordp(mi.mi_fend, wp->w_buffer))
 {
 	do
 	{
 	    mb_ptr_adv(mi.mi_fend);
-	} while (*mi.mi_fend != NUL && spell_iswordp(mi.mi_fend));
+	} while (*mi.mi_fend != NUL && spell_iswordp(mi.mi_fend, wp->w_buffer));
 }
 /* We always use the characters up to the next non-word character,
 * also for bad words. */
 mi.mi_end = mi.mi_fend;
 /* Check caps type later. */
 mi.mi_capflags = 0;
 mi.mi_cend = NULL;
+mi.mi_buf = wp->w_buffer;
 /* Include one non-word character so that we can check for the
 * word end. */
 if (*mi.mi_fend != NUL)
 	mb_ptr_adv(mi.mi_fend);
 #ifdef FEAT_MBYTE
 	if ((*mb_head_off)(ptr, ptr + wlen) > 0)
 	    continue;	    /* not at first byte of character */
 #endif
-	if (spell_iswordp(ptr + wlen))
+	if (spell_iswordp(ptr + wlen, mip->mi_buf))
 	    continue;	    /* next char is a word character */
 #ifdef FEAT_MBYTE
 	if (mode != FIND_KEEPWORD && has_mbyte)
 	{
 p = mip->mi_fend;
 do
 {
 	mb_ptr_adv(mip->mi_fend);
-} while (*mip->mi_fend != NUL && spell_iswordp(mip->mi_fend));
+} while (*mip->mi_fend != NUL && spell_iswordp(mip->mi_fend, mip->mi_buf));
 /* 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);
 	p = skipwhite(p + 1);
 if (*p != NUL)
 {
 	*buf = ' ';
-	vim_strncpy(buf + 1, line, maxlen - 1);
+	vim_strncpy(buf + 1, line, maxlen - 2);
 	n = p - line;
 	if (n >= maxlen)
 	    n = maxlen - 1;
 	vim_memset(buf + 1, ' ', n);
 }
 }
 ga_clear(gap);
 gap = &lp->sl_sal;
 if (lp->sl_sofo)
-	/* SOFOFROM and SOFOTO items: free lists of wide characters. */
+{
-	for (i = 0; i < gap->ga_len; ++i)
+	/* "ga_len" is set to 1 without adding an item for latin1 */
-	    vim_free(((int **)gap->ga_data)[i]);
+	if (gap->ga_data != NULL)
+	    /* SOFOFROM and SOFOTO items: free lists of wide characters. */
+	    for (i = 0; i < gap->ga_len; ++i)
+		vim_free(((int **)gap->ga_data)[i]);
+}
 else
 	/* SAL items: free salitem_T items */
 	while (gap->ga_len > 0)
 	{
 	    smp = &((salitem_T *)gap->ga_data)[--gap->ga_len];
 	}
 ga_clear(gap);
 for (i = 0; i < lp->sl_prefixcnt; ++i)
 	vim_free(lp->sl_prefprog[i]);
+lp->sl_prefixcnt = 0;
 vim_free(lp->sl_prefprog);
+lp->sl_prefprog = NULL;
+vim_free(lp->sl_midword);
+lp->sl_midword = NULL;
 #ifdef FEAT_MBYTE
 {
 	int	    todo = lp->sl_map_hash.ht_used;
 	hashitem_T  *hi;
 	if (p == NULL)
 	    goto endFAIL;
 	for (i = 0; i < cnt; ++i)
 	    p[i] = getc(fd);				/* <charflags> */
-	ccnt = (getc(fd) << 8) + getc(fd);		/* <fcharslen> */
+	/* <fcharslen> <fchars> */
-	if (ccnt <= 0)
+	fol = read_cnt_string(fd, 2, &ccnt);
+	if (ccnt != 0)
 	{
 	    vim_free(p);
-	    goto formerr;
+	    if (ccnt == ERR_NOMEM)
-	}
+		goto endFAIL;
-	fol = alloc((unsigned)ccnt + 1);
+	    if (ccnt == ERR_TRUNC)
-	if (fol == NULL)
+		goto formerr;
-	{
+	}
-	    vim_free(p);
-	    goto endFAIL;
-	}
-	for (i = 0; i < ccnt; ++i)
-	    fol[i] = getc(fd);				/* <fchars> */
-	fol[i] = NUL;
 	/* Set the word-char flags and fill SPELL_ISUPPER() table. */
 	i = set_spell_charflags(p, cnt, fol);
 	vim_free(p);
 	vim_free(fol);
 	if (cnt != 0)
 	    goto formerr;
 }
 /* <midwordlen> <midword> */
-cnt = (getc(fd) << 8) + getc(fd);
+lp->sl_midword = read_cnt_string(fd, 2, &cnt);
-if (cnt < 0)
+if (cnt == ERR_TRUNC)
 	goto truncerr;
-if (cnt > 0)
+if (cnt == ERR_NOMEM)
-{
+	goto endFAIL;
-	for (i = 0; i < cnt; ++i)
-	    if (i < MAXWLEN)	    /* truncate at reasonable length */
-		buf[i] = getc(fd);
-	if (i < MAXWLEN)
-	    buf[i] = NUL;
-	else
-	    buf[MAXWLEN] = NUL;
-	/* The midword characters add up to any midword characters from other
-	 * .spel files. */
-	for (p = buf; *p != NUL; )
-#ifdef FEAT_MBYTE
-	    if (has_mbyte)
-	    {
-		c = mb_ptr2char(p);
-		i = mb_ptr2len_check(p);
-		if (c < 256)
-		    spell_ismw[c] = TRUE;
-		else if (spell_ismw_mb == NULL)
-		    /* First multi-byte char in "spell_ismw_mb". */
-		    spell_ismw_mb = vim_strnsave(p, i);
-		else
-		{
-		    /* Append multi-byte chars to "spell_ismw_mb". */
-		    n = STRLEN(spell_ismw_mb);
-		    bp = vim_strnsave(spell_ismw_mb, n + i);
-		    if (bp != NULL)
-		    {
-			vim_free(spell_ismw_mb);
-			spell_ismw_mb = bp;
-			vim_strncpy(bp + n, p, i);
-		    }
-		}
-		p += i;
-	    }
-	    else
-#endif
-		spell_ismw[*p++] = TRUE;
-}
 /* <prefcondcnt> <prefcond> ... */
 cnt = (getc(fd) << 8) + getc(fd);			/* <prefcondcnt> */
 if (cnt > 0)
 {
 sourcing_name = save_sourcing_name;
 sourcing_lnum = save_sourcing_lnum;
 return lp;
 }
+/*
+* Read a length field from "fd" in "cnt_bytes" bytes.
+* Allocate memory and read the string into it.
+* Returns NULL when the count is zero.
+* Sets "errp" to ERR_TRUNC when reading failed, ERR_NOMEM when out of
+* memory, zero when OK.
+*/
+static char_u *
+read_cnt_string(fd, cnt_bytes, errp)
+FILE	*fd;
+int		cnt_bytes;
+int		*errp;
+{
+int		cnt = 0;
+int		i;
+char_u	*str;
+/* read the length bytes, MSB first */
+for (i = 0; i < cnt_bytes; ++i)
+	cnt = (cnt << 8) + getc(fd);
+if (cnt < 0)
+{
+	*errp = ERR_TRUNC;
+	return NULL;
+}
+/* allocate memory */
+str = alloc((unsigned)cnt + 1);
+if (str == NULL)
+{
+	*errp = ERR_NOMEM;
+	return NULL;
+}
+*errp = 0;
+/* Read the string.  Doesn't check for truncated file. */
+for (i = 0; i < cnt; ++i)
+	str[i] = getc(fd);
+str[i] = NUL;
+return str;
+}
 #ifdef FEAT_MBYTE
 /*
 * Turn a multi-byte string into a wide character string.
 * Return it in allocated memory (NULL for out-of-memory)
 int		load_spf;
 int		len;
 char_u	*p;
 ga_init2(&ga, sizeof(langp_T), 2);
+clear_midword(buf);
 /* Make the name of the .spl file associated with 'spellfile'. */
 if (*buf->b_p_spf == NUL)
 	load_spf = FALSE;
 else
 		    return e_outofmem;
 		}
 		LANGP_ENTRY(ga, ga.ga_len)->lp_slang = lp;
 		LANGP_ENTRY(ga, ga.ga_len)->lp_region = region_mask;
 		++ga.ga_len;
+		use_midword(lp, buf);
 		/* Check if this is the spell file related to 'spellfile'. */
 		if (load_spf && fullpathcmp(spf_name, lp->sl_fname, FALSE)
 								  == FPC_SAME)
 		    load_spf = FALSE;
 	if (lp != NULL && ga_grow(&ga, 1) == OK)
 	{
 	    LANGP_ENTRY(ga, ga.ga_len)->lp_slang = lp;
 	    LANGP_ENTRY(ga, ga.ga_len)->lp_region = REGION_ALL;
 	    ++ga.ga_len;
+	    use_midword(lp, buf);
 	}
 }
 /* Add a NULL entry to mark the end of the list. */
 if (ga_grow(&ga, 1) == FAIL)
 /* Everything is fine, store the new b_langp value. */
 ga_clear(&buf->b_langp);
 buf->b_langp = ga;
 return NULL;
+}
+/*
+* Clear the midword characters for buffer "buf".
+*/
+static void
+clear_midword(buf)
+buf_T	*buf;
+{
+vim_memset(buf->b_spell_ismw, 0, 256);
+#ifdef FEAT_MBYTE
+vim_free(buf->b_spell_ismw_mb);
+buf->b_spell_ismw_mb = NULL;
+#endif
+}
+/*
+* Use the "sl_midword" field of language "lp" for buffer "buf".
+* They add up to any currently used midword characters.
+*/
+static void
+use_midword(lp, buf)
+slang_T	*lp;
+buf_T	*buf;
+{
+char_u	*p;
+for (p = lp->sl_midword; *p != NUL; )
+#ifdef FEAT_MBYTE
+	if (has_mbyte)
+	{
+	    int	    c, l, n;
+	    char_u  *bp;
+	    c = mb_ptr2char(p);
+	    l = mb_ptr2len_check(p);
+	    if (c < 256)
+		buf->b_spell_ismw[c] = TRUE;
+	    else if (buf->b_spell_ismw_mb == NULL)
+		/* First multi-byte char in "b_spell_ismw_mb". */
+		buf->b_spell_ismw_mb = vim_strnsave(p, l);
+	    else
+	    {
+		/* Append multi-byte chars to "b_spell_ismw_mb". */
+		n = STRLEN(buf->b_spell_ismw_mb);
+		bp = vim_strnsave(buf->b_spell_ismw_mb, n + l);
+		if (bp != NULL)
+		{
+		    vim_free(buf->b_spell_ismw_mb);
+		    buf->b_spell_ismw_mb = bp;
+		    vim_strncpy(bp + n, p, l);
+		}
+	    }
+	    p += l;
+	}
+	else
+#endif
+	    buf->b_spell_ismw[*p++] = TRUE;
 }
 /*
 * Find the region "region[2]" in "rp" (points to "sl_regions").
 * Each region is simply stored as the two characters of it's name.
 int		firstcap;
 int		allcap;
 int		past_second = FALSE;	/* past second word char */
 /* find first letter */
-for (p = word; !spell_iswordp(p); mb_ptr_adv(p))
+for (p = word; !spell_iswordp_nmw(p); 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))
-	if (spell_iswordp(p))
+	if (spell_iswordp_nmw(p))
 	{
 #ifdef FEAT_MBYTE
 	    c = mb_ptr2char(p);
 #else
 	    c = *p;
 			    STRCPY(newword, word);
 			    if (ae->ae_chop != NULL)
 			    {
 				/* Remove chop string. */
 				p = newword + STRLEN(newword);
-#ifdef FEAT_MBYTE
+				i = MB_CHARLEN(ae->ae_chop);
-				if (has_mbyte)
-				    i = mb_charlen(ae->ae_chop);
-				else
-#endif
-				    i = STRLEN(ae->ae_chop);
 				for ( ; i > 0; --i)
 				    mb_ptr_back(newword, p);
 				*p = NUL;
 			    }
 			    if (ae->ae_add != NULL)
 {
 int	    i;
 did_set_spelltab = FALSE;
 clear_spell_chartab(&spelltab);
-vim_memset(spell_ismw, FALSE, sizeof(spell_ismw));
 #ifdef FEAT_MBYTE
-vim_free(spell_ismw_mb);
-spell_ismw_mb = NULL;
 if (enc_dbcs)
 {
 	/* DBCS: assume double-wide characters are word characters. */
 	for (i = 128; i <= 255; ++i)
 	    if (MB_BYTE2LEN(i) == 2)
 * As a special case we see "midword" characters as word character when it is
 * followed by a word character.  This finds they'there but not 'they there'.
 * Thus this only works properly when past the first character of the word.
 */
 static int
-spell_iswordp(p)
+spell_iswordp(p, buf)
 char_u	*p;
+buf_T	*buf;	    /* buffer used */
 {
 #ifdef FEAT_MBYTE
 char_u	*s;
 int		l;
 int		c;
 	l = MB_BYTE2LEN(*p);
 	s = p;
 	if (l == 1)
 	{
 	    /* be quick for ASCII */
-	    if (spell_ismw[*p])
+	    if (buf->b_spell_ismw[*p])
 	    {
 		s = p + 1;		/* skip a mid-word character */
 		l = MB_BYTE2LEN(*s);
 	    }
 	}
 	else
 	{
 	    c = mb_ptr2char(p);
-	    if (c < 256 ? spell_ismw[c] : (spell_ismw_mb != NULL
+	    if (c < 256 ? buf->b_spell_ismw[c]
-				     && vim_strchr(spell_ismw_mb, c) != NULL))
+		    : (buf->b_spell_ismw_mb != NULL
+			   && vim_strchr(buf->b_spell_ismw_mb, c) != NULL))
 	    {
 		s = p + l;
 		l = MB_BYTE2LEN(*s);
 	    }
 	}
 	    return mb_get_class(s) >= 2;
 	return spelltab.st_isw[*s];
 }
 #endif
-return spelltab.st_isw[spell_ismw[*p] ? p[1] : p[0]];
+return spelltab.st_isw[buf->b_spell_ismw[*p] ? p[1] : p[0]];
+}
+/*
+* Return TRUE if "p" points to a word character.
+* Unlike spell_iswordp() this doesn't check for "midword" characters.
+*/
+static int
+spell_iswordp_nmw(p)
+char_u	*p;
+{
+#ifdef FEAT_MBYTE
+if (has_mbyte && MB_BYTE2LEN(*p) > 1)
+	return mb_get_class(p) >= 2;
+#endif
+return spelltab.st_isw[*p];
 }
 #ifdef FEAT_MBYTE
 /*
 * Return TRUE if "p" points to a word character.
 * Wide version of spell_iswordp().
 */
 static int
-spell_iswordp_w(p)
+spell_iswordp_w(p, buf)
 int		*p;
+buf_T	*buf;
 {
 int		*s;
-if (*p < 256 ? spell_ismw[*p] : (spell_ismw_mb != NULL
+if (*p < 256 ? buf->b_spell_ismw[*p]
-				    && vim_strchr(spell_ismw_mb, *p) != NULL))
+		 : (buf->b_spell_ismw_mb != NULL
+			     && vim_strchr(buf->b_spell_ismw_mb, *p) != NULL))
 	s = p + 1;
 else
 	s = p;
 if (mb_char2len(*s) > 1)
 #endif
 {
 	l = 1;
 	wcopy[0] = c;
 }
-vim_strncpy(wcopy + l, p, MAXWLEN - l);
+vim_strncpy(wcopy + l, p, MAXWLEN - l - 1);
 }
 /*
 * Make a copy of "word" with all the letters upper cased into
 * "wcopy[MAXWLEN]".  The result is NUL terminated.
 static void
 suggest_try_special(su)
 suginfo_T	*su;
 {
 char_u	*p;
-int		len;
+size_t	len;
 int		c;
 char_u	word[MAXWLEN];
 /*
 * Recognize a word that is repeated: "the the".
 		if (!spell_valid_case(su->su_badflags,
 					 captype(preword + prewordlen, NULL)))
 		    newscore += SCORE_ICASE;
 		if ((fword[sp->ts_fidx] == NUL
-				       || !spell_iswordp(fword + sp->ts_fidx))
+			       || !spell_iswordp(fword + sp->ts_fidx, curbuf))
 			&& 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,"
 		     * -> "these". */
 		    if (has_mbyte)
 			mb_ptr_back(fword, p);
 		    else
 #endif
 			--p;
-		    if (!spell_iswordp(p))
+		    if (!spell_iswordp(p, curbuf))
 		    {
 			p = preword + STRLEN(preword);
 #ifdef FEAT_MBYTE
 			if (has_mbyte)
 			    mb_ptr_back(preword, p);
 			else
 #endif
 			    --p;
-			if (spell_iswordp(p))
+			if (spell_iswordp(p, curbuf))
 			    newscore += SCORE_NONWORD;
 		    }
 		    add_suggestion(su, &su->su_ga, preword,
 			    sp->ts_fidx - repextra,
 		    {
 			/* Save things to be restored at STATE_SPLITUNDO. */
 			sp->ts_save_prewordlen = prewordlen;
 			sp->ts_save_badflags = su->su_badflags;
 			sp->ts_save_splitoff = splitoff;
+			sp->ts_state = STATE_SPLITUNDO;
+			++depth;
+			sp = &stack[depth];
 			/* Append a space to preword. */
 			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))
+			{
+			    sp->ts_score -= SCORE_SPLIT - SCORE_SUBST;
+#ifdef FEAT_MBYTE
+			    if (has_mbyte)
+				sp->ts_fidx += MB_BYTE2LEN(fword[sp->ts_fidx]);
+			    else
+#endif
+				++sp->ts_fidx;
+			}
 #ifdef FEAT_MBYTE
 			if (has_mbyte)
 			{
 			    int		i = 0;
 			    /* Case-folding may change the number of bytes:
-			     * Count nr of chars in fword[sp->ts_fidx] and
+			     * Count nr of chars in fword[ts_fidx] and
 			     * advance that many chars in su->su_badptr. */
 			    for (p = fword; p < fword + sp->ts_fidx;
 								mb_ptr_adv(p))
 				++i;
 			    for (p = su->su_badptr; i > 0; mb_ptr_adv(p))
 #endif
 			    p = su->su_badptr + sp->ts_fidx;
 			su->su_badflags = captype(p, su->su_badptr
 							     + su->su_badlen);
-			sp->ts_state = STATE_SPLITUNDO;
-			++depth;
 			/* Restart at top of the tree. */
-			stack[depth].ts_arridx = 0;
+			sp->ts_arridx = 0;
 		    }
 		}
 		break;
 	    case STATE_SPLITUNDO:
 else if (i < 0)
 {
 	/* When replacing part of the word check that we actually change
 	 * something.  For "the the" a suggestion can be replacing the first
 	 * "the" with itself, since "the" wasn't banned. */
-	if (badlen == STRLEN(goodword)
+	if (badlen == (int)STRLEN(goodword)
 			    && STRNCMP(su->su_badword, goodword, badlen) == 0)
 	    return;
 }
 	    {
 		/* Found it.  Remember the lowest score. */
 		if (stp[i].st_score > score)
 		{
 		    stp[i].st_score = score;
+		    stp[i].st_altscore = altscore;
 		    stp[i].st_had_bonus = had_bonus;
 		}
 		break;
 	    }
 		*t++ = ' ';
 		s = skipwhite(s);
 	    }
 	    else
 	    {
-		if (spell_iswordp(s))
+		if (spell_iswordp_nmw(s))
 		    *t++ = *s;
 		++s;
 	    }
 	}
 	*t = NUL;
 		    s++;
 		if (*s == NUL
 			|| (*s == '^'
 			    && (i == 0 || !(word[i - 1] == ' '
-					      || spell_iswordp(word + i - 1)))
+				      || spell_iswordp(word + i - 1, curbuf)))
 			    && (*(s + 1) != '$'
-				|| (!spell_iswordp(word + i + k0))))
+				|| (!spell_iswordp(word + i + k0, curbuf))))
 			|| (*s == '$' && i > 0
-			    && spell_iswordp(word + i - 1)
+			    && spell_iswordp(word + i - 1, curbuf)
-			    && (!spell_iswordp(word + i + k0))))
+			    && (!spell_iswordp(word + i + k0, curbuf))))
 		{
 		    /* search for followup rules, if:    */
 		    /* followup and k > 1  and  NO '-' in searchstring */
 		    c0 = word[i + k - 1];
 		    n0 = slang->sl_sal_first[c0];
 			    }
 			    if (*s == NUL
 				    /* *s == '^' cuts */
 				    || (*s == '$'
-					    && !spell_iswordp(word + i + k0)))
+					    && !spell_iswordp(word + i + k0,
+								     curbuf)))
 			    {
 				if (k0 == k)
 				    /* this is just a piece of the string */
 				    continue;
 		did_white = TRUE;
 	    }
 	    else
 	    {
 		did_white = FALSE;
-		if (!spell_iswordp(t))
+		if (!spell_iswordp_nmw(t))
 		    continue;
 	    }
 	}
 	word[n++] = c;
 }
 		    s++;
 		if (*s == NUL
 			|| (*s == '^'
 			    && (i == 0 || !(word[i - 1] == ' '
-					   || spell_iswordp_w(word + i - 1)))
+				    || spell_iswordp_w(word + i - 1, curbuf)))
 			    && (*(s + 1) != '$'
-				|| (!spell_iswordp_w(word + i + k0))))
+				|| (!spell_iswordp_w(word + i + k0, curbuf))))
 			|| (*s == '$' && i > 0
-			    && spell_iswordp_w(word + i - 1)
+			    && spell_iswordp_w(word + i - 1, curbuf)
-			    && (!spell_iswordp_w(word + i + k0))))
+			    && (!spell_iswordp_w(word + i + k0, curbuf))))
 		{
 		    /* search for followup rules, if:    */
 		    /* followup and k > 1  and  NO '-' in searchstring */
 		    c0 = word[i + k - 1];
 		    n0 = slang->sl_sal_first[c0 & 0xff];
 			    }
 			    if (*s == NUL
 				    /* *s == '^' cuts */
 				    || (*s == '$'
-					 && !spell_iswordp_w(word + i + k0)))
+					 && !spell_iswordp_w(word + i + k0,
+								     curbuf)))
 			    {
 				if (k0 == k)
 				    /* this is just a piece of the string */
 				    continue;
 		    curi[depth] += i - 1;
 		    i = valid_word_prefix(i, n, prefid, word, slang);
 		    if (i != 0)
 		    {
-			vim_strncpy(prefix + depth, word, MAXWLEN - depth);
+			vim_strncpy(prefix + depth, word, MAXWLEN - depth - 1);
 			dump_word(prefix, round,
 				(i & WF_RAREPFX) ? (flags | WF_RARE)
 							     : flags, lnum++);
 		    }
 		}

Mercurial > vim

comparison src/spell.c @ 376:d2bc505a6d91