vim: src/spell.c comparison

comparison src/spell.c @ 366:b498dee21bd3

updated for version 7.0095

author	vimboss
date	Mon, 27 Jun 2005 22:27:46 +0000
parents	e111db373ca4
children	a698eb686ded

comparison

equal deleted inserted replaced

-:bda4394122e0
+:b498dee21bd3
 *
 * <HEADER>: <fileID>
 *		<regioncnt> <regionname> ...
 *		<charflagslen> <charflags>
 *		<fcharslen> <fchars>
+*		<midwordlen> <midword>
 *		<prefcondcnt> <prefcond> ...
 *
-* <fileID>     10 bytes    "VIMspell07"
+* <fileID>     10 bytes    "VIMspell08"
 * <regioncnt>  1 byte	    number of regions following (8 supported)
 * <regionname>	2 bytes     Region name: ca, au, etc.  Lower case.
 *			    First <regionname> is region 1.
 *
 * <charflagslen> 1 byte    Number of bytes in <charflags> (should be 128).
 * <charflags>  N bytes     List of flags (first one is for character 128):
 *			    0x01  word character	CF_WORD
 *			    0x02  upper-case character	CF_UPPER
 * <fcharslen>  2 bytes     Number of bytes in <fchars>.
 * <fchars>     N bytes	    Folded characters, first one is for character 128.
+*
+* <midwordlen> 2 bytes     Number of bytes in <midword>.
+* <midword>    N bytes	    Characters that are word characters only when used
+*			    in the middle of a word.
 *
 * <prefcondcnt> 2 bytes    Number of <prefcond> items following.
 *
 * <prefcond> : <condlen> <condstr>
 *
 *		      | <prefixID> <prefcondnr> ]
 *
 * <byte>	1 byte	    Byte value of the sibling.  Special cases:
 *			    BY_NOFLAGS: End of word without flags and for all
 *					regions.
-*			    BY_FLAGS: End of word, <flags> follow.  For
+*					For PREFIXTREE <prefixID> and
-*					PREFIXTREE <prefixID> and <prefcondnr>
+*					<prefcondnr> follow.
-*					follow.
+*			    BY_FLAGS: End of word, <flags> follow.
+*					For PREFIXTREE <prefixID> and
+*					<prefcondnr> follow for rare prefix.
 *			    BY_INDEX: Child of sibling is shared, <nodeidx>
 *					and <xbyte> follow.
 *
 * <nodeidx>	3 bytes	    Index of child for this sibling, MSB first.
 *
 #define WF_PFX	    0x20	/* prefix ID list follows */
 #define WF_KEEPCAP  0x80	/* keep-case word */
 #define WF_CAPMASK (WF_ONECAP | WF_ALLCAP | WF_KEEPCAP)
+#define WF_RAREPFX  0x1000000	/* in sl_pidxs: flag for rare postponed
+				   prefix; must be above prefixID (one byte)
+				   and prefcondnr (two bytes) */
 #define BY_NOFLAGS  0		/* end of word without flags or region */
 #define BY_FLAGS    1		/* end of word, flag byte follows */
 #define BY_INDEX    2		/* child is shared, index follows */
 #define BY_SPECIAL  BY_INDEX	/* hightest special byte value */
 #define SP_OK		0
 #define SP_RARE		1
 #define SP_LOCAL	2
 #define SP_BAD		3
-#define VIMSPELLMAGIC "VIMspell07"  /* string at start of Vim spell file */
+#define VIMSPELLMAGIC "VIMspell08"  /* string at start of Vim spell file */
 #define VIMSPELLMAGICL 10
 /*
 * Information used when looking for suggestions.
 */
 #define SCORE_SIMILAR	33	/* substitute a similar character */
 #define SCORE_DEL	94	/* delete a character */
 #define SCORE_DELDUP	64	/* delete a duplicated character */
 #define SCORE_INS	96	/* insert a character */
 #define SCORE_INSDUP	66	/* insert a duplicate character */
+#define SCORE_NONWORD	103	/* change non-word to word char */
 #define SCORE_MAXINIT	350	/* Initial maximum score: higher == slower.
 				 * 350 allows for about three changes. */
 #define SCORE_BIG	SCORE_INS * 3	/* big difference */
 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));
 		    continue;
 	    }
 	    /* When mode is FIND_PREFIX the word must support the prefix:
 	     * check the prefix ID and the condition.  Do that for the list at
-	     * mip->mi_prefarridx. */
+	     * mip->mi_prefarridx that find_prefix() filled. */
 	    if (mode == FIND_PREFIX)
 	    {
 		/* The prefix ID is stored two bytes above the flags. */
 		prefid = (unsigned)flags >> 16;
-		if (!valid_word_prefix(mip->mi_prefcnt, mip->mi_prefarridx,
+		c = valid_word_prefix(mip->mi_prefcnt, mip->mi_prefarridx,
 				   prefid, mip->mi_fword + mip->mi_prefixlen,
-								       slang))
+								       slang);
+		if (c == 0)
 		    continue;
+		/* Use the WF_RARE flag for a rare prefix. */
+		if (c & WF_RAREPFX)
+		    flags |= WF_RARE;
 	    }
 	    if (flags & WF_BANNED)
 		res = SP_BANNED;
 	    else if (flags & WF_REGION)
 	    break;
 }
 }
 /*
-* Return TRUE if the prefix indicated by "mip->mi_prefarridx" matches with
+* Return non-zero if the prefix indicated by "mip->mi_prefarridx" matches
-* the prefix ID "prefid" for the word "word".
+* with the prefix ID "prefid" for the word "word".
+* The WF_RAREPFX flag is included in the return value for a rare prefix.
 */
 static int
 valid_word_prefix(totprefcnt, arridx, prefid, word, slang)
 int		totprefcnt;	/* nr of prefix IDs */
 int		arridx;		/* idx in sl_pidxs[] */
 	/* Check the prefix ID. */
 	if (prefid != (pidx & 0xff))
 	    continue;
 	/* Check the condition, if there is one.  The condition index is
-	 * stored above the prefix ID byte.  */
+	 * stored in the two bytes above the prefix ID byte.  */
-	rp = slang->sl_prefprog[(unsigned)pidx >> 8];
+	rp = slang->sl_prefprog[((unsigned)pidx >> 8) & 0xffff];
 	if (rp != NULL)
 	{
 	    regmatch.regprog = rp;
 	    regmatch.rm_ic = FALSE;
 	    if (!vim_regexec(&regmatch, word, 0))
 		continue;
 	}
-	/* It's a match! */
+	/* It's a match!  Return the WF_RAREPFX flag. */
-	return TRUE;
+	return pidx;
 }
-return FALSE;
+return 0;
 }
 /*
 * Check if the word at "mip->mi_word" has a matching prefix.
 * If it does, then check the following word.
 /* <HEADER>: <fileID>
 *		<regioncnt> <regionname> ...
 *		<charflagslen> <charflags>
 *		<fcharslen> <fchars>
+*		<midwordlen> <midword>
 *		<prefcondcnt> <prefcond> ...
 */
 for (i = 0; i < VIMSPELLMAGICL; ++i)
 	buf[i] = getc(fd);				/* <fileID> */
 if (STRNCMP(buf, VIMSPELLMAGIC, VIMSPELLMAGICL) != 0)
 {
 	/* When <charflagslen> is zero then <fcharlen> must also be zero. */
 	cnt = (getc(fd) << 8) + getc(fd);
 	if (cnt != 0)
 	    goto formerr;
+}
+/* <midwordlen> <midword> */
+cnt = (getc(fd) << 8) + getc(fd);
+if (cnt < 0)
+	goto truncerr;
+if (cnt > 0)
+{
+	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)
 int		len;
 int		i;
 int		n;
 idx_T	idx = startidx;
 int		c;
+int		c2;
 #define SHARED_MASK	0x8000000
 len = getc(fd);					/* <siblingcount> */
 if (len <= 0)
 	return -1;
 	c = getc(fd);					/* <byte> */
 	if (c < 0)
 	    return -1;
 	if (c <= BY_SPECIAL)
 	{
-	    if (c == BY_NOFLAGS)
+	    if (c == BY_NOFLAGS && !prefixtree)
 	    {
 		/* No flags, all regions. */
 		idxs[idx] = 0;
 		c = 0;
 	    }
-	    else if (c == BY_FLAGS)
+	    else if (c == BY_FLAGS || c == BY_NOFLAGS)
 	    {
 		if (prefixtree)
 		{
 		    /* Read the prefix ID and the condition nr.  In idxs[]
 		     * store the prefix ID in the low byte, the condition
 		     * index shifted up 8 bits. */
-		    c = getc(fd);			/* <prefixID> */
+		    c2 = getc(fd);			/* <prefixID> */
 		    n = (getc(fd) << 8) + getc(fd);	/* <prefcondnr> */
 		    if (n >= maxprefcondnr)
 			return -2;
-		    c = (n << 8) + c;
+		    c2 += (n << 8);
+		    if (c == BY_NOFLAGS)
+			c = c2;
+		    else
+			c = c2 | WF_RAREPFX;
 		}
 		else
 		{
 		    /* Read flags and optional region and prefix ID.  In
 		     * idxs[] the flags go in the low byte, region above that
 {
 	lp = first_lang;
 	first_lang = lp->sl_next;
 	slang_free(lp);
 }
+init_spell_chartab();
 }
 # endif
 # if defined(FEAT_MBYTE) || defined(PROTO)
 /*
 affentry_T	*ae_next;	/* next affix with same name/number */
 char_u	*ae_chop;	/* text to chop off basic word (can be NULL) */
 char_u	*ae_add;	/* text to add to basic word (can be NULL) */
 char_u	*ae_cond;	/* condition (NULL for ".") */
 regprog_T	*ae_prog;	/* regexp program for ae_cond or NULL */
+int		ae_rare;	/* rare affix */
 };
 /* Affix header from ".aff" file.  Used for af_pref and af_suff. */
 typedef struct affheader_S
 {
 garray_T	si_sal;		/* list of fromto_T entries from SAL lines */
 int		si_followup;	/* soundsalike: ? */
 int		si_collapse;	/* soundsalike: ? */
 int		si_rem_accents;	/* soundsalike: remove accents */
 garray_T	si_map;		/* MAP info concatenated */
+char_u	*si_midword;	/* MIDWORD chars, alloc'ed string or NULL  */
 garray_T	si_prefcond;	/* table with conditions for postponed
 				 * prefixes, each stored as a string */
 int		si_newID;	/* current value for ah_newID */
 } spellinfo_T;
 char_u	*upp = NULL;
 static char *e_affname = N_("Affix name too long in %s line %d: %s");
 int		do_rep;
 int		do_sal;
 int		do_map;
+int		do_midword;
 int		found_map = FALSE;
 hashitem_T	*hi;
 /*
 * Open the file.
 if (spin->si_verbose || p_verbose > 2)
 {
 	if (!spin->si_verbose)
 	    verbose_enter();
-	smsg((char_u *)_("Reading affix file %s..."), fname);
+	smsg((char_u *)_("Reading affix file %s ..."), fname);
 	out_flush();
 	if (!spin->si_verbose)
 	    verbose_leave();
 }
 /* Only do SAL lines when not done in another .aff file already. */
 do_sal = spin->si_sal.ga_len == 0;
 /* Only do MAP lines when not done in another .aff file already. */
 do_map = spin->si_map.ga_len == 0;
+/* Only do MIDWORD line when not done in another .aff file already */
+do_midword = spin->si_midword == NULL;
 /*
 * Allocate and init the afffile_T structure.
 */
 aff = (afffile_T *)getroom(&spin->si_blocks, sizeof(afffile_T));
 		    smsg((char_u *)_("Conversion in %s not supported: from %s to %s"),
 					       fname, aff->af_enc, p_enc);
 #else
 		    smsg((char_u *)_("Conversion in %s not supported"), fname);
 #endif
+	    }
+	    else if (STRCMP(items[0], "MIDWORD") == 0 && itemcnt == 2)
+	    {
+		if (do_midword)
+		    spin->si_midword = vim_strsave(items[1]);
 	    }
 	    else if (STRCMP(items[0], "NOSPLITSUGS") == 0 && itemcnt == 1)
 	    {
 		/* ignored, we always split */
 	    }
 		    && aff_todo > 0
 		    && STRCMP(cur_aff->ah_key, items[1]) == 0
 		    && itemcnt >= 5)
 	    {
 		affentry_T	*aff_entry;
+		int		rare = FALSE;
+		int		lasti = 5;
+		/* Check for "rare" after the other info. */
+		if (itemcnt > 5 && STRICMP(items[5], "rare") == 0)
+		{
+		    rare = TRUE;
+		    lasti = 6;
+		}
 		/* Myspell allows extra text after the item, but that might
 		 * mean mistakes go unnoticed.  Require a comment-starter. */
-		if (itemcnt > 5 && *items[5] != '#')
+		if (itemcnt > lasti && *items[lasti] != '#')
 		    smsg((char_u *)_("Trailing text in %s line %d: %s"),
-						       fname, lnum, items[5]);
+						   fname, lnum, items[lasti]);
 		/* New item for an affix letter. */
 		--aff_todo;
 		aff_entry = (affentry_T *)getroom(&spin->si_blocks,
 							  sizeof(affentry_T));
 		if (aff_entry == NULL)
 		    break;
+		aff_entry->ae_rare = rare;
 		if (STRCMP(items[2], "0") != 0)
 		    aff_entry->ae_chop = getroom_save(&spin->si_blocks,
 								    items[2]);
 		if (STRCMP(items[3], "0") != 0)
 			/* Add the prefix to the prefix tree. */
 			if (aff_entry->ae_add == NULL)
 			    p = (char_u *)"";
 			else
 			    p = aff_entry->ae_add;
-			tree_add_word(p, spin->si_prefroot, -1, idx,
+			tree_add_word(p, spin->si_prefroot, rare ? -2 : -1,
-					 cur_aff->ah_newID, &spin->si_blocks);
+				    idx, cur_aff->ah_newID, &spin->si_blocks);
 		    }
 		}
 	    }
 	    else if (STRCMP(items[0], "FOL") == 0 && itemcnt == 2)
 	    {
 if (spin->si_verbose || p_verbose > 2)
 {
 	if (!spin->si_verbose)
 	    verbose_enter();
-	smsg((char_u *)_("Reading dictionary file %s..."), fname);
+	smsg((char_u *)_("Reading dictionary file %s ..."), fname);
 	out_flush();
 	if (!spin->si_verbose)
 	    verbose_leave();
 }
 regmatch_T	regmatch;
 char_u	newword[MAXWLEN];
 int		retval = OK;
 int		i;
 char_u	*p;
+int		use_flags;
 todo = ht->ht_used;
 for (hi = ht->ht_array; todo > 0 && retval == OK; ++hi)
 {
 	if (!HASHITEM_EMPTY(hi))
 			    }
 			    if (ae->ae_add != NULL)
 				STRCAT(newword, ae->ae_add);
 			}
+			/* Obey the "rare" flag of the affix. */
+			if (ae->ae_rare)
+			    use_flags = flags | WF_RARE;
+			else
+			    use_flags = flags;
 			/* Store the modified word. */
-			if (store_word(newword, spin,
+			if (store_word(newword, spin, use_flags,
-				     flags, spin->si_region, pfxlist) == FAIL)
+					    spin->si_region, pfxlist) == FAIL)
 			    retval = FAIL;
 			/* When added a suffix and combining is allowed also
 			 * try adding prefixes additionally. */
 			if (xht != NULL && ah->ah_combine)
 			    if (store_aff_word(newword, spin, afflist, affile,
-				     xht, NULL, TRUE, flags, pfxlist) == FAIL)
+					  xht, NULL, TRUE, use_flags, pfxlist)
+								      == FAIL)
 				retval = FAIL;
 		    }
 		}
 	    }
 	}
 if (spin->si_verbose || p_verbose > 2)
 {
 	if (!spin->si_verbose)
 	    verbose_enter();
-	smsg((char_u *)_("Reading word file %s..."), fname);
+	smsg((char_u *)_("Reading word file %s ..."), fname);
 	out_flush();
 	if (!spin->si_verbose)
 	    verbose_leave();
 }
 return res;
 }
 /*
 * Add word "word" to a word tree at "root".
-* When "flags" is -1 we are adding to the prefix tree where flags don't
+* When "flags" < 0 we are adding to the prefix tree where flags is used for
-* matter and "region" is the condition nr.
+* "rare" and "region" is the condition nr.
 * Returns FAIL when out of memory.
 */
 static int
 tree_add_word(word, root, flags, region, prefixID, blp)
 char_u	*word;
 }
 /* <HEADER>: <fileID> <regioncnt> <regionname> ...
 *		 <charflagslen> <charflags>
 *		 <fcharslen> <fchars>
+*		 <midwordlen> <midword>
 *		 <prefcondcnt> <prefcond> ... */
 							    /* <fileID> */
 if (fwrite(VIMSPELLMAGIC, VIMSPELLMAGICL, (size_t)1, fd) != 1)
 	EMSG(_(e_write));
 	putc(0, fd);
 }
 else
 	write_spell_chartab(fd);
+if (spin->si_midword == NULL)
+	put_bytes(fd, 0L, 2);			/* <midwordlen> */
+else
+{
+	i = STRLEN(spin->si_midword);
+	put_bytes(fd, (long_u)i, 2);		/* <midwordlen> */
+	fwrite(spin->si_midword, (size_t)i, (size_t)1, fd); /* <midword> */
+}
 /* Write the prefix conditions. */
 write_spell_prefcond(fd, &spin->si_prefcond);
+/* <SUGGEST> : <repcount> <rep> ...
+*             <salflags> <salcount> <sal> ...
+*             <maplen> <mapstr> */
 /* Sort the REP items. */
 qsort(spin->si_rep.ga_data, (size_t)spin->si_rep.ga_len,
 					       sizeof(fromto_T), rep_compare);
-/* <SUGGEST> : <repcount> <rep> ...
-*             <salflags> <salcount> <sal> ...
-*             <maplen> <mapstr> */
 for (round = 1; round <= 2; ++round)
 {
 	if (round == 1)
 	    gap = &spin->si_rep;
 	else
 		/* For a NUL byte (end of word) write the flags etc. */
 		if (prefixtree)
 		{
 		    /* In PREFIXTREE write the required prefixID and the
 		     * associated condition nr (stored in wn_region). */
-		    putc(BY_FLAGS, fd);			/* <byte> */
+		    if (np->wn_flags == (char_u)-2)
+			putc(BY_FLAGS, fd);		/* <byte> rare */
+		    else
+			putc(BY_NOFLAGS, fd);		/* <byte> */
 		    putc(np->wn_prefixID, fd);		/* <prefixID> */
 		    put_bytes(fd, (long_u)np->wn_region, 2); /* <prefcondnr> */
 		}
 		else
 		{
 	     * "path/en.latin1.add.spl". */
 	    innames = &fnames[0];
 	    incount = 1;
 	    vim_snprintf((char *)wfname, sizeof(wfname), "%s.spl", fnames[0]);
 	}
+	else if (fcount == 1)
+	{
+	    /* For ":mkspell path/vim" output file is "path/vim.latin1.spl". */
+	    innames = &fnames[0];
+	    incount = 1;
+	    vim_snprintf((char *)wfname, sizeof(wfname), "%s.%s.spl", fnames[0],
+			     spin.si_ascii ? (char_u *)"ascii" : spell_enc());
+	}
 	else if (len > 4 && STRCMP(fnames[0] + len - 4, ".spl") == 0)
 	{
 	    /* Name ends in ".spl", use as the file name. */
 	    vim_strncpy(wfname, fnames[0], sizeof(wfname) - 1);
 	}
 	     */
 	    if (!added_word || p_verbose > 2)
 	    {
 		if (added_word)
 		    verbose_enter();
-		smsg((char_u *)_("Writing spell file %s..."), wfname);
+		smsg((char_u *)_("Writing spell file %s ..."), wfname);
 		out_flush();
 		if (added_word)
 		    verbose_leave();
 	    }
 	/* Free the allocated memory. */
 	ga_clear(&spin.si_rep);
 	ga_clear(&spin.si_sal);
 	ga_clear(&spin.si_map);
 	ga_clear(&spin.si_prefcond);
+	vim_free(spin.si_midword);
 	/* Free the .aff file structures. */
 	for (i = 0; i < incount; ++i)
 	    if (afile[i] != NULL)
 		spell_free_aff(afile[i]);
 {
 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)
 return OK;
 }
 /*
 * Return TRUE if "p" points to a word character.
-* As a special case we see a single quote as a word character when it is
+* 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)
 char_u	*p;
 {
+#ifdef FEAT_MBYTE
 char_u	*s;
+int		l;
-if (*p == '\'')
+int		c;
-	s = p + 1;
-else
+if (has_mbyte)
+{
+	l = MB_BYTE2LEN(*p);
 	s = p;
-#ifdef FEAT_MBYTE
+	if (l == 1)
-if (has_mbyte && MB_BYTE2LEN(*s) > 1)
+	{
-	return mb_get_class(s) >= 2;
+	    /* be quick for ASCII */
+	    if (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
+				     && vim_strchr(spell_ismw_mb, c) != NULL))
+	    {
+		s = p + l;
+		l = MB_BYTE2LEN(*s);
+	    }
+	}
+	if (l > 1)
+	    return mb_get_class(s) >= 2;
+	return spelltab.st_isw[*s];
+}
 #endif
-return spelltab.st_isw[*s];
+return spelltab.st_isw[spell_ismw[*p] ? p[1] : p[0]];
 }
 /*
 * Write the table with prefix conditions to the .spl file.
 */
 		if ((fword[sp->ts_fidx] == NUL
 				       || !spell_iswordp(fword + sp->ts_fidx))
 			&& sp->ts_fidx >= sp->ts_fidxtry)
 		{
-		    /* The badword also ends: add suggestions, */
+		    /* The badword also ends: add suggestions.  Give a penalty
+		     * when changing non-word char to word char, e.g., "thes,"
+		     * -> "these". */
+		    p = fword + sp->ts_fidx;
+#ifdef FEAT_MBYTE
+		    if (has_mbyte)
+			mb_ptr_back(fword, p);
+		    else
+#endif
+			--p;
+		    if (!spell_iswordp(p))
+		    {
+			p = preword + STRLEN(preword);
+#ifdef FEAT_MBYTE
+			if (has_mbyte)
+			    mb_ptr_back(preword, p);
+			else
+#endif
+			    --p;
+			if (spell_iswordp(p))
+			    newscore += SCORE_NONWORD;
+		    }
 		    add_suggestion(su, &su->su_ga, preword,
 			    sp->ts_fidx - repextra,
 					   sp->ts_score + newscore, 0, FALSE);
 		}
 		else if (sp->ts_fidx >= sp->ts_fidxtry
 	    p = NULL;
 }
 if (score <= su->su_maxscore)
 {
-	/* Check if the word is already there. */
+	/* Check if the word is already there.  Also check the length that is
+	 * being replaced "thes," -> "these" is a different suggestion from
+	 * "thes" -> "these". */
 	stp = &SUG(*gap, 0);
 	for (i = gap->ga_len - 1; i >= 0; --i)
-	    if (STRCMP(stp[i].st_word, goodword) == 0)
+	    if (STRCMP(stp[i].st_word, goodword) == 0
+						&& stp[i].st_orglen == badlen)
 	    {
 		/* Found it.  Remember the lowest score. */
 		if (stp[i].st_score > score)
 		{
 		    stp[i].st_score = score;
 		    for (i = 1; i < len; ++i)
 			if (byts[n + i] != 0)
 			    break;
 		    curi[depth] += i - 1;
-		    if (valid_word_prefix(i, n, prefid, word, slang))
+		    i = valid_word_prefix(i, n, prefid, word, slang);
+		    if (i != 0)
 		    {
 			vim_strncpy(prefix + depth, word, MAXWLEN - depth);
-			dump_word(prefix, round, flags, lnum++);
+			dump_word(prefix, round,
+				(i & WF_RAREPFX) ? (flags | WF_RARE)
+							     : flags, lnum++);
 		    }
 		}
 		else
 		{
 		    /* Normal char, go one level deeper. */

Mercurial > vim

comparison src/spell.c @ 366:b498dee21bd3