* regions.
* For PREFIXTREE <prefixID> and
* <prefcondnr> follow.
- * BY_FLAGS: End of word, <flags> 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>
+ * BY_FLAGS2: End of word, <flags> and <flags2>
+ * follow. Not used in PREFIXTREE.
+ * BY_PFX_NC: For PREFIXTREE <prefixID> and
+ * <prefcondnr> follow for non-combining
+ * prefix.
+ * BY_PFX_RNC: For PREFIXTREE <prefixID> and
+ * <prefcondnr> follow for non-combining
+ * rare prefix.
+ * BY_INDEX: Child of sibling is shared, <nodeidx>
* and <xbyte> follow.
*
* <nodeidx> 3 bytes Index of child for this sibling, MSB first.
* WF_REGION <region> follows
* WF_PFX <prefixID> follows
*
+ * <flags2> 1 byte Only used when there are postponed prefixes.
+ * Bitmask of:
+ * WF_HAS_AFF >> 8 word includes affix
+ *
* <region> 1 byte Bitmask for regions in which word is valid. When
* omitted it's valid in all regions.
* Lowest bit is for region 1.
#define WF_ALLCAP 0x04 /* word must be all capitals */
#define WF_RARE 0x08 /* rare word */
#define WF_BANNED 0x10 /* bad word */
-#define WF_PFX 0x20 /* prefix ID list follows */
+#define WF_PFX 0x20 /* prefix ID follows */
#define WF_FIXCAP 0x40 /* keep-case word, allcap not allowed */
#define WF_KEEPCAP 0x80 /* keep-case word */
+/* for <flags2>, shifted up one byte to be used in wn_flags */
+#define WF_HAS_AFF 0x0100 /* word includes affix */
+
#define WF_CAPMASK (WF_ONECAP | WF_ALLCAP | WF_KEEPCAP | WF_FIXCAP)
+/* flags for postponed prefixes. Must be above prefixID (one byte)
+ * and prefcondnr (two bytes). */
#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 */
+ * prefix */
+#define WF_PFX_NC 0x2000000 /* in sl_pidxs: flag for non-combining
+ * postponed prefix */
+
+/* Special byte values for <byte>. Some are only used in the tree for
+ * postponed prefixes, some only in the other trees. This is a bit messy... */
+#define BY_NOFLAGS 0 /* end of word without flags or region; for
+ * postponed prefix: not rare, combining */
+#define BY_FLAGS 1 /* end of word, flags byte follows; for
+ * postponed prefix: rare, combining */
+#define BY_INDEX 2 /* child is shared, index follows */
+#define BY_FLAGS2 3 /* end of word, two flags bytes follow; never
+ * used in prefix tree */
+#define BY_PFX_NC 3 /* postponed prefix: not rare, not combining */
+#define BY_PFX_RNC 4 /* postponed prefix: rare, not combining */
+#define BY_SPECIAL BY_PFX_RNC /* highest special byte value */
/* Info from "REP" and "SAL" entries in ".aff" file used in si_rep, sl_rep,
* and si_sal. Not for sl_sal!
* The "idxs" array stores the index of the child node corresponding to the
* byte in "byts".
* Exception: when the byte is zero, the word may end here and "idxs" holds
- * the flags and region for the word. There may be several zeros in sequence
- * for alternative flag/region combinations.
+ * the flags, region mask and prefixID for the word. There may be several
+ * zeros in sequence for alternative flag/region combinations.
*/
typedef struct slang_S slang_T;
struct slang_S
#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.
- * Checking for a word character is done very often, avoid the function call
- * overhead.
- */
-#ifdef FEAT_MBYTE
-# define SPELL_ISWORDP(p) ((has_mbyte && MB_BYTE2LEN(*(p)) > 1) \
- ? (mb_get_class(p) >= 2) : spelltab.st_isw[*(p)])
-#else
-# define SPELL_ISWORDP(p) (spelltab.st_isw[*(p)])
-#endif
-
/*
* For finding suggestions: At each node in the tree these states are tried:
*/
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 valid_word_prefix __ARGS((int totprefcnt, int arridx, int flags, char_u *word, slang_T *slang));
static void find_prefix __ARGS((matchinf_T *mip));
static int fold_more __ARGS((matchinf_T *mip));
static int spell_valid_case __ARGS((int wordflags, int treeflags));
/* When we are at a non-word character there is no error, just
* skip over the character (try looking for a word after it). */
- else if (!SPELL_ISWORDP(ptr))
+ else if (!spell_iswordp_nmw(ptr))
{
if (capcol != NULL && wp->w_buffer->b_cap_prog != NULL)
{
unsigned flags;
char_u *byts;
idx_T *idxs;
- int prefid;
if (mode == FIND_KEEPWORD)
{
if (mode == FIND_PREFIX)
{
/* The prefix ID is stored two bytes above the flags. */
- prefid = (unsigned)flags >> 16;
c = valid_word_prefix(mip->mi_prefcnt, mip->mi_prefarridx,
- prefid, mip->mi_fword + mip->mi_prefixlen,
- slang);
+ flags,
+ mip->mi_fword + mip->mi_prefixlen, slang);
if (c == 0)
continue;
else if (flags & WF_REGION)
{
/* Check region. */
- if ((mip->mi_lp->lp_region & (flags >> 8)) != 0)
+ if ((mip->mi_lp->lp_region & (flags >> 16)) != 0)
res = SP_OK;
else
res = SP_LOCAL;
}
/*
- * Return non-zero if the prefix indicated by "mip->mi_prefarridx" matches
- * with the prefix ID "prefid" for the word "word".
+ * Return non-zero if the prefix indicated by "arridx" matches with the prefix
+ * ID in "flags" 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)
+valid_word_prefix(totprefcnt, arridx, flags, word, slang)
int totprefcnt; /* nr of prefix IDs */
int arridx; /* idx in sl_pidxs[] */
- int prefid;
+ int flags;
char_u *word;
slang_T *slang;
{
int pidx;
regprog_T *rp;
regmatch_T regmatch;
+ int prefid;
+ prefid = (unsigned)flags >> 24;
for (prefcnt = totprefcnt - 1; prefcnt >= 0; --prefcnt)
{
pidx = slang->sl_pidxs[arridx + prefcnt];
if (prefid != (pidx & 0xff))
continue;
+ /* Check if the prefix doesn't combine and the word already has a
+ * suffix. */
+ if ((flags & WF_HAS_AFF) && (pidx & WF_PFX_NC))
+ continue;
+
/* Check the condition, if there is one. The condition index is
* stored in the two bytes above the prefix ID byte. */
rp = slang->sl_prefprog[((unsigned)pidx >> 8) & 0xffff];
{
lp->sl_name = vim_strsave(lang);
ga_init2(&lp->sl_rep, sizeof(fromto_T), 10);
- ga_init2(&lp->sl_sal, sizeof(salitem_T), 10);
}
return lp;
}
* SAL items
*/
gap = &lp->sl_sal;
+ ga_init2(gap, sizeof(salitem_T), 10);
if (ga_grow(gap, cnt) == FAIL)
goto endFAIL;
idxs[idx] = 0;
c = 0;
}
- else if (c == BY_FLAGS || c == BY_NOFLAGS)
+ else if (c != BY_INDEX)
{
if (prefixtree)
{
if (n >= maxprefcondnr)
return -2;
c2 += (n << 8);
- if (c == BY_NOFLAGS)
- c = c2;
- else
- c = c2 | WF_RAREPFX;
+
+ /* the byte value is misused to pass two flags: rare
+ * and non-combining. */
+ if (c == BY_FLAGS || c == BY_PFX_RNC)
+ c2 |= WF_RAREPFX;
+ if (c == BY_PFX_NC || c == BY_PFX_RNC)
+ c2 |= WF_PFX_NC;
+ c = c2;
}
- else
+ else /* c must be BY_FLAGS or BY_FLAGS2 */
{
/* Read flags and optional region and prefix ID. In
- * idxs[] the flags go in the low byte, region above that
- * and prefix ID above the region. */
+ * idxs[] the flags go in the low two bytes, region above
+ * that and prefix ID above the region. */
+ c2 = c;
c = getc(fd); /* <flags> */
+ if (c2 == BY_FLAGS2)
+ c = (getc(fd) << 8) + c; /* <flags2> */
if (c & WF_REGION)
- c = (getc(fd) << 8) + c; /* <region> */
+ c = (getc(fd) << 16) + c; /* <region> */
if (c & WF_PFX)
- c = (getc(fd) <<
16) + c; /* <prefixID> */
+ c = (getc(fd) <<
24) + c; /* <prefixID> */
}
idxs[idx] = c;
wordnode_T *wn_sibling; /* next sibling (alternate byte in word,
always sorted) */
char_u wn_byte; /* Byte for this node. NUL for word end */
- char_u wn_flags; /* when wn_byte is NUL: WF_ flags */
+ short_u wn_flags; /* when wn_byte is NUL: WF_ flags */
short wn_region; /* when wn_byte is NUL: region mask; for
PREFIXTREE it's the prefcondnr */
char_u wn_prefixID; /* supported/required prefix ID or 0 */
};
+#define WN_MASK 0xffff /* mask relevant bits of "wn_flags" */
+
#define HI2WN(hi) (wordnode_T *)((hi)->hi_key)
/*
static void mkspell __ARGS((int fcount, char_u **fnames, int ascii, int overwrite, int added_word));
static void init_spellfile __ARGS((void));
+/* values for wn_flags used in the postponed prefixes tree */
+#define PFX_FLAGS -1 /* not rare, combining */
+#define PFX_FLAGS_R -2 /* rare, combining */
+#define PFX_FLAGS_NC -3 /* not rare, not combining */
+#define PFX_FLAGS_RNC -4 /* rare, not combining */
+
/*
* Read the affix file "fname".
* Returns an afffile_T, NULL for complete failure.
{
int idx;
char_u **pp;
+ int n;
for (idx = spin->si_prefcond.ga_len - 1; idx >= 0;
--idx)
p = (char_u *)"";
else
p = aff_entry->ae_add;
- tree_add_word(p, spin->si_prefroot, rare ? -2 : -1,
+ if (rare)
+ {
+ if (cur_aff->ah_combine)
+ n = PFX_FLAGS_R;
+ else
+ n = PFX_FLAGS_RNC;
+ }
+ else
+ {
+ if (cur_aff->ah_combine)
+ n = PFX_FLAGS;
+ else
+ n = PFX_FLAGS_NC;
+ }
+ tree_add_word(p, spin->si_prefroot, n,
idx, cur_aff->ah_newID, &spin->si_blocks);
}
}
int i;
char_u *p;
int use_flags;
+ char_u *use_pfxlist;
todo = ht->ht_used;
for (hi = ht->ht_array; todo > 0 && retval == OK; ++hi)
use_flags = flags | WF_RARE;
else
use_flags = flags;
+ use_pfxlist = pfxlist;
+
+ /* When there are postponed prefixes... */
+ if (spin->si_prefroot != NULL)
+ {
+ /* ... add a flag to indicate an affix was used. */
+ use_flags |= WF_HAS_AFF;
+
+ /* ... don't use a prefix list if combining
+ * affixes is not allowed */
+ if (!ah->ah_combine || comb)
+ use_pfxlist = NULL;
+ }
/* Store the modified word. */
if (store_word(newword, spin, use_flags,
- spin->si_region, pfxlist) == FAIL)
+ 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,
- xht, NULL, TRUE, use_flags, pfxlist)
- == FAIL)
+ xht, NULL, TRUE,
+ use_flags, use_pfxlist) == FAIL)
retval = FAIL;
}
}
/*
* Store a word in the tree(s).
- * Always store it in the case-folded tree. A keep-case word can also be used
- * with all caps.
+ * Always store it in the case-folded tree. For a keep-case word this is
+ * useful when the word can also be used with all caps (no WF_FIXCAP flag) and
+ * used to find suggestions.
* For a keep-case word also store it in the keep-case tree.
- * When "pfxlist" is not NULL store the word for each prefix ID.
+ * When "pfxlist" is not NULL store the word for each postponed prefix ID.
*/
static int
store_word(word, spin, flags, region, pfxlist)
|| (node->wn_byte == NUL
&& (flags < 0
? node->wn_prefixID < prefixID
- : node->wn_flags < (flags & 0xff)
- || (node->wn_flags == (flags & 0xff)
+ : node->wn_flags < (flags & WN_MASK)
+ || (node->wn_flags == (flags & WN_MASK)
&& node->wn_prefixID < prefixID)))))
{
prev = &node->wn_sibling;
|| node->wn_byte != word[i]
|| (word[i] == NUL
&& (flags < 0
- || node->wn_flags != (flags & 0xff)
+ || node->wn_flags != (flags & WN_MASK)
|| node->wn_prefixID != prefixID)))
{
/* Allocate a new node. */
if (prefixtree)
{
/* In PREFIXTREE write the required prefixID and the
- * associated condition nr (stored in wn_region). */
- if (np->wn_flags == (char_u)-2)
- putc(BY_FLAGS, fd); /* <byte> rare */
+ * associated condition nr (stored in wn_region). The
+ * byte value is misused to store the "rare" and "not
+ * combining" flags */
+ if (np->wn_flags == (short_u)PFX_FLAGS_R)
+ putc(BY_FLAGS, fd); /* <byte> */
+ else if (np->wn_flags == (short_u)PFX_FLAGS_NC)
+ putc(BY_PFX_NC, fd);
+ else if (np->wn_flags == (short_u)PFX_FLAGS_RNC)
+ putc(BY_PFX_RNC, fd);
else
- putc(BY_NOFLAGS, fd); /* <byte> */
+ putc(BY_NOFLAGS, fd);
putc(np->wn_prefixID, fd); /* <prefixID> */
put_bytes(fd, (long_u)np->wn_region, 2); /* <prefcondnr> */
}
}
else
{
- putc(BY_FLAGS, fd); /* <byte> */
- putc(flags, fd); /* <flags> */
+ if (np->wn_flags >= 0x100)
+ {
+ putc(BY_FLAGS2, fd); /* <byte> */
+ putc(flags, fd); /* <flags> */
+ putc((unsigned)flags >> 8, fd); /* <flags2> */
+ }
+ else
+ {
+ putc(BY_FLAGS, fd); /* <byte> */
+ putc(flags, fd); /* <flags> */
+ }
if (flags & WF_REGION)
putc(np->wn_region, fd); /* <region> */
if (flags & WF_PFX)
* Called once while starting up and when 'encoding' changes.
* The default is to use isalpha(), but the spell file should define the word
* characters to make it possible that 'encoding' differs from the current
- * locale.
+ * locale. For utf-8 we don't use isalpha() but our own functions.
*/
void
init_spell_chartab()
}
}
- if (l > 1)
+ c = mb_ptr2char(s);
+ if (c > 255)
return mb_get_class(s) >= 2;
- return spelltab.st_isw[*s];
+ return spelltab.st_isw[c];
}
#endif
char_u *p;
{
#ifdef FEAT_MBYTE
- if (has_mbyte && MB_BYTE2LEN(*p) > 1)
- return mb_get_class(p) >= 2;
-#endif
+ int c;
+ if (has_mbyte)
+ {
+ c = mb_ptr2char(p);
+ if (c > 255)
+ return mb_get_class(p) >= 2;
+ return spelltab.st_isw[c];
+ }
+#endif
return spelltab.st_isw[*p];
}
else
s = p;
- if (mb_char2len(*s) > 1)
+ if (*s > 255)
{
if (enc_utf8)
return utf_class(*s) >= 2;
line = ml_get_curline();
p = line + curwin->w_cursor.col;
/* Backup to before start of word. */
- while (p > line && SPELL_ISWORDP(p))
+ while (p > line && spell_iswordp_nmw(p))
mb_ptr_back(line, p);
/* Forward to start of word. */
- while (*p != NUL && !SPELL_ISWORDP(p))
+ while (*p != NUL && !spell_iswordp_nmw(p))
mb_ptr_adv(p);
- if (!SPELL_ISWORDP(p)) /* No word found. */
+ if (!spell_iswordp_nmw(p)) /* No word found. */
{
beep_flush();
return;
for (;;)
{
mb_ptr_back(line, p);
- if (p == line || SPELL_ISWORDP(p))
+ if (p == line || spell_iswordp_nmw(p))
break;
if (vim_regexec(®match, p, 0)
&& regmatch.endp[0] == line + endcol)
idx_T *idxs, *fidxs, *pidxs;
int depth;
int c, c2, c3;
- int n = 0;
+ int n;
int flags;
garray_T *gap;
idx_T arridx;
;
sp->ts_curi += n;
+ /* Always past NUL bytes now. */
+ n = (int)sp->ts_state;
+ sp->ts_state = STATE_ENDNUL;
+
/* At end of a prefix or at start of prefixtree: check for
* following word. */
- if (byts[arridx] == 0 || sp->ts_state == STATE_NOPREFIX)
+ if (byts[arridx] == 0 || n == (int)STATE_NOPREFIX)
{
- sp->ts_state = STATE_START;
++depth;
stack[depth] = stack[depth - 1];
sp = &stack[depth];
* find_keepcap_word() works. */
prewordlen = splitoff = sp->ts_twordlen;
mch_memmove(preword, tword, splitoff);
- break;
}
-
- /* Always past NUL bytes now. */
- sp->ts_state = STATE_ENDNUL;
break;
}
;
if (c > 0)
{
- /* The prefix ID is stored two bytes above the flags. */
- c = valid_word_prefix(c, n, (unsigned)flags >> 16,
+ /* The prefix ID is stored three bytes above the
+ * flags. */
+ c = valid_word_prefix(c, n, flags,
tword + splitoff, lp->lp_slang);
if (c == 0)
break;
newscore = 0;
if ((flags & WF_REGION)
- && (((unsigned)flags >> 8) & lp->lp_region) == 0)
+ && (((unsigned)flags >> 16) & lp->lp_region) == 0)
newscore += SCORE_REGION;
if (flags & WF_RARE)
newscore += SCORE_RARE;
if ((round == 2 || (flags & WF_KEEPCAP) == 0)
&& (do_region
|| (flags & WF_REGION) == 0
- || (((unsigned)flags >> 8)
+ || (((unsigned)flags >> 16)
& lp->lp_region) != 0))
{
word[depth] = NUL;
/* Dump the basic word if there is no prefix or
* when it's the first one. */
- c = (unsigned)flags >> 16;
+ c = (unsigned)flags >> 24;
if (c == 0 || curi[depth] == 2)
dump_word(word, round, flags, lnum++);
STRCAT(badword, "?");
if (flags & WF_REGION)
for (i = 0; i < 7; ++i)
- if (flags & (0x100 << i))
+ if (flags & (0x10000 << i))
sprintf((char *)badword + STRLEN(badword), "%d", i + 1);
p = badword;
}
int depth;
int n;
int len;
- int prefid = (unsigned)flags >> 16;
int i;
byts = slang->sl_pbyts;
{
/*
* Loop over all prefixes, building them byte-by-byte in prefix[].
- * When at the end of a prefix check that it supports "prefid".
+ * When at the end of a prefix check that it supports "flags".
*/
depth = 0;
arridx[0] = 0;
curi[0] = 1;
while (depth >= 0 && !got_int)
{
- len = arridx[depth];
- if (curi[depth] > byts[len])
+ n = arridx[depth];
+ len = byts[n];
+ if (curi[depth] > len)
{
/* Done all bytes at this node, go up one level. */
--depth;
else
{
/* Do one more byte at this node. */
- n = len + curi[depth];
+ n += curi[depth];
++curi[depth];
c = byts[n];
if (c == 0)
break;
curi[depth] += i - 1;
- i = valid_word_prefix(i, n, prefid, word, slang);
+ i = valid_word_prefix(i, n, flags, word, slang);
if (i != 0)
{
vim_strncpy(prefix + depth, word, MAXWLEN - depth - 1);
projects / vim / commitdiff