diff options
Diffstat (limited to 'src/spell.c')
| -rw-r--r-- | src/spell.c | 4025 |
1 files changed, 3862 insertions, 163 deletions
diff --git a/src/spell.c b/src/spell.c index 30a02ab41..e3a97fc83 100644 --- a/src/spell.c +++ b/src/spell.c @@ -16,6 +16,11 @@ * "word" is either a "dword" or an "nword". */ +/* + * Why doesn't Vim use aspell/ispell/myspell/etc.? + * See ":help develop-spell". + */ + #if defined(MSDOS) || defined(WIN16) || defined(WIN32) || defined(_WIN64) # include <io.h> /* for lseek(), must be before vim.h */ #endif @@ -32,8 +37,3860 @@ /* * Structure that is used to store the text from the language file. This - * avoids the need to allocate each individual word and copying it. It's - * allocated in big chunks for speed. + * avoids the need to allocate space for each individual word. It's allocated + * in big chunks for speed. + */ +#define SBLOCKSIZE 4096 /* default size of sb_data */ +typedef struct sblock_S sblock_T; +struct sblock_S +{ + sblock_T *sb_next; /* next block in list */ + char_u sb_data[1]; /* data, actually longer */ +}; + +/* Info from "REP" entries in ".aff" file used in af_rep. */ +typedef struct repentry_S +{ + char_u *re_from; + char_u *re_to; +} repentry_T; + +/* + * Structure to store affix info. + */ +typedef struct affitem_S affitem_T; +struct affitem_S +{ + affitem_T *ai_next; /* next affix with same ai_add[] or NULL */ + short_u ai_nr; /* affix number */ + char_u ai_combine; /* prefix combines with suffix */ + char_u ai_choplen; /* length of ai_chop in bytes */ + char_u ai_addlen; /* length of ai_add in bytes */ + char_u *ai_chop; /* text chopped off basic word (can be NULL) */ + char_u ai_add[1]; /* text added to basic word (actually longer) */ +}; + +/* Get affitem_T pointer from hashitem that uses ai_add */ +static affitem_T dumai; +#define HI2AI(hi) ((affitem_T *)((hi)->hi_key - (dumai.ai_add - (char_u *)&dumai))) + +/* + * Structure used to store words and other info for one language. + */ +typedef struct slang_S slang_T; +struct slang_S +{ + slang_T *sl_next; /* next language */ + char_u *sl_name; /* language name "en", "en.rare", "nl", etc. */ + hashtab_T sl_words; /* main word table, fword_T */ + int sl_prefcnt; /* number of prefix NRs */ + garray_T sl_preftab; /* list of hashtables to lookup prefixes */ + affitem_T *sl_prefzero; /* list of prefixes with zero add length */ + int sl_suffcnt; /* number of suffix NRs */ + garray_T sl_sufftab; /* list of hashtables to lookup suffixes */ + affitem_T *sl_suffzero; /* list of suffixes with zero add length */ + char_u *sl_try; /* "TRY" from .aff file */ + garray_T sl_rep; /* list of repentry_T entries from REP lines */ + char_u sl_regions[17]; /* table with up to 8 region names plus NUL */ + sblock_T *sl_block; /* list with allocated memory blocks */ + int sl_error; /* error while loading */ +}; + +static slang_T *first_lang = NULL; + +/* + * Structure to store an addition to a basic word. + */ +typedef struct addword_S addword_T; +struct addword_S +{ + addword_T *aw_next; /* next addition */ + char_u aw_flags; /* ADD_ flags */ + char_u aw_leadlen; /* length of lead in bytes */ + char_u aw_wordlen; /* length of aw_word in bytes */ + char_u aw_region; /* region for word with this addition */ + char_u aw_word[1]; /* text, actually longer: case-folded addition + plus, with ADD_KEEPCAP: keep-case addition */ +}; + +/* + * Structure to store a basic word. + */ +typedef struct fword_S fword_T; +struct fword_S +{ + fword_T *fw_next; /* same basic word with different caps */ + char_u fw_region; /* region bits */ + char_u fw_prefixcnt; /* number of prefix numbers */ + char_u fw_suffixcnt; /* number of suffix numbers */ + short_u fw_flags; /* BWF_ flags */ + void *fw_prefix; /* table with prefix numbers */ + void *fw_suffix; /* table with suffix numbers */ + addword_T *fw_adds; /* first addword_T entry */ + char_u fw_word[1]; /* actually longer: case folded word, or + keep-case word when (flags & BWF_KEEPCAP) */ +}; + +/* Get fword_T pointer from hashitem that uses fw_word */ +static fword_T dumfw; +#define HI2FWORD(hi) ((fword_T *)((hi)->hi_key - (dumfw.fw_word - (char_u *)&dumfw))) + +#define REGION_ALL 0xff + + +/* + * Structure used in "b_langp", filled from 'spelllang'. + */ +typedef struct langp_S +{ + slang_T *lp_slang; /* info for this language (NULL for last one) */ + int lp_region; /* bitmask for region or REGION_ALL */ +} langp_T; + +#define LANGP_ENTRY(ga, i) (((langp_T *)(ga).ga_data) + (i)) + +#define SP_OK 0 +#define SP_BAD 1 +#define SP_RARE 2 +#define SP_LOCAL 3 + +/* flags used for basic words in the spell file */ +#define BWF_VALID 0x01 /* word is valid without additions */ +#define BWF_REGION 0x02 /* region byte follows */ +#define BWF_ONECAP 0x04 /* first letter must be capital */ +#define BWF_SUFFIX 0x08 /* has suffix NR list */ +#define BWF_SECOND 0x10 /* second flags byte follows */ + +#define BWF_ADDS 0x0100 /* there are additions */ +#define BWF_PREFIX 0x0200 /* has prefix NR list */ +#define BWF_ALLCAP 0x0400 /* all letters must be capital (not used + for single-letter words) */ +#define BWF_KEEPCAP 0x0800 /* Keep case as-is */ + +/* flags used for addition in the spell file */ +#define ADD_REGION 0x02 /* region byte follows */ +#define ADD_ONECAP 0x04 /* first letter must be capital */ +#define ADD_ALLCAP 0x40 /* all letters must be capital (not used + for single-letter words) */ +#define ADD_KEEPCAP 0x80 /* fixed case */ + +/* Translate ADD_ flags to BWF_ flags. + * (Needed to keep ADD_ flags in one byte.) */ +#define ADD2BWF(x) (((x) & 0x0f) | (((x) & 0xf0) << 4)) + +#define VIMSPELLMAGIC "VIMspell01" /* string at start of Vim spell file */ +#define VIMSPELLMAGICL 10 + +/* + * Structure to store info for word matching. + */ +typedef struct matchinf_S +{ + langp_T *mi_lp; /* info for language and region */ + slang_T *mi_slang; /* info for the language */ + char_u *mi_line; /* start of line containing word */ + char_u *mi_word; /* start of word being checked */ + char_u *mi_end; /* first non-word char after mi_word */ + char_u *mi_wend; /* end of matching word (is "mi_end" + * or further) */ + char_u *mi_cword; /* word to check, can be "mi_fword" */ + char_u mi_fword[MAXWLEN + 1]; /* "mi_word" to "mi_end" case-folded */ + int mi_faddlen; /* length of valid bytes in "mi_fadd" */ + char_u *mi_faddp; /* next char to be added to "mi_fadd" */ + char_u mi_fadd[MAXWLEN + 1]; /* "mi_end" and further case-folded */ + int mi_result; /* result so far: SP_BAD, SP_OK, etc. */ + int mi_capflags; /* BWF_ONECAP BWF_ALLCAP BWF_KEEPCAP */ +} matchinf_T; + +static int word_match __ARGS((matchinf_T *mip)); +static int check_adds __ARGS((matchinf_T *mip, fword_T *fw, int req_pref, int req_suf)); +static int supports_afffix __ARGS((int cnt, void *afffix, int afffixcnt, int nr)); +static int prefix_match __ARGS((matchinf_T *mip)); +static int suffix_match __ARGS((matchinf_T *mip)); +static int match_caps __ARGS((int flags, char_u *caseword, matchinf_T *mip, char_u *cword, char_u *end)); +static slang_T *slang_alloc __ARGS((char_u *lang)); +static void slang_free __ARGS((slang_T *lp)); +static slang_T *spell_load_lang __ARGS((char_u *lang)); +static void spell_load_file __ARGS((char_u *fname, void *cookie)); +static int spell_load_affixes __ARGS((FILE *fd, slang_T *lp, int *bl_usedp, int affm, void **affp)); +static void *getroom __ARGS((slang_T *lp, int *bl_used, int len)); +static int find_region __ARGS((char_u *rp, char_u *region)); +static int captype __ARGS((char_u *word, char_u *end)); + +/* + * Main spell-checking function. + * "ptr" points to the start of a word. + * "*attrp" is set to the attributes for a badly spelled word. For a non-word + * or when it's OK it remains unchanged. + * This must only be called when 'spelllang' is not empty. + * Returns the length of the word in bytes, also when it's OK, so that the + * caller can skip over the word. + */ + int +spell_check(wp, line, ptr, attrp) + win_T *wp; /* current window */ + char_u *line; /* start of line where "ptr" points into */ + char_u *ptr; + int *attrp; +{ + matchinf_T mi; /* Most things are put in "mi" so that it can + be passed to functions quickly. */ + + /* Find the end of the word. We already know that *ptr is a word char. */ + mi.mi_word = ptr; + mi.mi_end = ptr; + do + { + mb_ptr_adv(mi.mi_end); + } while (*mi.mi_end != NUL && spell_iswordc(mi.mi_end)); + + /* A word starting with a number is always OK. */ + if (*ptr >= '0' && *ptr <= '9') + return (int)(mi.mi_end - ptr); + + /* Make case-folded copy of the Word. Compute its hash value. */ + (void)str_foldcase(ptr, mi.mi_end - ptr, mi.mi_fword, MAXWLEN + 1); + mi.mi_cword = mi.mi_fword; + + /* The word is bad unless we find it in the dictionary. */ + mi.mi_result = SP_BAD; + mi.mi_wend = mi.mi_end; + mi.mi_faddp = mi.mi_end; + mi.mi_faddlen = 0; + mi.mi_capflags = captype(ptr, mi.mi_end); + mi.mi_line = line; + + /* + * Loop over the languages specified in 'spelllang'. + * We check them all, because a matching word may have additions that are + * longer than an already found matching word. + */ + for (mi.mi_lp = LANGP_ENTRY(wp->w_buffer->b_langp, 0); + mi.mi_lp->lp_slang != NULL; ++mi.mi_lp) + { + /* + * Check for a matching word. + * If not found or wrong region try removing prefixes (and then + * suffixes). + * If still not found or wrong region try removing suffixes. + */ + mi.mi_slang = mi.mi_lp->lp_slang; + if (!word_match(&mi) || mi.mi_result != SP_OK) + if (!prefix_match(&mi) || mi.mi_result != SP_OK) + suffix_match(&mi); + } + + if (mi.mi_result != SP_OK) + { + if (mi.mi_result == SP_BAD) + *attrp = highlight_attr[HLF_SPB]; + else if (mi.mi_result == SP_RARE) + *attrp = highlight_attr[HLF_SPR]; + else + *attrp = highlight_attr[HLF_SPL]; + } + + return (int)(mi.mi_wend - ptr); +} + +/* + * Check if the word "mip->mi_cword" matches. + */ + static int +word_match(mip) + matchinf_T *mip; +{ + hash_T fhash = hash_hash(mip->mi_cword); + hashitem_T *hi; + fword_T *fw; + int valid = FALSE; + + hi = hash_lookup(&mip->mi_slang->sl_words, mip->mi_cword, fhash); + if (HASHITEM_EMPTY(hi)) + return FALSE; + + /* + * Find a basic word for which the case of word "cword" is correct. + * If it is, check additions and use the longest one. + */ + for (fw = HI2FWORD(hi); fw != NULL; fw = fw->fw_next) + if (match_caps(fw->fw_flags, fw->fw_word, mip, + mip->mi_word, mip->mi_end)) + valid |= check_adds(mip, fw, -1, -1); + + return valid; +} + +/* + * Check a matching basic word for additions. + * Return TRUE if we have a valid match. + */ + static int +check_adds(mip, fw, req_pref, req_suf) + matchinf_T *mip; + fword_T *fw; + int req_pref; /* required prefix nr, -1 if none */ + int req_suf; /* required suffix nr, -1 if none */ +{ + int valid = FALSE; + addword_T *aw; + char_u *p; + int addlen; + int fl; + + /* A word may be valid without additions. */ + if ((fw->fw_flags & BWF_VALID) + && (req_pref < 0 || supports_afffix(mip->mi_slang->sl_prefcnt, + fw->fw_prefix, fw->fw_prefixcnt, req_pref)) + && (req_suf < 0 || supports_afffix(mip->mi_slang->sl_suffcnt, + fw->fw_suffix, fw->fw_suffixcnt, req_suf))) + { + valid = TRUE; + if (mip->mi_result != SP_OK) + { + if ((fw->fw_region & mip->mi_lp->lp_region) == 0) + mip->mi_result = SP_LOCAL; + else + mip->mi_result = SP_OK; + } + } + + /* + * Check additions, both before and after the word. + * This may make the word longer, thus we also need to check + * when we already found a matching word. + */ + for (aw = fw->fw_adds; aw != NULL; aw = aw->aw_next) + { + if (aw->aw_leadlen > 0) + { + /* There is a leader, verify that it matches. */ + if (aw->aw_leadlen > mip->mi_word - mip->mi_line + || STRNCMP(mip->mi_word - aw->aw_leadlen, + aw->aw_word, aw->aw_leadlen) != 0) + continue; + if (mip->mi_word - aw->aw_leadlen > mip->mi_line) + { + /* There must not be a word character just before the + * leader. */ + p = mip->mi_word - aw->aw_leadlen; + mb_ptr_back(mip->mi_line, p); + if (spell_iswordc(p)) + continue; + } + /* Leader matches. Addition is rest of "aw_word". */ + p = aw->aw_word + aw->aw_leadlen; + } + else + /* No leader, use whole of "aw_word" for addition. */ + p = aw->aw_word; + + addlen = aw->aw_wordlen - aw->aw_leadlen; + if (addlen > 0) + { + /* Check for matching addition and no word character after it. + * First make sure we have enough case-folded chars to compare + * with. */ + while (mip->mi_faddlen <= addlen) + { + if (*mip->mi_faddp == NUL) + { + mip->mi_fadd[mip->mi_faddlen] = NUL; + break; + } +#ifdef FEAT_MBYTE + fl = (*mb_ptr2len_check)(mip->mi_faddp); +#else + fl = 1; +#endif + (void)str_foldcase(mip->mi_faddp, fl, + mip->mi_fadd + mip->mi_faddlen, + MAXWLEN - mip->mi_faddlen); + mip->mi_faddp += fl; + mip->mi_faddlen += STRLEN(mip->mi_fadd + mip->mi_faddlen); + } + + if (STRNCMP(mip->mi_fadd, p, addlen) != 0 + || (mip->mi_fadd[addlen] != NUL + && spell_iswordc(mip->mi_fadd + addlen))) + continue; + + /* Compute the length in the original word, before case folding. */ +#ifdef FEAT_MBYTE + if (has_mbyte) + { + int l; + + p = mip->mi_end; + for (l = 0; l < addlen; + l += (*mb_ptr2len_check)(mip->mi_fadd + l)) + mb_ptr_adv(p); + addlen = p - mip->mi_end; + } +#endif + + /* Check case of the addition. */ + if (!match_caps(ADD2BWF(aw->aw_flags), + aw->aw_word + aw->aw_wordlen + 1, mip, + mip->mi_end, mip->mi_end + addlen)) + continue; + } + + /* Match! Use the new length if it's longer. */ + if (mip->mi_wend < mip->mi_end + addlen) + mip->mi_wend = mip->mi_end + addlen; + + valid = TRUE; + if (mip->mi_result != SP_OK) + { + if ((aw->aw_region & mip->mi_lp->lp_region) == 0) + mip->mi_result = SP_LOCAL; + else + mip->mi_result = SP_OK; + } + } + + return valid; +} + +/* + * Return TRUE if word "fw" supports afffix "nr". + */ + static int +supports_afffix(cnt, afffix, afffixcnt, nr) + int cnt; + void *afffix; + int afffixcnt; + int nr; +{ + char_u *pc; + short_u *ps; + int i; + + if (cnt <= 256) + { + /* char_u affix numbers */ + pc = afffix; + for (i = afffixcnt; --i >= 0; ) + if (*pc++ == nr) + return TRUE; + } + else + { + /* short_u affix numbers */ + ps = afffix; + for (i = afffixcnt; --i >= 0; ) + if (*ps++ == nr) + return TRUE; + } + return FALSE; +} + +/* + * Try finding a match for "mip->mi_cword" by removing prefixes. + */ + static int +prefix_match(mip) + matchinf_T *mip; +{ + int len = 0; + int charlen = 0; + int cc; + affitem_T *ai; + char_u pword[MAXWLEN + 1]; + fword_T *fw; + hashtab_T *ht; + hashitem_T *hi; + int i; + int found_valid = FALSE; + int cstart_charlen = 0; + char_u *cstart = mip->mi_word; + int capflags_save = mip->mi_capflags; + char_u *p; + + /* + * Check for prefixes with different character lengths. + * Start with zero length (only chop off). + */ + for (charlen = 0; charlen <= mip->mi_slang->sl_preftab.ga_len; ++charlen) + { + if (charlen > 0) + { +#ifdef FEAT_MBYTE + if (has_mbyte) + len += mb_ptr2len_check(mip->mi_cword + len); + else +#endif + len += 1; + } + if (mip->mi_cword[len] == NUL) /* end of word, no prefix possible */ + break; + + if (charlen == 0) + ai = mip->mi_slang->sl_prefzero; + else + { + /* Get pointer to hashtab for prefix of this many chars. */ + ht = ((hashtab_T *)mip->mi_slang->sl_preftab.ga_data) + charlen - 1; + if (ht->ht_used == 0) + continue; + + cc = mip->mi_cword[len]; + mip->mi_cword[len] = NUL; + hi = hash_find(ht, mip->mi_cword); + mip->mi_cword[len] = cc; + + if (HASHITEM_EMPTY(hi)) + ai = NULL; + else + ai = HI2AI(hi); + } + + /* Loop over all matching prefixes. */ + for ( ; ai != NULL; ai = ai->ai_next) + { + /* Create the basic word by removing the prefix and adding the + * chop string. */ + mch_memmove(pword, ai->ai_chop, ai->ai_choplen); + STRCPY(pword + ai->ai_choplen, mip->mi_cword + ai->ai_addlen); + + /* Adjust the word start for case checks, we only check the + * part after the prefix. */ + while (cstart_charlen < charlen) + { + mb_ptr_adv(cstart); + ++cstart_charlen; + } + + /* Removing the prefix may change the caps, e.g. for + * "deAlf" removing "de" makes it ONECAP. */ + mip->mi_capflags = captype(cstart, mip->mi_end); + + /* Find the basic word. */ + hi = hash_find(&mip->mi_slang->sl_words, pword); + if (!HASHITEM_EMPTY(hi)) + { + /* Check if the word supports this prefix. */ + for (fw = HI2FWORD(hi); fw != NULL; fw = fw->fw_next) + if (match_caps(fw->fw_flags, fw->fw_word, mip, + cstart, mip->mi_end)) + found_valid |= check_adds(mip, fw, ai->ai_nr, -1); + + if (found_valid && mip->mi_result == SP_OK) + { + /* Found a valid word, no need to try other suffixes. */ + mip->mi_capflags = capflags_save; + return TRUE; + } + } + + /* No matching basic word without prefix. When combining is + * allowed try with suffixes. */ + if (ai->ai_combine) + { + /* Pass the word with prefix removed to suffix_match(). */ + mip->mi_cword = pword; + p = mip->mi_word; + mip->mi_word = cstart; + i = suffix_match(mip); + mip->mi_cword = mip->mi_fword; + mip->mi_word = p; + if (i) + { + mip->mi_capflags = capflags_save; + return TRUE; + } + } + } + } + + mip->mi_capflags = capflags_save; + return FALSE; +} + +/* + * Try finding a match for "mip->mi_cword" by removing suffixes. + */ + static int +suffix_match(mip) + matchinf_T *mip; +{ + char_u *sufp; + int charlen; + affitem_T *ai; + char_u pword[MAXWLEN + 1]; + fword_T *fw; + hashtab_T *ht; + hashitem_T *hi; + int tlen; + int cend_charlen = 0; + char_u *cend = mip->mi_end; + int found_valid = FALSE; + int capflags_save = mip->mi_capflags; + + /* + * Try suffixes of different length, starting with an empty suffix (chop + * only, thus adds something). + * Stop checking if there are no suffixes with so many characters. + */ + sufp = mip->mi_cword + STRLEN(mip->mi_cword); + for (charlen = 0; charlen <= mip->mi_slang->sl_sufftab.ga_len; ++charlen) + { + /* Move the pointer to the possible suffix back one character, unless + * doing the first round (empty suffix). */ + if (charlen > 0) + { + mb_ptr_back(mip->mi_cword, sufp); + if (sufp <= mip->mi_cword) /* start of word, no suffix possible */ + break; + } + + if (charlen == 0) + ai = mip->mi_slang->sl_suffzero; + else + { + /* Get pointer to hashtab for suffix of this many chars. */ + ht = ((hashtab_T *)mip->mi_slang->sl_sufftab.ga_data) + charlen - 1; + if (ht->ht_used == 0) + continue; + + hi = hash_find(ht, sufp); + if (HASHITEM_EMPTY(hi)) + ai = NULL; + else + ai = HI2AI(hi); + } + + if (ai != NULL) + { + /* Found a list of matching suffixes. Now check that there is one + * we can use. */ + tlen = sufp - mip->mi_cword; /* length of word without suffix */ + mch_memmove(pword, mip->mi_cword, tlen); + + for ( ; ai != NULL; ai = ai->ai_next) + { + /* Found a matching suffix. Create the basic word by removing + * the suffix and adding the chop string. */ + if (ai->ai_choplen == 0) + pword[tlen] = NUL; + else + mch_memmove(pword + tlen, ai->ai_chop, ai->ai_choplen + 1); + + /* Find the basic word. */ + hi = hash_find(&mip->mi_slang->sl_words, pword); + if (!HASHITEM_EMPTY(hi)) + { + /* Adjust the end for case checks, we only check the part + * before the suffix. */ + while (cend_charlen < charlen) + { + mb_ptr_back(mip->mi_word, cend); + ++cend_charlen; + } + + /* Removing the suffix may change the caps, e.g. for + * "UFOs" removing 's' makes it ALLCAP. */ + mip->mi_capflags = captype(mip->mi_word, cend); + + /* Check if the word supports this suffix. */ + for (fw = HI2FWORD(hi); fw != NULL; fw = fw->fw_next) + if (match_caps(fw->fw_flags, fw->fw_word, mip, + mip->mi_word, cend)) + found_valid |= check_adds(mip, fw, -1, ai->ai_nr); + + if (found_valid && mip->mi_result == SP_OK) + { + /* Found a valid word, no need to try other suffixes. */ + mip->mi_capflags = capflags_save; + return TRUE; + } + } + } + } + } + + mip->mi_capflags = capflags_save; + return FALSE; +} + +/* + * Return TRUE if case of "cword" meets the requirements of case flags + * "flags". + */ + static int +match_caps(flags, caseword, mip, cword, end) + int flags; /* flags required by basic word or addition */ + char_u *caseword; /* word with case as required */ + matchinf_T *mip; + char_u *cword; /* word to compare against "caseword" */ + char_u *end; /* end of "cword" */ +{ + char_u *p; + int c; + int len; + int capflags = mip->mi_capflags; /* flags of checked word */ + int past_second; + + if ((capflags & BWF_KEEPCAP) == 0 && end > mip->mi_end) + { + /* If "end" is past "mip->mi_end" we need to check the characters + * after the basic word. */ +#ifdef FEAT_MBYTE + past_second = (mip->mi_word + (*mb_ptr2len_check)(mip->mi_word) + < mip->mi_end); +#else + past_second = mip->mi_word + 1 < mip->mi_end; +#endif + for (p = mip->mi_end; p < end; ) + { + if (!spell_iswordc(p)) + mb_ptr_adv(p); + else + { +#ifdef FEAT_MBYTE + if (has_mbyte) + c = mb_ptr2char_adv(&p); + else +#endif + c = *p++; + if (MB_ISUPPER(c)) + { + if (capflags == 0 || (capflags & BWF_ONECAP)) + { + capflags = BWF_KEEPCAP; /* lU or UlU */ + break; + } + } + else + { + if (capflags & BWF_ALLCAP) + { + if (past_second) + { + capflags = BWF_KEEPCAP; /* UUl */ + break; + } + capflags = BWF_ONECAP; /* Uu */ + } + } + past_second = TRUE; + } + } + } + + if (capflags == BWF_ALLCAP) + return TRUE; /* All caps is always OK. */ + + if (flags & BWF_KEEPCAP) + { + len = STRLEN(caseword); + return (len == end - cword && STRNCMP(caseword, cword, len) == 0); + } + + if (flags & BWF_ALLCAP) + return FALSE; /* need ALLCAP, already checked above */ + + if (flags & BWF_ONECAP) + return capflags == BWF_ONECAP; + + return capflags != BWF_KEEPCAP; /* no case check, only KEEPCAP is bad */ +} + +/* + * Move to next spell error. + * Return OK if found, FAIL otherwise. + */ + int +spell_move_to(dir, allwords) + int dir; /* FORWARD or BACKWARD */ + int allwords; /* TRUE for "[s" and "]s" */ +{ + pos_T pos; + char_u *line; + char_u *p; + int wc; + int nwc; + int attr = 0; + int len; + + if (!curwin->w_p_spell || *curwin->w_buffer->b_p_spl == NUL) + { + EMSG(_("E756: Spell checking not enabled")); + return FAIL; + } + + /* TODO: moving backwards */ + + /* Start looking for bad word at the start of the line, because we can't + * start halfway a word and know where it ends. */ + pos = curwin->w_cursor; + pos.col = 0; + wc = FALSE; + + while (!got_int) + { + line = ml_get(pos.lnum); + p = line + pos.col; + while (*p != NUL) + { + nwc = spell_iswordc(p); + if (!wc && nwc) + { + /* start of word */ + /* TODO: check for bad word attr */ + len = spell_check(curwin, line, p, &attr); + if (attr != 0) + { + if (curwin->w_cursor.lnum < pos.lnum + || (curwin->w_cursor.lnum == pos.lnum + && curwin->w_cursor.col < (colnr_T)(p - line))) + { + curwin->w_cursor.lnum = pos.lnum; + curwin->w_cursor.col = p - line; + return OK; + } + attr = 0; /* bad word is before or at cursor */ + } + p += len; + if (*p == NUL) + break; + nwc = FALSE; + } + + /* advance to next character */ + mb_ptr_adv(p); + wc = nwc; + } + + /* Advance to next line. */ + if (pos.lnum == curbuf->b_ml.ml_line_count) + return FAIL; + ++pos.lnum; + pos.col = 0; + wc = FALSE; + + line_breakcheck(); + } + + return FAIL; /* interrupted */ +} + +/* + * Load word list for "lang" from a Vim spell file. + * "lang" must be the language without the region: "en" or "en-rare". + */ + static slang_T * +spell_load_lang(lang) + char_u *lang; +{ + slang_T *lp; + char_u fname_enc[80]; + char_u *p; + int r; + + lp = slang_alloc(lang); + if (lp != NULL) + { + /* Find all spell files for "lang" in 'runtimepath' and load them. + * Use 'encoding', except that we use "latin1" for "latin9". */ +#ifdef FEAT_MBYTE + if (STRLEN(p_enc) < 60 && STRCMP(p_enc, "iso-8859-15") != 0) + p = p_enc; + else +#endif + p = (char_u *)"latin1"; + sprintf((char *)fname_enc, "spell/%s.%s.spl", lang, p); + + r = do_in_runtimepath(fname_enc, TRUE, spell_load_file, lp); + if (r == FAIL || lp->sl_error) + { + slang_free(lp); + lp = NULL; + if (r == FAIL) + smsg((char_u *)_("Warning: Cannot find word list \"%s\""), + fname_enc + 6); + } + else + { + lp->sl_next = first_lang; + first_lang = lp; + } + } + + return lp; +} + +/* + * Allocate a new slang_T. + * Caller must fill "sl_next". + */ + static slang_T * +slang_alloc(lang) + char_u *lang; +{ + slang_T *lp; + + lp = (slang_T *)alloc(sizeof(slang_T)); + if (lp != NULL) + { + lp->sl_name = vim_strsave(lang); + hash_init(&lp->sl_words); + ga_init2(&lp->sl_preftab, sizeof(hashtab_T), 4); + ga_init2(&lp->sl_sufftab, sizeof(hashtab_T), 4); + lp->sl_prefzero = NULL; + lp->sl_suffzero = NULL; + lp->sl_try = NULL; + ga_init2(&lp->sl_rep, sizeof(repentry_T), 4); + lp->sl_regions[0] = NUL; + lp->sl_block = NULL; + lp->sl_error = FALSE; + } + return lp; +} + +/* + * Free the contents of an slang_T and the structure itself. + */ + static void +slang_free(lp) + slang_T *lp; +{ + sblock_T *sp; + int i; + + vim_free(lp->sl_name); + hash_clear(&lp->sl_words); + for (i = 0; i < lp->sl_preftab.ga_len; ++i) + hash_clear(((hashtab_T *)lp->sl_preftab.ga_data) + i); + ga_clear(&lp->sl_preftab); + for (i = 0; i < lp->sl_sufftab.ga_len; ++i) + hash_clear(((hashtab_T *)lp->sl_sufftab.ga_data) + i); + ga_clear(&lp->sl_sufftab); + ga_clear(&lp->sl_rep); + vim_free(lp->sl_try); + while (lp->sl_block != NULL) + { + sp = lp->sl_block; + lp->sl_block = sp->sb_next; + vim_free(sp); + } + vim_free(lp); +} + +/* + * Load one spell file into an slang_T. + * Invoked through do_in_runtimepath(). + */ + static void +spell_load_file(fname, cookie) + char_u *fname; + void *cookie; /* points to the slang_T to be filled */ +{ + slang_T *lp = cookie; + FILE *fd; + char_u buf[MAXWLEN + 1]; + char_u cbuf[MAXWLEN + 1]; + char_u fbuf[MAXWLEN + 1]; + char_u *p; + int itm; + int i; + int affcount; + int affnr; + int affflags; + int affitemcnt; + int bl_used = SBLOCKSIZE; + int widx; + int prefm; /* 1 if <= 256 prefixes, sizeof(short_u) otherw. */ + int suffm; /* 1 if <= 256 suffixes, sizeof(short_u) otherw. */ + int wlen; + int flags; + affitem_T *ai, *ai2, **aip; + int round; + char_u *save_sourcing_name = sourcing_name; + linenr_T save_sourcing_lnum = sourcing_lnum; + int cnt; + int choplen; + int addlen; + int leadlen; + int wordcount; + fword_T *fw, *fw2; + garray_T *gap; + hashtab_T *ht; + hashitem_T *hi; + hash_T hash; + int adds; + addword_T *aw; + int flen; + + fd = fopen((char *)fname, "r"); + if (fd == NULL) + { + EMSG2(_(e_notopen), fname); + goto errorend; + } + + /* Set sourcing_name, so that error messages mention the file name. */ + sourcing_name = fname; + sourcing_lnum = 0; + + /* <HEADER>: <fileID> <regioncnt> <regionname> ... */ + for (i = 0; i < VIMSPELLMAGICL; ++i) + buf[i] = getc(fd); /* <fileID> */ + if (STRNCMP(buf, VIMSPELLMAGIC, VIMSPELLMAGICL) != 0) + { + EMSG(_("E757: Wrong file ID in spell file")); + goto errorend; + } + + cnt = getc(fd); /* <regioncnt> */ + if (cnt == EOF) + { +truncerr: + EMSG(_("E758: Truncated spell file")); + goto errorend; + } + if (cnt > 8) + { +formerr: + EMSG(_("E759: Format error in spell file")); + goto errorend; + } + for (i = 0; i < cnt; ++i) + { + lp->sl_regions[i * 2] = getc(fd); /* <regionname> */ + lp->sl_regions[i * 2 + 1] = getc(fd); + } + lp->sl_regions[cnt * 2] = NUL; + + /* round 1: <PREFIXLIST>: <affcount> <afftotcnt> <affix> ... + * round 2: <SUFFIXLIST>: <affcount> <afftotcnt> <affix> ... */ + for (round = 1; round <= 2; ++round) + { + affcount = (getc(fd) << 8) + getc(fd); /* <affcount> */ + if (affcount < 0) + goto truncerr; + if (round == 1) + { + gap = &lp->sl_preftab; + aip = &lp->sl_prefzero; + lp->sl_prefcnt = affcount; + prefm = affcount > 256 ? sizeof(short_u) : 1; + } + else + { + gap = &lp->sl_sufftab; + aip = &lp->sl_suffzero; + lp->sl_suffcnt = affcount; + suffm = affcount > 256 ? sizeof(short_u) : 1; + } + + i = (getc(fd) << 8) + getc(fd); /* <afftotcnt> */ + /* afftotcnt is not used */ + + /* + * For each affix NR there can be several affixes. + */ + for (affnr = 0; affnr < affcount; ++affnr) + { + /* <affix>: <affflags> <affitemcnt> <affitem> ... */ + affflags = getc(fd); /* <affflags> */ + if (affflags == EOF) + goto truncerr; + affitemcnt = (getc(fd) << 8) + getc(fd); /* <affitemcnt> */ + if (affitemcnt < 0) + goto truncerr; + for (itm = 0; itm < affitemcnt; ++itm) + { + /* <affitem>: <affchoplen> <affchop> <affaddlen> <affadd> */ + choplen = getc(fd); /* <affchoplen> */ + if (choplen == EOF) + goto truncerr; + if (choplen >= MAXWLEN) + goto formerr; + for (i = 0; i < choplen; ++i) /* <affchop> */ + buf[i] = getc(fd); + buf[i] = NUL; + addlen = getc(fd); /* <affaddlen> */ + if (addlen == EOF) + goto truncerr; + /* Get room to store the affitem_T, chop and add strings. */ + p = (char_u *)getroom(lp, &bl_used, + sizeof(affitem_T) + choplen + addlen + 1); + if (p == NULL) + goto errorend; + + ai = (affitem_T *)p; + ai->ai_nr = affnr; + ai->ai_combine = affflags; + ai->ai_choplen = choplen; + ai->ai_addlen = addlen; + + p += sizeof(affitem_T) + addlen; + ai->ai_chop = p; + STRCPY(p, buf); + + p = ai->ai_add; + for (i = 0; i < addlen; ++i) /* <affadd> */ + p[i] = getc(fd); + p[i] = NUL; + + /* + * Add the affix to a hashtable. Which one depends on the + * length of the added string in characters. + */ +#ifdef FEAT_MBYTE + /* Change "addlen" from length in bytes to length in chars. */ + if (has_mbyte) + addlen = mb_charlen(p); +#endif + if (addlen == 0) + { + /* Link in list of zero length affixes. */ + ai->ai_next = *aip; + *aip = ai; + } + else + { + if (gap->ga_len < addlen) + { + /* Longer affix, need more hashtables. */ + if (ga_grow(gap, addlen - gap->ga_len) == FAIL) + goto errorend; + + /* Re-allocating ga_data means that an ht_array + * pointing to ht_smallarray becomes invalid. We can + * recognize this: ht_mask is at its init value. */ + for (i = 0; i < gap->ga_len; ++i) + { + ht = ((hashtab_T *)gap->ga_data) + i; + if (ht->ht_mask == HT_INIT_SIZE - 1) + ht->ht_array = ht->ht_smallarray; + } + + /* Init the newly used hashtable(s). */ + while (gap->ga_len < addlen) + { + hash_init(((hashtab_T *)gap->ga_data) + + gap->ga_len); + ++gap->ga_len; + } + } + ht = ((hashtab_T *)gap->ga_data) + addlen - 1; + hash = hash_hash(p); + hi = hash_lookup(ht, p, hash); + if (HASHITEM_EMPTY(hi)) + { + /* First affix with this "ai_add", add to hashtable. */ + hash_add_item(ht, hi, p, hash); + ai->ai_next = NULL; + } + else + { + /* There already is an affix with this "ai_add", link + * in the list. */ + ai2 = HI2AI(hi); + ai->ai_next = ai2->ai_next; + ai2->ai_next = ai; + } + } + } + } + } + + /* <SUGGEST> : <suggestlen> <more> ... */ + /* TODO, just skip this for now */ + i = (getc(fd) << 24) + (getc(fd) << 16) + (getc(fd) << 8) + getc(fd); + while (i-- > 0) + if (getc(fd) == EOF) /* <suggestlen> */ + goto truncerr; + + /* <WORDLIST>: <wordcount> <worditem> ... */ /* <wordcount> */ + wordcount = (getc(fd) << 24) + (getc(fd) << 16) + (getc(fd) << 8) + + getc(fd); + if (wordcount < 0) + goto truncerr; + + /* Init hashtable for this number of words, so that it doesn't need to + * reallocate the table halfway. */ + hash_lock_size(&lp->sl_words, wordcount); + + for (widx = 0; ; ++widx) + { + /* <worditem>: <nr> <string> <flags> [<flags2>] + * [<caselen> <caseword>] + * [<affixcnt> <affixNR> ...] (prefixes) + * [<affixcnt> <affixNR> ...] (suffixes) + * [<region>] + * [<addcnt> <add> ...] + */ + /* Use <nr> bytes from the previous word. */ + wlen = getc(fd); /* <nr> */ + if (wlen == EOF) + { + if (widx >= wordcount) /* normal way to end the file */ + break; + goto truncerr; + } + + /* Read further word bytes until one below 0x20, that must be the + * flags. Keep this fast! */ + for (;;) + { + if ((buf[wlen] = getc(fd)) < 0x20) /* <string> */ + break; + if (++wlen == MAXWLEN) + goto formerr; + } + flags = buf[wlen]; /* <flags> */ + buf[wlen] = NUL; + + /* Get more flags if they're there. */ + if (flags & BWF_SECOND) + flags += getc(fd) << 8; /* <flags2> */ + + if (flags & BWF_KEEPCAP) + { + /* Read <caselen> and <caseword> first, its length may differ from + * the case-folded word. Note: this should only happen after the + * basic word! */ + wlen = getc(fd); + if (wlen == EOF) + goto truncerr; + for (i = 0; i < wlen; ++i) + cbuf[i] = getc(fd); + cbuf[i] = NUL; + } + + /* Find room to store the word in a fword_T. */ + fw = (fword_T *)getroom(lp, &bl_used, (int)sizeof(fword_T) + wlen); + if (fw == NULL) + goto errorend; + mch_memmove(fw->fw_word, (flags & BWF_KEEPCAP) ? cbuf : buf, wlen + 1); + fw->fw_flags = flags; + + hash = hash_hash(buf); + hi = hash_lookup(&lp->sl_words, buf, hash); + if (HASHITEM_EMPTY(hi)) + { + if (hash_add_item(&lp->sl_words, hi, fw->fw_word, hash) == FAIL) + goto errorend; + fw->fw_next = NULL; + } + else + { + /* Already have this basic word in the hashtable, this one will + * have different case flags. */ + fw2 = HI2FWORD(hi); + fw->fw_next = fw2->fw_next; + fw2->fw_next = fw; + --widx; /* don't count this one */ + } + + /* Optional prefixes and suffixes. */ + if (flags & BWF_PREFIX) + fw->fw_prefixcnt = spell_load_affixes(fd, lp, &bl_used, + prefm, &fw->fw_prefix); + else + fw->fw_prefixcnt = 0; + if (flags & BWF_SUFFIX) + fw->fw_suffixcnt = spell_load_affixes(fd, lp, &bl_used, + suffm, &fw->fw_suffix); + else + fw->fw_suffixcnt = 0; + + if (flags & BWF_REGION) + fw->fw_region = getc(fd); /* <region> */ + else + fw->fw_region = REGION_ALL; + + fw->fw_adds = NULL; + if (flags & BWF_ADDS) + { + adds = (getc(fd) << 8) + getc(fd); /* <addcnt> */ + + while (--adds >= 0) + { + /* <add>: <addflags> <addlen> [<leadlen> <addstring>] + * [<region>] */ + flags = getc(fd); /* <addflags> */ + addlen = getc(fd); /* <addlen> */ + if (addlen == EOF) + goto truncerr; + if (addlen >= MAXWLEN) + goto formerr; + + if (addlen > 0) + { + leadlen = getc(fd); /* <leadlen> */ + for (i = 0; i < addlen; ++i) /* <addstring> */ + cbuf[i] = getc(fd); + cbuf[i] = NUL; + } + else + leadlen = 0; + + if (flags & ADD_KEEPCAP) + { + /* <addstring> is in original case, need to get + * case-folded word too. */ + (void)str_foldcase(cbuf, addlen, fbuf, MAXWLEN); + flen = addlen - leadlen + 1; + addlen = STRLEN(fbuf); + } + else + flen = 0; + + aw = (addword_T *)getroom(lp, &bl_used, + sizeof(addword_T) + addlen + flen); + if (aw == NULL) + goto errorend; + aw->aw_next = fw->fw_adds; + fw->fw_adds = aw; + aw->aw_leadlen = leadlen; + + if (flags & ADD_KEEPCAP) + { + /* Put the addition in original case after the case-folded + * string. */ + STRCPY(aw->aw_word, fbuf); + STRCPY(aw->aw_word + addlen + 1, cbuf + leadlen); + } + else + STRCPY(aw->aw_word, cbuf); + + aw->aw_flags = flags; + aw->aw_wordlen = addlen; + + if (flags & ADD_REGION) + aw->aw_region = getc(fd); /* <region> */ + else + aw->aw_region = REGION_ALL; + } + } + } + goto end_OK; + +errorend: + lp->sl_error = TRUE; +end_OK: + if (fd != NULL) + fclose(fd); + hash_unlock(&lp->sl_words); + sourcing_name = save_sourcing_name; + sourcing_lnum = save_sourcing_lnum; +} + +/* + * Read a list of affixes from the spell file. + */ + static int +spell_load_affixes(fd, lp, bl_usedp, affm, affp) + FILE *fd; + slang_T *lp; + int *bl_usedp; + int affm; + void **affp; +{ + int cnt; + int i, n; + char_u *p; + + cnt = getc(fd); /* <affixcnt> */ + if (cnt == EOF) + return 0; + + /* Get room to store the affixNR list, either as char_u (1 + * byte) or short_u (2 bytes). */ + p = (char_u *)getroom(lp, bl_usedp, cnt * affm); + if (p == NULL) + return 0; + *affp = p; + for (n = 0; n < cnt; ++n) + { + i = getc(fd); /* <affixNR> */ + if (affm > 1) + { + i = (i << 8) + getc(fd); + *(short_u *)p = i; + p += sizeof(short_u); + } + else + { + *(char_u *)p = i; + ++p; + } + } + return cnt; +} + +/* + * Get part of an sblock_T, at least "len" bytes long. + * Returns NULL when out of memory. + */ + static void * +getroom(lp, bl_used, len) + slang_T *lp; /* lp->sl_block is current block or NULL */ + int *bl_used; /* used up from current block */ + int len; /* length needed */ +{ + char_u *p; + sblock_T *bl = lp->sl_block; + + if (bl == NULL || *bl_used + len > SBLOCKSIZE) + { + /* Allocate a block of memory. This is not freed until spell_reload() + * is called. */ + bl = (sblock_T *)alloc((unsigned)(sizeof(sblock_T) + SBLOCKSIZE)); + if (bl == NULL) + return NULL; + bl->sb_next = lp->sl_block; + lp->sl_block = bl; + *bl_used = 0; + } + + p = bl->sb_data + *bl_used; + *bl_used += len; + + return p; +} + +/* + * Parse 'spelllang' and set buf->b_langp accordingly. + * Returns an error message or NULL. + */ + char_u * +did_set_spelllang(buf) + buf_T *buf; +{ + garray_T ga; + char_u *lang; + char_u *e; + char_u *region; + int region_mask; + slang_T *lp; + int c; + char_u lbuf[MAXWLEN + 1]; + + ga_init2(&ga, sizeof(langp_T), 2); + + /* loop over comma separated languages. */ + for (lang = buf->b_p_spl; *lang != NUL; lang = e) + { + e = vim_strchr(lang, ','); + if (e == NULL) + e = lang + STRLEN(lang); + if (e > lang + 2) + { + if (e - lang >= MAXWLEN) + { + ga_clear(&ga); + return e_invarg; + } + if (lang[2] == '_') + region = lang + 3; + } + else + region = NULL; + + for (lp = first_lang; lp != NULL; lp = lp->sl_next) + if (STRNICMP(lp->sl_name, lang, 2) == 0) + break; + + if (lp == NULL) + { + /* Not found, load the language. */ + STRNCPY(lbuf, lang, e - lang); + lbuf[e - lang] = NUL; + if (region != NULL) + mch_memmove(lbuf + 2, lbuf + 5, e - lang - 4); + lp = spell_load_lang(lbuf); + } + + if (lp != NULL) + { + if (region == NULL) + region_mask = REGION_ALL; + else + { + /* find region in sl_regions */ + c = find_region(lp->sl_regions, region); + if (c == REGION_ALL) + { + c = *e; + *e = NUL; + smsg((char_u *)_("Warning: region %s not supported"), lang); + *e = c; + region_mask = REGION_ALL; + } + else + region_mask = 1 << c; + } + + if (ga_grow(&ga, 1) == FAIL) + { + ga_clear(&ga); + 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; + } + + if (*e == ',') + ++e; + } + + /* Add a NULL entry to mark the end of the list. */ + if (ga_grow(&ga, 1) == FAIL) + { + ga_clear(&ga); + return e_outofmem; + } + LANGP_ENTRY(ga, ga.ga_len)->lp_slang = NULL; + ++ga.ga_len; + + /* Everything is fine, store the new b_langp value. */ + ga_clear(&buf->b_langp); + buf->b_langp = ga; + + return NULL; +} + +/* + * Find the region "region[2]" in "rp" (points to "sl_regions"). + * Each region is simply stored as the two characters of it's name. + * Returns the index if found, REGION_ALL if not found. + */ + static int +find_region(rp, region) + char_u *rp; + char_u *region; +{ + int i; + + for (i = 0; ; i += 2) + { + if (rp[i] == NUL) + return REGION_ALL; + if (rp[i] == region[0] && rp[i + 1] == region[1]) + break; + } + return i / 2; +} + +/* + * Return type of word: + * w word 0 + * Word BWF_ONECAP + * W WORD BWF_ALLCAP + * WoRd wOrd BWF_KEEPCAP + */ + static int +captype(word, end) + char_u *word; + char_u *end; +{ + char_u *p; + int c; + int firstcap; + int allcap; + int past_second = FALSE; /* past second word char */ + + /* find first letter */ + for (p = word; !spell_iswordc(p); mb_ptr_adv(p)) + if (p >= end) + return 0; /* only non-word characters, illegal word */ +#ifdef FEAT_MBYTE + c = mb_ptr2char_adv(&p); +#else + c = *p++; +#endif + firstcap = allcap = MB_ISUPPER(c); + + /* + * 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 ( ; p < end; mb_ptr_adv(p)) + if (spell_iswordc(p)) + { +#ifdef FEAT_MBYTE + c = mb_ptr2char(p); +#else + c = *p; +#endif + if (!MB_ISUPPER(c)) + { + /* UUl -> KEEPCAP */ + if (past_second && allcap) + return BWF_KEEPCAP; + allcap = FALSE; + } + else if (!allcap) + /* UlU -> KEEPCAP */ + return BWF_KEEPCAP; + past_second = TRUE; + } + + if (allcap) + return BWF_ALLCAP; + if (firstcap) + return BWF_ONECAP; + return 0; +} + +# if defined(FEAT_MBYTE) || defined(PROTO) +/* + * Clear all spelling tables and reload them. + * Used after 'encoding' is set. + */ + void +spell_reload() +{ + buf_T *buf; + slang_T *lp; + + /* Initialize the table for spell_iswordc(). */ + init_spell_chartab(); + + /* Unload all allocated memory. */ + while (first_lang != NULL) + { + lp = first_lang; + first_lang = lp->sl_next; + slang_free(lp); + } + + /* Go through all buffers and handle 'spelllang'. */ + for (buf = firstbuf; buf != NULL; buf = buf->b_next) + { + ga_clear(&buf->b_langp); + if (*buf->b_p_spl != NUL) + did_set_spelllang(buf); + } +} +# endif + +/* + * Recognizing words uses a two-step mechanism: + * 1. Locate a basic word, made out of word characters only and separated by + * non-word characters. + * 2. When a basic word is found, check if (possibly required) additions + * before and after the word are present. + * + * Both mechanisms use affixes (prefixes and suffixes) to reduce the number of + * words. When no matching word was found in the hashtable the start of the + * word is checked for matching prefixes and the end of the word for matching + * suffixes. All matching affixes are removed and then the resulting word is + * searched for. If found it is checked if it supports the used affix. + */ + + +#if defined(FEAT_MBYTE) || defined(PROTO) +/* + * Functions for ":mkspell". + * Only possible with the multi-byte feature. + */ + +#define MAXLINELEN 300 /* Maximum length in bytes of a line in a .aff + and .dic file. */ +/* + * Main structure to store the contents of a ".aff" file. + */ +typedef struct afffile_S +{ + char_u *af_enc; /* "SET", normalized, alloc'ed string or NULL */ + char_u *af_try; /* "TRY" line in "af_enc" encoding */ + hashtab_T af_pref; /* hashtable for prefixes, affheader_T */ + hashtab_T af_suff; /* hashtable for suffixes, affheader_T */ + garray_T af_rep; /* list of repentry_T entries from REP lines */ +} afffile_T; + +typedef struct affentry_S affentry_T; + +/* Affix header from ".aff" file. Used for af_pref and af_suff. */ +typedef struct affheader_S +{ + char_u ah_key[2]; /* key for hashtable == name of affix entry */ + int ah_combine; + affentry_T *ah_first; /* first affix entry */ + short_u ah_affnr; /* used in get_new_aff() */ +} affheader_T; + +#define HI2AH(hi) ((affheader_T *)(hi)->hi_key) + +/* Affix entry from ".aff" file. Used for prefixes and suffixes. */ +struct affentry_S +{ + 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_add_nw; /* first non-word character in "ae_add" */ + char_u *ae_cond; /* condition (NULL for ".") */ + regprog_T *ae_prog; /* regexp program for ae_cond or NULL */ + short_u ae_affnr; /* for old affix: new affix number */ +}; + +/* + * Structure to store a word from a ".dic" file. + */ +typedef struct dicword_S +{ + char_u *dw_affnm; /* original affix names */ + char_u dw_word[1]; /* actually longer: the word in 'encoding' */ +} dicword_T; + +static dicword_T dumdw; +#define HI2DW(hi) ((dicword_T *)((hi)->hi_key - (dumdw.dw_word - (char_u *)&dumdw))) + +/* + * Structure to store a basic word for the spell file. + * This is used for ":mkspell", not for spell checking. + */ +typedef struct basicword_S basicword_T; +struct basicword_S +{ + basicword_T *bw_next; /* next word with same basic word */ + basicword_T *bw_cnext; /* next word with same caps */ + int bw_flags; /* BWF_ flags */ + garray_T bw_prefix; /* table with prefix numbers */ + garray_T bw_suffix; /* table with suffix numbers */ + int bw_region; /* region bits */ + char_u *bw_caseword; /* keep-case word */ + char_u *bw_leadstring; /* must come before bw_word */ + char_u *bw_addstring; /* must come after bw_word */ + char_u bw_word[1]; /* actually longer: word case folded */ +}; + +static basicword_T dumbw; +#define KEY2BW(p) ((basicword_T *)((p) - (dumbw.bw_word - (char_u *)&dumbw))) +#define HI2BW(hi) KEY2BW((hi)->hi_key) + +/* Store the affix number related with a certain string. */ +typedef struct affhash_S +{ + short_u as_nr; /* the affix nr */ + char_u as_word[1]; /* actually longer */ +} affhash_T; + +static affhash_T dumas; +#define HI2AS(hi) ((affhash_T *)((hi)->hi_key - (dumas.as_word - (char_u *)&dumas))) + + +static afffile_T *spell_read_aff __ARGS((char_u *fname, vimconv_T *conv)); +static void spell_free_aff __ARGS((afffile_T *aff)); +static int spell_read_dic __ARGS((hashtab_T *ht, char_u *fname, vimconv_T *conv)); +static int get_new_aff __ARGS((hashtab_T *oldaff, garray_T *gap)); +static void spell_free_dic __ARGS((hashtab_T *dic)); +static int same_affentries __ARGS((affheader_T *ah1, affheader_T *ah2)); +static void add_affhash __ARGS((hashtab_T *ht, char_u *key, int newnr)); +static void clear_affhash __ARGS((hashtab_T *ht)); +static void trans_affixes __ARGS((dicword_T *dw, basicword_T *bw, afffile_T *oldaff, hashtab_T *newwords)); +static int build_wordlist __ARGS((hashtab_T *newwords, hashtab_T *oldwords, afffile_T *oldaff, int regionmask)); +static void combine_regions __ARGS((hashtab_T *newwords)); +static int same_affixes __ARGS((basicword_T *bw, basicword_T *nbw)); +static void expand_affixes __ARGS((hashtab_T *newwords, garray_T *prefgap, garray_T *suffgap)); +static void expand_one_aff __ARGS((basicword_T *bw, garray_T *add_words, affentry_T *pae, affentry_T *sae)); +static void add_to_wordlist __ARGS((hashtab_T *newwords, basicword_T *bw)); +static void put_bytes __ARGS((FILE *fd, long_u nr, int len)); +static void write_affix __ARGS((FILE *fd, affheader_T *ah)); +static void write_affixlist __ARGS((FILE *fd, garray_T *aff, int bytes)); +static void write_vim_spell __ARGS((char_u *fname, garray_T *prefga, garray_T *suffga, hashtab_T *newwords, int regcount, char_u *regchars)); +static void write_bword __ARGS((FILE *fd, basicword_T *bw, int lowcap, basicword_T **prevbw, int regionmask, int prefm, int suffm)); +static void free_wordtable __ARGS((hashtab_T *ht)); +static void free_basicword __ARGS((basicword_T *bw)); +static void free_affixentries __ARGS((affentry_T *first)); + +/* + * Read an affix ".aff" file. + * Returns an afffile_T, NULL for failure. + */ + static afffile_T * +spell_read_aff(fname, conv) + char_u *fname; + vimconv_T *conv; /* info for encoding conversion */ +{ + FILE *fd; + afffile_T *aff; + char_u rline[MAXLINELEN]; + char_u *line; + char_u *pc = NULL; + char_u *(items[6]); + int itemcnt; + char_u *p; + int lnum = 0; + affheader_T *cur_aff = NULL; + int aff_todo = 0; + hashtab_T *tp; + + fd = fopen((char *)fname, "r"); + if (fd == NULL) + { + EMSG2(_(e_notopen), fname); + return NULL; + } + + smsg((char_u *)_("Reading affix file %s..."), fname); + out_flush(); + + aff = (afffile_T *)alloc_clear((unsigned)sizeof(afffile_T)); + if (aff == NULL) + return NULL; + hash_init(&aff->af_pref); + hash_init(&aff->af_suff); + ga_init2(&aff->af_rep, (int)sizeof(repentry_T), 20); + + /* + * Read all the lines in the file one by one. + */ + while (!vim_fgets(rline, MAXLINELEN, fd)) + { + ++lnum; + + /* Skip comment lines. */ + if (*rline == '#') + continue; + + /* Convert from "SET" to 'encoding' when needed. */ + vim_free(pc); + if (conv->vc_type != CONV_NONE) + { + pc = string_convert(conv, rline, NULL); + line = pc; + } + else + { + pc = NULL; + line = rline; + } + + /* Split the line up in white separated items. Put a NUL after each + * item. */ + itemcnt = 0; + for (p = line; ; ) + { + while (*p != NUL && *p <= ' ') /* skip white space and CR/NL */ + ++p; + if (*p == NUL) + break; + items[itemcnt++] = p; + while (*p > ' ') /* skip until white space or CR/NL */ + ++p; + if (*p == NUL) + break; + *p++ = NUL; + } + + /* Handle non-empty lines. */ + if (itemcnt > 0) + { + if (STRCMP(items[0], "SET") == 0 && itemcnt == 2 + && aff->af_enc == NULL) + { + if (aff->af_enc != NULL) + smsg((char_u *)_("Duplicate SET line ignored in %s line %d: %s"), + fname, lnum, line); + else + { + /* Setup for conversion from "ENC" to 'encoding'. */ + aff->af_enc = enc_canonize(items[1]); + if (aff->af_enc != NULL + && convert_setup(conv, aff->af_enc, p_enc) == FAIL) + smsg((char_u *)_("Conversion in %s not supported: from %s to %s"), + fname, aff->af_enc, p_enc); + } + } + else if (STRCMP(items[0], "TRY") == 0 && itemcnt == 2 + && aff->af_try == NULL) + aff->af_try = vim_strsave(items[1]); + else if ((STRCMP(items[0], "PFX") == 0 + || STRCMP(items[0], "SFX") == 0) + && aff_todo == 0 + && itemcnt == 4) + { + /* New affix letter. */ + cur_aff = (affheader_T *)alloc((unsigned)sizeof(affheader_T)); + if (cur_aff == NULL) + break; + cur_aff->ah_key[0] = *items[1]; + cur_aff->ah_key[1] = NUL; + if (items[1][1] != NUL) + smsg((char_u *)_("Affix name too long in %s line %d: %s"), + fname, lnum, items[1]); + if (*items[2] == 'Y') + cur_aff->ah_combine = TRUE; + else if (*items[2] == 'N') + cur_aff->ah_combine = FALSE; + else if (p_verbose > 0) + smsg((char_u *)_("Expected Y or N in %s line %d: %s"), + fname, lnum, items[2]); + cur_aff->ah_first = NULL; + if (*items[0] == 'P') + tp = &aff->af_pref; + else + tp = &aff->af_suff; + if (!HASHITEM_EMPTY(hash_find(tp, cur_aff->ah_key))) + smsg((char_u *)_("Duplicate affix in %s line %d: %s"), + fname, lnum, items[1]); + else + hash_add(tp, cur_aff->ah_key); + + aff_todo = atoi((char *)items[3]); + } + else if ((STRCMP(items[0], "PFX") == 0 + || STRCMP(items[0], "SFX") == 0) + && aff_todo > 0 + && STRCMP(cur_aff->ah_key, items[1]) == 0 + && itemcnt == 5) + { + affentry_T *aff_entry; + + /* New item for an affix letter. */ + --aff_todo; + aff_entry = (affentry_T *)alloc_clear( + (unsigned)sizeof(affentry_T)); + if (aff_entry == NULL) + break; + aff_entry->ae_next = cur_aff->ah_first; + cur_aff->ah_first = aff_entry; + if (STRCMP(items[2], "0") != 0) + aff_entry->ae_chop = vim_strsave(items[2]); + if (STRCMP(items[3], "0") != 0) + aff_entry->ae_add = vim_strsave(items[3]); + if (STRCMP(items[4], ".") != 0) + { + char_u buf[MAXLINELEN]; + + aff_entry->ae_cond = vim_strsave(items[4]); + if (*items[0] == 'P') + sprintf((char *)buf, "^%s", items[4]); + else + sprintf((char *)buf, "%s$", items[4]); + aff_entry->ae_prog = vim_regcomp(buf, RE_MAGIC + RE_STRING); + } + } + else if (STRCMP(items[0], "REP") == 0 && itemcnt == 2) + /* Ignore REP count */; + else if (STRCMP(items[0], "REP") == 0 && itemcnt == 3) + { + repentry_T *rp; + + /* REP item */ + if (ga_grow(&aff->af_rep, 1) == FAIL) + break; + rp = ((repentry_T *)aff->af_rep.ga_data) + aff->af_rep.ga_len; + rp->re_from = vim_strsave(items[1]); + rp->re_to = vim_strsave(items[2]); + ++aff->af_rep.ga_len; + } + else if (p_verbose > 0) + smsg((char_u *)_("Unrecognized item in %s line %d: %s"), + fname, lnum, items[0]); + } + + } + + vim_free(pc); + fclose(fd); + return aff; +} + +/* + * Free the structure filled by spell_read_aff(). + */ + static void +spell_free_aff(aff) + afffile_T *aff; +{ + hashtab_T *ht; + hashitem_T *hi; + int todo; + int i; + repentry_T *rp; + affheader_T *ah; + + vim_free(aff->af_enc); + vim_free(aff->af_try); + + for (ht = &aff->af_pref; ; ht = &aff->af_suff) + { + todo = ht->ht_used; + for (hi = ht->ht_array; todo > 0; ++hi) + { + if (!HASHITEM_EMPTY(hi)) + { + --todo; + ah = HI2AH(hi); + free_affixentries(ah->ah_first); + vim_free(ah); + } + } + if (ht == &aff->af_suff) + break; + } + hash_clear(&aff->af_pref); + hash_clear(&aff->af_suff); + + for (i = 0; i < aff->af_rep.ga_len; ++i) + { + rp = ((repentry_T *)aff->af_rep.ga_data) + i; + vim_free(rp->re_from); + vim_free(rp->re_to); + } + ga_clear(&aff->af_rep); + + vim_free(aff); +} + +/* + * Read a dictionary ".dic" file. + * Returns OK or FAIL; + * Each entry in the hashtab_T is a dicword_T. + */ + static int +spell_read_dic(ht, fname, conv) + hashtab_T *ht; + char_u *fname; + vimconv_T *conv; /* info for encoding conversion */ +{ + char_u line[MAXLINELEN]; + char_u *p; + dicword_T *dw; + char_u *pc; + char_u *w; + int l; + hash_T hash; + hashitem_T *hi; + FILE *fd; + int lnum = 1; + + fd = fopen((char *)fname, "r"); + if (fd == NULL) + { + EMSG2(_(e_notopen), fname); + return FAIL; + } + + smsg((char_u *)_("Reading dictionary file %s..."), fname); + out_flush(); + + /* Read and ignore the first line: word count. */ + (void)vim_fgets(line, MAXLINELEN, fd); + if (!isdigit(*skipwhite(line))) + EMSG2(_("E760: No word count in %s"), fname); + + /* + * Read all the lines in the file one by one. + * The words are converted to 'encoding' here, before being added to + * the hashtable. + */ + while (!vim_fgets(line, MAXLINELEN, fd)) + { + ++lnum; + + /* Remove CR, LF and white space from end. */ + l = STRLEN(line); + while (l > 0 && line[l - 1] <= ' ') + --l; + if (l == 0) + continue; /* empty line */ + line[l] = NUL; + + /* Find the optional affix names. */ + p = vim_strchr(line, '/'); + if (p != NULL) + *p++ = NUL; + + /* Convert from "SET" to 'encoding' when needed. */ + if (conv->vc_type != CONV_NONE) + { + pc = string_convert(conv, line, NULL); + w = pc; + } + else + { + pc = NULL; + w = line; + } + + dw = (dicword_T *)alloc_clear((unsigned)sizeof(dicword_T) + + STRLEN(w)); + if (dw == NULL) + break; + STRCPY(dw->dw_word, w); + vim_free(pc); + + hash = hash_hash(dw->dw_word); + hi = hash_lookup(ht, dw->dw_word, hash); + if (!HASHITEM_EMPTY(hi)) + smsg((char_u *)_("Duplicate word in %s line %d: %s"), + fname, lnum, line); + else + hash_add_item(ht, hi, dw->dw_word, hash); + + if (p != NULL) + dw->dw_affnm = vim_strsave(p); + } + + fclose(fd); + return OK; +} + +/* + * Free the structure filled by spell_read_dic(). + */ + static void +spell_free_dic(dic) + hashtab_T *dic; +{ + int todo; + dicword_T *dw; + hashitem_T *hi; + + todo = dic->ht_used; + for (hi = dic->ht_array; todo > 0; ++hi) + { + if (!HASHITEM_EMPTY(hi)) + { + --todo; + dw = HI2DW(hi); + vim_free(dw->dw_affnm); + vim_free(dw); + } + } + hash_clear(dic); +} + +/* + * Take the affixes read by spell_read_aff() and add them to the new list. + * Attempts to re-use the same number for identical affixes (ignoring the + * condition, since we remove that). That is especially important when using + * multiple regions. + * Returns OK or FAIL; + */ + static int +get_new_aff(oldaff, gap) + hashtab_T *oldaff; /* hashtable with affheader_T */ + garray_T *gap; /* table with new affixes */ +{ + int oldtodo; + affheader_T *oldah, *newah, *gapah; + affentry_T *oldae, *newae; + hashitem_T *oldhi; + hashitem_T *hi; + hashtab_T condht; /* conditions already found */ + char_u condkey[MAXLINELEN]; + int newnr; + int gapnr; + int retval = OK; + char_u *p; + garray_T tga; + + /* + * Loop over all the old affix names. + */ + oldtodo = oldaff->ht_used; + for (oldhi = oldaff->ht_array; oldtodo > 0 && retval == OK; ++oldhi) + { + if (!HASHITEM_EMPTY(oldhi)) + { + --oldtodo; + oldah = (affheader_T *)oldhi->hi_key; + + /* Put entries with the same condition under the same new affix + * nr in "tga". Use hashtable "condht" to find them. */ + ga_init2(&tga, sizeof(affheader_T), 10); + hash_init(&condht); + + /* + * Loop over all affixes with the same name. + * The affixes with the same condition will get the same number, + * since they can be used with the same words. + * 1. build the lists of new affentry_T, with the headers in "tga". + * 2. Check if some of the lists already exist in "gap", re-use + * their number. + * 3. Assign the new numbers to the old affixes. + */ + + /* 1. build the lists of new affentry_T. */ + for (oldae = oldah->ah_first; oldae != NULL && retval == OK; + oldae = oldae->ae_next) + { + oldae->ae_add_nw = NULL; + if (oldae->ae_add != NULL) + { + /* Check for non-word characters in the suffix. If there + * is one this affix will be turned into an addition. + * This is stored with the old affix, that is where + * trans_affixes() will check. */ + for (p = oldae->ae_add; *p != NUL; mb_ptr_adv(p)) + if (!spell_iswordc(p)) + break; + if (*p != NUL) + oldae->ae_add_nw = p; + } + + if (oldae->ae_cond == NULL) + /* hashtable requires a non-empty key */ + STRCPY(condkey, "---"); + else + STRCPY(condkey, oldae->ae_cond); + + /* Look for an existing list with this name and condition. */ + hi = hash_find(&condht, condkey); + if (!HASHITEM_EMPTY(hi)) + /* Match with existing affix, use that one. */ + newnr = HI2AS(hi)->as_nr; + else + { + /* Add a new affix number. */ + newnr = tga.ga_len; + if (ga_grow(&tga, 1) == FAIL) + retval = FAIL; + else + { + newah = ((affheader_T *)tga.ga_data) + newnr; + newah->ah_combine = oldah->ah_combine; + newah->ah_first = NULL; + ++tga.ga_len; + + /* Add the new list to the condht hashtable. */ + add_affhash(&condht, condkey, newnr); + } + } + + /* Add the new affentry_T to the list. */ + newah = ((affheader_T *)tga.ga_data) + newnr; + newae = (affentry_T *)alloc_clear((unsigned)sizeof(affentry_T)); + if (newae == NULL) + retval = FAIL; + else + { + newae->ae_next = newah->ah_first; + newah->ah_first = newae; + if (oldae->ae_chop == NULL) + newae->ae_chop = NULL; + else + newae->ae_chop = vim_strsave(oldae->ae_chop); + if (oldae->ae_add == NULL) + newae->ae_add = NULL; + else + newae->ae_add = vim_strsave(oldae->ae_add); + + /* The condition is not copied, since the new affix is + * only used for words where the condition matches. */ + } + } + + /* 2. Check if some of the lists already exist, re-use their + * number. Otherwise add the list to "gap". */ + for (newnr = 0; newnr < tga.ga_len; ++newnr) + { + newah = ((affheader_T *)tga.ga_data) + newnr; + for (gapnr = 0; gapnr < gap->ga_len; ++gapnr) + { + gapah = ((affheader_T *)gap->ga_data) + gapnr; + if (same_affentries(newah, gapah)) + /* Found an existing affheader_T entry with same + * affentry_T list, use its number. */ + break; + } + + newah->ah_affnr = gapnr; + if (gapnr == gap->ga_len) + { + /* This is a new affentry_T list, add it. */ + if (ga_grow(gap, 1) == FAIL) + retval = FAIL; + else + { + *(((affheader_T *)gap->ga_data) + gap->ga_len) = *newah; + ++gap->ga_len; + } + } + else + { + /* free unused affentry_T list */ + free_affixentries(newah->ah_first); + } + } + + /* 3. Assign the new affix numbers to the old affixes. */ + for (oldae = oldah->ah_first; oldae != NULL && retval == OK; + oldae = oldae->ae_next) + { + if (oldae->ae_cond == NULL) + /* hashtable requires a non-empty key */ + STRCPY(condkey, "---"); + else + STRCPY(condkey, oldae->ae_cond); + + /* Look for an existing affix with this name and condition. */ + hi = hash_find(&condht, condkey); + if (!HASHITEM_EMPTY(hi)) + /* Match with existing affix, use that one. */ + newnr = HI2AS(hi)->as_nr; + else + { + EMSG(_(e_internal)); + retval = FAIL; + } + newah = ((affheader_T *)tga.ga_data) + newnr; + oldae->ae_affnr = newah->ah_affnr; + } + + ga_clear(&tga); + clear_affhash(&condht); + } + } + + return retval; +} + +/* + * Return TRUE if the affentry_T lists for "ah1" and "ah2" contain the same + * items, ignoring the order. + * Only compares the chop and add strings, not the condition. + */ + static int +same_affentries(ah1, ah2) + affheader_T *ah1; + affheader_T *ah2; +{ + affentry_T *ae1, *ae2; + + /* Check the length of the lists first. */ + ae2 = ah2->ah_first; + for (ae1 = ah1->ah_first; ae1 != NULL; ae1 = ae1->ae_next) + { + if (ae2 == NULL) + return FALSE; /* "ah1" list is longer */ + ae2 = ae2->ae_next; + } + if (ae2 != NULL) + return FALSE; /* "ah2" list is longer */ + + /* Check that each entry in "ah1" appears in "ah2". */ + for (ae1 = ah1->ah_first; ae1 != NULL; ae1 = ae1->ae_next) + { + for (ae2 = ah2->ah_first; ae2 != NULL; ae2 = ae2->ae_next) + { + if ((ae1->ae_chop == NULL) == (ae2->ae_chop == NULL) + && (ae1->ae_add == NULL) == (ae2->ae_add == NULL) + && (ae1->ae_chop == NULL + || STRCMP(ae1->ae_chop, ae2->ae_chop) == 0) + && (ae1->ae_add == NULL + || STRCMP(ae1->ae_add, ae2->ae_add) == 0)) + break; + } + if (ae2 == NULL) + return FALSE; + } + + return TRUE; +} + +/* + * Add a chop/add or cond hashtable entry. + */ + static void +add_affhash(ht, key, newnr) + hashtab_T *ht; + char_u *key; + int newnr; +{ + affhash_T *as; + + as = (affhash_T *)alloc((unsigned)sizeof(affhash_T) + STRLEN(key)); + if (as != NULL) + { + as->as_nr = newnr; + STRCPY(as->as_word, key); + hash_add(ht, as->as_word); + } +} + +/* + * Clear the chop/add hashtable used to detect identical affixes. + */ + static void +clear_affhash(ht) + hashtab_T *ht; +{ + int todo; + hashitem_T *hi; + + todo = ht->ht_used; + for (hi = ht->ht_array; todo > 0; ++hi) + { + if (!HASHITEM_EMPTY(hi)) + { + --todo; + vim_free(HI2AS(hi)); + } + } + hash_clear(ht); +} + +/* + * Translate list of affix names for an old word to affix numbers in a new + * basic word. + * This checks if the conditions match with the old word. The result is that + * the new affix does not need to store the condition. + */ + static void +trans_affixes(dw, bw, oldaff, newwords) + dicword_T *dw; /* old word */ + basicword_T *bw; /* basic word */ + afffile_T *oldaff; /* affixes for "oldwords" */ + hashtab_T *newwords; /* table with words */ +{ + char_u key[2]; + char_u *p; + char_u *affnm; + garray_T *gap; + hashitem_T *aff_hi; + affheader_T *ah; + affentry_T *ae; + regmatch_T regmatch; + int i; + basicword_T *nbw; + int alen; + int wlen; + garray_T fixga; + char_u nword[MAXWLEN]; + int flags; + int n; + + ga_init2(&fixga, (int)sizeof(basicword_T *), 5); + + /* Loop over all the affix names of the old word. */ + key[1] = NUL; + for (affnm = dw->dw_affnm; *affnm != NUL; ++affnm) + { + key[0] = *affnm; + aff_hi = hash_find(&oldaff->af_pref, key); + if (!HASHITEM_EMPTY(aff_hi)) + gap = &bw->bw_prefix; /* found a prefix */ + else + { + gap = &bw->bw_suffix; /* must be a suffix */ + aff_hi = hash_find(&oldaff->af_suff, key); + if (HASHITEM_EMPTY(aff_hi)) + { + smsg((char_u *)_("No affix entry '%s' for word %s"), + key, dw->dw_word); + continue; + } + } + + /* Loop over all the affix entries for this affix name. */ + ah = HI2AH(aff_hi); + for (ae = ah->ah_first; ae != NULL; ae = ae->ae_next) + { + regmatch.regprog = ae->ae_prog; + regmatch.rm_ic = FALSE; /* TODO: Should this be TRUE??? */ + if (ae->ae_prog == NULL + || vim_regexec(®match, dw->dw_word, (colnr_T)0)) + { + if (ae->ae_add_nw != NULL && (gap == &bw->bw_suffix + ? bw->bw_addstring : bw->bw_leadstring) == NULL) + { + /* Affix has a non-word character and isn't prepended to + * leader or appended to addition. Need to use another + * word with an addition. It's a copy of the basicword_T + * "bw". */ + if (gap == &bw->bw_suffix) + { + alen = ae->ae_add_nw - ae->ae_add; + nbw = (basicword_T *)alloc((unsigned)( + sizeof(basicword_T) + STRLEN(bw->bw_word) + + alen + 1)); + if (nbw != NULL) + { + *nbw = *bw; + ga_init2(&nbw->bw_prefix, sizeof(short_u), 1); + ga_init2(&nbw->bw_suffix, sizeof(short_u), 1); + + /* Adding the suffix may change the caps. */ + STRCPY(nword, dw->dw_word); + if (ae->ae_chop != NULL) + { + /* Remove chop string. */ + p = nword + STRLEN(nword); + for (i = mb_charlen(ae->ae_chop); i > 0; --i) + mb_ptr_back(nword, p); + *p = NUL; + } + STRCAT(nword, ae->ae_add); + flags = captype(nword, nword + STRLEN(nword)); + if (flags & BWF_KEEPCAP) + { + nword[STRLEN(dw->dw_word) + alen] = NUL; + nbw->bw_caseword = vim_strsave(nword); + } + nbw->bw_flags &= ~(BWF_ONECAP | BWF_ALLCAP + | BWF_KEEPCAP); + nbw->bw_flags |= flags; + + if (bw->bw_leadstring != NULL) + nbw->bw_leadstring = + vim_strsave(bw->bw_leadstring); + nbw->bw_addstring = vim_strsave(ae->ae_add_nw); + + STRCPY(nbw->bw_word, bw->bw_word); + if (alen > 0 || ae->ae_chop != NULL) + { + /* Suffix starts with word character. Append + * it to the word. Add new word entry. */ + wlen = STRLEN(nbw->bw_word); + if (ae->ae_chop != NULL) + wlen -= STRLEN(ae->ae_chop); + mch_memmove(nbw->bw_word + wlen, ae->ae_add, + alen); + nbw->bw_word[wlen + alen] = NUL; + add_to_wordlist(newwords, nbw); + } + else + /* Basic word is the same, link "nbw" after + * "bw". */ + bw->bw_next = nbw; + + /* Remember this word, we need to set bw_prefix + * and bw_suffix later. */ + if (ga_grow(&fixga, 1) == OK) + ((basicword_T **)fixga.ga_data)[fixga.ga_len++] + = nbw; + } + } + else + { + /* TODO: prefix with non-word char */ + } + } + else + { + /* Affix applies to this word, add the related affix + * number. But only if it's not there yet. And keep the + * list sorted, so that we can compare it later. */ + for (i = 0; i < gap->ga_len; ++i) + { + n = ((short_u *)gap->ga_data)[i]; + if (n >= ae->ae_affnr) + { + if (n == ae->ae_affnr) + i = -1; + break; + } + } + if (i >= 0 && ga_grow(gap, 1) == OK) + { + if (i < gap->ga_len) + mch_memmove(((short_u *)gap->ga_data) + i + 1, + ((short_u *)gap->ga_data) + i, + sizeof(short_u) * (gap->ga_len - i)); + ((short_u *)gap->ga_data)[i] = ae->ae_affnr; + ++gap->ga_len; + } + } + } + } + } + + /* + * For the words that we added for suffixes with non-word characters: Use + * the prefix list of the main word. + * TODO: do the same for prefixes. + */ + for (i = 0; i < fixga.ga_len; ++i) + { + nbw = ((basicword_T **)fixga.ga_data)[i]; + if (ga_grow(&nbw->bw_prefix, bw->bw_prefix.ga_len) == OK) + { + mch_memmove(nbw->bw_prefix.ga_data, bw->bw_prefix.ga_data, + bw->bw_prefix.ga_len * sizeof(short_u)); + nbw->bw_prefix.ga_len = bw->bw_prefix.ga_len; + } + } + + ga_clear(&fixga); +} + +/* + * Go over all words in "oldwords" and change the old affix names to the new + * affix numbers, check the conditions, fold case, extract the basic word and + * additions. + */ + static int +build_wordlist(newwords, oldwords, oldaff, regionmask) + hashtab_T *newwords; /* basicword_T entries */ + hashtab_T *oldwords; /* dicword_T entries */ + afffile_T *oldaff; /* affixes for "oldwords" */ + int regionmask; /* value for bw_region */ +{ + int todo; + hashitem_T *old_hi; + dicword_T *dw; + basicword_T *bw; + char_u foldword[MAXLINELEN]; + int leadlen; + char_u leadstring[MAXLINELEN]; + int addlen; + char_u addstring[MAXLINELEN]; + int dwlen; + char_u *p; + int clen; + int flags; + char_u *cp; + int l; + + todo = oldwords->ht_used; + for (old_hi = oldwords->ht_array; todo > 0; ++old_hi) + { + if (!HASHITEM_EMPTY(old_hi)) + { + --todo; + dw = HI2DW(old_hi); + + /* This takes time, print a message now and then. */ + if ((todo & 0x3ff) == 0 || todo == oldwords->ht_used - 1) + { + if (todo != oldwords->ht_used - 1) + { + msg_didout = FALSE; + msg_col = 0; + } + smsg((char_u *)_("%6d todo - %s"), todo, dw->dw_word); + out_flush(); + ui_breakcheck(); + if (got_int) + break; + } + + /* The basic words are always stored with folded case. */ + dwlen = STRLEN(dw->dw_word); + (void)str_foldcase(dw->dw_word, dwlen, foldword, MAXLINELEN); + flags = captype(dw->dw_word, dw->dw_word + dwlen); + + /* Check for non-word characters before the word. */ + clen = 0; + leadlen = 0; + if (!spell_iswordc(foldword)) + { + p = foldword; + for (;;) + { + mb_ptr_adv(p); + ++clen; + if (*p == NUL) /* Only non-word chars (bad word!) */ + { + if (p_verbose > 0) + smsg((char_u *)_("Warning: word without word characters: \"%s\""), + foldword); + break; + } + if (spell_iswordc(p)) + { + /* Move the leader to "leadstring" and remove it from + * "foldword". */ + leadlen = p - foldword; + mch_memmove(leadstring, foldword, leadlen); + leadstring[leadlen] = NUL; + mch_memmove(foldword, p, STRLEN(p) + 1); + break; + } + } + } + + /* Check for non-word characters after word characters. */ + addlen = 0; + for (p = foldword; spell_iswordc(p); mb_ptr_adv(p)) + { + if (*p == NUL) + break; + ++clen; + } + if (*p != NUL) + { + /* Move the addition to "addstring" and truncate "foldword". */ + if (flags & BWF_KEEPCAP) + { + /* Preserve caps, need to skip the right number of + * characters in the original word (case folding may + * change the byte count). */ + l = 0; + for (cp = dw->dw_word; l < clen; mb_ptr_adv(cp)) + ++l; + addlen = STRLEN(cp); + mch_memmove(addstring, cp, addlen + 1); + } + else + { + addlen = STRLEN(p); + mch_memmove(addstring, p, addlen + 1); + } + *p = NUL; + } + + bw = (basicword_T *)alloc_clear((unsigned)sizeof(basicword_T) + + STRLEN(foldword)); + if (bw == NULL) + break; + STRCPY(bw->bw_word, foldword); + bw->bw_region = regionmask; + + if (leadlen > 0) + bw->bw_leadstring = vim_strsave(leadstring); + else + bw->bw_leadstring = NULL; + if (addlen > 0) + bw->bw_addstring = vim_strsave(addstring); + else + bw->bw_addstring = NULL; + + add_to_wordlist(newwords, bw); + + if (flags & BWF_KEEPCAP) + { + if (addlen == 0) + /* use the whole word */ + bw->bw_caseword = vim_strsave(dw->dw_word + leadlen); + else + /* use only up to the addition */ + bw->bw_caseword = vim_strnsave(dw->dw_word + leadlen, + cp - dw->dw_word - leadlen); + if (bw->bw_caseword == NULL) /* out of memory */ + flags &= ~BWF_KEEPCAP; + } + bw->bw_flags = flags; + + /* Deal with any affix names on the old word, translate them + * into affix numbers. */ + ga_init2(&bw->bw_prefix, sizeof(short_u), 10); + ga_init2(&bw->bw_suffix, sizeof(short_u), 10); + if (dw->dw_affnm != NULL) + trans_affixes(dw, bw, oldaff, newwords); + } + } + if (todo > 0) + return FAIL; + return OK; +} + +/* + * Go through the list of words and combine the ones that are identical except + * for the region. + */ + static void +combine_regions(newwords) + hashtab_T *newwords; +{ + int todo; + hashitem_T *hi; + basicword_T *bw, *nbw, *pbw; + + /* Loop over all basic words in the words table. */ + todo = newwords->ht_used; + for (hi = newwords->ht_array; todo > 0; ++hi) + { + if (!HASHITEM_EMPTY(hi)) + { + --todo; + + /* Loop over the list of words for this basic word. Compare with + * each following word in the same list. */ + for (bw = HI2BW(hi); bw != NULL; bw = bw->bw_next) + { + pbw = bw; + for (nbw = pbw->bw_next; nbw != NULL; nbw = pbw->bw_next) + { + if (bw->bw_flags == nbw->bw_flags + && (bw->bw_leadstring == NULL) + == (nbw->bw_leadstring == NULL) + && (bw->bw_addstring == NULL) + == (nbw->bw_addstring == NULL) + && ((bw->bw_flags & BWF_KEEPCAP) == 0 + || (STRCMP(bw->bw_caseword, + nbw->bw_caseword) == 0)) + && (bw->bw_leadstring == NULL + || (STRCMP(bw->bw_leadstring, + nbw->bw_leadstring) == 0)) + && (bw->bw_addstring == NULL + || (STRCMP(bw->bw_addstring, + nbw->bw_addstring) == 0)) + && same_affixes(bw, nbw) + ) + { + /* Match, combine regions and delete "nbw". */ + pbw->bw_next = nbw->bw_next; + bw->bw_region |= nbw->bw_region; + free_basicword(nbw); + } + else + /* No match, continue with next one. */ + pbw = nbw; + } + } + } + } +} + +/* + * Return TRUE when the prefixes and suffixes for "bw" and "nbw" are equal. + */ + static int +same_affixes(bw, nbw) + basicword_T *bw; + basicword_T *nbw; +{ + return (bw->bw_prefix.ga_len == nbw->bw_prefix.ga_len + && bw->bw_suffix.ga_len == nbw->bw_suffix.ga_len + && (bw->bw_prefix.ga_len == 0 + || vim_memcmp(bw->bw_prefix.ga_data, + nbw->bw_prefix.ga_data, + bw->bw_prefix.ga_len * sizeof(short_u)) == 0) + && (bw->bw_suffix.ga_len == 0 + || vim_memcmp(bw->bw_suffix.ga_data, + nbw->bw_suffix.ga_data, + bw->bw_suffix.ga_len * sizeof(short_u)) == 0)); +} + +/* + * For each basic word with additions turn the affixes into other additions + * and/or new basic words. The result is that no affixes apply to a word with + * additions. + */ + static void +expand_affixes(newwords, prefgap, suffgap) + hashtab_T *newwords; + garray_T *prefgap; + garray_T *suffgap; +{ + int todo; + hashitem_T *hi; + basicword_T *bw; + int pi, si; + affentry_T *pae, *sae; + garray_T add_words; + int n; + + ga_init2(&add_words, sizeof(basicword_T *), 10); + + todo = newwords->ht_used; + for (hi = newwords->ht_array; todo > 0; ++hi) + { + if (!HASHITEM_EMPTY(hi)) + { + --todo; + for (bw = HI2BW(hi); bw != NULL; bw = bw->bw_next) + { + /* + * Need to fix affixes if there is a leader or addition and + * there are prefixes or suffixes. + */ + if ((bw->bw_leadstring != NULL || bw->bw_addstring != NULL) + && (bw->bw_prefix.ga_len != 0 + || bw->bw_suffix.ga_len != 0)) + { + /* Loop over all prefix numbers, but first without a + * prefix. */ + for (pi = -1; pi < bw->bw_prefix.ga_len; ++pi) + { + pae = NULL; + if (pi >= 0) + { + n = ((short_u *)bw->bw_prefix.ga_data)[pi]; + pae = ((affheader_T *)prefgap->ga_data + n) + ->ah_first; + } + + /* Loop over all entries for prefix "pi". Do it once + * when there is no prefix (pi == -1). */ + do + { + /* Loop over all suffix numbers. Do without a + * suffix first when there is a prefix. */ + for (si = (pi == -1 ? 0 : -1); + si < bw->bw_suffix.ga_len; ++si) + { + sae = NULL; + if (si >= 0) + { + n = ((short_u *)bw->bw_suffix.ga_data)[si]; + sae = ((affheader_T *)suffgap->ga_data + n) + ->ah_first; + } + + /* Loop over all entries for suffix "si". Do + * it once when there is no suffix (si == -1). + */ + do + { + /* Expand the word for this combination of + * prefixes and affixes. */ + expand_one_aff(bw, &add_words, pae, sae); + + /* Advance to next suffix entry, if there + * is one. */ + if (sae != NULL) + sae = sae->ae_next; + } while (sae != NULL); + } + + /* Advance to next prefix entry, if there is one. */ + if (pae != NULL) + pae = pae->ae_next; + } while (pae != NULL); + } + } + } + } + } + + /* + * Add the new words afterwards, can't change "newwords" while going over + * all its items. + */ + for (pi = 0; pi < add_words.ga_len; ++pi) + add_to_wordlist(newwords, ((basicword_T **)add_words.ga_data)[pi]); + + ga_clear(&add_words); +} + +/* + * Add one word to "add_words" for basic word "bw" with additions, adding + * prefix "pae" and suffix "sae". Either "pae" or "sae" can be NULL. + */ + static void +expand_one_aff(bw, add_words, pae, sae) + basicword_T *bw; + garray_T *add_words; + affentry_T *pae; + affentry_T *sae; +{ + char_u word[MAXWLEN + 1]; + char_u caseword[MAXWLEN + 1]; + int l = 0; + int choplen = 0; + int ll; + basicword_T *nbw; + + /* Prepend prefix to the basic word if there is a prefix and there is no + * leadstring. */ + if (pae != NULL && bw->bw_leadstring == NULL) + { + if (pae->ae_add != NULL) + { + l = STRLEN(pae->ae_add); + mch_memmove(word, pae->ae_add, l); + } + if (pae->ae_chop != NULL) + choplen = STRLEN(pae->ae_chop); + } + + /* Copy the body of the word. */ + STRCPY(word + l, bw->bw_word + choplen); + + /* Do the same for bw_caseword, if it's there. */ + if (bw->bw_flags & BWF_KEEPCAP) + { + if (l > 0) + mch_memmove(caseword, pae->ae_add, l); + STRCPY(caseword + l, bw->bw_caseword + choplen); + } + + /* Append suffix to the basic word if there is a suffix and there is no + * addstring. */ + if (sae != 0 && bw->bw_addstring == NULL) + { + l = STRLEN(word); + if (sae->ae_chop != NULL) + l -= STRLEN(sae->ae_chop); + if (sae->ae_add == NULL) + word[l] = NUL; + else + STRCPY(word + l, sae->ae_add); + + if (bw->bw_flags & BWF_KEEPCAP) + { + /* Do the same for the caseword. */ + l = STRLEN(caseword); + if (sae->ae_chop != NULL) + l -= STRLEN(sae->ae_chop); + if (sae->ae_add == NULL) + caseword[l] = NUL; + else + STRCPY(caseword + l, sae->ae_add); + } + } + + nbw = (basicword_T *)alloc_clear((unsigned) + sizeof(basicword_T) + STRLEN(word)); + if (nbw != NULL) + { + /* Add the new word to the list of words to be added later. */ + if (ga_grow(add_words, 1) == FAIL) + { + vim_free(nbw); + return; + } + ((basicword_T **)add_words->ga_data)[add_words->ga_len++] = nbw; + + /* Copy the (modified) basic word, flags and region. */ + STRCPY(nbw->bw_word, word); + nbw->bw_flags = bw->bw_flags; + nbw->bw_region = bw->bw_region; + + /* Set the (modified) caseword. */ + if (bw->bw_flags & BWF_KEEPCAP) + if ((nbw->bw_caseword = vim_strsave(caseword)) == NULL) + nbw->bw_flags &= ~BWF_KEEPCAP; + + if (bw->bw_leadstring != NULL) + { + if (pae != NULL) + { + /* Prepend prefix to leadstring. */ + ll = STRLEN(bw->bw_leadstring); + l = choplen = 0; + if (pae->ae_add != NULL) + l = STRLEN(pae->ae_add); + if (pae->ae_chop != NULL) + { + choplen = STRLEN(pae->ae_chop); + if (choplen > ll) /* TODO: error? */ + choplen = ll; + } + nbw->bw_leadstring = alloc((unsigned)(ll + l - choplen + 1)); + if (nbw->bw_leadstring != NULL) + { + if (l > 0) + mch_memmove(nbw->bw_leadstring, pae->ae_add, l); + STRCPY(nbw->bw_leadstring + l, bw->bw_leadstring + choplen); + } + } + else + nbw->bw_leadstring = vim_strsave(bw->bw_leadstring); + } + + if (bw->bw_addstring != NULL) + { + if (sae != NULL) + { + /* Append suffix to addstring. */ + l = STRLEN(bw->bw_addstring); + if (sae->ae_chop != NULL) + { + l -= STRLEN(sae->ae_chop); + if (l < 0) /* TODO: error? */ + l = 0; + } + if (sae->ae_add == NULL) + ll = 0; + else + ll = STRLEN(sae->ae_add); + nbw->bw_addstring = alloc((unsigned)(ll + l - choplen + 1)); + if (nbw->bw_addstring != NULL) + { + STRCPY(nbw->bw_addstring, bw->bw_addstring); + if (sae->ae_add == NULL) + nbw->bw_addstring[l] = NUL; + else + STRCPY(nbw->bw_addstring + l, sae->ae_add); + } + } + else + nbw->bw_addstring = vim_strsave(bw->bw_addstring); + } + } +} + +/* + * Add basicword_T "*bw" to wordlist "newwords". + */ + static void +add_to_wordlist(newwords, bw) + hashtab_T *newwords; + basicword_T *bw; +{ + hashitem_T *hi; + basicword_T *bw2; + + hi = hash_find(newwords, bw->bw_word); + if (HASHITEM_EMPTY(hi)) + { + /* New entry, add to hashlist. */ + hash_add(newwords, bw->bw_word); + bw->bw_next = NULL; + } + else + { + /* Existing entry, append to list of basic words. */ + bw2 = HI2BW(hi); + bw->bw_next = bw2->bw_next; + bw2->bw_next = bw; + } +} + +/* + * Write a number to file "fd", MSB first, in "len" bytes. + */ + static void +put_bytes(fd, nr, len) + FILE *fd; + long_u nr; + int len; +{ + int i; + + for (i = len - 1; i >= 0; --i) + putc((int)(nr >> (i * 8)), fd); +} + +/* + * Write affix info. <affflags> <affitemcnt> <affitem> ... + */ + static void +write_affix(fd, ah) + FILE *fd; + affheader_T *ah; +{ + int i = 0; + affentry_T *ae; + char_u *p; + int round; + + fputc(ah->ah_combine ? 1 : 0, fd); /* <affflags> */ + + /* Count the number of entries. */ + for (ae = ah->ah_first; ae != NULL; ae = ae->ae_next) + ++i; + put_bytes(fd, (long_u)i, 2); /* <affitemcnt> */ + + for (ae = ah->ah_first; ae != NULL; ae = ae->ae_next) + for (round = 1; round <= 2; ++round) + { + p = round == 1 ? ae->ae_chop : ae->ae_add; + if (p == NULL) + putc(0, fd); /* <affchoplen> / <affaddlen> */ + else + { + putc(STRLEN(p), fd); /* <affchoplen> / <affaddlen> */ + /* <affchop> / <affadd> */ + fwrite(p, STRLEN(p), (size_t)1, fd); + } + } +} + +/* + * Write list of affix NRs: <affixcnt> <affixNR> ... + */ + static void +write_affixlist(fd, aff, bytes) + FILE *fd; + garray_T *aff; + int bytes; +{ + int i; + + if (aff->ga_len > 0) + { + putc(aff->ga_len, fd); /* <affixcnt> */ + for (i = 0; i < aff->ga_len; ++i) + put_bytes(fd, (long_u )((short_u *)aff->ga_data)[i], bytes); + } +} + +/* + * Vim spell file format: <HEADER> <PREFIXLIST> <SUFFIXLIST> + * <SUGGEST> <WORDLIST> + * + * <HEADER>: <fileID> <regioncnt> <regionname> ... + * + * <fileID> 10 bytes "VIMspell01" + * <regioncnt> 1 byte number of regions following (8 supported) + * <regionname> 2 bytes Region name: ca, au, etc. + * First <regionname> is region 1. + * + * + * <PREFIXLIST>: <affcount> <afftotcnt> <affix> ... + * <SUFFIXLIST>: <affcount> <afftotcnt> <affix> ... + * list of possible affixes: prefixes and suffixes. + * + * <affcount> 2 bytes Number of affixes (MSB comes first). + * When more than 256 an affixNR is 2 bytes. + * This is separate for prefixes and suffixes! + * First affixNR is 0. + * <afftotcnt> 2 bytes Total number of affix items (MSB comes first). + * + * <affix>: <affflags> <affitemcnt> <affitem> ... + * + * <affflags> 1 byte 0x01: prefix combines with suffix. + * 0x02-0x80: unset + * <affitemcnt> 2 bytes Number of affixes with this affixNR (MSB first). + * + * <affitem>: <affchoplen> <affchop> <affaddlen> <affadd> + * + * <affchoplen> 1 byte Length of <affchop> in bytes. + * <affchop> N bytes To be removed from basic word. + * <affaddlen> 1 byte Length of <affadd> in bytes. + * <affadd> N bytes To be added to basic word. + * + * + * <SUGGEST> : <suggestlen> <more> ... + * + * <suggestlen> 4 bytes Length of <SUGGEST> in bytes, excluding + * <suggestlen>. MSB first. + * <more> To be defined. + * + * + * <WORDLIST>: <wordcount> <worditem> ... + * + * <wordcount> 4 bytes Number of <worditem> following. MSB first. + * + * <worditem>: <nr> <string> <flags> [<flags2>] + * [<caselen> <caseword>] + * [<affixcnt> <affixNR> ...] (prefixes) + * [<affixcnt> <affixNR> ...] (suffixes) + * [<region>] + * [<addcnt> <add> ...] + * + * <nr> i 1 byte Number of bytes copied from previous word. + * <string> N bytes Additional bytes for word, up to byte smaller than + * 0x20 (space). + * Must only contain case-folded word characters. + * <flags> 1 byte 0x01: word is valid without addition + * 0x02: has region byte + * 0x04: first letter must be upper-case + * 0x08: has suffixes, <affixcnt> and <affixNR> follow + * 0x10: more flags, <flags2> follows next + * 0x20-0x80: can't be used, unset + * <flags2> 1 byte 0x01: has additions, <addcnt> and <add> follow + * 0x02: has prefixes, <affixcnt> and <affixNR> follow + * 0x04: all letters must be upper-case + * 0x08: case must match + * 0x10-0x80: unset + * <caselen> 1 byte Length of <caseword>. + * <caseword> N bytes Word with matching case. + * <affixcnt> 1 byte Number of affix NRs following. + * <affixNR> 1 or 2 byte Number of possible affix for this word. + * When using 2 bytes MSB comes first. + * <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. + * <addcnt> 2 bytes Number of <add> items following. + * + * <add>: <addflags> <addlen> [<leadlen> <addstring>] [<region>] + * + * <addflags> 1 byte 0x01: fixed case, <addstring> is the whole word + * with matching case. + * 0x02: first letter must be upper-case + * 0x04: all letters must be upper-case + * 0x08: has region byte + * 0x10-0x80: unset + * <addlen> 1 byte Length of <addstring> in bytes. + * <leadlen> 1 byte Number of bytes at start of <addstring> that must + * come before the start of the basic word. + * <addstring> N bytes Word characters, before/in/after the word. + * + * All text characters are in 'encoding': <affchop>, <affadd>, <string>, + * <caseword>> and <addstring>. + * All other fields are ASCII: <regionname> + * <string> is always case-folded. + */ + +/* + * Write the Vim spell file "fname". + */ + static void +write_vim_spell(fname, prefga, suffga, newwords, regcount, regchars) + char_u *fname; + garray_T *prefga; /* prefixes, affheader_T entries */ + garray_T *suffga; /* suffixes, affheader_T entries */ + hashtab_T *newwords; /* basic words, basicword_T entries */ + int regcount; /* number of regions */ + char_u *regchars; /* region names */ +{ + FILE *fd; + garray_T *gap; + hashitem_T *hi; + char_u **wtab; + int todo; + int flags, aflags; + basicword_T *bw, *bwf, *bw2, *prevbw = NULL; + int regionmask; /* mask for all relevant region bits */ + int i; + int cnt; + affentry_T *ae; + int round; + int prefm, suffm; + garray_T bwga; + + fd = fopen((char *)fname, "w"); + if (fd == NULL) + { + EMSG2(_(e_notopen), fname); + return; + } + + fwrite(VIMSPELLMAGIC, VIMSPELLMAGICL, (size_t)1, fd); + + /* write the region names if there is more than one */ + if (regcount > 1) + { + putc(regcount, fd); + fwrite(regchars, (size_t)(regcount * 2), (size_t)1, fd); + regionmask = (1 << regcount) - 1; + } + else + { + putc(0, fd); + regionmask = 0; + } + + /* Write the prefix and suffix lists. */ + for (round = 1; round <= 2; ++round) + { + gap = round == 1 ? prefga : suffga; + put_bytes(fd, (long_u)gap->ga_len, 2); /* <affcount> */ + + /* Count the total number of affix items. */ + cnt = 0; + for (i = 0; i < gap->ga_len; ++i) + for (ae = ((affheader_T *)gap->ga_data + i)->ah_first; + ae != NULL; ae = ae->ae_next) + ++cnt; + put_bytes(fd, (long_u)cnt, 2); /* <afftotcnt> */ + + for (i = 0; i < gap->ga_len; ++i) + write_affix(fd, (affheader_T *)gap->ga_data + i); + } + + /* Number of bytes used for affix NR depends on affix count. */ + prefm = (prefga->ga_len > 256) ? 2 : 1; + suffm = (suffga->ga_len > 256) ? 2 : 1; + + /* Write the suggest info. TODO */ + put_bytes(fd, 0L, 4); + + /* + * Write the word list. <wordcount> <worditem> ... + */ + /* number of basic words in 4 bytes */ + put_bytes(fd, newwords->ht_used, 4); /* <wordcount> */ + + /* + * Sort the word list, so that we can reuse as many bytes as possible. + */ + wtab = (char_u **)alloc((unsigned)(sizeof(char_u *) * newwords->ht_used)); + if (wtab != NULL) + { + /* Make a table with pointers to each word. */ + todo = newwords->ht_used; + for (hi = newwords->ht_array; todo > 0; ++hi) + if (!HASHITEM_EMPTY(hi)) + wtab[--todo] = hi->hi_key; + + /* Sort. */ + sort_strings(wtab, (int)newwords->ht_used); + + /* Now write each basic word to the spell file. */ + ga_init2(&bwga, sizeof(basicword_T *), 10); + for (todo = 0; todo < newwords->ht_used; ++todo) + { + bwf = KEY2BW(wtab[todo]); + + /* + * Reorder the list of basicword_T words: make a list for words + * with the same case-folded word. Put them together for same + * caps (ONECAP, ALLCAP and various KEEPCAP words) and same + * affixes. Each list will then be put as a basic word with + * additions. + * This won't take much space, since the basic word is the same + * every time, only its length is written. + */ + bwga.ga_len = 0; + for (bw = bwf; bw != NULL; bw = bw->bw_next) + { + flags = bw->bw_flags & (BWF_ONECAP | BWF_KEEPCAP | BWF_ALLCAP); + + /* Go through the lists we found so far. Break when the case + * matches. */ + for (i = 0; i < bwga.ga_len; ++i) + { + bw2 = ((basicword_T **)bwga.ga_data)[i]; + aflags = bw2->bw_flags & (BWF_ONECAP | BWF_KEEPCAP + | BWF_ALLCAP); + if (flags == aflags + && ((flags & BWF_KEEPCAP) == 0 + || (STRCMP(bw->bw_caseword, + bw2->bw_caseword) == 0)) + && same_affixes(bw, bw2)) + break; + } + if (i == bwga.ga_len) + { + /* No word with similar caps, make a new list. */ + if (ga_grow(&bwga, 1) == FAIL) + break; + ((basicword_T **)bwga.ga_data)[i] = bw; + bw->bw_cnext = NULL; + ++bwga.ga_len; + } + else + { + /* Add to list of words with similar caps. */ + bw->bw_cnext = bw2->bw_cnext; + bw2->bw_cnext = bw; + } + } + + /* Prefer the word with no caps to use as the first basic word. + * At least one without KEEPCAP. */ + bw = NULL; + for (i = 0; i < bwga.ga_len; ++i) + { + bw2 = ((basicword_T **)bwga.ga_data)[i]; + if (bw == NULL + || (bw2->bw_flags & (BWF_ONECAP | BWF_KEEPCAP + | BWF_ALLCAP)) == 0 + || (bw->bw_flags & BWF_KEEPCAP)) + bw = bw2; + } + + /* Write first basic word. If it's KEEPCAP then we need a word + * without VALID flag first (makes it easier to read the list back + * in). */ + if (bw->bw_flags & BWF_KEEPCAP) + write_bword(fd, bw, TRUE, &prevbw, regionmask, prefm, suffm); + write_bword(fd, bw, FALSE, &prevbw, regionmask, prefm, suffm); + + /* Write other basic words, with different caps. */ + for (i = 0; i < bwga.ga_len; ++i) + { + bw2 = ((basicword_T **)bwga.ga_data)[i]; + if (bw2 != bw) + write_bword(fd, bw2, FALSE, &prevbw, regionmask, + prefm, suffm); + } + } + + ga_clear(&bwga); + } + + fclose(fd); +} + +/* + * Write basic word, followed by any additions. + * + * <worditem>: <nr> <string> <flags> [<flags2>] + * [<caselen> <caseword>] + * [<affixcnt> <affixNR> ...] (prefixes) + * [<affixcnt> <affixNR> ...] (suffixes) + * [<region>] + * [<addcnt> <add> ...] + */ + static void +write_bword(fd, bwf, lowcap, prevbw, regionmask, prefm, suffm) + FILE *fd; + basicword_T *bwf; + int lowcap; /* write KEEPKAP word as not-valid */ + basicword_T **prevbw; /* last written basic word */ + int regionmask; /* mask that includes all possible regions */ + int prefm; + int suffm; +{ + int flags; + int aflags; + int len; + int leadlen, addlen; + int clen; + int adds = 0; + int i; + basicword_T *bw, *bw2; + + /* Check how many bytes can be copied from the previous word. */ + len = STRLEN(bwf->bw_word); + if (*prevbw == NULL) + clen = 0; + else + for (clen = 0; clen < len + && (*prevbw)->bw_word[clen] == bwf->bw_word[clen]; ++clen) + ; + putc(clen, fd); /* <nr> */ + *prevbw = bwf; + /* <string> */ + if (len > clen) + fwrite(bwf->bw_word + clen, (size_t)(len - clen), (size_t)1, fd); + + /* Try to find a word without additions to use first. */ + bw = bwf; + for (bw2 = bwf; bw2 != NULL; bw2 = bw2->bw_cnext) + { + if (bw2->bw_addstring != NULL || bw2->bw_leadstring != NULL) + ++adds; + else + bw = bw2; + } + + /* Flags: If there is no leadstring and no addstring the basic word is + * valid, may have prefixes, suffixes and region. */ + flags = bw->bw_flags; + if (bw->bw_addstring == NULL && bw->bw_leadstring == NULL) + { + flags |= BWF_VALID; + + /* Add the prefix/suffix list if there are prefixes/suffixes. */ + if (bw->bw_prefix.ga_len > 0) + flags |= BWF_PREFIX; + if (bw->bw_suffix.ga_len > 0) + flags |= BWF_SUFFIX; + + /* Flags: add the region byte if the word isn't valid in all + * regions. */ + if (regionmask != 0 && (bw->bw_region & regionmask) != regionmask) + flags |= BWF_REGION; + } + + /* Flags: may have additions. */ + if (adds > 0) + flags |= BWF_ADDS; + + /* The dummy word before a KEEPCAP word doesn't have any flags, they are + * in the actual word that follows. */ + if (lowcap) + flags = 0; + + /* Flags: when the upper byte is not used we only write one flags + * byte, if it's used then set an extra flag in the first byte and + * also write the second byte. */ + if ((flags & 0xff00) == 0) + putc(flags, fd); /* <flags> */ + else + { + putc(flags | BWF_SECOND, fd); /* <flags> */ + putc((int)((unsigned)flags >> 8), fd); /* <flags2> */ + } + + /* First dummy word doesn't need anything but flags. */ + if (lowcap) + return; + + if (flags & BWF_KEEPCAP) + { + len = STRLEN(bw->bw_caseword); + putc(len, fd); /* <caselen> */ + for (i = 0; i < len; ++i) + putc(bw->bw_caseword[i], fd); /* <caseword> */ + } + + /* write prefix and suffix lists: <affixcnt> <affixNR> ... */ + if (flags & BWF_PREFIX) + write_affixlist(fd, &bw->bw_prefix, prefm); + if (flags & BWF_SUFFIX) + write_affixlist(fd, &bw->bw_suffix, suffm); + + if (flags & BWF_REGION) + putc(bw->bw_region, fd); /* <region> */ + + /* + * Additions. + */ + if (adds > 0) + { + put_bytes(fd, (long_u)adds, 2); /* <addcnt> */ + + for (bw = bwf; bw != NULL; bw = bw->bw_cnext) + if (bw->bw_leadstring != NULL || bw->bw_addstring != NULL) + { + /* <add>: <addflags> <addlen> [<leadlen> <addstring>] + * [<region>] */ + aflags = 0; + if (bw->bw_flags & BWF_ONECAP) + aflags |= ADD_ONECAP; + if (bw->bw_flags & BWF_ALLCAP) + aflags |= ADD_ALLCAP; + if (bw->bw_flags & BWF_KEEPCAP) + aflags |= ADD_KEEPCAP; + if (regionmask != 0 + && (bw->bw_region & regionmask) != regionmask) + aflags |= ADD_REGION; + putc(aflags, fd); /* <addflags> */ + + if (bw->bw_leadstring == NULL) + leadlen = 0; + else + leadlen = STRLEN(bw->bw_leadstring); + if (bw->bw_addstring == NULL) + addlen = 0; + else + addlen = STRLEN(bw->bw_addstring); + putc(leadlen + addlen, fd); /* <addlen> */ + putc(leadlen, fd); /* <leadlen> */ + /* <addstring> */ + if (bw->bw_leadstring != NULL) + fwrite(bw->bw_leadstring, (size_t)leadlen, (size_t)1, fd); + if (bw->bw_addstring != NULL) + fwrite(bw->bw_addstring, (size_t)addlen, (size_t)1, fd); + + if (aflags & ADD_REGION) + putc(bw->bw_region, fd); /* <region> */ + } + } +} + + +/* + * ":mkspell outfile infile ..." + */ + void +ex_mkspell(eap) + exarg_T *eap; +{ + int fcount; + char_u **fnames; + char_u fname[MAXPATHL]; + char_u wfname[MAXPATHL]; + afffile_T *(afile[8]); + hashtab_T dfile[8]; + int i; + int len; + char_u region_name[16]; + struct stat st; + int round; + vimconv_T conv; + + /* Expand all the arguments (e.g., $VIMRUNTIME). */ + if (get_arglist_exp(eap->arg, &fcount, &fnames) == FAIL) + return; + if (fcount < 2) + EMSG(_(e_invarg)); /* need at least output and input names */ + else if (fcount > 9) + EMSG(_("E754: Only up to 8 regions supported")); + else + { + /* Check for overwriting before doing things that may take a lot of + * time. */ + sprintf((char *)wfname, "%s.%s.spl", fnames[0], p_enc); + if (!eap->forceit && mch_stat((char *)wfname, &st) >= 0) + { + EMSG(_(e_exists)); + goto theend; + } + if (mch_isdir(fnames[0])) + { + EMSG2(_(e_isadir2), fnames[0]); + goto theend; + } + + /* + * Init the aff and dic pointers. + * Get the region names if there are more than 2 arguments. + */ + for (i = 1; i < fcount; ++i) + { + afile[i - 1] = NULL; + hash_init(&dfile[i - 1]); + if (fcount > 2) + { + len = STRLEN(fnames[i]); + if (STRLEN(gettail(fnames[i])) < 5 || fnames[i][len - 3] != '_') + { + EMSG2(_("E755: Invalid region in %s"), fnames[i]); + goto theend; + } + else + { + region_name[(i - 1) * 2] = TOLOWER_ASC(fnames[i][len - 2]); + region_name[(i - 1) * 2 + 1] = + TOLOWER_ASC(fnames[i][len - 1]); + } + } + } + + /* + * Read all the .aff and .dic files. + * Text is converted to 'encoding'. + */ + for (i = 1; i < fcount; ++i) + { + /* Read the .aff file. Will init "conv" based on the "SET" line. */ + conv.vc_type = CONV_NONE; + sprintf((char *)fname, "%s.aff", fnames[i]); + if ((afile[i - 1] = spell_read_aff(fname, &conv)) == NULL) + break; + + /* Read the .dic file. */ + sprintf((char *)fname, "%s.dic", fnames[i]); + if (spell_read_dic(&dfile[i - 1], fname, &conv) == FAIL) + break; + + /* Free any conversion stuff. */ + convert_setup(&conv, NULL, NULL); + } + + /* Process the data when all the files could be read. */ + if (i == fcount) + { + garray_T prefga; + garray_T suffga; + garray_T *gap; + hashtab_T newwords; + + /* + * Combine all the affixes into one new affix list. This is done + * for prefixes and suffixes separately. + * We need to do this for each region, try to re-use the same + * affixes. + * Since we number the new affix entries, a growarray will do. In + * the affheader_T the ah_key is unused. + */ + MSG(_("Combining affixes...")); + out_flush(); + for (round = 1; round <= 2; ++round) + { + gap = round == 1 ? &prefga : &suffga; + ga_init2(gap, sizeof(affheader_T), 50); + for (i = 1; i < fcount; ++i) + get_new_aff(round == 1 ? &afile[i - 1]->af_pref + : &afile[i - 1]->af_suff, gap); + } + + /* + * Go over all words and: + * - change the old affix names to the new affix numbers + * - check the conditions + * - fold case + * - extract the basic word and additions. + * Do this for each region. + */ + MSG(_("Building word list...")); + out_flush(); + hash_init(&newwords); + + for (i = 1; i < fcount; ++i) + build_wordlist(&newwords, &dfile[i - 1], afile[i - 1], + 1 << (i - 1)); + + if (fcount > 2) + { + /* Combine words for the different regions into one. */ + MSG(_("Combining regions...")); + out_flush(); + combine_regions(&newwords); + } + + /* + * Affixes on a word with additions are clumsy, would require + * inefficient searching. Turn the affixes into additions and/or + * the expanded word. + */ + MSG(_("Processing words...")); + out_flush(); + expand_affixes(&newwords, &prefga, &suffga); + + /* Write the info in the spell file. */ + smsg((char_u *)_("Writing spell file %s..."), wfname); + out_flush(); + write_vim_spell(wfname, &prefga, &suffga, &newwords, + fcount - 1, region_name); + MSG(_("Done!")); + out_flush(); + + /* Free the allocated stuff. */ + free_wordtable(&newwords); + for (round = 1; round <= 2; ++round) + { + gap = round == 1 ? &prefga: &suffga; + for (i = 0; i < gap->ga_len; ++i) + free_affixentries(((affheader_T *)gap->ga_data + i) + ->ah_first); + ga_clear(gap); + } + } + + /* Free the .aff and .dic file structures. */ + for (i = 1; i < fcount; ++i) + { + if (afile[i - 1] != NULL) + spell_free_aff(afile[i - 1]); + spell_free_dic(&dfile[i - 1]); + } + } + +theend: + FreeWild(fcount, fnames); +} + + static void +free_wordtable(ht) + hashtab_T *ht; +{ + int todo; + basicword_T *bw, *nbw; + hashitem_T *hi; + + todo = ht->ht_used; + for (hi = ht->ht_array; todo > 0; ++hi) + { + if (!HASHITEM_EMPTY(hi)) + { + --todo; + for (bw = HI2BW(hi); bw != NULL; bw = nbw) + { + nbw = bw->bw_next; + free_basicword(bw); + } + } + } +} + +/* + * Free a basicword_T and what it contains. + */ + static void +free_basicword(bw) + basicword_T *bw; +{ + ga_clear(&bw->bw_prefix); + ga_clear(&bw->bw_suffix); + vim_free(bw->bw_caseword); + vim_free(bw->bw_leadstring); + vim_free(bw->bw_addstring); + vim_free(bw); +} + +/* + * Free a list of affentry_T. + */ + static void +free_affixentries(first) + affentry_T *first; +{ + affentry_T *ap, *an; + + for (ap = first; ap != NULL; ap = an) + { + an = ap->ae_next; + vim_free(ap->ae_chop); + vim_free(ap->ae_add); + vim_free(ap->ae_cond); + vim_free(ap->ae_prog); + vim_free(ap); + } +} + +#endif /* FEAT_MBYTE */ + +#endif /* FEAT_SYN_HL */ + +#if 0 /* old spell code with words in .spl file */ +/* + * Structure that is used to store the text from the language file. This + * avoids the need to allocate space for each individual word. It's allocated + * in big chunks for speed. */ #define SBLOCKSIZE 4096 /* default size of sb_data */ typedef struct sblock_S sblock_T; @@ -75,7 +3932,7 @@ static slang_T *first_lang = NULL; typedef struct dword_S { char_u dw_region; /* one bit per region where it's valid */ - char_u dw_flags; /* WF_ flags */ + char_u dw_flags; /* DW_ flags */ char_u dw_word[1]; /* actually longer, NUL terminated */ } dword_T; @@ -91,7 +3948,7 @@ typedef struct nword_S starting with non-word character */ int nw_maxlen; /* longest nword length (after the dword) */ char_u nw_region; /* one bit per region where it's valid */ - char_u nw_flags; /* WF_ flags */ + char_u nw_flags; /* DW_ flags */ char_u nw_word[1]; /* actually longer, NUL terminated */ } nword_T; @@ -921,163 +4778,5 @@ theend: vim_free(rbuf); } -/* - * Parse 'spelllang' and set buf->b_langp accordingly. - * Returns an error message or NULL. - */ - char_u * -did_set_spelllang(buf) - buf_T *buf; -{ - garray_T ga; - char_u *lang; - char_u *e; - char_u *region; - int region_mask; - slang_T *lp; - int c; - - ga_init2(&ga, sizeof(langp_T), 2); - - /* loop over comma separated languages. */ - for (lang = buf->b_p_spl; *lang != NUL; lang = e) - { - e = vim_strchr(lang, ','); - if (e == NULL) - e = lang + STRLEN(lang); - if (e > lang + 2) - { - if (lang[2] != '_' || e - lang != 5) - { - ga_clear(&ga); - return e_invarg; - } - region = lang + 3; - } - else - region = NULL; - - for (lp = first_lang; lp != NULL; lp = lp->sl_next) - if (STRNICMP(lp->sl_name, lang, 2) == 0) - break; - - if (lp == NULL) - /* Not found, load the language. */ - lp = spell_load_lang(lang); - - if (lp != NULL) - { - if (region == NULL) - region_mask = REGION_ALL; - else - { - /* find region in sl_regions */ - c = find_region(lp->sl_regions, region); - if (c == REGION_ALL) - { - c = lang[5]; - lang[5] = NUL; - smsg((char_u *)_("Warning: region %s not supported"), lang); - lang[5] = c; - region_mask = REGION_ALL; - } - else - region_mask = 1 << c; - } - - if (ga_grow(&ga, 1) == FAIL) - { - ga_clear(&ga); - 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; - } - - if (*e == ',') - ++e; - } - - /* Add a NULL entry to mark the end of the list. */ - if (ga_grow(&ga, 1) == FAIL) - { - ga_clear(&ga); - return e_outofmem; - } - LANGP_ENTRY(ga, ga.ga_len)->lp_slang = NULL; - ++ga.ga_len; - - /* Everything is fine, store the new b_langp value. */ - ga_clear(&buf->b_langp); - buf->b_langp = ga; - - return NULL; -} - -/* - * Find the region "region[2]" in "rp" (points to "sl_regions"). - * Each region is simply stored as the two characters of it's name. - * Returns the index if found, REGION_ALL if not found. - */ - static int -find_region(rp, region) - char_u *rp; - char_u *region; -{ - int i; - - for (i = 0; ; i += 2) - { - if (rp[i] == NUL) - return REGION_ALL; - if (rp[i] == region[0] && rp[i + 1] == region[1]) - break; - } - return i / 2; -} - -# if defined(FEAT_MBYTE) || defined(PROTO) -/* - * Clear all spelling tables and reload them. - * Used after 'encoding' is set. - */ - void -spell_reload() -{ - buf_T *buf; - slang_T *lp; - sblock_T *sp; - /* Initialize the table for spell_iswordc(). */ - init_spell_chartab(); - - /* Unload all allocated memory. */ - while (first_lang != NULL) - { - lp = first_lang; - first_lang = lp->sl_next; - - hash_clear(&lp->sl_fwords.wi_ht); - ga_clear(&lp->sl_fwords.wi_add); - hash_clear(&lp->sl_kwords.wi_ht); - ga_clear(&lp->sl_kwords.wi_add); - while (lp->sl_block != NULL) - { - sp = lp->sl_block; - lp->sl_block = sp->sb_next; - vim_free(sp); - } - } - - /* Go through all buffers and handle 'spelllang'. */ - for (buf = firstbuf; buf != NULL; buf = buf->b_next) - { - ga_clear(&buf->b_langp); - if (*buf->b_p_spl != NUL) - did_set_spelllang(buf); - } -} -# endif - -#endif /* FEAT_SYN_HL */ +#endif |