updated for version 7.0127
diff --git a/src/spell.c b/src/spell.c
index 9c3742f..e402069 100644
--- a/src/spell.c
+++ b/src/spell.c
@@ -51,8 +51,9 @@
*/
/* Use SPELL_PRINTTREE for debugging: dump the word tree after adding a word.
- * Only use for small word lists!
- * SPELL_COMPRESS_CNT is in how many words we compress the tree. */
+ * Only use it for small word lists!
+ * SPELL_COMPRESS_CNT is in how many words we compress the tree to limit the
+ * amount of memory used (esp. for Italian). */
#if 0
# define SPELL_PRINTTREE
# define SPELL_COMPRESS_CNT 1
@@ -639,6 +640,7 @@
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 int badword_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));
@@ -722,7 +724,7 @@
: (c) < 256 ? spelltab.st_isu[c] : iswupper(c))
# else
# define SPELL_ISUPPER(c) (enc_utf8 && (c) >= 128 ? utf_isupper(c) \
- : (c) < 256 ? spelltab.st_isu[c] : (c))
+ : (c) < 256 ? spelltab.st_isu[c] : (FALSE))
# endif
#endif
@@ -873,7 +875,7 @@
#ifdef FEAT_MBYTE
if (has_mbyte)
- return mb_ptr2len_check(ptr);
+ return (*mb_ptr2len)(ptr);
#endif
return 1;
}
@@ -1358,7 +1360,8 @@
{
return ((wordflags == WF_ALLCAP && (treeflags & WF_FIXCAP) == 0)
|| ((treeflags & (WF_ALLCAP | WF_KEEPCAP)) == 0
- && ((treeflags & WF_ONECAP) == 0 || wordflags == WF_ONECAP)));
+ && ((treeflags & WF_ONECAP) == 0
+ || (wordflags & WF_ONECAP) != 0)));
}
/*
@@ -2303,8 +2306,8 @@
* sl_sal_first[] for this. */
for (p = from, s = to; *p != NUL && *s != NUL; )
{
- c = mb_ptr2char_adv(&p);
- mb_ptr_adv(s);
+ c = mb_cptr2char_adv(&p);
+ mb_cptr_adv(s);
if (c >= 256)
++lp->sl_sal_first[c & 0xff];
}
@@ -2327,8 +2330,8 @@
vim_memset(lp->sl_sal_first, 0, sizeof(salfirst_T) * 256);
for (p = from, s = to; *p != NUL && *s != NUL; )
{
- c = mb_ptr2char_adv(&p);
- i = mb_ptr2char_adv(&s);
+ c = mb_cptr2char_adv(&p);
+ i = mb_cptr2char_adv(&s);
if (c >= 256)
{
/* Append the from-to chars at the end of the list with
@@ -2840,8 +2843,8 @@
char_u *bp;
c = mb_ptr2char(p);
- l = mb_ptr2len_check(p);
- if (c < 256)
+ l = (*mb_ptr2len)(p);
+ if (c < 256 && l <= 2)
buf->b_spell_ismw[c] = TRUE;
else if (buf->b_spell_ismw_mb == NULL)
/* First multi-byte char in "b_spell_ismw_mb". */
@@ -2945,6 +2948,50 @@
return 0;
}
+/*
+ * Like captype() but for a KEEPCAP word add ONECAP if the word starts with a
+ * capital. So that make_case_word() can turn WOrd into Word.
+ * Add ALLCAP for "WOrD".
+ */
+ static int
+badword_captype(word, end)
+ char_u *word;
+ char_u *end;
+{
+ int flags = captype(word, end);
+ int l, u;
+ int first;
+ char_u *p;
+
+ 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))
+ {
+ if (SPELL_ISUPPER(PTR2CHAR(p)))
+ {
+ ++u;
+ if (p == word)
+ first = TRUE;
+ }
+ else
+ ++l;
+ }
+
+ /* If there are more UPPER than lower case letters suggest an
+ * ALLCAP word. Otherwise, if the first letter is UPPER then
+ * suggest ONECAP. Exception: "ALl" most likely should be "All",
+ * require three upper case letters. */
+ if (u > l && u > 2)
+ flags |= WF_ALLCAP;
+ else if (first)
+ flags |= WF_ONECAP;
+ }
+ return flags;
+}
+
# if defined(FEAT_MBYTE) || defined(EXITFREE) || defined(PROTO)
/*
* Free all languages.
@@ -3097,8 +3144,8 @@
/*
* Structure that is used to store the items in the word tree. This avoids
- * the need to keep track of each allocated thing, it's freed all at once
- * after ":mkspell" is done.
+ * the need to keep track of each allocated thing, everything is freed all at
+ * once after ":mkspell" is done.
*/
#define SBLOCKSIZE 16000 /* size of sb_data */
typedef struct sblock_S sblock_T;
@@ -3129,7 +3176,10 @@
wordnode_T *wn_child; /* child (next byte in word) */
wordnode_T *wn_sibling; /* next sibling (alternate byte in word,
always sorted) */
- int wn_refs; /* nr of references to this node */
+ int wn_refs; /* Nr. of references to this node. Only
+ relevant for first node in a list of
+ siblings, in following siblings it is
+ always one. */
char_u wn_byte; /* Byte for this node. NUL for word end */
char_u wn_prefixID; /* when "wn_byte" is NUL: supported/required
prefix ID or 0 */
@@ -3152,10 +3202,22 @@
{
wordnode_T *si_foldroot; /* tree with case-folded words */
long si_foldwcount; /* nr of words in si_foldroot */
+ int si_fold_added; /* nr of words added since compressing */
+
wordnode_T *si_keeproot; /* tree with keep-case words */
long si_keepwcount; /* nr of words in si_keeproot */
+ int si_keep_added; /* nr of words added since compressing */
+
wordnode_T *si_prefroot; /* tree with postponed prefixes */
+
sblock_T *si_blocks; /* memory blocks used */
+ wordnode_T *si_first_free; /* List of nodes that have been freed during
+ compression, linked by "wn_child" field. */
+#ifdef SPELL_PRINTTREE
+ int si_wordnode_nr; /* sequence nr for nodes */
+#endif
+
+
int si_ascii; /* handling only ASCII words */
int si_add; /* addition file */
int si_clear_chartab; /* when TRUE clear char tables */
@@ -3163,6 +3225,7 @@
vimconv_T si_conv; /* for conversion to 'encoding' */
int si_memtot; /* runtime memory used */
int si_verbose; /* verbose messages */
+ int si_msg_count; /* number of words added since last message */
int si_region_count; /* number of regions supported (1 when there
are no regions) */
char_u si_region_name[16]; /* region names (if count > 1) */
@@ -3181,28 +3244,29 @@
int si_newID; /* current value for ah_newID */
} spellinfo_T;
-static afffile_T *spell_read_aff __ARGS((char_u *fname, spellinfo_T *spin));
+static afffile_T *spell_read_aff __ARGS((spellinfo_T *spin, char_u *fname));
static int str_equal __ARGS((char_u *s1, char_u *s2));
static void add_fromto __ARGS((spellinfo_T *spin, garray_T *gap, char_u *from, char_u *to));
static int sal_to_bool __ARGS((char_u *s));
static int has_non_ascii __ARGS((char_u *s));
static void spell_free_aff __ARGS((afffile_T *aff));
-static int spell_read_dic __ARGS((char_u *fname, spellinfo_T *spin, afffile_T *affile));
-static char_u *get_pfxlist __ARGS((afffile_T *affile, char_u *afflist, sblock_T **blp));
-static int store_aff_word __ARGS((char_u *word, spellinfo_T *spin, char_u *afflist, afffile_T *affile, hashtab_T *ht, hashtab_T *xht, int comb, int flags, char_u *pfxlist));
-static int spell_read_wordfile __ARGS((char_u *fname, spellinfo_T *spin));
-static void *getroom __ARGS((sblock_T **blp, size_t len, int align));
-static char_u *getroom_save __ARGS((sblock_T **blp, char_u *s));
+static int spell_read_dic __ARGS((spellinfo_T *spin, char_u *fname, afffile_T *affile));
+static char_u *get_pfxlist __ARGS((spellinfo_T *spin, afffile_T *affile, char_u *afflist));
+static int store_aff_word __ARGS((spellinfo_T *spin, char_u *word, char_u *afflist, afffile_T *affile, hashtab_T *ht, hashtab_T *xht, int comb, int flags, char_u *pfxlist));
+static int spell_read_wordfile __ARGS((spellinfo_T *spin, char_u *fname));
+static void *getroom __ARGS((spellinfo_T *spin, size_t len, int align));
+static char_u *getroom_save __ARGS((spellinfo_T *spin, char_u *s));
static void free_blocks __ARGS((sblock_T *bl));
-static wordnode_T *wordtree_alloc __ARGS((sblock_T **blp));
-static int store_word __ARGS((char_u *word, spellinfo_T *spin, int flags, int region, char_u *pfxlist));
-static int tree_add_word __ARGS((char_u *word, wordnode_T *tree, int flags, int region, int prefixID, spellinfo_T *spin));
-static wordnode_T *get_wordnode __ARGS((sblock_T **blp));
-static void free_wordnode __ARGS((wordnode_T *n));
-static void wordtree_compress __ARGS((wordnode_T *root, spellinfo_T *spin));
-static int node_compress __ARGS((wordnode_T *node, hashtab_T *ht, int *tot));
+static wordnode_T *wordtree_alloc __ARGS((spellinfo_T *spin));
+static int store_word __ARGS((spellinfo_T *spin, char_u *word, int flags, int region, char_u *pfxlist));
+static int tree_add_word __ARGS((spellinfo_T *spin, char_u *word, wordnode_T *tree, int flags, int region, int prefixID));
+static wordnode_T *get_wordnode __ARGS((spellinfo_T *spin));
+static void deref_wordnode __ARGS((spellinfo_T *spin, wordnode_T *node));
+static void free_wordnode __ARGS((spellinfo_T *spin, wordnode_T *n));
+static void wordtree_compress __ARGS((spellinfo_T *spin, wordnode_T *root));
+static int node_compress __ARGS((spellinfo_T *spin, wordnode_T *node, hashtab_T *ht, int *tot));
static int node_equal __ARGS((wordnode_T *n1, wordnode_T *n2));
-static void write_vim_spell __ARGS((char_u *fname, spellinfo_T *spin));
+static void write_vim_spell __ARGS((spellinfo_T *spin, char_u *fname));
static void clear_node __ARGS((wordnode_T *node));
static int put_node __ARGS((FILE *fd, wordnode_T *node, int index, int regionmask, int prefixtree));
static void mkspell __ARGS((int fcount, char_u **fnames, int ascii, int overwrite, int added_word));
@@ -3213,8 +3277,6 @@
* Use a negative number with the lower 8 bits zero. */
#define PFX_FLAGS -256
-static int words_added = 0; /* number of words added to tree */
-
#ifdef SPELL_PRINTTREE
/*
* For debugging the tree code: print the current tree in a (more or less)
@@ -3321,9 +3383,9 @@
* Returns an afffile_T, NULL for complete failure.
*/
static afffile_T *
-spell_read_aff(fname, spin)
- char_u *fname;
+spell_read_aff(spin, fname)
spellinfo_T *spin;
+ char_u *fname;
{
FILE *fd;
afffile_T *aff;
@@ -3389,7 +3451,7 @@
/*
* Allocate and init the afffile_T structure.
*/
- aff = (afffile_T *)getroom(&spin->si_blocks, sizeof(afffile_T), TRUE);
+ aff = (afffile_T *)getroom(spin, sizeof(afffile_T), TRUE);
if (aff == NULL)
return NULL;
hash_init(&aff->af_pref);
@@ -3516,14 +3578,14 @@
fname, lnum, items[4]);
/* New affix letter. */
- cur_aff = (affheader_T *)getroom(&spin->si_blocks,
+ cur_aff = (affheader_T *)getroom(spin,
sizeof(affheader_T), TRUE);
if (cur_aff == NULL)
break;
#ifdef FEAT_MBYTE
if (has_mbyte)
{
- l = mb_ptr2len_check(items[1]);
+ l = (*mb_ptr2len)(items[1]);
if (l >= AH_KEY_LEN)
l = 1; /* too long, must be an overlong sequence */
else
@@ -3591,18 +3653,16 @@
/* New item for an affix letter. */
--aff_todo;
- aff_entry = (affentry_T *)getroom(&spin->si_blocks,
+ aff_entry = (affentry_T *)getroom(spin,
sizeof(affentry_T), TRUE);
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]);
+ aff_entry->ae_chop = getroom_save(spin, items[2]);
if (STRCMP(items[3], "0") != 0)
- aff_entry->ae_add = getroom_save(&spin->si_blocks,
- items[3]);
+ aff_entry->ae_add = getroom_save(spin, items[3]);
/* Don't use an affix entry with non-ASCII characters when
* "spin->si_ascii" is TRUE. */
@@ -3616,8 +3676,7 @@
{
char_u buf[MAXLINELEN];
- aff_entry->ae_cond = getroom_save(&spin->si_blocks,
- items[4]);
+ aff_entry->ae_cond = getroom_save(spin, items[4]);
if (*items[0] == 'P')
sprintf((char *)buf, "^%s", items[4]);
else
@@ -3638,7 +3697,7 @@
if (aff_entry->ae_chop != NULL
&& aff_entry->ae_add != NULL
#ifdef FEAT_MBYTE
- && aff_entry->ae_chop[mb_ptr2len_check(
+ && aff_entry->ae_chop[(*mb_ptr2len)(
aff_entry->ae_chop)] == NUL
#else
&& aff_entry->ae_chop[1] == NUL
@@ -3673,7 +3732,7 @@
{
onecap_copy(items[4], buf, TRUE);
aff_entry->ae_cond = getroom_save(
- &spin->si_blocks, buf);
+ spin, buf);
}
else
#endif
@@ -3713,7 +3772,7 @@
if (aff_entry->ae_cond == NULL)
*pp = NULL;
else
- *pp = getroom_save(&spin->si_blocks,
+ *pp = getroom_save(spin,
aff_entry->ae_cond);
}
@@ -3731,8 +3790,8 @@
n |= WFP_NC;
if (upper)
n |= WFP_UP;
- tree_add_word(p, spin->si_prefroot, n,
- idx, cur_aff->ah_newID, spin);
+ tree_add_word(spin, p, spin->si_prefroot, n,
+ idx, cur_aff->ah_newID);
}
}
}
@@ -3924,9 +3983,9 @@
{
ftp = ((fromto_T *)gap->ga_data) + gap->ga_len;
(void)spell_casefold(from, STRLEN(from), word, MAXWLEN);
- ftp->ft_from = getroom_save(&spin->si_blocks, word);
+ ftp->ft_from = getroom_save(spin, word);
(void)spell_casefold(to, STRLEN(to), word, MAXWLEN);
- ftp->ft_to = getroom_save(&spin->si_blocks, word);
+ ftp->ft_to = getroom_save(spin, word);
++gap->ga_len;
}
}
@@ -4000,9 +4059,9 @@
* Returns OK or FAIL;
*/
static int
-spell_read_dic(fname, spin, affile)
- char_u *fname;
+spell_read_dic(spin, fname, affile)
spellinfo_T *spin;
+ char_u *fname;
afffile_T *affile;
{
hashtab_T ht;
@@ -4035,9 +4094,6 @@
/* The hashtable is only used to detect duplicated words. */
hash_init(&ht);
- spin->si_foldwcount = 0;
- spin->si_keepwcount = 0;
-
if (spin->si_verbose || p_verbose > 2)
{
if (!spin->si_verbose)
@@ -4048,6 +4104,9 @@
verbose_leave();
}
+ /* start with a message for the first line */
+ spin->si_msg_count = 999999;
+
/* Read and ignore the first line: word count. */
(void)vim_fgets(line, MAXLINELEN, fd);
if (!vim_isdigit(*skipwhite(line)))
@@ -4106,9 +4165,10 @@
w = line;
}
- /* This takes time, print a message now and then. */
- if (spin->si_verbose && (lnum & 0x3ff) == 0)
+ /* This takes time, print a message every 10000 words. */
+ if (spin->si_verbose && spin->si_msg_count > 10000)
{
+ spin->si_msg_count = 0;
vim_snprintf((char *)message, sizeof(message),
_("line %6d, word %6d - %s"),
lnum, spin->si_foldwcount + spin->si_keepwcount, w);
@@ -4121,7 +4181,7 @@
}
/* Store the word in the hashtable to be able to find duplicates. */
- dw = (char_u *)getroom_save(&spin->si_blocks, w);
+ dw = (char_u *)getroom_save(spin, w);
if (dw == NULL)
retval = FAIL;
vim_free(pc);
@@ -4154,24 +4214,24 @@
if (affile->af_pfxpostpone)
/* Need to store the list of prefix IDs with the word. */
- pfxlist = get_pfxlist(affile, afflist, &spin->si_blocks);
+ pfxlist = get_pfxlist(spin, affile, afflist);
}
/* Add the word to the word tree(s). */
- if (store_word(dw, spin, flags, spin->si_region, pfxlist) == FAIL)
+ if (store_word(spin, dw, flags, spin->si_region, pfxlist) == FAIL)
retval = FAIL;
if (afflist != NULL)
{
/* Find all matching suffixes and add the resulting words.
* Additionally do matching prefixes that combine. */
- if (store_aff_word(dw, spin, afflist, affile,
+ if (store_aff_word(spin, dw, afflist, affile,
&affile->af_suff, &affile->af_pref,
FALSE, flags, pfxlist) == FAIL)
retval = FAIL;
/* Find all matching prefixes and add the resulting words. */
- if (store_aff_word(dw, spin, afflist, affile,
+ if (store_aff_word(spin, dw, afflist, affile,
&affile->af_pref, NULL,
FALSE, flags, pfxlist) == FAIL)
retval = FAIL;
@@ -4194,10 +4254,10 @@
* or when out of memory.
*/
static char_u *
-get_pfxlist(affile, afflist, blp)
+get_pfxlist(spin, affile, afflist)
+ spellinfo_T *spin;
afffile_T *affile;
char_u *afflist;
- sblock_T **blp;
{
char_u *p;
int cnt;
@@ -4226,7 +4286,7 @@
}
}
if (round == 1 && cnt > 0)
- res = getroom(blp, cnt + 1, FALSE);
+ res = getroom(spin, cnt + 1, FALSE);
if (res == NULL)
break;
}
@@ -4246,9 +4306,9 @@
* Returns FAIL when out of memory.
*/
static int
-store_aff_word(word, spin, afflist, affile, ht, xht, comb, flags, pfxlist)
- char_u *word; /* basic word start */
+store_aff_word(spin, word, afflist, affile, ht, xht, comb, flags, pfxlist)
spellinfo_T *spin; /* spell info */
+ char_u *word; /* basic word start */
char_u *afflist; /* list of names of supported affixes */
afffile_T *affile;
hashtab_T *ht;
@@ -4361,14 +4421,14 @@
}
/* Store the modified word. */
- if (store_word(newword, spin, use_flags,
+ if (store_word(spin, newword, use_flags,
spin->si_region, use_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,
+ if (store_aff_word(spin, newword, afflist, affile,
xht, NULL, TRUE,
use_flags, use_pfxlist) == FAIL)
retval = FAIL;
@@ -4385,9 +4445,9 @@
* Read a file with a list of words.
*/
static int
-spell_read_wordfile(fname, spin)
- char_u *fname;
+spell_read_wordfile(spin, fname)
spellinfo_T *spin;
+ char_u *fname;
{
FILE *fd;
long lnum = 0;
@@ -4573,7 +4633,7 @@
}
/* Normal word: store it. */
- if (store_word(line, spin, flags, regionmask, NULL) == FAIL)
+ if (store_word(spin, line, flags, regionmask, NULL) == FAIL)
{
retval = FAIL;
break;
@@ -4598,18 +4658,19 @@
/*
* Get part of an sblock_T, "len" bytes long.
- * This avoids calling free() for every little struct we use.
+ * This avoids calling free() for every little struct we use (and keeping
+ * track of them).
* The memory is cleared to all zeros.
* Returns NULL when out of memory.
*/
static void *
-getroom(blp, len, align)
- sblock_T **blp;
+getroom(spin, len, align)
+ spellinfo_T *spin;
size_t len; /* length needed */
int align; /* align for pointer */
{
char_u *p;
- sblock_T *bl = *blp;
+ sblock_T *bl = spin->si_blocks;
if (align && bl != NULL)
/* Round size up for alignment. On some systems structures need to be
@@ -4623,8 +4684,8 @@
bl = (sblock_T *)alloc_clear((unsigned)(sizeof(sblock_T) + SBLOCKSIZE));
if (bl == NULL)
return NULL;
- bl->sb_next = *blp;
- *blp = bl;
+ bl->sb_next = spin->si_blocks;
+ spin->si_blocks = bl;
bl->sb_used = 0;
}
@@ -4638,13 +4699,13 @@
* Make a copy of a string into memory allocated with getroom().
*/
static char_u *
-getroom_save(blp, s)
- sblock_T **blp;
+getroom_save(spin, s)
+ spellinfo_T *spin;
char_u *s;
{
char_u *sc;
- sc = (char_u *)getroom(blp, STRLEN(s) + 1, FALSE);
+ sc = (char_u *)getroom(spin, STRLEN(s) + 1, FALSE);
if (sc != NULL)
STRCPY(sc, s);
return sc;
@@ -4672,10 +4733,10 @@
* Allocate the root of a word tree.
*/
static wordnode_T *
-wordtree_alloc(blp)
- sblock_T **blp;
+wordtree_alloc(spin)
+ spellinfo_T *spin;
{
- return (wordnode_T *)getroom(blp, sizeof(wordnode_T), TRUE);
+ return (wordnode_T *)getroom(spin, sizeof(wordnode_T), TRUE);
}
/*
@@ -4687,9 +4748,9 @@
* When "pfxlist" is not NULL store the word for each postponed prefix ID.
*/
static int
-store_word(word, spin, flags, region, pfxlist)
- char_u *word;
+store_word(spin, word, flags, region, pfxlist)
spellinfo_T *spin;
+ char_u *word;
int flags; /* extra flags, WF_BANNED */
int region; /* supported region(s) */
char_u *pfxlist; /* list of prefix IDs or NULL */
@@ -4703,19 +4764,19 @@
(void)spell_casefold(word, len, foldword, MAXWLEN);
for (p = pfxlist; res == OK; ++p)
{
- res = tree_add_word(foldword, spin->si_foldroot, ct | flags,
- region, p == NULL ? 0 : *p, spin);
+ res = tree_add_word(spin, foldword, spin->si_foldroot, ct | flags,
+ region, p == NULL ? 0 : *p);
if (p == NULL || *p == NUL)
break;
}
++spin->si_foldwcount;
- if (res == OK && (ct == WF_KEEPCAP || flags & WF_KEEPCAP))
+ if (res == OK && (ct == WF_KEEPCAP || (flags & WF_KEEPCAP)))
{
for (p = pfxlist; res == OK; ++p)
{
- res = tree_add_word(word, spin->si_keeproot, flags,
- region, p == NULL ? 0 : *p, spin);
+ res = tree_add_word(spin, word, spin->si_keeproot, flags,
+ region, p == NULL ? 0 : *p);
if (p == NULL || *p == NUL)
break;
}
@@ -4731,20 +4792,19 @@
* Returns FAIL when out of memory.
*/
static int
-tree_add_word(word, root, flags, region, prefixID, spin)
+tree_add_word(spin, word, root, flags, region, prefixID)
+ spellinfo_T *spin;
char_u *word;
wordnode_T *root;
int flags;
int region;
int prefixID;
- spellinfo_T *spin;
{
wordnode_T *node = root;
wordnode_T *np;
wordnode_T *copyp, **copyprev;
wordnode_T **prev = NULL;
int i;
- sblock_T **blp = &spin->si_blocks;
/* Add each byte of the word to the tree, including the NUL at the end. */
for (i = 0; ; ++i)
@@ -4759,7 +4819,7 @@
for (copyp = node; copyp != NULL; copyp = copyp->wn_sibling)
{
/* Allocate a new node and copy the info. */
- np = get_wordnode(blp);
+ np = get_wordnode(spin);
if (np == NULL)
return FAIL;
np->wn_child = copyp->wn_child;
@@ -4808,7 +4868,7 @@
|| node->wn_prefixID != prefixID)))
{
/* Allocate a new node. */
- np = get_wordnode(blp);
+ np = get_wordnode(spin);
if (np == NULL)
return FAIL;
np->wn_byte = word[i];
@@ -4844,85 +4904,124 @@
spell_print_tree(root->wn_sibling);
#endif
+ /* count nr of words added since last message */
+ ++spin->si_msg_count;
+
/*
* Every so many words compress the tree, so that we don't use too much
* memory.
*/
- if (++words_added >= SPELL_COMPRESS_CNT)
+ i = FALSE;
+ if (root == spin->si_foldroot)
{
- words_added = 0;
-
- msg_start();
- msg_puts((char_u *)_(msg_compressing));
- msg_clr_eos();
- msg_didout = FALSE;
- msg_col = 0;
- out_flush();
- wordtree_compress(root->wn_sibling, spin);
+ if (++spin->si_fold_added >= SPELL_COMPRESS_CNT)
+ {
+ i = TRUE;
+ spin->si_fold_added = 0;
+ }
+ }
+ else if (root == spin->si_keeproot)
+ {
+ if (++spin->si_keep_added >= SPELL_COMPRESS_CNT)
+ {
+ i = TRUE;
+ spin->si_keep_added = 0;
+ }
+ }
+ if (i)
+ {
+ if (spin->si_verbose)
+ {
+ msg_start();
+ msg_puts((char_u *)_(msg_compressing));
+ msg_clr_eos();
+ msg_didout = FALSE;
+ msg_col = 0;
+ out_flush();
+ }
+ wordtree_compress(spin, root);
}
return OK;
}
-/* We keep a list of nodes that have been freed during compression. They are
- * re-used when adding a new node. The "wn_child" fields links them. */
-static wordnode_T *first_free_node = NULL;
-#ifdef SPELL_PRINTTREE
-static int wordnode_nr = 0;
-#endif
-
/*
* Get a wordnode_T, either from the list of previously freed nodes or
* allocate a new one.
*/
static wordnode_T *
-get_wordnode(blp)
- sblock_T **blp;
+get_wordnode(spin)
+ spellinfo_T *spin;
{
wordnode_T *n;
- if (first_free_node == NULL)
- n = (wordnode_T *)getroom(blp, sizeof(wordnode_T), TRUE);
+ if (spin->si_first_free == NULL)
+ n = (wordnode_T *)getroom(spin, sizeof(wordnode_T), TRUE);
else
{
- n = first_free_node;
- first_free_node = n->wn_child;
+ n = spin->si_first_free;
+ spin->si_first_free = n->wn_child;
vim_memset(n, 0, sizeof(wordnode_T));
}
#ifdef SPELL_PRINTTREE
- n->wn_nr = ++wordnode_nr;
+ n->wn_nr = ++spin->si_wordnode_nr;
#endif
return n;
}
/*
- * Free a wordnode_T for re-use later.
+ * Decrement the reference count on a node (which is the head of a list of
+ * siblings). If the reference count becomes zero free the node and its
+ * siblings.
*/
static void
-free_wordnode(n)
- wordnode_T *n;
+deref_wordnode(spin, node)
+ spellinfo_T *spin;
+ wordnode_T *node;
{
- n->wn_child = first_free_node;
- first_free_node = n;
+ wordnode_T *np;
+
+ if (--node->wn_refs == 0)
+ for (np = node; np != NULL; np = np->wn_sibling)
+ {
+ if (np->wn_child != NULL)
+ deref_wordnode(spin, np->wn_child);
+ free_wordnode(spin, np);
+ }
+}
+
+/*
+ * Free a wordnode_T for re-use later.
+ * Only the "wn_child" field becomes invalid.
+ */
+ static void
+free_wordnode(spin, n)
+ spellinfo_T *spin;
+ wordnode_T *n;
+{
+ n->wn_child = spin->si_first_free;
+ spin->si_first_free = n;
}
/*
* Compress a tree: find tails that are identical and can be shared.
*/
static void
-wordtree_compress(root, spin)
- wordnode_T *root;
+wordtree_compress(spin, root)
spellinfo_T *spin;
+ wordnode_T *root;
{
hashtab_T ht;
int n;
int tot = 0;
int perc;
- if (root != NULL)
+ /* Skip the root itself, it's not actually used. The first sibling is the
+ * start of the tree. */
+ if (root->wn_sibling != NULL)
{
hash_init(&ht);
- n = node_compress(root, &ht, &tot);
+ n = node_compress(spin, root->wn_sibling, &ht, &tot);
#ifndef SPELL_PRINTTREE
if (spin->si_verbose || p_verbose > 2)
@@ -4940,7 +5039,7 @@
verbose_leave();
}
#ifdef SPELL_PRINTTREE
- spell_print_tree(root);
+ spell_print_tree(root->wn_sibling);
#endif
hash_clear(&ht);
}
@@ -4951,7 +5050,8 @@
* Returns the number of compressed nodes.
*/
static int
-node_compress(node, ht, tot)
+node_compress(spin, node, ht, tot)
+ spellinfo_T *spin;
wordnode_T *node;
hashtab_T *ht;
int *tot; /* total count of nodes before compressing,
@@ -4978,7 +5078,7 @@
if ((child = np->wn_child) != NULL)
{
/* Compress the child. This fills hashkey. */
- compressed += node_compress(child, ht, tot);
+ compressed += node_compress(spin, child, ht, tot);
/* Try to find an identical child. */
hash = hash_hash(child->wn_u1.hashkey);
@@ -4995,14 +5095,7 @@
* current one. This means the current child and all
* its siblings is unlinked from the tree. */
++tp->wn_refs;
- --child->wn_refs;
- if (child->wn_refs == 0)
- for (; child != NULL; child = child->wn_sibling)
- {
- if (child->wn_child != NULL)
- --child->wn_child->wn_refs;
- free_wordnode(child);
- }
+ deref_wordnode(spin, child);
np->wn_child = tp;
++compressed;
break;
@@ -5123,9 +5216,9 @@
* Write the Vim spell file "fname".
*/
static void
-write_vim_spell(fname, spin)
- char_u *fname;
+write_vim_spell(spin, fname)
spellinfo_T *spin;
+ char_u *fname;
{
FILE *fd;
int regionmask;
@@ -5523,11 +5616,6 @@
ga_init2(&spin.si_sal, (int)sizeof(fromto_T), 20);
ga_init2(&spin.si_map, (int)sizeof(char_u), 100);
ga_init2(&spin.si_prefcond, (int)sizeof(char_u *), 50);
- first_free_node = NULL;
-#ifdef SPELL_PRINTTREE
- wordnode_nr = 0;
-#endif
- words_added = 0;
/* default: fnames[0] is output file, following are input files */
innames = &fnames[1];
@@ -5616,9 +5704,9 @@
}
spin.si_region_count = incount;
- spin.si_foldroot = wordtree_alloc(&spin.si_blocks);
- spin.si_keeproot = wordtree_alloc(&spin.si_blocks);
- spin.si_prefroot = wordtree_alloc(&spin.si_blocks);
+ spin.si_foldroot = wordtree_alloc(&spin);
+ spin.si_keeproot = wordtree_alloc(&spin);
+ spin.si_prefroot = wordtree_alloc(&spin);
if (spin.si_foldroot == NULL
|| spin.si_keeproot == NULL
|| spin.si_prefroot == NULL)
@@ -5650,7 +5738,7 @@
{
/* Read the .aff file. Will init "spin->si_conv" based on the
* "SET" line. */
- afile[i] = spell_read_aff(fname, &spin);
+ afile[i] = spell_read_aff(&spin, fname);
if (afile[i] == NULL)
error = TRUE;
else
@@ -5658,7 +5746,7 @@
/* Read the .dic file and store the words in the trees. */
vim_snprintf((char *)fname, sizeof(fname), "%s.dic",
innames[i]);
- if (spell_read_dic(fname, &spin, afile[i]) == FAIL)
+ if (spell_read_dic(&spin, fname, afile[i]) == FAIL)
error = TRUE;
}
}
@@ -5666,7 +5754,7 @@
{
/* No .aff file, try reading the file as a word list. Store
* the words in the trees. */
- if (spell_read_wordfile(innames[i], &spin) == FAIL)
+ if (spell_read_wordfile(&spin, innames[i]) == FAIL)
error = TRUE;
}
@@ -5681,18 +5769,18 @@
/*
* Combine tails in the tree.
*/
- if (!added_word || p_verbose > 2)
+ if (spin.si_verbose || p_verbose > 2)
{
- if (added_word)
+ if (!spin.si_verbose)
verbose_enter();
MSG(_(msg_compressing));
out_flush();
- if (added_word)
+ if (!spin.si_verbose)
verbose_leave();
}
- wordtree_compress(spin.si_foldroot->wn_sibling, &spin);
- wordtree_compress(spin.si_keeproot->wn_sibling, &spin);
- wordtree_compress(spin.si_prefroot->wn_sibling, &spin);
+ wordtree_compress(&spin, spin.si_foldroot);
+ wordtree_compress(&spin, spin.si_keeproot);
+ wordtree_compress(&spin, spin.si_prefroot);
}
if (!error)
@@ -5700,27 +5788,27 @@
/*
* Write the info in the spell file.
*/
- if (!added_word || p_verbose > 2)
+ if (spin.si_verbose || p_verbose > 2)
{
- if (added_word)
+ if (!spin.si_verbose)
verbose_enter();
smsg((char_u *)_("Writing spell file %s ..."), wfname);
out_flush();
- if (added_word)
+ if (!spin.si_verbose)
verbose_leave();
}
- write_vim_spell(wfname, &spin);
+ write_vim_spell(&spin, wfname);
- if (!added_word || p_verbose > 2)
+ if (spin.si_verbose || p_verbose > 2)
{
- if (added_word)
+ if (!spin.si_verbose)
verbose_enter();
MSG(_("Done!"));
smsg((char_u *)_("Estimated runtime memory use: %d bytes"),
spin.si_memtot);
out_flush();
- if (added_word)
+ if (!spin.si_verbose)
verbose_leave();
}
@@ -6393,7 +6481,7 @@
buf[outi] = NUL;
return FAIL;
}
- c = mb_ptr2char_adv(&p);
+ c = mb_cptr2char_adv(&p);
outi += mb_char2bytes(SPELL_TOFOLD(c), buf + outi);
}
buf[outi] = NUL;
@@ -6580,11 +6668,27 @@
vim_free(repl_to);
repl_to = NULL;
+#ifdef FEAT_RIGHTLEFT
+ /* When 'rightleft' is set the list is drawn right-left. */
+ cmdmsg_rl = curwin->w_p_rl;
+ if (cmdmsg_rl)
+ msg_col = Columns - 1;
+#endif
+
/* List the suggestions. */
msg_start();
lines_left = Rows; /* avoid more prompt */
vim_snprintf((char *)IObuff, IOSIZE, _("Change \"%.*s\" to:"),
sug.su_badlen, sug.su_badptr);
+#ifdef FEAT_RIGHTLEFT
+ if (cmdmsg_rl && STRNCMP(IObuff, "Change", 6) == 0)
+ {
+ /* And now the rabbit from the high hat: Avoid showing the
+ * untranslated message rightleft. */
+ vim_snprintf((char *)IObuff, IOSIZE, ":ot \"%.*s\" egnahC",
+ sug.su_badlen, sug.su_badptr);
+ }
+#endif
msg_puts(IObuff);
msg_clr_eos();
msg_putchar('\n');
@@ -6601,7 +6705,14 @@
vim_strncpy(wcopy + STRLEN(wcopy),
sug.su_badptr + stp->st_orglen,
sug.su_badlen - stp->st_orglen);
- vim_snprintf((char *)IObuff, IOSIZE, _("%2d \"%s\""), i + 1, wcopy);
+ vim_snprintf((char *)IObuff, IOSIZE, "%2d", i + 1);
+#ifdef FEAT_RIGHTLEFT
+ if (cmdmsg_rl)
+ rl_mirror(IObuff);
+#endif
+ msg_puts(IObuff);
+
+ vim_snprintf((char *)IObuff, IOSIZE, " \"%s\"", wcopy);
msg_puts(IObuff);
/* The word may replace more than "su_badlen". */
@@ -6616,18 +6727,27 @@
{
/* Add the score. */
if (sps_flags & (SPS_DOUBLE | SPS_BEST))
- vim_snprintf((char *)IObuff, IOSIZE, _(" (%s%d - %d)"),
+ vim_snprintf((char *)IObuff, IOSIZE, " (%s%d - %d)",
stp->st_salscore ? "s " : "",
stp->st_score, stp->st_altscore);
else
- vim_snprintf((char *)IObuff, IOSIZE, _(" (%d)"),
+ vim_snprintf((char *)IObuff, IOSIZE, " (%d)",
stp->st_score);
+#ifdef FEAT_RIGHTLEFT
+ if (cmdmsg_rl)
+ /* Mirror the numbers, but keep the leading space. */
+ rl_mirror(IObuff + 1);
+#endif
msg_advance(30);
msg_puts(IObuff);
}
msg_putchar('\n');
}
+#ifdef FEAT_RIGHTLEFT
+ cmdmsg_rl = FALSE;
+ msg_col = 0;
+#endif
/* Ask for choice. */
i = prompt_for_number(&mouse_used);
if (mouse_used)
@@ -6815,7 +6935,8 @@
(void)spell_casefold(su->su_badptr, su->su_badlen,
su->su_fbadword, MAXWLEN);
/* get caps flags for bad word */
- su->su_badflags = captype(su->su_badptr, su->su_badptr + su->su_badlen);
+ su->su_badflags = badword_captype(su->su_badptr,
+ su->su_badptr + su->su_badlen);
if (need_cap)
su->su_badflags |= WF_ONECAP;
@@ -6916,7 +7037,7 @@
#endif
/*
- * Find suggestions a file "fname".
+ * Find suggestions in file "fname". Used for "file:" in 'spellsuggest'.
*/
static void
spell_suggest_file(su, fname)
@@ -7070,7 +7191,7 @@
p = word;
#ifdef FEAT_MBYTE
if (has_mbyte)
- c = mb_ptr2char_adv(&p);
+ c = mb_cptr2char_adv(&p);
else
#endif
c = *p++;
@@ -7108,7 +7229,7 @@
{
#ifdef FEAT_MBYTE
if (has_mbyte)
- c = mb_ptr2char_adv(&s);
+ c = mb_cptr2char_adv(&s);
else
#endif
c = *s++;
@@ -7298,10 +7419,10 @@
else
#endif
n = sp->ts_fidx;
- flags = captype(su->su_badptr, su->su_badptr + n);
- su->su_badflags = captype(su->su_badptr + n,
+ flags = badword_captype(su->su_badptr,
+ su->su_badptr + n);
+ su->su_badflags = badword_captype(su->su_badptr + n,
su->su_badptr + su->su_badlen);
-
++depth;
stack[depth] = stack[depth - 1];
sp = &stack[depth];
@@ -7380,7 +7501,7 @@
c = su->su_badflags;
if ((c & WF_ALLCAP)
#ifdef FEAT_MBYTE
- && su->su_badlen == mb_ptr2len_check(su->su_badptr)
+ && su->su_badlen == (*mb_ptr2len)(su->su_badptr)
#else
&& su->su_badlen == 1
#endif
@@ -7492,7 +7613,7 @@
else
#endif
n = sp->ts_fidx;
- su->su_badflags = captype(su->su_badptr + n,
+ su->su_badflags = badword_captype(su->su_badptr + n,
su->su_badptr + su->su_badlen);
/* Restart at top of the tree. */
@@ -7751,7 +7872,7 @@
#ifdef FEAT_MBYTE
if (has_mbyte)
{
- n = mb_ptr2len_check(p);
+ n = mb_cptr2len(p);
c = mb_ptr2char(p);
c2 = mb_ptr2char(p + n);
}
@@ -7816,9 +7937,9 @@
#ifdef FEAT_MBYTE
if (has_mbyte)
{
- n = mb_ptr2len_check(p);
+ n = mb_cptr2len(p);
c = mb_ptr2char(p);
- fl = mb_ptr2len_check(p + n);
+ fl = mb_cptr2len(p + n);
c2 = mb_ptr2char(p + n);
c3 = mb_ptr2char(p + n + fl);
}
@@ -7897,10 +8018,10 @@
#ifdef FEAT_MBYTE
if (has_mbyte)
{
- n = mb_ptr2len_check(p);
+ n = mb_cptr2len(p);
c = mb_ptr2char(p);
- fl = mb_ptr2len_check(p + n);
- fl += mb_ptr2len_check(p + n + fl);
+ fl = mb_cptr2len(p + n);
+ fl += mb_cptr2len(p + n + fl);
mch_memmove(p, p + n, fl);
mb_char2bytes(c, p + fl);
stack[depth].ts_fidxtry = sp->ts_fidx + n + fl;
@@ -7951,10 +8072,10 @@
#ifdef FEAT_MBYTE
if (has_mbyte)
{
- n = mb_ptr2len_check(p);
- n += mb_ptr2len_check(p + n);
+ n = mb_cptr2len(p);
+ n += mb_cptr2len(p + n);
c = mb_ptr2char(p + n);
- tl = mb_ptr2len_check(p + n);
+ tl = mb_cptr2len(p + n);
mch_memmove(p + tl, p, n);
mb_char2bytes(c, p);
stack[depth].ts_fidxtry = sp->ts_fidx + n + tl;
@@ -8230,8 +8351,8 @@
#ifdef FEAT_MBYTE
if (has_mbyte)
{
- flen = mb_ptr2len_check(fword + fwordidx[depth]);
- ulen = mb_ptr2len_check(uword + uwordidx[depth]);
+ flen = mb_cptr2len(fword + fwordidx[depth]);
+ ulen = mb_cptr2len(uword + uwordidx[depth]);
}
else
#endif
@@ -8703,7 +8824,7 @@
for (p = map; *p != NUL; )
{
#ifdef FEAT_MBYTE
- c = mb_ptr2char_adv(&p);
+ c = mb_cptr2char_adv(&p);
#else
c = *p++;
#endif
@@ -9138,7 +9259,7 @@
* 255, sl_sal the rest. */
for (s = inword; *s != NUL; )
{
- c = mb_ptr2char_adv(&s);
+ c = mb_cptr2char_adv(&s);
if (enc_utf8 ? utf_class(c) == 0 : vim_iswhite(c))
c = ' ';
else if (c < 256)
@@ -9510,7 +9631,7 @@
for (s = inword; *s != NUL; )
{
t = s;
- c = mb_ptr2char_adv(&s);
+ c = mb_cptr2char_adv(&s);
if (slang->sl_rem_accents)
{
if (enc_utf8 ? utf_class(c) == 0 : vim_iswhite(c))
@@ -10026,10 +10147,10 @@
/* Get the characters from the multi-byte strings and put them in an
* int array for easy access. */
for (p = badword, badlen = 0; *p != NUL; )
- wbadword[badlen++] = mb_ptr2char_adv(&p);
+ wbadword[badlen++] = mb_cptr2char_adv(&p);
wbadword[badlen++] = 0;
for (p = goodword, goodlen = 0; *p != NUL; )
- wgoodword[goodlen++] = mb_ptr2char_adv(&p);
+ wgoodword[goodlen++] = mb_cptr2char_adv(&p);
wgoodword[goodlen++] = 0;
}
else