Mercurial > vim
diff src/spellfile.c @ 18814:7e7ec935e7c8 v8.1.2395
patch 8.1.2395: using old C style comments
Commit: https://github.com/vim/vim/commit/0d6f5d9740dbad1b0207f3ab257de806169dd905
Author: Bram Moolenaar <Bram@vim.org>
Date: Thu Dec 5 21:33:15 2019 +0100
patch 8.1.2395: using old C style comments
Problem: Using old C style comments.
Solution: Use // comments where appropriate.
| author | Bram Moolenaar <Bram@vim.org> |
|---|---|
| date | Thu, 05 Dec 2019 21:45:04 +0100 |
| parents | 4fbfecbb968c |
| children | 847cc7932c42 |
line wrap: on
line diff
--- a/src/spellfile.c +++ b/src/spellfile.c @@ -241,57 +241,57 @@ #if defined(FEAT_SPELL) || defined(PROTO) -#ifndef UNIX /* it's in os_unix.h for Unix */ -# include <time.h> /* for time_t */ +#ifndef UNIX // it's in os_unix.h for Unix +# include <time.h> // for time_t #endif -#ifndef UNIX /* it's in os_unix.h for Unix */ -# include <time.h> /* for time_t */ +#ifndef UNIX // it's in os_unix.h for Unix +# include <time.h> // for time_t #endif -/* Special byte values for <byte>. Some are only used in the tree for - * postponed prefixes, some only in the other trees. This is a bit messy... */ -#define BY_NOFLAGS 0 /* end of word without flags or region; for - * postponed prefix: no <pflags> */ -#define BY_INDEX 1 /* child is shared, index follows */ -#define BY_FLAGS 2 /* end of word, <flags> byte follows; for - * postponed prefix: <pflags> follows */ -#define BY_FLAGS2 3 /* end of word, <flags> and <flags2> bytes - * follow; never used in prefix tree */ -#define BY_SPECIAL BY_FLAGS2 /* highest special byte value */ +// Special byte values for <byte>. Some are only used in the tree for +// postponed prefixes, some only in the other trees. This is a bit messy... +#define BY_NOFLAGS 0 // end of word without flags or region; for + // postponed prefix: no <pflags> +#define BY_INDEX 1 // child is shared, index follows +#define BY_FLAGS 2 // end of word, <flags> byte follows; for + // postponed prefix: <pflags> follows +#define BY_FLAGS2 3 // end of word, <flags> and <flags2> bytes + // follow; never used in prefix tree +#define BY_SPECIAL BY_FLAGS2 // highest special byte value #define ZERO_FLAG 65009 // used when flag is zero: "0" -/* Flags used in .spl file for soundsalike flags. */ +// Flags used in .spl file for soundsalike flags. #define SAL_F0LLOWUP 1 #define SAL_COLLAPSE 2 #define SAL_REM_ACCENTS 4 -#define VIMSPELLMAGIC "VIMspell" /* string at start of Vim spell file */ +#define VIMSPELLMAGIC "VIMspell" // string at start of Vim spell file #define VIMSPELLMAGICL 8 #define VIMSPELLVERSION 50 -/* Section IDs. Only renumber them when VIMSPELLVERSION changes! */ -#define SN_REGION 0 /* <regionname> section */ -#define SN_CHARFLAGS 1 /* charflags section */ -#define SN_MIDWORD 2 /* <midword> section */ -#define SN_PREFCOND 3 /* <prefcond> section */ -#define SN_REP 4 /* REP items section */ -#define SN_SAL 5 /* SAL items section */ -#define SN_SOFO 6 /* soundfolding section */ -#define SN_MAP 7 /* MAP items section */ -#define SN_COMPOUND 8 /* compound words section */ -#define SN_SYLLABLE 9 /* syllable section */ -#define SN_NOBREAK 10 /* NOBREAK section */ -#define SN_SUGFILE 11 /* timestamp for .sug file */ -#define SN_REPSAL 12 /* REPSAL items section */ -#define SN_WORDS 13 /* common words */ -#define SN_NOSPLITSUGS 14 /* don't split word for suggestions */ -#define SN_INFO 15 /* info section */ -#define SN_NOCOMPOUNDSUGS 16 /* don't compound for suggestions */ -#define SN_END 255 /* end of sections */ - -#define SNF_REQUIRED 1 /* <sectionflags>: required section */ +// Section IDs. Only renumber them when VIMSPELLVERSION changes! +#define SN_REGION 0 // <regionname> section +#define SN_CHARFLAGS 1 // charflags section +#define SN_MIDWORD 2 // <midword> section +#define SN_PREFCOND 3 // <prefcond> section +#define SN_REP 4 // REP items section +#define SN_SAL 5 // SAL items section +#define SN_SOFO 6 // soundfolding section +#define SN_MAP 7 // MAP items section +#define SN_COMPOUND 8 // compound words section +#define SN_SYLLABLE 9 // syllable section +#define SN_NOBREAK 10 // NOBREAK section +#define SN_SUGFILE 11 // timestamp for .sug file +#define SN_REPSAL 12 // REPSAL items section +#define SN_WORDS 13 // common words +#define SN_NOSPLITSUGS 14 // don't split word for suggestions +#define SN_INFO 15 // info section +#define SN_NOCOMPOUNDSUGS 16 // don't compound for suggestions +#define SN_END 255 // end of sections + +#define SNF_REQUIRED 1 // <sectionflags>: required section #define CF_WORD 0x01 #define CF_UPPER 0x02 @@ -341,7 +341,7 @@ spell_load_file( char_u *fname, char_u *lang, slang_T *old_lp, - int silent) /* no error if file doesn't exist */ + int silent) // no error if file doesn't exist { FILE *fd; char_u buf[VIMSPELLMAGICL]; @@ -381,18 +381,18 @@ spell_load_file( if (lp == NULL) goto endFAIL; - /* Remember the file name, used to reload the file when it's updated. */ + // Remember the file name, used to reload the file when it's updated. lp->sl_fname = vim_strsave(fname); if (lp->sl_fname == NULL) goto endFAIL; - /* Check for .add.spl (_add.spl for VMS). */ + // Check for .add.spl (_add.spl for VMS). lp->sl_add = strstr((char *)gettail(fname), SPL_FNAME_ADD) != NULL; } else lp = old_lp; - /* Set sourcing_name, so that error messages mention the file name. */ + // Set sourcing_name, so that error messages mention the file name. sourcing_name = fname; sourcing_lnum = 0; @@ -400,13 +400,13 @@ spell_load_file( * <HEADER>: <fileID> */ for (i = 0; i < VIMSPELLMAGICL; ++i) - buf[i] = getc(fd); /* <fileID> */ + buf[i] = getc(fd); // <fileID> if (STRNCMP(buf, VIMSPELLMAGIC, VIMSPELLMAGICL) != 0) { emsg(_("E757: This does not look like a spell file")); goto endFAIL; } - c = getc(fd); /* <versionnr> */ + c = getc(fd); // <versionnr> if (c < VIMSPELLVERSION) { emsg(_("E771: Old spell file, needs to be updated")); @@ -425,11 +425,11 @@ spell_load_file( */ for (;;) { - n = getc(fd); /* <sectionID> or <sectionend> */ + n = getc(fd); // <sectionID> or <sectionend> if (n == SN_END) break; - c = getc(fd); /* <sectionflags> */ - len = get4c(fd); /* <sectionlen> */ + c = getc(fd); // <sectionflags> + len = get4c(fd); // <sectionlen> if (len < 0) goto truncerr; @@ -437,7 +437,7 @@ spell_load_file( switch (n) { case SN_INFO: - lp->sl_info = read_string(fd, len); /* <infotext> */ + lp->sl_info = read_string(fd, len); // <infotext> if (lp->sl_info == NULL) goto endFAIL; break; @@ -451,7 +451,7 @@ spell_load_file( break; case SN_MIDWORD: - lp->sl_midword = read_string(fd, len); /* <midword> */ + lp->sl_midword = read_string(fd, len); // <midword> if (lp->sl_midword == NULL) goto endFAIL; break; @@ -477,7 +477,7 @@ spell_load_file( break; case SN_MAP: - p = read_string(fd, len); /* <mapstr> */ + p = read_string(fd, len); // <mapstr> if (p == NULL) goto endFAIL; set_map_str(lp, p); @@ -489,7 +489,7 @@ spell_load_file( break; case SN_SUGFILE: - lp->sl_sugtime = get8ctime(fd); /* <timestamp> */ + lp->sl_sugtime = get8ctime(fd); // <timestamp> break; case SN_NOSPLITSUGS: @@ -509,7 +509,7 @@ spell_load_file( break; case SN_SYLLABLE: - lp->sl_syllable = read_string(fd, len); /* <syllable> */ + lp->sl_syllable = read_string(fd, len); // <syllable> if (lp->sl_syllable == NULL) goto endFAIL; if (init_syl_tab(lp) == FAIL) @@ -517,8 +517,8 @@ spell_load_file( break; default: - /* Unsupported section. When it's required give an error - * message. When it's not required skip the contents. */ + // Unsupported section. When it's required give an error + // message. When it's not required skip the contents. if (c & SNF_REQUIRED) { emsg(_("E770: Unsupported section in spell file")); @@ -545,23 +545,23 @@ truncerr: goto endFAIL; } - /* <LWORDTREE> */ + // <LWORDTREE> res = spell_read_tree(fd, &lp->sl_fbyts, &lp->sl_fidxs, FALSE, 0); if (res != 0) goto someerror; - /* <KWORDTREE> */ + // <KWORDTREE> res = spell_read_tree(fd, &lp->sl_kbyts, &lp->sl_kidxs, FALSE, 0); if (res != 0) goto someerror; - /* <PREFIXTREE> */ + // <PREFIXTREE> res = spell_read_tree(fd, &lp->sl_pbyts, &lp->sl_pidxs, TRUE, lp->sl_prefixcnt); if (res != 0) goto someerror; - /* For a new file link it in the list of spell files. */ + // For a new file link it in the list of spell files. if (old_lp == NULL && lang != NULL) { lp->sl_next = first_lang; @@ -572,7 +572,7 @@ truncerr: endFAIL: if (lang != NULL) - /* truncating the name signals the error to spell_load_lang() */ + // truncating the name signals the error to spell_load_lang() *lang = NUL; if (lp != NULL && old_lp == NULL) slang_free(lp); @@ -609,7 +609,7 @@ tree_count_words(char_u *byts, idx_T *id { if (curi[depth] > byts[arridx[depth]]) { - /* Done all bytes at this node, go up one level. */ + // Done all bytes at this node, go up one level. idxs[arridx[depth]] = wordcount[depth]; if (depth > 0) wordcount[depth - 1] += wordcount[depth]; @@ -619,18 +619,18 @@ tree_count_words(char_u *byts, idx_T *id } else { - /* Do one more byte at this node. */ + // Do one more byte at this node. n = arridx[depth] + curi[depth]; ++curi[depth]; c = byts[n]; if (c == 0) { - /* End of word, count it. */ + // End of word, count it. ++wordcount[depth]; - /* Skip over any other NUL bytes (same word with different - * flags). */ + // Skip over any other NUL bytes (same word with different + // flags). while (byts[n + 1] == 0) { ++n; @@ -639,7 +639,7 @@ tree_count_words(char_u *byts, idx_T *id } else { - /* Normal char, go one level deeper to count the words. */ + // Normal char, go one level deeper to count the words. ++depth; arridx[depth] = idxs[n]; curi[depth] = 1; @@ -668,16 +668,16 @@ suggest_load_files(void) garray_T ga; int c; - /* Do this for all languages that support sound folding. */ + // Do this for all languages that support sound folding. for (lpi = 0; lpi < curwin->w_s->b_langp.ga_len; ++lpi) { lp = LANGP_ENTRY(curwin->w_s->b_langp, lpi); slang = lp->lp_slang; if (slang->sl_sugtime != 0 && !slang->sl_sugloaded) { - /* Change ".spl" to ".sug" and open the file. When the file isn't - * found silently skip it. Do set "sl_sugloaded" so that we - * don't try again and again. */ + // Change ".spl" to ".sug" and open the file. When the file isn't + // found silently skip it. Do set "sl_sugloaded" so that we + // don't try again and again. slang->sl_sugloaded = TRUE; dotp = vim_strrchr(slang->sl_fname, '.'); @@ -692,14 +692,14 @@ suggest_load_files(void) * <SUGHEADER>: <fileID> <versionnr> <timestamp> */ for (i = 0; i < VIMSUGMAGICL; ++i) - buf[i] = getc(fd); /* <fileID> */ + buf[i] = getc(fd); // <fileID> if (STRNCMP(buf, VIMSUGMAGIC, VIMSUGMAGICL) != 0) { semsg(_("E778: This does not look like a .sug file: %s"), slang->sl_fname); goto nextone; } - c = getc(fd); /* <versionnr> */ + c = getc(fd); // <versionnr> if (c < VIMSUGVERSION) { semsg(_("E779: Old .sug file, needs to be updated: %s"), @@ -713,9 +713,9 @@ suggest_load_files(void) goto nextone; } - /* Check the timestamp, it must be exactly the same as the one in - * the .spl file. Otherwise the word numbers won't match. */ - timestamp = get8ctime(fd); /* <timestamp> */ + // Check the timestamp, it must be exactly the same as the one in + // the .spl file. Otherwise the word numbers won't match. + timestamp = get8ctime(fd); // <timestamp> if (timestamp != slang->sl_sugtime) { semsg(_("E781: .sug file doesn't match .spl file: %s"), @@ -747,20 +747,20 @@ someerror: slang->sl_sugbuf = open_spellbuf(); if (slang->sl_sugbuf == NULL) goto someerror; - /* <sugwcount> */ + // <sugwcount> wcount = get4c(fd); if (wcount < 0) goto someerror; - /* Read all the wordnr lists into the buffer, one NUL terminated - * list per line. */ + // Read all the wordnr lists into the buffer, one NUL terminated + // list per line. ga_init2(&ga, 1, 100); for (wordnr = 0; wordnr < wcount; ++wordnr) { ga.ga_len = 0; for (;;) { - c = getc(fd); /* <sugline> */ + c = getc(fd); // <sugline> if (c < 0 || ga_grow(&ga, 1) == FAIL) goto someerror; ((char_u *)ga.ga_data)[ga.ga_len++] = c; @@ -803,7 +803,7 @@ read_cnt_string(FILE *fd, int cnt_bytes, int i; char_u *str; - /* read the length bytes, MSB first */ + // read the length bytes, MSB first for (i = 0; i < cnt_bytes; ++i) cnt = (cnt << 8) + getc(fd); if (cnt < 0) @@ -813,7 +813,7 @@ read_cnt_string(FILE *fd, int cnt_bytes, } *cntp = cnt; if (cnt == 0) - return NULL; /* nothing to read, return NULL */ + return NULL; // nothing to read, return NULL str = read_string(fd, cnt); if (str == NULL) @@ -833,7 +833,7 @@ read_region_section(FILE *fd, slang_T *l if (len > MAXREGIONS * 2) return SP_FORMERROR; for (i = 0; i < len; ++i) - lp->sl_regions[i] = getc(fd); /* <regionname> */ + lp->sl_regions[i] = getc(fd); // <regionname> lp->sl_regions[len] = NUL; return 0; } @@ -850,12 +850,12 @@ read_charflags_section(FILE *fd) char_u *fol; int flagslen, follen; - /* <charflagslen> <charflags> */ + // <charflagslen> <charflags> flags = read_cnt_string(fd, 1, &flagslen); if (flagslen < 0) return flagslen; - /* <folcharslen> <folchars> */ + // <folcharslen> <folchars> fol = read_cnt_string(fd, 2, &follen); if (follen < 0) { @@ -863,14 +863,14 @@ read_charflags_section(FILE *fd) return follen; } - /* Set the word-char flags and fill SPELL_ISUPPER() table. */ + // Set the word-char flags and fill SPELL_ISUPPER() table. if (flags != NULL && fol != NULL) set_spell_charflags(flags, flagslen, fol); vim_free(flags); vim_free(fol); - /* When <charflagslen> is zero then <fcharlen> must also be zero. */ + // When <charflagslen> is zero then <fcharlen> must also be zero. if ((flags == NULL) != (fol == NULL)) return SP_FORMERROR; return 0; @@ -889,8 +889,8 @@ read_prefcond_section(FILE *fd, slang_T char_u *p; char_u buf[MAXWLEN + 1]; - /* <prefcondcnt> <prefcond> ... */ - cnt = get2c(fd); /* <prefcondcnt> */ + // <prefcondcnt> <prefcond> ... + cnt = get2c(fd); // <prefcondcnt> if (cnt <= 0) return SP_FORMERROR; @@ -901,19 +901,19 @@ read_prefcond_section(FILE *fd, slang_T for (i = 0; i < cnt; ++i) { - /* <prefcond> : <condlen> <condstr> */ - n = getc(fd); /* <condlen> */ + // <prefcond> : <condlen> <condstr> + n = getc(fd); // <condlen> if (n < 0 || n >= MAXWLEN) return SP_FORMERROR; - /* When <condlen> is zero we have an empty condition. Otherwise - * compile the regexp program used to check for the condition. */ + // When <condlen> is zero we have an empty condition. Otherwise + // compile the regexp program used to check for the condition. if (n > 0) { - buf[0] = '^'; /* always match at one position only */ + buf[0] = '^'; // always match at one position only p = buf + 1; while (n-- > 0) - *p++ = getc(fd); /* <condstr> */ + *p++ = getc(fd); // <condstr> *p = NUL; lp->sl_prefprog[i] = vim_regcomp(buf, RE_MAGIC + RE_STRING); } @@ -932,14 +932,14 @@ read_rep_section(FILE *fd, garray_T *gap fromto_T *ftp; int i; - cnt = get2c(fd); /* <repcount> */ + cnt = get2c(fd); // <repcount> if (cnt < 0) return SP_TRUNCERROR; if (ga_grow(gap, cnt) == FAIL) return SP_OTHERERROR; - /* <rep> : <repfromlen> <repfrom> <reptolen> <repto> */ + // <rep> : <repfromlen> <repfrom> <reptolen> <repto> for (; gap->ga_len < cnt; ++gap->ga_len) { ftp = &((fromto_T *)gap->ga_data)[gap->ga_len]; @@ -958,7 +958,7 @@ read_rep_section(FILE *fd, garray_T *gap } } - /* Fill the first-index table. */ + // Fill the first-index table. for (i = 0; i < 256; ++i) first[i] = -1; for (i = 0; i < gap->ga_len; ++i) @@ -987,7 +987,7 @@ read_sal_section(FILE *fd, slang_T *slan slang->sl_sofo = FALSE; - i = getc(fd); /* <salflags> */ + i = getc(fd); // <salflags> if (i & SAL_F0LLOWUP) slang->sl_followup = TRUE; if (i & SAL_COLLAPSE) @@ -995,7 +995,7 @@ read_sal_section(FILE *fd, slang_T *slan if (i & SAL_REM_ACCENTS) slang->sl_rem_accents = TRUE; - cnt = get2c(fd); /* <salcount> */ + cnt = get2c(fd); // <salcount> if (cnt < 0) return SP_TRUNCERROR; @@ -1004,21 +1004,21 @@ read_sal_section(FILE *fd, slang_T *slan if (ga_grow(gap, cnt + 1) == FAIL) return SP_OTHERERROR; - /* <sal> : <salfromlen> <salfrom> <saltolen> <salto> */ + // <sal> : <salfromlen> <salfrom> <saltolen> <salto> for (; gap->ga_len < cnt; ++gap->ga_len) { smp = &((salitem_T *)gap->ga_data)[gap->ga_len]; - ccnt = getc(fd); /* <salfromlen> */ + ccnt = getc(fd); // <salfromlen> if (ccnt < 0) return SP_TRUNCERROR; if ((p = alloc(ccnt + 2)) == NULL) return SP_OTHERERROR; smp->sm_lead = p; - /* Read up to the first special char into sm_lead. */ + // Read up to the first special char into sm_lead. for (i = 0; i < ccnt; ++i) { - c = getc(fd); /* <salfrom> */ + c = getc(fd); // <salfrom> if (vim_strchr((char_u *)"0123456789(-<^$", c) != NULL) break; *p++ = c; @@ -1026,13 +1026,13 @@ read_sal_section(FILE *fd, slang_T *slan smp->sm_leadlen = (int)(p - smp->sm_lead); *p++ = NUL; - /* Put (abc) chars in sm_oneof, if any. */ + // Put (abc) chars in sm_oneof, if any. if (c == '(') { smp->sm_oneof = p; for (++i; i < ccnt; ++i) { - c = getc(fd); /* <salfrom> */ + c = getc(fd); // <salfrom> if (c == ')') break; *p++ = c; @@ -1044,16 +1044,16 @@ read_sal_section(FILE *fd, slang_T *slan else smp->sm_oneof = NULL; - /* Any following chars go in sm_rules. */ + // Any following chars go in sm_rules. smp->sm_rules = p; if (i < ccnt) - /* store the char we got while checking for end of sm_lead */ + // store the char we got while checking for end of sm_lead *p++ = c; for (++i; i < ccnt; ++i) - *p++ = getc(fd); /* <salfrom> */ + *p++ = getc(fd); // <salfrom> *p++ = NUL; - /* <saltolen> <salto> */ + // <saltolen> <salto> smp->sm_to = read_cnt_string(fd, 1, &ccnt); if (ccnt < 0) { @@ -1063,7 +1063,7 @@ read_sal_section(FILE *fd, slang_T *slan if (has_mbyte) { - /* convert the multi-byte strings to wide char strings */ + // convert the multi-byte strings to wide char strings smp->sm_lead_w = mb_str2wide(smp->sm_lead); smp->sm_leadlen = mb_charlen(smp->sm_lead); if (smp->sm_oneof == NULL) @@ -1090,8 +1090,8 @@ read_sal_section(FILE *fd, slang_T *slan if (gap->ga_len > 0) { - /* Add one extra entry to mark the end with an empty sm_lead. Avoids - * that we need to check the index every time. */ + // Add one extra entry to mark the end with an empty sm_lead. Avoids + // that we need to check the index every time. smp = &((salitem_T *)gap->ga_data)[gap->ga_len]; if ((p = alloc(1)) == NULL) return SP_OTHERERROR; @@ -1111,7 +1111,7 @@ read_sal_section(FILE *fd, slang_T *slan ++gap->ga_len; } - /* Fill the first-index table. */ + // Fill the first-index table. set_sal_first(slang); return 0; @@ -1131,7 +1131,7 @@ read_words_section(FILE *fd, slang_T *lp while (done < len) { - /* Read one word at a time. */ + // Read one word at a time. for (i = 0; ; ++i) { c = getc(fd); @@ -1144,7 +1144,7 @@ read_words_section(FILE *fd, slang_T *lp return SP_FORMERROR; } - /* Init the count to 10. */ + // Init the count to 10. count_common_word(lp, word, -1, 10); done += i + 1; } @@ -1164,12 +1164,12 @@ read_sofo_section(FILE *fd, slang_T *sla slang->sl_sofo = TRUE; - /* <sofofromlen> <sofofrom> */ + // <sofofromlen> <sofofrom> from = read_cnt_string(fd, 2, &cnt); if (cnt < 0) return cnt; - /* <sofotolen> <sofoto> */ + // <sofotolen> <sofoto> to = read_cnt_string(fd, 2, &cnt); if (cnt < 0) { @@ -1177,11 +1177,11 @@ read_sofo_section(FILE *fd, slang_T *sla return cnt; } - /* Store the info in slang->sl_sal and/or slang->sl_sal_first. */ + // Store the info in slang->sl_sal and/or slang->sl_sal_first. if (from != NULL && to != NULL) res = set_sofo(slang, from, to); else if (from != NULL || to != NULL) - res = SP_FORMERROR; /* only one of two strings is an error */ + res = SP_FORMERROR; // only one of two strings is an error else res = 0; @@ -1210,38 +1210,38 @@ read_compound(FILE *fd, slang_T *slang, garray_T *gap; if (todo < 2) - return SP_FORMERROR; /* need at least two bytes */ + return SP_FORMERROR; // need at least two bytes --todo; - c = getc(fd); /* <compmax> */ + c = getc(fd); // <compmax> if (c < 2) c = MAXWLEN; slang->sl_compmax = c; --todo; - c = getc(fd); /* <compminlen> */ + c = getc(fd); // <compminlen> if (c < 1) c = 0; slang->sl_compminlen = c; --todo; - c = getc(fd); /* <compsylmax> */ + c = getc(fd); // <compsylmax> if (c < 1) c = MAXWLEN; slang->sl_compsylmax = c; - c = getc(fd); /* <compoptions> */ + c = getc(fd); // <compoptions> if (c != 0) - ungetc(c, fd); /* be backwards compatible with Vim 7.0b */ + ungetc(c, fd); // be backwards compatible with Vim 7.0b else { --todo; - c = getc(fd); /* only use the lower byte for now */ + c = getc(fd); // only use the lower byte for now --todo; slang->sl_compoptions = c; gap = &slang->sl_comppat; - c = get2c(fd); /* <comppatcount> */ + c = get2c(fd); // <comppatcount> todo -= 2; ga_init2(gap, sizeof(char_u *), c); if (ga_grow(gap, c) == OK) @@ -1249,7 +1249,7 @@ read_compound(FILE *fd, slang_T *slang, { ((char_u **)(gap->ga_data))[gap->ga_len++] = read_cnt_string(fd, 1, &cnt); - /* <comppatlen> <comppattext> */ + // <comppatlen> <comppattext> if (cnt < 0) return cnt; todo -= cnt + 1; @@ -1258,10 +1258,10 @@ read_compound(FILE *fd, slang_T *slang, if (todo < 0) return SP_FORMERROR; - /* Turn the COMPOUNDRULE items into a regexp pattern: - * "a[bc]/a*b+" -> "^\(a[bc]\|a*b\+\)$". - * Inserting backslashes may double the length, "^\(\)$<Nul>" is 7 bytes. - * Conversion to utf-8 may double the size. */ + // Turn the COMPOUNDRULE items into a regexp pattern: + // "a[bc]/a*b+" -> "^\(a[bc]\|a*b\+\)$". + // Inserting backslashes may double the length, "^\(\)$<Nul>" is 7 bytes. + // Conversion to utf-8 may double the size. c = todo * 2 + 7; if (enc_utf8) c += todo * 2; @@ -1269,8 +1269,8 @@ read_compound(FILE *fd, slang_T *slang, if (pat == NULL) return SP_OTHERERROR; - /* We also need a list of all flags that can appear at the start and one - * for all flags. */ + // We also need a list of all flags that can appear at the start and one + // for all flags. cp = alloc(todo + 1); if (cp == NULL) { @@ -1289,9 +1289,9 @@ read_compound(FILE *fd, slang_T *slang, slang->sl_compallflags = ap; *ap = NUL; - /* And a list of all patterns in their original form, for checking whether - * compounding may work in match_compoundrule(). This is freed when we - * encounter a wildcard, the check doesn't work then. */ + // And a list of all patterns in their original form, for checking whether + // compounding may work in match_compoundrule(). This is freed when we + // encounter a wildcard, the check doesn't work then. crp = alloc(todo + 1); slang->sl_comprules = crp; @@ -1303,14 +1303,14 @@ read_compound(FILE *fd, slang_T *slang, atstart = 1; while (todo-- > 0) { - c = getc(fd); /* <compflags> */ + c = getc(fd); // <compflags> if (c == EOF) { vim_free(pat); return SP_TRUNCERROR; } - /* Add all flags to "sl_compallflags". */ + // Add all flags to "sl_compallflags". if (vim_strchr((char_u *)"?*+[]/", c) == NULL && !byte_in_str(slang->sl_compallflags, c)) { @@ -1320,8 +1320,8 @@ read_compound(FILE *fd, slang_T *slang, if (atstart != 0) { - /* At start of item: copy flags to "sl_compstartflags". For a - * [abc] item set "atstart" to 2 and copy up to the ']'. */ + // At start of item: copy flags to "sl_compstartflags". For a + // [abc] item set "atstart" to 2 and copy up to the ']'. if (c == '[') atstart = 2; else if (c == ']') @@ -1338,7 +1338,7 @@ read_compound(FILE *fd, slang_T *slang, } } - /* Copy flag to "sl_comprules", unless we run into a wildcard. */ + // Copy flag to "sl_comprules", unless we run into a wildcard. if (crp != NULL) { if (c == '?' || c == '+' || c == '*') @@ -1350,16 +1350,16 @@ read_compound(FILE *fd, slang_T *slang, *crp++ = c; } - if (c == '/') /* slash separates two items */ + if (c == '/') // slash separates two items { *pp++ = '\\'; *pp++ = '|'; atstart = 1; } - else /* normal char, "[abc]" and '*' are copied as-is */ + else // normal char, "[abc]" and '*' are copied as-is { if (c == '?' || c == '+' || c == '~') - *pp++ = '\\'; /* "a?" becomes "a\?", "a+" becomes "a\+" */ + *pp++ = '\\'; // "a?" becomes "a\?", "a+" becomes "a\+" if (enc_utf8) pp += mb_char2bytes(c, pp); else @@ -1400,10 +1400,10 @@ set_sofo(slang_T *lp, char_u *from, char if (has_mbyte) { - /* Use "sl_sal" as an array with 256 pointers to a list of wide - * characters. The index is the low byte of the character. - * The list contains from-to pairs with a terminating NUL. - * sl_sal_first[] is used for latin1 "from" characters. */ + // Use "sl_sal" as an array with 256 pointers to a list of wide + // characters. The index is the low byte of the character. + // The list contains from-to pairs with a terminating NUL. + // sl_sal_first[] is used for latin1 "from" characters. gap = &lp->sl_sal; ga_init2(gap, sizeof(int *), 1); if (ga_grow(gap, 256) == FAIL) @@ -1411,8 +1411,8 @@ set_sofo(slang_T *lp, char_u *from, char vim_memset(gap->ga_data, 0, sizeof(int *) * 256); gap->ga_len = 256; - /* First count the number of items for each list. Temporarily use - * sl_sal_first[] for this. */ + // First count the number of items for each list. Temporarily use + // sl_sal_first[] for this. for (p = from, s = to; *p != NUL && *s != NUL; ) { c = mb_cptr2char_adv(&p); @@ -1420,10 +1420,10 @@ set_sofo(slang_T *lp, char_u *from, char if (c >= 256) ++lp->sl_sal_first[c & 0xff]; } - if (*p != NUL || *s != NUL) /* lengths differ */ + if (*p != NUL || *s != NUL) // lengths differ return SP_FORMERROR; - /* Allocate the lists. */ + // Allocate the lists. for (i = 0; i < 256; ++i) if (lp->sl_sal_first[i] > 0) { @@ -1434,8 +1434,8 @@ set_sofo(slang_T *lp, char_u *from, char *(int *)p = 0; } - /* Put the characters up to 255 in sl_sal_first[] the rest in a sl_sal - * list. */ + // Put the characters up to 255 in sl_sal_first[] the rest in a sl_sal + // list. vim_memset(lp->sl_sal_first, 0, sizeof(salfirst_T) * 256); for (p = from, s = to; *p != NUL && *s != NUL; ) { @@ -1443,29 +1443,29 @@ set_sofo(slang_T *lp, char_u *from, char i = mb_cptr2char_adv(&s); if (c >= 256) { - /* Append the from-to chars at the end of the list with - * the low byte. */ + // Append the from-to chars at the end of the list with + // the low byte. inp = ((int **)gap->ga_data)[c & 0xff]; while (*inp != 0) ++inp; - *inp++ = c; /* from char */ - *inp++ = i; /* to char */ - *inp++ = NUL; /* NUL at the end */ + *inp++ = c; // from char + *inp++ = i; // to char + *inp++ = NUL; // NUL at the end } else - /* mapping byte to char is done in sl_sal_first[] */ + // mapping byte to char is done in sl_sal_first[] lp->sl_sal_first[c] = i; } } else { - /* mapping bytes to bytes is done in sl_sal_first[] */ + // mapping bytes to bytes is done in sl_sal_first[] if (STRLEN(from) != STRLEN(to)) return SP_FORMERROR; for (i = 0; to[i] != NUL; ++i) lp->sl_sal_first[from[i]] = to[i]; - lp->sl_sal.ga_len = 1; /* indicates we have soundfolding */ + lp->sl_sal.ga_len = 1; // indicates we have soundfolding } return 0; @@ -1490,9 +1490,9 @@ set_sal_first(slang_T *lp) for (i = 0; i < gap->ga_len; ++i) { if (has_mbyte) - /* Use the lowest byte of the first character. For latin1 it's - * the character, for other encodings it should differ for most - * characters. */ + // Use the lowest byte of the first character. For latin1 it's + // the character, for other encodings it should differ for most + // characters. c = *smp[i].sm_lead_w & 0xff; else c = *smp[i].sm_lead; @@ -1503,12 +1503,12 @@ set_sal_first(slang_T *lp) { int n; - /* Make sure all entries with this byte are following each - * other. Move the ones that are in the wrong position. Do - * keep the same ordering! */ + // Make sure all entries with this byte are following each + // other. Move the ones that are in the wrong position. Do + // keep the same ordering! while (i + 1 < gap->ga_len && (*smp[i + 1].sm_lead_w & 0xff) == c) - /* Skip over entry with same index byte. */ + // Skip over entry with same index byte. ++i; for (n = 1; i + n < gap->ga_len; ++n) @@ -1516,8 +1516,8 @@ set_sal_first(slang_T *lp) { salitem_T tsal; - /* Move entry with same index byte after the entries - * we already found. */ + // Move entry with same index byte after the entries + // we already found. ++i; --n; tsal = smp[i + n]; @@ -1562,37 +1562,37 @@ spell_read_tree( FILE *fd, char_u **bytsp, idx_T **idxsp, - int prefixtree, /* TRUE for the prefix tree */ - int prefixcnt) /* when "prefixtree" is TRUE: prefix count */ + int prefixtree, // TRUE for the prefix tree + int prefixcnt) // when "prefixtree" is TRUE: prefix count { long len; int idx; char_u *bp; idx_T *ip; - /* The tree size was computed when writing the file, so that we can - * allocate it as one long block. <nodecount> */ + // The tree size was computed when writing the file, so that we can + // allocate it as one long block. <nodecount> len = get4c(fd); if (len < 0) return SP_TRUNCERROR; if (len >= LONG_MAX / (long)sizeof(int)) - /* Invalid length, multiply with sizeof(int) would overflow. */ + // Invalid length, multiply with sizeof(int) would overflow. return SP_FORMERROR; if (len > 0) { - /* Allocate the byte array. */ + // Allocate the byte array. bp = alloc(len); if (bp == NULL) return SP_OTHERERROR; *bytsp = bp; - /* Allocate the index array. */ + // Allocate the index array. ip = lalloc_clear(len * sizeof(int), TRUE); if (ip == NULL) return SP_OTHERERROR; *idxsp = ip; - /* Recursively read the tree and store it in the array. */ + // Recursively read the tree and store it in the array. idx = read_tree_node(fd, bp, ip, len, 0, prefixtree, prefixcnt); if (idx < 0) return idx; @@ -1615,10 +1615,10 @@ read_tree_node( FILE *fd, char_u *byts, idx_T *idxs, - int maxidx, /* size of arrays */ - idx_T startidx, /* current index in "byts" and "idxs" */ - int prefixtree, /* TRUE for reading PREFIXTREE */ - int maxprefcondnr) /* maximum for <prefcondnr> */ + int maxidx, // size of arrays + idx_T startidx, // current index in "byts" and "idxs" + int prefixtree, // TRUE for reading PREFIXTREE + int maxprefcondnr) // maximum for <prefcondnr> { int len; int i; @@ -1628,7 +1628,7 @@ read_tree_node( int c2; #define SHARED_MASK 0x8000000 - len = getc(fd); /* <siblingcount> */ + len = getc(fd); // <siblingcount> if (len <= 0) return SP_TRUNCERROR; @@ -1636,17 +1636,17 @@ read_tree_node( return SP_FORMERROR; byts[idx++] = len; - /* Read the byte values, flag/region bytes and shared indexes. */ + // Read the byte values, flag/region bytes and shared indexes. for (i = 1; i <= len; ++i) { - c = getc(fd); /* <byte> */ + c = getc(fd); // <byte> if (c < 0) return SP_TRUNCERROR; if (c <= BY_SPECIAL) { if (c == BY_NOFLAGS && !prefixtree) { - /* No flags, all regions. */ + // No flags, all regions. idxs[idx] = 0; c = 0; } @@ -1654,56 +1654,56 @@ read_tree_node( { if (prefixtree) { - /* Read the optional pflags byte, the prefix ID and the - * condition nr. In idxs[] store the prefix ID in the low - * byte, the condition index shifted up 8 bits, the flags - * shifted up 24 bits. */ + // Read the optional pflags byte, the prefix ID and the + // condition nr. In idxs[] store the prefix ID in the low + // byte, the condition index shifted up 8 bits, the flags + // shifted up 24 bits. if (c == BY_FLAGS) - c = getc(fd) << 24; /* <pflags> */ + c = getc(fd) << 24; // <pflags> else c = 0; - c |= getc(fd); /* <affixID> */ - - n = get2c(fd); /* <prefcondnr> */ + c |= getc(fd); // <affixID> + + n = get2c(fd); // <prefcondnr> if (n >= maxprefcondnr) return SP_FORMERROR; c |= (n << 8); } - else /* c must be BY_FLAGS or BY_FLAGS2 */ + else // c must be BY_FLAGS or BY_FLAGS2 { - /* Read flags and optional region and prefix ID. In - * idxs[] the flags go in the low two bytes, region above - * that and prefix ID above the region. */ + // Read flags and optional region and prefix ID. In + // idxs[] the flags go in the low two bytes, region above + // that and prefix ID above the region. c2 = c; - c = getc(fd); /* <flags> */ + c = getc(fd); // <flags> if (c2 == BY_FLAGS2) - c = (getc(fd) << 8) + c; /* <flags2> */ + c = (getc(fd) << 8) + c; // <flags2> if (c & WF_REGION) - c = (getc(fd) << 16) + c; /* <region> */ + c = (getc(fd) << 16) + c; // <region> if (c & WF_AFX) - c = (getc(fd) << 24) + c; /* <affixID> */ + c = (getc(fd) << 24) + c; // <affixID> } idxs[idx] = c; c = 0; } - else /* c == BY_INDEX */ + else // c == BY_INDEX { - /* <nodeidx> */ + // <nodeidx> n = get3c(fd); if (n < 0 || n >= maxidx) return SP_FORMERROR; idxs[idx] = n + SHARED_MASK; - c = getc(fd); /* <xbyte> */ + c = getc(fd); // <xbyte> } } byts[idx++] = c; } - /* Recursively read the children for non-shared siblings. - * Skip the end-of-word ones (zero byte value) and the shared ones (and - * remove SHARED_MASK) */ + // Recursively read the children for non-shared siblings. + // Skip the end-of-word ones (zero byte value) and the shared ones (and + // remove SHARED_MASK) for (i = 1; i <= len; ++i) if (byts[startidx + i] != 0) { @@ -1728,7 +1728,7 @@ read_tree_node( static void spell_reload_one( char_u *fname, - int added_word) /* invoked through "zg" */ + int added_word) // invoked through "zg" { slang_T *slang; int didit = FALSE; @@ -1739,15 +1739,15 @@ spell_reload_one( { slang_clear(slang); if (spell_load_file(fname, NULL, slang, FALSE) == NULL) - /* reloading failed, clear the language */ + // reloading failed, clear the language slang_clear(slang); redraw_all_later(SOME_VALID); didit = TRUE; } } - /* When "zg" was used and the file wasn't loaded yet, should redo - * 'spelllang' to load it now. */ + // When "zg" was used and the file wasn't loaded yet, should redo + // 'spelllang' to load it now. if (added_word && !didit) did_set_spelllang(curwin); } @@ -1757,73 +1757,73 @@ spell_reload_one( * Functions for ":mkspell". */ -#define MAXLINELEN 500 /* Maximum length in bytes of a line in a .aff - and .dic file. */ +#define MAXLINELEN 500 // 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 */ - int af_flagtype; /* AFT_CHAR, AFT_LONG, AFT_NUM or AFT_CAPLONG */ - unsigned af_rare; /* RARE ID for rare word */ - unsigned af_keepcase; /* KEEPCASE ID for keep-case word */ - unsigned af_bad; /* BAD ID for banned word */ - unsigned af_needaffix; /* NEEDAFFIX ID */ - unsigned af_circumfix; /* CIRCUMFIX ID */ - unsigned af_needcomp; /* NEEDCOMPOUND ID */ - unsigned af_comproot; /* COMPOUNDROOT ID */ - unsigned af_compforbid; /* COMPOUNDFORBIDFLAG ID */ - unsigned af_comppermit; /* COMPOUNDPERMITFLAG ID */ - unsigned af_nosuggest; /* NOSUGGEST ID */ - int af_pfxpostpone; /* postpone prefixes without chop string and - without flags */ - int af_ignoreextra; /* IGNOREEXTRA present */ - hashtab_T af_pref; /* hashtable for prefixes, affheader_T */ - hashtab_T af_suff; /* hashtable for suffixes, affheader_T */ - hashtab_T af_comp; /* hashtable for compound flags, compitem_T */ + char_u *af_enc; // "SET", normalized, alloc'ed string or NULL + int af_flagtype; // AFT_CHAR, AFT_LONG, AFT_NUM or AFT_CAPLONG + unsigned af_rare; // RARE ID for rare word + unsigned af_keepcase; // KEEPCASE ID for keep-case word + unsigned af_bad; // BAD ID for banned word + unsigned af_needaffix; // NEEDAFFIX ID + unsigned af_circumfix; // CIRCUMFIX ID + unsigned af_needcomp; // NEEDCOMPOUND ID + unsigned af_comproot; // COMPOUNDROOT ID + unsigned af_compforbid; // COMPOUNDFORBIDFLAG ID + unsigned af_comppermit; // COMPOUNDPERMITFLAG ID + unsigned af_nosuggest; // NOSUGGEST ID + int af_pfxpostpone; // postpone prefixes without chop string and + // without flags + int af_ignoreextra; // IGNOREEXTRA present + hashtab_T af_pref; // hashtable for prefixes, affheader_T + hashtab_T af_suff; // hashtable for suffixes, affheader_T + hashtab_T af_comp; // hashtable for compound flags, compitem_T } afffile_T; -#define AFT_CHAR 0 /* flags are one character */ -#define AFT_LONG 1 /* flags are two characters */ -#define AFT_CAPLONG 2 /* flags are one or two characters */ -#define AFT_NUM 3 /* flags are numbers, comma separated */ +#define AFT_CHAR 0 // flags are one character +#define AFT_LONG 1 // flags are two characters +#define AFT_CAPLONG 2 // flags are one or two characters +#define AFT_NUM 3 // flags are numbers, comma separated typedef struct affentry_S affentry_T; -/* Affix entry from ".aff" file. Used for prefixes and suffixes. */ +// 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_flags; /* flags on the affix (can be NULL) */ - char_u *ae_cond; /* condition (NULL for ".") */ - regprog_T *ae_prog; /* regexp program for ae_cond or NULL */ - char ae_compforbid; /* COMPOUNDFORBIDFLAG found */ - char ae_comppermit; /* COMPOUNDPERMITFLAG found */ + 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_flags; // flags on the affix (can be NULL) + char_u *ae_cond; // condition (NULL for ".") + regprog_T *ae_prog; // regexp program for ae_cond or NULL + char ae_compforbid; // COMPOUNDFORBIDFLAG found + char ae_comppermit; // COMPOUNDPERMITFLAG found }; -#define AH_KEY_LEN 17 /* 2 x 8 bytes + NUL */ - -/* Affix header from ".aff" file. Used for af_pref and af_suff. */ +#define AH_KEY_LEN 17 // 2 x 8 bytes + NUL + +// Affix header from ".aff" file. Used for af_pref and af_suff. typedef struct affheader_S { - char_u ah_key[AH_KEY_LEN]; /* key for hashtab == name of affix */ - unsigned ah_flag; /* affix name as number, uses "af_flagtype" */ - int ah_newID; /* prefix ID after renumbering; 0 if not used */ - int ah_combine; /* suffix may combine with prefix */ - int ah_follows; /* another affix block should be following */ - affentry_T *ah_first; /* first affix entry */ + char_u ah_key[AH_KEY_LEN]; // key for hashtab == name of affix + unsigned ah_flag; // affix name as number, uses "af_flagtype" + int ah_newID; // prefix ID after renumbering; 0 if not used + int ah_combine; // suffix may combine with prefix + int ah_follows; // another affix block should be following + affentry_T *ah_first; // first affix entry } affheader_T; #define HI2AH(hi) ((affheader_T *)(hi)->hi_key) -/* Flag used in compound items. */ +// Flag used in compound items. typedef struct compitem_S { - char_u ci_key[AH_KEY_LEN]; /* key for hashtab == name of compound */ - unsigned ci_flag; /* affix name as number, uses "af_flagtype" */ - int ci_newID; /* affix ID after renumbering. */ + char_u ci_key[AH_KEY_LEN]; // key for hashtab == name of compound + unsigned ci_flag; // affix name as number, uses "af_flagtype" + int ci_newID; // affix ID after renumbering. } compitem_T; #define HI2CI(hi) ((compitem_T *)(hi)->hi_key) @@ -1836,13 +1836,13 @@ typedef struct compitem_S * "sb_data" is correct for systems where pointers must be aligned on * pointer-size boundaries and sizeof(pointer) > sizeof(int) (e.g., Sparc). */ -#define SBLOCKSIZE 16000 /* size of sb_data */ +#define SBLOCKSIZE 16000 // size of sb_data typedef struct sblock_S sblock_T; struct sblock_S { - int sb_used; /* nr of bytes already in use */ - sblock_T *sb_next; /* next block in list */ - char_u sb_data[1]; /* data, actually longer */ + int sb_used; // nr of bytes already in use + sblock_T *sb_next; // next block in list + char_u sb_data[1]; // data, actually longer }; /* @@ -1851,40 +1851,40 @@ struct sblock_S typedef struct wordnode_S wordnode_T; struct wordnode_S { - union /* shared to save space */ + union // shared to save space { - char_u hashkey[6]; /* the hash key, only used while compressing */ - int index; /* index in written nodes (valid after first - round) */ + char_u hashkey[6]; // the hash key, only used while compressing + int index; // index in written nodes (valid after first + // round) } wn_u1; - union /* shared to save space */ + union // shared to save space { - wordnode_T *next; /* next node with same hash key */ - wordnode_T *wnode; /* parent node that will write this node */ + wordnode_T *next; // next node with same hash key + wordnode_T *wnode; // parent node that will write this node } wn_u2; - wordnode_T *wn_child; /* child (next byte in word) */ - wordnode_T *wn_sibling; /* next sibling (alternate byte in word, - always sorted) */ - int wn_refs; /* Nr. of references to this node. Only - relevant for first node in a list of - siblings, in following siblings it is - always one. */ - char_u wn_byte; /* Byte for this node. NUL for word end */ - - /* Info for when "wn_byte" is NUL. - * In PREFIXTREE "wn_region" is used for the prefcondnr. - * In the soundfolded word tree "wn_flags" has the MSW of the wordnr and - * "wn_region" the LSW of the wordnr. */ - char_u wn_affixID; /* supported/required prefix ID or 0 */ - short_u wn_flags; /* WF_ flags */ - short wn_region; /* region mask */ + wordnode_T *wn_child; // child (next byte in word) + wordnode_T *wn_sibling; // next sibling (alternate byte in word, + // always sorted) + int wn_refs; // Nr. of references to this node. Only + // relevant for first node in a list of + // siblings, in following siblings it is + // always one. + char_u wn_byte; // Byte for this node. NUL for word end + + // Info for when "wn_byte" is NUL. + // In PREFIXTREE "wn_region" is used for the prefcondnr. + // In the soundfolded word tree "wn_flags" has the MSW of the wordnr and + // "wn_region" the LSW of the wordnr. + char_u wn_affixID; // supported/required prefix ID or 0 + short_u wn_flags; // WF_ flags + short wn_region; // region mask #ifdef SPELL_PRINTTREE - int wn_nr; /* sequence nr for printing */ + int wn_nr; // sequence nr for printing #endif }; -#define WN_MASK 0xffff /* mask relevant bits of "wn_flags" */ +#define WN_MASK 0xffff // mask relevant bits of "wn_flags" #define HI2WN(hi) (wordnode_T *)((hi)->hi_key) @@ -1893,73 +1893,73 @@ struct wordnode_S */ typedef struct spellinfo_S { - wordnode_T *si_foldroot; /* tree with case-folded words */ - long si_foldwcount; /* nr of words in si_foldroot */ - - wordnode_T *si_keeproot; /* tree with keep-case words */ - long si_keepwcount; /* nr of words in si_keeproot */ - - wordnode_T *si_prefroot; /* tree with postponed prefixes */ - - long si_sugtree; /* creating the soundfolding trie */ - - sblock_T *si_blocks; /* memory blocks used */ - long si_blocks_cnt; /* memory blocks allocated */ - int si_did_emsg; /* TRUE when ran out of memory */ - - long si_compress_cnt; /* words to add before lowering - compression limit */ - wordnode_T *si_first_free; /* List of nodes that have been freed during - compression, linked by "wn_child" field. */ - long si_free_count; /* number of nodes in si_first_free */ + wordnode_T *si_foldroot; // tree with case-folded words + long si_foldwcount; // nr of words in si_foldroot + + wordnode_T *si_keeproot; // tree with keep-case words + long si_keepwcount; // nr of words in si_keeproot + + wordnode_T *si_prefroot; // tree with postponed prefixes + + long si_sugtree; // creating the soundfolding trie + + sblock_T *si_blocks; // memory blocks used + long si_blocks_cnt; // memory blocks allocated + int si_did_emsg; // TRUE when ran out of memory + + long si_compress_cnt; // words to add before lowering + // compression limit + wordnode_T *si_first_free; // List of nodes that have been freed during + // compression, linked by "wn_child" field. + long si_free_count; // number of nodes in si_first_free #ifdef SPELL_PRINTTREE - int si_wordnode_nr; /* sequence nr for nodes */ + int si_wordnode_nr; // sequence nr for nodes #endif - buf_T *si_spellbuf; /* buffer used to store soundfold word table */ - - int si_ascii; /* handling only ASCII words */ - int si_add; /* addition file */ - int si_clear_chartab; /* when TRUE clear char tables */ - int si_region; /* region mask */ - vimconv_T si_conv; /* for conversion to 'encoding' */ - int si_memtot; /* runtime memory used */ - int si_verbose; /* verbose messages */ - int si_msg_count; /* number of words added since last message */ - char_u *si_info; /* info text chars or NULL */ - int si_region_count; /* number of regions supported (1 when there - are no regions) */ + buf_T *si_spellbuf; // buffer used to store soundfold word table + + int si_ascii; // handling only ASCII words + int si_add; // addition file + int si_clear_chartab; // when TRUE clear char tables + int si_region; // region mask + vimconv_T si_conv; // for conversion to 'encoding' + int si_memtot; // runtime memory used + int si_verbose; // verbose messages + int si_msg_count; // number of words added since last message + char_u *si_info; // info text chars or NULL + int si_region_count; // number of regions supported (1 when there + // are no regions) char_u si_region_name[MAXREGIONS * 2 + 1]; - /* region names; used only if - * si_region_count > 1) */ - - garray_T si_rep; /* list of fromto_T entries from REP lines */ - garray_T si_repsal; /* list of fromto_T entries from REPSAL lines */ - garray_T si_sal; /* list of fromto_T entries from SAL lines */ - char_u *si_sofofr; /* SOFOFROM text */ - char_u *si_sofoto; /* SOFOTO text */ - int si_nosugfile; /* NOSUGFILE item found */ - int si_nosplitsugs; /* NOSPLITSUGS item found */ - int si_nocompoundsugs; /* NOCOMPOUNDSUGS item found */ - int si_followup; /* soundsalike: ? */ - int si_collapse; /* soundsalike: ? */ - hashtab_T si_commonwords; /* hashtable for common words */ - time_t si_sugtime; /* timestamp for .sug file */ - int si_rem_accents; /* soundsalike: remove accents */ - garray_T si_map; /* MAP info concatenated */ - char_u *si_midword; /* MIDWORD chars or NULL */ - int si_compmax; /* max nr of words for compounding */ - int si_compminlen; /* minimal length for compounding */ - int si_compsylmax; /* max nr of syllables for compounding */ - int si_compoptions; /* COMP_ flags */ - garray_T si_comppat; /* CHECKCOMPOUNDPATTERN items, each stored as - a string */ - char_u *si_compflags; /* flags used for compounding */ - char_u si_nobreak; /* NOBREAK */ - char_u *si_syllable; /* syllable string */ - garray_T si_prefcond; /* table with conditions for postponed - * prefixes, each stored as a string */ - int si_newprefID; /* current value for ah_newID */ - int si_newcompID; /* current value for compound ID */ + // region names; used only if + // si_region_count > 1) + + garray_T si_rep; // list of fromto_T entries from REP lines + garray_T si_repsal; // list of fromto_T entries from REPSAL lines + garray_T si_sal; // list of fromto_T entries from SAL lines + char_u *si_sofofr; // SOFOFROM text + char_u *si_sofoto; // SOFOTO text + int si_nosugfile; // NOSUGFILE item found + int si_nosplitsugs; // NOSPLITSUGS item found + int si_nocompoundsugs; // NOCOMPOUNDSUGS item found + int si_followup; // soundsalike: ? + int si_collapse; // soundsalike: ? + hashtab_T si_commonwords; // hashtable for common words + time_t si_sugtime; // timestamp for .sug file + int si_rem_accents; // soundsalike: remove accents + garray_T si_map; // MAP info concatenated + char_u *si_midword; // MIDWORD chars or NULL + int si_compmax; // max nr of words for compounding + int si_compminlen; // minimal length for compounding + int si_compsylmax; // max nr of syllables for compounding + int si_compoptions; // COMP_ flags + garray_T si_comppat; // CHECKCOMPOUNDPATTERN items, each stored as + // a string + char_u *si_compflags; // flags used for compounding + char_u si_nobreak; // NOBREAK + char_u *si_syllable; // syllable string + garray_T si_prefcond; // table with conditions for postponed + // prefixes, each stored as a string + int si_newprefID; // current value for ah_newID + int si_newcompID; // current value for compound ID } spellinfo_T; static int is_aff_rule(char_u **items, int itemcnt, char *rulename, int mincount); @@ -1997,23 +1997,23 @@ static void sug_write(spellinfo_T *spin, static void spell_message(spellinfo_T *spin, char_u *str); static void init_spellfile(void); -/* In the postponed prefixes tree wn_flags is used to store the WFP_ flags, - * but it must be negative to indicate the prefix tree to tree_add_word(). - * Use a negative number with the lower 8 bits zero. */ +// In the postponed prefixes tree wn_flags is used to store the WFP_ flags, +// but it must be negative to indicate the prefix tree to tree_add_word(). +// Use a negative number with the lower 8 bits zero. #define PFX_FLAGS -256 -/* flags for "condit" argument of store_aff_word() */ -#define CONDIT_COMB 1 /* affix must combine */ -#define CONDIT_CFIX 2 /* affix must have CIRCUMFIX flag */ -#define CONDIT_SUF 4 /* add a suffix for matching flags */ -#define CONDIT_AFF 8 /* word already has an affix */ +// flags for "condit" argument of store_aff_word() +#define CONDIT_COMB 1 // affix must combine +#define CONDIT_CFIX 2 // affix must have CIRCUMFIX flag +#define CONDIT_SUF 4 // add a suffix for matching flags +#define CONDIT_AFF 8 // word already has an affix /* * Tunable parameters for when the tree is compressed. See 'mkspellmem'. */ -static long compress_start = 30000; /* memory / SBLOCKSIZE */ -static long compress_inc = 100; /* memory / SBLOCKSIZE */ -static long compress_added = 500000; /* word count */ +static long compress_start = 30000; // memory / SBLOCKSIZE +static long compress_inc = 100; // memory / SBLOCKSIZE +static long compress_added = 500000; // word count /* * Check the 'mkspellmem' option. Return FAIL if it's wrong. @@ -2029,7 +2029,7 @@ spell_check_msm(void) if (!VIM_ISDIGIT(*p)) return FAIL; - /* block count = (value * 1024) / SBLOCKSIZE (but avoid overflow)*/ + // block count = (value * 1024) / SBLOCKSIZE (but avoid overflow) start = (getdigits(&p) * 10) / (SBLOCKSIZE / 102); if (*p != ',') return FAIL; @@ -2089,7 +2089,7 @@ spell_print_node(wordnode_T *node, int d { if (node->wn_u1.index) { - /* Done this node before, print the reference. */ + // Done this node before, print the reference. PRINTSOME(line1, depth, "(%d)", node->wn_nr, 0); PRINTSOME(line2, depth, " ", 0, 0); PRINTSOME(line3, depth, " ", 0, 0); @@ -2106,7 +2106,7 @@ spell_print_node(wordnode_T *node, int d if (node->wn_child != NULL) PRINTSOME(line1, depth, " %c -> ", node->wn_byte, 0); else - /* Cannot happen? */ + // Cannot happen? PRINTSOME(line1, depth, " %c ???", node->wn_byte, 0); } else @@ -2126,14 +2126,14 @@ spell_print_node(wordnode_T *node, int d msg(line3); } - /* do the children */ + // do the children if (node->wn_byte != NUL && node->wn_child != NULL) spell_print_node(node->wn_child, depth + 1); - /* do the siblings */ + // do the siblings if (node->wn_sibling != NULL) { - /* get rid of all parent details except | */ + // get rid of all parent details except | STRCPY(line1, line3); STRCPY(line2, line3); spell_print_node(node->wn_sibling, depth); @@ -2146,15 +2146,15 @@ spell_print_tree(wordnode_T *root) { if (root != NULL) { - /* Clear the "wn_u1.index" fields, used to remember what has been - * done. */ + // Clear the "wn_u1.index" fields, used to remember what has been + // done. spell_clear_flags(root); - /* Recursively print the tree. */ + // Recursively print the tree. spell_print_node(root, 0); } } -#endif /* SPELL_PRINTTREE */ +#endif // SPELL_PRINTTREE /* * Read the affix file "fname". @@ -2187,16 +2187,16 @@ spell_read_aff(spellinfo_T *spin, char_u int found_map = FALSE; hashitem_T *hi; int l; - int compminlen = 0; /* COMPOUNDMIN value */ - int compsylmax = 0; /* COMPOUNDSYLMAX value */ - int compoptions = 0; /* COMP_ flags */ - int compmax = 0; /* COMPOUNDWORDMAX value */ - char_u *compflags = NULL; /* COMPOUNDFLAG and COMPOUNDRULE - concatenated */ - char_u *midword = NULL; /* MIDWORD value */ - char_u *syllable = NULL; /* SYLLABLE value */ - char_u *sofofrom = NULL; /* SOFOFROM value */ - char_u *sofoto = NULL; /* SOFOTO value */ + int compminlen = 0; // COMPOUNDMIN value + int compsylmax = 0; // COMPOUNDSYLMAX value + int compoptions = 0; // COMP_ flags + int compmax = 0; // COMPOUNDWORDMAX value + char_u *compflags = NULL; // COMPOUNDFLAG and COMPOUNDRULE + // concatenated + char_u *midword = NULL; // MIDWORD value + char_u *syllable = NULL; // SYLLABLE value + char_u *sofofrom = NULL; // SOFOFROM value + char_u *sofoto = NULL; // SOFOTO value /* * Open the file. @@ -2211,16 +2211,16 @@ spell_read_aff(spellinfo_T *spin, char_u vim_snprintf((char *)IObuff, IOSIZE, _("Reading affix file %s..."), fname); spell_message(spin, IObuff); - /* Only do REP lines when not done in another .aff file already. */ + // Only do REP lines when not done in another .aff file already. do_rep = spin->si_rep.ga_len == 0; - /* Only do REPSAL lines when not done in another .aff file already. */ + // Only do REPSAL lines when not done in another .aff file already. do_repsal = spin->si_repsal.ga_len == 0; - /* Only do SAL lines when not done in another .aff file already. */ + // Only do SAL lines when not done in another .aff file already. do_sal = spin->si_sal.ga_len == 0; - /* Only do MAP lines when not done in another .aff file already. */ + // Only do MAP lines when not done in another .aff file already. do_mapline = spin->si_map.ga_len == 0; /* @@ -2244,11 +2244,11 @@ spell_read_aff(spellinfo_T *spin, char_u line_breakcheck(); ++lnum; - /* Skip comment lines. */ + // Skip comment lines. if (*rline == '#') continue; - /* Convert from "SET" to 'encoding' when needed. */ + // Convert from "SET" to 'encoding' when needed. vim_free(pc); if (spin->si_conv.vc_type != CONV_NONE) { @@ -2267,36 +2267,36 @@ spell_read_aff(spellinfo_T *spin, char_u line = rline; } - /* Split the line up in white separated items. Put a NUL after each - * item. */ + // 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 */ + while (*p != NUL && *p <= ' ') // skip white space and CR/NL ++p; if (*p == NUL) break; - if (itemcnt == MAXITEMCNT) /* too many items */ + if (itemcnt == MAXITEMCNT) // too many items break; items[itemcnt++] = p; - /* A few items have arbitrary text argument, don't split them. */ + // A few items have arbitrary text argument, don't split them. if (itemcnt == 2 && spell_info_item(items[0])) - while (*p >= ' ' || *p == TAB) /* skip until CR/NL */ + while (*p >= ' ' || *p == TAB) // skip until CR/NL ++p; else - while (*p > ' ') /* skip until white space or CR/NL */ + while (*p > ' ') // skip until white space or CR/NL ++p; if (*p == NUL) break; *p++ = NUL; } - /* Handle non-empty lines. */ + // Handle non-empty lines. if (itemcnt > 0) { if (is_aff_rule(items, itemcnt, "SET", 2) && aff->af_enc == NULL) { - /* Setup for conversion from "ENC" to 'encoding'. */ + // Setup for conversion from "ENC" to 'encoding'. aff->af_enc = enc_canonize(items[1]); if (aff->af_enc != NULL && !spin->si_ascii && convert_setup(&spin->si_conv, aff->af_enc, @@ -2357,9 +2357,9 @@ spell_read_aff(spellinfo_T *spin, char_u } else if (is_aff_rule(items, itemcnt, "TRY", 2)) { - /* ignored, we look in the tree for what chars may appear */ + // ignored, we look in the tree for what chars may appear } - /* TODO: remove "RAR" later */ + // TODO: remove "RAR" later else if ((is_aff_rule(items, itemcnt, "RAR", 2) || is_aff_rule(items, itemcnt, "RARE", 2)) && aff->af_rare == 0) @@ -2367,7 +2367,7 @@ spell_read_aff(spellinfo_T *spin, char_u aff->af_rare = affitem2flag(aff->af_flagtype, items[1], fname, lnum); } - /* TODO: remove "KEP" later */ + // TODO: remove "KEP" later else if ((is_aff_rule(items, itemcnt, "KEP", 2) || is_aff_rule(items, itemcnt, "KEEPCASE", 2)) && aff->af_keepcase == 0) @@ -2434,8 +2434,8 @@ spell_read_aff(spellinfo_T *spin, char_u else if (is_aff_rule(items, itemcnt, "COMPOUNDFLAG", 2) && compflags == NULL) { - /* Turn flag "c" into COMPOUNDRULE compatible string "c+", - * "Na" into "Na+", "1234" into "1234+". */ + // Turn flag "c" into COMPOUNDRULE compatible string "c+", + // "Na" into "Na+", "1234" into "1234+". p = getroom(spin, STRLEN(items[1]) + 2, FALSE); if (p != NULL) { @@ -2446,19 +2446,19 @@ spell_read_aff(spellinfo_T *spin, char_u } else if (is_aff_rule(items, itemcnt, "COMPOUNDRULES", 2)) { - /* We don't use the count, but do check that it's a number and - * not COMPOUNDRULE mistyped. */ + // We don't use the count, but do check that it's a number and + // not COMPOUNDRULE mistyped. if (atoi((char *)items[1]) == 0) smsg(_("Wrong COMPOUNDRULES value in %s line %d: %s"), fname, lnum, items[1]); } else if (is_aff_rule(items, itemcnt, "COMPOUNDRULE", 2)) { - /* Don't use the first rule if it is a number. */ + // Don't use the first rule if it is a number. if (compflags != NULL || *skipdigits(items[1]) != NUL) { - /* Concatenate this string to previously defined ones, - * using a slash to separate them. */ + // Concatenate this string to previously defined ones, + // using a slash to separate them. l = (int)STRLEN(items[1]) + 1; if (compflags != NULL) l += (int)STRLEN(compflags) + 1; @@ -2526,7 +2526,7 @@ spell_read_aff(spellinfo_T *spin, char_u garray_T *gap = &spin->si_comppat; int i; - /* Only add the couple if it isn't already there. */ + // Only add the couple if it isn't already there. for (i = 0; i < gap->ga_len - 1; i += 2) if (STRCMP(((char_u **)(gap->ga_data))[i], items[1]) == 0 && STRCMP(((char_u **)(gap->ga_data))[i + 1], @@ -2582,10 +2582,10 @@ spell_read_aff(spellinfo_T *spin, char_u else tp = &aff->af_suff; - /* Myspell allows the same affix name to be used multiple - * times. The affix files that do this have an undocumented - * "S" flag on all but the last block, thus we check for that - * and store it in ah_follows. */ + // Myspell allows the same affix name to be used multiple + // times. The affix files that do this have an undocumented + // "S" flag on all but the last block, thus we check for that + // and store it in ah_follows. vim_strncpy(key, items[1], AH_KEY_LEN - 1); hi = hash_find(tp, key); if (!HASHITEM_EMPTY(hi)) @@ -2600,7 +2600,7 @@ spell_read_aff(spellinfo_T *spin, char_u } else { - /* New affix letter. */ + // New affix letter. cur_aff = (affheader_T *)getroom(spin, sizeof(affheader_T), TRUE); if (cur_aff == NULL) @@ -2625,8 +2625,8 @@ spell_read_aff(spellinfo_T *spin, char_u cur_aff->ah_combine = (*items[2] == 'Y'); } - /* Check for the "S" flag, which apparently means that another - * block with the same affix name is following. */ + // Check for the "S" flag, which apparently means that another + // block with the same affix name is following. if (itemcnt > lasti && STRCMP(items[lasti], "S") == 0) { ++lasti; @@ -2635,8 +2635,8 @@ spell_read_aff(spellinfo_T *spin, char_u else cur_aff->ah_follows = FALSE; - /* Myspell allows extra text after the item, but that might - * mean mistakes go unnoticed. Require a comment-starter. */ + // Myspell allows extra text after the item, but that might + // mean mistakes go unnoticed. Require a comment-starter. if (itemcnt > lasti && *items[lasti] != '#') smsg(_(e_afftrailing), fname, lnum, items[lasti]); @@ -2648,18 +2648,18 @@ spell_read_aff(spellinfo_T *spin, char_u { if (cur_aff->ah_newID == 0) { - /* Use a new number in the .spl file later, to be able - * to handle multiple .aff files. */ + // Use a new number in the .spl file later, to be able + // to handle multiple .aff files. check_renumber(spin); cur_aff->ah_newID = ++spin->si_newprefID; - /* We only really use ah_newID if the prefix is - * postponed. We know that only after handling all - * the items. */ + // We only really use ah_newID if the prefix is + // postponed. We know that only after handling all + // the items. did_postpone_prefix = FALSE; } else - /* Did use the ID in a previous block. */ + // Did use the ID in a previous block. did_postpone_prefix = TRUE; } @@ -2675,9 +2675,9 @@ spell_read_aff(spellinfo_T *spin, char_u int upper = FALSE; int lasti = 5; - /* Myspell allows extra text after the item, but that might - * mean mistakes go unnoticed. Require a comment-starter, - * unless IGNOREEXTRA is used. Hunspell uses a "-" item. */ + // Myspell allows extra text after the item, but that might + // mean mistakes go unnoticed. Require a comment-starter, + // unless IGNOREEXTRA is used. Hunspell uses a "-" item. if (itemcnt > lasti && !aff->af_ignoreextra && *items[lasti] != '#' @@ -2685,7 +2685,7 @@ spell_read_aff(spellinfo_T *spin, char_u || itemcnt != lasti + 1)) smsg(_(e_afftrailing), fname, lnum, items[lasti]); - /* New item for an affix letter. */ + // New item for an affix letter. --aff_todo; aff_entry = (affentry_T *)getroom(spin, sizeof(affentry_T), TRUE); @@ -2698,7 +2698,7 @@ spell_read_aff(spellinfo_T *spin, char_u { aff_entry->ae_add = getroom_save(spin, items[3]); - /* Recognize flags on the affix: abcd/XYZ */ + // Recognize flags on the affix: abcd/XYZ aff_entry->ae_flags = vim_strchr(aff_entry->ae_add, '/'); if (aff_entry->ae_flags != NULL) { @@ -2707,8 +2707,8 @@ spell_read_aff(spellinfo_T *spin, char_u } } - /* Don't use an affix entry with non-ASCII characters when - * "spin->si_ascii" is TRUE. */ + // Don't use an affix entry with non-ASCII characters when + // "spin->si_ascii" is TRUE. if (!spin->si_ascii || !(has_non_ascii(aff_entry->ae_chop) || has_non_ascii(aff_entry->ae_add))) { @@ -2731,18 +2731,18 @@ spell_read_aff(spellinfo_T *spin, char_u fname, lnum, items[4]); } - /* For postponed prefixes we need an entry in si_prefcond - * for the condition. Use an existing one if possible. - * Can't be done for an affix with flags, ignoring - * COMPOUNDFORBIDFLAG and COMPOUNDPERMITFLAG. */ + // For postponed prefixes we need an entry in si_prefcond + // for the condition. Use an existing one if possible. + // Can't be done for an affix with flags, ignoring + // COMPOUNDFORBIDFLAG and COMPOUNDPERMITFLAG. if (*items[0] == 'P' && aff->af_pfxpostpone && aff_entry->ae_flags == NULL) { - /* When the chop string is one lower-case letter and - * the add string ends in the upper-case letter we set - * the "upper" flag, clear "ae_chop" and remove the - * letters from "ae_add". The condition must either - * be empty or start with the same letter. */ + // When the chop string is one lower-case letter and + // the add string ends in the upper-case letter we set + // the "upper" flag, clear "ae_chop" and remove the + // letters from "ae_add". The condition must either + // be empty or start with the same letter. if (aff_entry->ae_chop != NULL && aff_entry->ae_add != NULL && aff_entry->ae_chop[(*mb_ptr2len)( @@ -2765,9 +2765,9 @@ spell_read_aff(spellinfo_T *spin, char_u aff_entry->ae_chop = NULL; *p = NUL; - /* The condition is matched with the - * actual word, thus must check for the - * upper-case letter. */ + // The condition is matched with the + // actual word, thus must check for the + // upper-case letter. if (aff_entry->ae_cond != NULL) { char_u buf[MAXLINELEN]; @@ -2800,7 +2800,7 @@ spell_read_aff(spellinfo_T *spin, char_u char_u **pp; int n; - /* Find a previously used condition. */ + // Find a previously used condition. for (idx = spin->si_prefcond.ga_len - 1; idx >= 0; --idx) { @@ -2810,7 +2810,7 @@ spell_read_aff(spellinfo_T *spin, char_u } if (idx < 0 && ga_grow(&spin->si_prefcond, 1) == OK) { - /* Not found, add a new condition. */ + // Not found, add a new condition. idx = spin->si_prefcond.ga_len++; pp = ((char_u **)spin->si_prefcond.ga_data) + idx; @@ -2821,14 +2821,14 @@ spell_read_aff(spellinfo_T *spin, char_u aff_entry->ae_cond); } - /* Add the prefix to the prefix tree. */ + // Add the prefix to the prefix tree. if (aff_entry->ae_add == NULL) p = (char_u *)""; else p = aff_entry->ae_add; - /* PFX_FLAGS is a negative number, so that - * tree_add_word() knows this is the prefix tree. */ + // PFX_FLAGS is a negative number, so that + // tree_add_word() knows this is the prefix tree. n = PFX_FLAGS; if (!cur_aff->ah_combine) n |= WFP_NC; @@ -2843,7 +2843,7 @@ spell_read_aff(spellinfo_T *spin, char_u did_postpone_prefix = TRUE; } - /* Didn't actually use ah_newID, backup si_newprefID. */ + // Didn't actually use ah_newID, backup si_newprefID. if (aff_todo == 0 && !did_postpone_prefix) { --spin->si_newprefID; @@ -2867,7 +2867,7 @@ spell_read_aff(spellinfo_T *spin, char_u else if (is_aff_rule(items, itemcnt, "REP", 2) || is_aff_rule(items, itemcnt, "REPSAL", 2)) { - /* Ignore REP/REPSAL count */; + // Ignore REP/REPSAL count if (!isdigit(*items[1])) smsg(_("Expected REP(SAL) count in %s line %d"), fname, lnum); @@ -2876,15 +2876,15 @@ spell_read_aff(spellinfo_T *spin, char_u || STRCMP(items[0], "REPSAL") == 0) && itemcnt >= 3) { - /* REP/REPSAL item */ - /* Myspell ignores extra arguments, we require it starts with - * # to detect mistakes. */ + // REP/REPSAL item + // Myspell ignores extra arguments, we require it starts with + // # to detect mistakes. if (itemcnt > 3 && items[3][0] != '#') smsg(_(e_afftrailing), fname, lnum, items[3]); if (items[0][3] == 'S' ? do_repsal : do_rep) { - /* Replace underscore with space (can't include a space - * directly). */ + // Replace underscore with space (can't include a space + // directly). for (p = items[1]; *p != NUL; MB_PTR_ADV(p)) if (*p == '_') *p = ' '; @@ -2898,10 +2898,10 @@ spell_read_aff(spellinfo_T *spin, char_u } else if (is_aff_rule(items, itemcnt, "MAP", 2)) { - /* MAP item or count */ + // MAP item or count if (!found_map) { - /* First line contains the count. */ + // First line contains the count. found_map = TRUE; if (!isdigit(*items[1])) smsg(_("Expected MAP count in %s line %d"), @@ -2911,7 +2911,7 @@ spell_read_aff(spellinfo_T *spin, char_u { int c; - /* Check that every character appears only once. */ + // Check that every character appears only once. for (p = items[1]; *p != NUL; ) { c = mb_ptr2char_adv(&p); @@ -2923,19 +2923,19 @@ spell_read_aff(spellinfo_T *spin, char_u fname, lnum); } - /* We simply concatenate all the MAP strings, separated by - * slashes. */ + // We simply concatenate all the MAP strings, separated by + // slashes. ga_concat(&spin->si_map, items[1]); ga_append(&spin->si_map, '/'); } } - /* Accept "SAL from to" and "SAL from to #comment". */ + // Accept "SAL from to" and "SAL from to #comment". else if (is_aff_rule(items, itemcnt, "SAL", 3)) { if (do_sal) { - /* SAL item (sounds-a-like) - * Either one of the known keys or a from-to pair. */ + // SAL item (sounds-a-like) + // Either one of the known keys or a from-to pair. if (STRCMP(items[1], "followup") == 0) spin->si_followup = sal_to_bool(items[2]); else if (STRCMP(items[1], "collapse_result") == 0) @@ -2943,7 +2943,7 @@ spell_read_aff(spellinfo_T *spin, char_u else if (STRCMP(items[1], "remove_accents") == 0) spin->si_rem_accents = sal_to_bool(items[2]); else - /* when "to" is "_" it means empty */ + // when "to" is "_" it means empty add_fromto(spin, &spin->si_sal, items[1], STRCMP(items[2], "_") == 0 ? (char_u *)"" : items[2]); @@ -2985,8 +2985,8 @@ spell_read_aff(spellinfo_T *spin, char_u { if (spin->si_clear_chartab) { - /* Clear the char type tables, don't want to use any of the - * currently used spell properties. */ + // Clear the char type tables, don't want to use any of the + // currently used spell properties. init_spell_chartab(); spin->si_clear_chartab = FALSE; } @@ -3010,7 +3010,7 @@ spell_read_aff(spellinfo_T *spin, char_u vim_free(upp); } - /* Use compound specifications of the .aff file for the spell info. */ + // Use compound specifications of the .aff file for the spell info. if (compmax != 0) { aff_check_number(spin->si_compmax, compmax, "COMPOUNDWORDMAX"); @@ -3040,7 +3040,7 @@ spell_read_aff(spellinfo_T *spin, char_u if (compflags != NULL) process_compflags(spin, aff, compflags); - /* Check that we didn't use too many renumbered flags. */ + // Check that we didn't use too many renumbered flags. if (spin->si_newcompID < spin->si_newprefID) { if (spin->si_newcompID == 127 || spin->si_newcompID == 255) @@ -3131,7 +3131,7 @@ aff_process_flags(afffile_T *affile, aff ++p; } if (*entry->ae_flags == NUL) - entry->ae_flags = NULL; /* nothing left */ + entry->ae_flags = NULL; // nothing left } } @@ -3196,7 +3196,7 @@ get_affitem(int flagtype, char_u **pp) { if (!VIM_ISDIGIT(**pp)) { - ++*pp; /* always advance, avoid getting stuck */ + ++*pp; // always advance, avoid getting stuck return 0; } res = getdigits(pp); @@ -3239,9 +3239,9 @@ process_compflags( char_u key[AH_KEY_LEN]; hashitem_T *hi; - /* Make room for the old and the new compflags, concatenated with a / in - * between. Processing it makes it shorter, but we don't know by how - * much, thus allocate the maximum. */ + // Make room for the old and the new compflags, concatenated with a / in + // between. Processing it makes it shorter, but we don't know by how + // much, thus allocate the maximum. len = (int)STRLEN(compflags) + 1; if (spin->si_compflags != NULL) len += (int)STRLEN(spin->si_compflags) + 1; @@ -3259,17 +3259,17 @@ process_compflags( for (p = compflags; *p != NUL; ) { if (vim_strchr((char_u *)"/?*+[]", *p) != NULL) - /* Copy non-flag characters directly. */ + // Copy non-flag characters directly. *tp++ = *p++; else { - /* First get the flag number, also checks validity. */ + // First get the flag number, also checks validity. prevp = p; flag = get_affitem(aff->af_flagtype, &p); if (flag != 0) { - /* Find the flag in the hashtable. If it was used before, use - * the existing ID. Otherwise add a new entry. */ + // Find the flag in the hashtable. If it was used before, use + // the existing ID. Otherwise add a new entry. vim_strncpy(key, prevp, p - prevp); hi = hash_find(&aff->af_comp, key); if (!HASHITEM_EMPTY(hi)) @@ -3281,8 +3281,8 @@ process_compflags( break; STRCPY(ci->ci_key, key); ci->ci_flag = flag; - /* Avoid using a flag ID that has a special meaning in a - * regexp (also inside []). */ + // Avoid using a flag ID that has a special meaning in a + // regexp (also inside []). do { check_renumber(spin); @@ -3352,7 +3352,7 @@ flag_in_afflist(int flagtype, char_u *af n = ZERO_FLAG; if (n == flag) return TRUE; - if (*p != NUL) /* skip over comma */ + if (*p != NUL) // skip over comma ++p; } break; @@ -3440,7 +3440,7 @@ spell_free_aff(afffile_T *aff) vim_free(aff->af_enc); - /* All this trouble to free the "ae_prog" items... */ + // All this trouble to free the "ae_prog" items... for (ht = &aff->af_pref; ; ht = &aff->af_suff) { todo = (int)ht->ht_used; @@ -3501,17 +3501,17 @@ spell_read_dic(spellinfo_T *spin, char_u return FAIL; } - /* The hashtable is only used to detect duplicated words. */ + // The hashtable is only used to detect duplicated words. hash_init(&ht); vim_snprintf((char *)IObuff, IOSIZE, _("Reading dictionary file %s..."), fname); spell_message(spin, IObuff); - /* start with a message for the first line */ + // start with a message for the first line spin->si_msg_count = 999999; - /* Read and ignore the first line: word count. */ + // Read and ignore the first line: word count. (void)vim_fgets(line, MAXLINELEN, fd); if (!vim_isdigit(*skipwhite(line))) semsg(_("E760: No word count in %s"), fname); @@ -3526,18 +3526,18 @@ spell_read_dic(spellinfo_T *spin, char_u line_breakcheck(); ++lnum; if (line[0] == '#' || line[0] == '/') - continue; /* comment line */ - - /* Remove CR, LF and white space from the end. White space halfway - * the word is kept to allow e.g., "et al.". */ + continue; // comment line + + // Remove CR, LF and white space from the end. White space halfway + // the word is kept to allow e.g., "et al.". l = (int)STRLEN(line); while (l > 0 && line[l - 1] <= ' ') --l; if (l == 0) - continue; /* empty line */ + continue; // empty line line[l] = NUL; - /* Convert from "SET" to 'encoding' when needed. */ + // Convert from "SET" to 'encoding' when needed. if (spin->si_conv.vc_type != CONV_NONE) { pc = string_convert(&spin->si_conv, line, NULL); @@ -3555,8 +3555,8 @@ spell_read_dic(spellinfo_T *spin, char_u w = line; } - /* Truncate the word at the "/", set "afflist" to what follows. - * Replace "\/" by "/" and "\\" by "\". */ + // Truncate the word at the "/", set "afflist" to what follows. + // Replace "\/" by "/" and "\\" by "\". afflist = NULL; for (p = w; *p != NUL; MB_PTR_ADV(p)) { @@ -3570,7 +3570,7 @@ spell_read_dic(spellinfo_T *spin, char_u } } - /* Skip non-ASCII words when "spin->si_ascii" is TRUE. */ + // Skip non-ASCII words when "spin->si_ascii" is TRUE. if (spin->si_ascii && has_non_ascii(w)) { ++non_ascii; @@ -3578,7 +3578,7 @@ spell_read_dic(spellinfo_T *spin, char_u continue; } - /* This takes time, print a message every 10000 words. */ + // This takes time, print a message every 10000 words. if (spin->si_verbose && spin->si_msg_count > 10000) { spin->si_msg_count = 0; @@ -3593,7 +3593,7 @@ spell_read_dic(spellinfo_T *spin, char_u out_flush(); } - /* Store the word in the hashtable to be able to find duplicates. */ + // Store the word in the hashtable to be able to find duplicates. dw = (char_u *)getroom_save(spin, w); if (dw == NULL) { @@ -3623,7 +3623,7 @@ spell_read_dic(spellinfo_T *spin, char_u need_affix = FALSE; if (afflist != NULL) { - /* Extract flags from the affix list. */ + // Extract flags from the affix list. flags |= get_affix_flags(affile, afflist); if (affile->af_needaffix != 0 && flag_in_afflist( @@ -3631,30 +3631,30 @@ spell_read_dic(spellinfo_T *spin, char_u need_affix = TRUE; if (affile->af_pfxpostpone) - /* Need to store the list of prefix IDs with the word. */ + // Need to store the list of prefix IDs with the word. pfxlen = get_pfxlist(affile, afflist, store_afflist); if (spin->si_compflags != NULL) - /* Need to store the list of compound flags with the word. - * Concatenate them to the list of prefix IDs. */ + // Need to store the list of compound flags with the word. + // Concatenate them to the list of prefix IDs. get_compflags(affile, afflist, store_afflist + pfxlen); } - /* Add the word to the word tree(s). */ + // Add the word to the word tree(s). if (store_word(spin, dw, flags, spin->si_region, store_afflist, need_affix) == FAIL) retval = FAIL; if (afflist != NULL) { - /* Find all matching suffixes and add the resulting words. - * Additionally do matching prefixes that combine. */ + // Find all matching suffixes and add the resulting words. + // Additionally do matching prefixes that combine. if (store_aff_word(spin, dw, afflist, affile, &affile->af_suff, &affile->af_pref, CONDIT_SUF, flags, store_afflist, pfxlen) == FAIL) retval = FAIL; - /* Find all matching prefixes and add the resulting words. */ + // Find all matching prefixes and add the resulting words. if (store_aff_word(spin, dw, afflist, affile, &affile->af_pref, NULL, CONDIT_SUF, flags, store_afflist, pfxlen) == FAIL) @@ -3729,8 +3729,8 @@ get_pfxlist( prevp = p; if (get_affitem(affile->af_flagtype, &p) != 0) { - /* A flag is a postponed prefix flag if it appears in "af_pref" - * and its ID is not zero. */ + // A flag is a postponed prefix flag if it appears in "af_pref" + // and its ID is not zero. vim_strncpy(key, prevp, p - prevp); hi = hash_find(&affile->af_pref, key); if (!HASHITEM_EMPTY(hi)) @@ -3770,7 +3770,7 @@ get_compflags( prevp = p; if (get_affitem(affile->af_flagtype, &p) != 0) { - /* A flag is a compound flag if it appears in "af_comp". */ + // A flag is a compound flag if it appears in "af_comp". vim_strncpy(key, prevp, p - prevp); hi = hash_find(&affile->af_comp, key); if (!HASHITEM_EMPTY(hi)) @@ -3794,17 +3794,17 @@ get_compflags( */ static int store_aff_word( - spellinfo_T *spin, /* spell info */ - char_u *word, /* basic word start */ - char_u *afflist, /* list of names of supported affixes */ + spellinfo_T *spin, // spell info + char_u *word, // basic word start + char_u *afflist, // list of names of supported affixes afffile_T *affile, hashtab_T *ht, hashtab_T *xht, - int condit, /* CONDIT_SUF et al. */ - int flags, /* flags for the word */ - char_u *pfxlist, /* list of prefix IDs */ - int pfxlen) /* nr of flags in "pfxlist" for prefixes, rest - * is compound flags */ + int condit, // CONDIT_SUF et al. + int flags, // flags for the word + char_u *pfxlist, // list of prefix IDs + int pfxlen) // nr of flags in "pfxlist" for prefixes, rest + // is compound flags { int todo; hashitem_T *hi; @@ -3831,25 +3831,25 @@ store_aff_word( --todo; ah = HI2AH(hi); - /* Check that the affix combines, if required, and that the word - * supports this affix. */ + // Check that the affix combines, if required, and that the word + // supports this affix. if (((condit & CONDIT_COMB) == 0 || ah->ah_combine) && flag_in_afflist(affile->af_flagtype, afflist, ah->ah_flag)) { - /* Loop over all affix entries with this name. */ + // Loop over all affix entries with this name. for (ae = ah->ah_first; ae != NULL; ae = ae->ae_next) { - /* Check the condition. It's not logical to match case - * here, but it is required for compatibility with - * Myspell. - * Another requirement from Myspell is that the chop - * string is shorter than the word itself. - * For prefixes, when "PFXPOSTPONE" was used, only do - * prefixes with a chop string and/or flags. - * When a previously added affix had CIRCUMFIX this one - * must have it too, if it had not then this one must not - * have one either. */ + // Check the condition. It's not logical to match case + // here, but it is required for compatibility with + // Myspell. + // Another requirement from Myspell is that the chop + // string is shorter than the word itself. + // For prefixes, when "PFXPOSTPONE" was used, only do + // prefixes with a chop string and/or flags. + // When a previously added affix had CIRCUMFIX this one + // must have it too, if it had not then this one must not + // have one either. if ((xht != NULL || !affile->af_pfxpostpone || ae->ae_chop != NULL || ae->ae_flags != NULL) @@ -3864,10 +3864,10 @@ store_aff_word( || !flag_in_afflist(affile->af_flagtype, ae->ae_flags, affile->af_circumfix)))) { - /* Match. Remove the chop and add the affix. */ + // Match. Remove the chop and add the affix. if (xht == NULL) { - /* prefix: chop/add at the start of the word */ + // prefix: chop/add at the start of the word if (ae->ae_add == NULL) *newword = NUL; else @@ -3875,7 +3875,7 @@ store_aff_word( p = word; if (ae->ae_chop != NULL) { - /* Skip chop string. */ + // Skip chop string. if (has_mbyte) { i = mb_charlen(ae->ae_chop); @@ -3889,11 +3889,11 @@ store_aff_word( } else { - /* suffix: chop/add at the end of the word */ + // suffix: chop/add at the end of the word vim_strncpy(newword, word, MAXWLEN - 1); if (ae->ae_chop != NULL) { - /* Remove chop string. */ + // Remove chop string. p = newword + STRLEN(newword); i = (int)MB_CHARLEN(ae->ae_chop); for ( ; i > 0; --i) @@ -3911,7 +3911,7 @@ store_aff_word( use_condit = condit | CONDIT_COMB | CONDIT_AFF; if (ae->ae_flags != NULL) { - /* Extract flags from the affix list. */ + // Extract flags from the affix list. use_flags |= get_affix_flags(affile, ae->ae_flags); if (affile->af_needaffix != 0 && flag_in_afflist( @@ -3919,9 +3919,9 @@ store_aff_word( affile->af_needaffix)) need_affix = TRUE; - /* When there is a CIRCUMFIX flag the other affix - * must also have it and we don't add the word - * with one affix. */ + // When there is a CIRCUMFIX flag the other affix + // must also have it and we don't add the word + // with one affix. if (affile->af_circumfix != 0 && flag_in_afflist( affile->af_flagtype, ae->ae_flags, affile->af_circumfix)) @@ -3935,15 +3935,15 @@ store_aff_word( || spin->si_compflags != NULL) { if (affile->af_pfxpostpone) - /* Get prefix IDS from the affix list. */ + // Get prefix IDS from the affix list. use_pfxlen = get_pfxlist(affile, ae->ae_flags, store_afflist); else use_pfxlen = 0; use_pfxlist = store_afflist; - /* Combine the prefix IDs. Avoid adding the - * same ID twice. */ + // Combine the prefix IDs. Avoid adding the + // same ID twice. for (i = 0; i < pfxlen; ++i) { for (j = 0; j < use_pfxlen; ++j) @@ -3954,13 +3954,13 @@ store_aff_word( } if (spin->si_compflags != NULL) - /* Get compound IDS from the affix list. */ + // Get compound IDS from the affix list. get_compflags(affile, ae->ae_flags, use_pfxlist + use_pfxlen); - /* Combine the list of compound flags. - * Concatenate them to the prefix IDs list. - * Avoid adding the same ID twice. */ + // Combine the list of compound flags. + // Concatenate them to the prefix IDs list. + // Avoid adding the same ID twice. for (i = pfxlen; pfxlist[i] != NUL; ++i) { for (j = use_pfxlen; @@ -3976,31 +3976,31 @@ store_aff_word( } } - /* Obey a "COMPOUNDFORBIDFLAG" of the affix: don't - * use the compound flags. */ + // Obey a "COMPOUNDFORBIDFLAG" of the affix: don't + // use the compound flags. if (use_pfxlist != NULL && ae->ae_compforbid) { vim_strncpy(pfx_pfxlist, use_pfxlist, use_pfxlen); use_pfxlist = pfx_pfxlist; } - /* When there are postponed prefixes... */ + // When there are postponed prefixes... if (spin->si_prefroot != NULL && spin->si_prefroot->wn_sibling != NULL) { - /* ... add a flag to indicate an affix was used. */ + // ... add a flag to indicate an affix was used. use_flags |= WF_HAS_AFF; - /* ... don't use a prefix list if combining - * affixes is not allowed. But do use the - * compound flags after them. */ + // ... don't use a prefix list if combining + // affixes is not allowed. But do use the + // compound flags after them. if (!ah->ah_combine && use_pfxlist != NULL) use_pfxlist += use_pfxlen; } - /* When compounding is supported and there is no - * "COMPOUNDPERMITFLAG" then forbid compounding on the - * side where the affix is applied. */ + // When compounding is supported and there is no + // "COMPOUNDPERMITFLAG" then forbid compounding on the + // side where the affix is applied. if (spin->si_compflags != NULL && !ae->ae_comppermit) { if (xht != NULL) @@ -4009,14 +4009,14 @@ store_aff_word( use_flags |= WF_NOCOMPBEF; } - /* Store the modified word. */ + // Store the modified word. if (store_word(spin, newword, use_flags, spin->si_region, use_pfxlist, need_affix) == FAIL) retval = FAIL; - /* When added a prefix or a first suffix and the affix - * has flags may add a(nother) suffix. RECURSIVE! */ + // When added a prefix or a first suffix and the affix + // has flags may add a(nother) suffix. RECURSIVE! if ((condit & CONDIT_SUF) && ae->ae_flags != NULL) if (store_aff_word(spin, newword, ae->ae_flags, affile, &affile->af_suff, xht, @@ -4025,9 +4025,9 @@ store_aff_word( use_flags, use_pfxlist, pfxlen) == FAIL) retval = FAIL; - /* When added a suffix and combining is allowed also - * try adding a prefix additionally. Both for the - * word flags and for the affix flags. RECURSIVE! */ + // When added a suffix and combining is allowed also + // try adding a prefix additionally. Both for the + // word flags and for the affix flags. RECURSIVE! if (xht != NULL && ah->ah_combine) { if (store_aff_word(spin, newword, @@ -4092,19 +4092,19 @@ spell_read_wordfile(spellinfo_T *spin, c line_breakcheck(); ++lnum; - /* Skip comment lines. */ + // Skip comment lines. if (*rline == '#') continue; - /* Remove CR, LF and white space from the end. */ + // Remove CR, LF and white space from the end. l = (int)STRLEN(rline); while (l > 0 && rline[l - 1] <= ' ') --l; if (l == 0) - continue; /* empty or blank line */ + continue; // empty or blank line rline[l] = NUL; - /* Convert from "/encoding={encoding}" to 'encoding' when needed. */ + // Convert from "/encoding={encoding}" to 'encoding' when needed. vim_free(pc); if (spin->si_conv.vc_type != CONV_NONE) { @@ -4138,7 +4138,7 @@ spell_read_wordfile(spellinfo_T *spin, c { char_u *enc; - /* Setup for conversion to 'encoding'. */ + // Setup for conversion to 'encoding'. line += 9; enc = enc_canonize(line); if (enc != NULL && !spin->si_ascii @@ -4168,7 +4168,7 @@ spell_read_wordfile(spellinfo_T *spin, c spin->si_region_count = (int)STRLEN(line) / 2; STRCPY(spin->si_region_name, line); - /* Adjust the mask for a word valid in all regions. */ + // Adjust the mask for a word valid in all regions. spin->si_region = (1 << spin->si_region_count) - 1; } } @@ -4183,22 +4183,22 @@ spell_read_wordfile(spellinfo_T *spin, c flags = 0; regionmask = spin->si_region; - /* Check for flags and region after a slash. */ + // Check for flags and region after a slash. p = vim_strchr(line, '/'); if (p != NULL) { *p++ = NUL; while (*p != NUL) { - if (*p == '=') /* keep-case word */ + if (*p == '=') // keep-case word flags |= WF_KEEPCAP | WF_FIXCAP; - else if (*p == '!') /* Bad, bad, wicked word. */ + else if (*p == '!') // Bad, bad, wicked word. flags |= WF_BANNED; - else if (*p == '?') /* Rare word. */ + else if (*p == '?') // Rare word. flags |= WF_RARE; - else if (VIM_ISDIGIT(*p)) /* region number(s) */ + else if (VIM_ISDIGIT(*p)) // region number(s) { - if ((flags & WF_REGION) == 0) /* first one */ + if ((flags & WF_REGION) == 0) // first one regionmask = 0; flags |= WF_REGION; @@ -4221,14 +4221,14 @@ spell_read_wordfile(spellinfo_T *spin, c } } - /* Skip non-ASCII words when "spin->si_ascii" is TRUE. */ + // Skip non-ASCII words when "spin->si_ascii" is TRUE. if (spin->si_ascii && has_non_ascii(line)) { ++non_ascii; continue; } - /* Normal word: store it. */ + // Normal word: store it. if (store_word(spin, line, flags, regionmask, NULL, FALSE) == FAIL) { retval = FAIL; @@ -4260,15 +4260,15 @@ spell_read_wordfile(spellinfo_T *spin, c static void * getroom( spellinfo_T *spin, - size_t len, /* length needed */ - int align) /* align for pointer */ + size_t len, // length needed + int align) // align for pointer { char_u *p; sblock_T *bl = spin->si_blocks; if (align && bl != NULL) - /* Round size up for alignment. On some systems structures need to be - * aligned to the size of a pointer (e.g., SPARC). */ + // Round size up for alignment. On some systems structures need to be + // aligned to the size of a pointer (e.g., SPARC). bl->sb_used = (bl->sb_used + sizeof(char *) - 1) & ~(sizeof(char *) - 1); @@ -4277,7 +4277,7 @@ getroom( if (len >= SBLOCKSIZE) bl = NULL; else - /* Allocate a block of memory. It is not freed until much later. */ + // Allocate a block of memory. It is not freed until much later. bl = alloc_clear(sizeof(sblock_T) + SBLOCKSIZE); if (bl == NULL) { @@ -4355,10 +4355,10 @@ wordtree_alloc(spellinfo_T *spin) store_word( spellinfo_T *spin, char_u *word, - int flags, /* extra flags, WF_BANNED */ - int region, /* supported region(s) */ - char_u *pfxlist, /* list of prefix IDs or NULL */ - int need_affix) /* only store word with affix ID */ + int flags, // extra flags, WF_BANNED + int region, // supported region(s) + char_u *pfxlist, // list of prefix IDs or NULL + int need_affix) // only store word with affix ID { int len = (int)STRLEN(word); int ct = captype(word, word + len); @@ -4413,25 +4413,25 @@ tree_add_word( wordnode_T **prev = NULL; int i; - /* Add each byte of the word to the tree, including the NUL at the end. */ + // Add each byte of the word to the tree, including the NUL at the end. for (i = 0; ; ++i) { - /* When there is more than one reference to this node we need to make - * a copy, so that we can modify it. Copy the whole list of siblings - * (we don't optimize for a partly shared list of siblings). */ + // When there is more than one reference to this node we need to make + // a copy, so that we can modify it. Copy the whole list of siblings + // (we don't optimize for a partly shared list of siblings). if (node != NULL && node->wn_refs > 1) { --node->wn_refs; copyprev = prev; for (copyp = node; copyp != NULL; copyp = copyp->wn_sibling) { - /* Allocate a new node and copy the info. */ + // Allocate a new node and copy the info. np = get_wordnode(spin); if (np == NULL) return FAIL; np->wn_child = copyp->wn_child; if (np->wn_child != NULL) - ++np->wn_child->wn_refs; /* child gets extra ref */ + ++np->wn_child->wn_refs; // child gets extra ref np->wn_byte = copyp->wn_byte; if (np->wn_byte == NUL) { @@ -4440,22 +4440,22 @@ tree_add_word( np->wn_affixID = copyp->wn_affixID; } - /* Link the new node in the list, there will be one ref. */ + // Link the new node in the list, there will be one ref. np->wn_refs = 1; if (copyprev != NULL) *copyprev = np; copyprev = &np->wn_sibling; - /* Let "node" point to the head of the copied list. */ + // Let "node" point to the head of the copied list. if (copyp == node) node = np; } } - /* Look for the sibling that has the same character. They are sorted - * on byte value, thus stop searching when a sibling is found with a - * higher byte value. For zero bytes (end of word) the sorting is - * done on flags and then on affixID. */ + // Look for the sibling that has the same character. They are sorted + // on byte value, thus stop searching when a sibling is found with a + // higher byte value. For zero bytes (end of word) the sorting is + // done on flags and then on affixID. while (node != NULL && (node->wn_byte < word[i] || (node->wn_byte == NUL @@ -4479,16 +4479,16 @@ tree_add_word( || node->wn_flags != (flags & WN_MASK) || node->wn_affixID != affixID))) { - /* Allocate a new node. */ + // Allocate a new node. np = get_wordnode(spin); if (np == NULL) return FAIL; np->wn_byte = word[i]; - /* If "node" is NULL this is a new child or the end of the sibling - * list: ref count is one. Otherwise use ref count of sibling and - * make ref count of sibling one (matters when inserting in front - * of the list of siblings). */ + // If "node" is NULL this is a new child or the end of the sibling + // list: ref count is one. Otherwise use ref count of sibling and + // make ref count of sibling one (matters when inserting in front + // of the list of siblings). if (node == NULL) np->wn_refs = 1; else @@ -4517,13 +4517,13 @@ tree_add_word( spell_print_tree(root->wn_sibling); #endif - /* count nr of words added since last message */ + // count nr of words added since last message ++spin->si_msg_count; if (spin->si_compress_cnt > 1) { if (--spin->si_compress_cnt == 1) - /* Did enough words to lower the block count limit. */ + // Did enough words to lower the block count limit. spin->si_blocks_cnt += compress_inc; } @@ -4545,10 +4545,10 @@ tree_add_word( : spin->si_blocks_cnt >= compress_start) #endif { - /* Decrement the block counter. The effect is that we compress again - * when the freed up room has been used and another "compress_inc" - * blocks have been allocated. Unless "compress_added" words have - * been added, then the limit is put back again. */ + // Decrement the block counter. The effect is that we compress again + // when the freed up room has been used and another "compress_inc" + // blocks have been allocated. Unless "compress_added" words have + // been added, then the limit is put back again. spin->si_blocks_cnt -= compress_inc; spin->si_compress_cnt = compress_added; @@ -4562,10 +4562,10 @@ tree_add_word( out_flush(); } - /* Compress both trees. Either they both have many nodes, which makes - * compression useful, or one of them is small, which means - * compression goes fast. But when filling the soundfold word tree - * there is no keep-case tree. */ + // Compress both trees. Either they both have many nodes, which makes + // compression useful, or one of them is small, which means + // compression goes fast. But when filling the soundfold word tree + // there is no keep-case tree. wordtree_compress(spin, spin->si_foldroot); if (affixID >= 0) wordtree_compress(spin, spin->si_keeproot); @@ -4621,7 +4621,7 @@ deref_wordnode(spellinfo_T *spin, wordno free_wordnode(spin, np); ++cnt; } - ++cnt; /* length field */ + ++cnt; // length field } return cnt; } @@ -4649,8 +4649,8 @@ wordtree_compress(spellinfo_T *spin, wor int tot = 0; int perc; - /* Skip the root itself, it's not actually used. The first sibling is the - * start of the tree. */ + // Skip the root itself, it's not actually used. The first sibling is the + // start of the tree. if (root->wn_sibling != NULL) { hash_init(&ht); @@ -4687,8 +4687,8 @@ node_compress( spellinfo_T *spin, wordnode_T *node, hashtab_T *ht, - int *tot) /* total count of nodes before compressing, - incremented while going through the tree */ + int *tot) // total count of nodes before compressing, + // incremented while going through the tree { wordnode_T *np; wordnode_T *tp; @@ -4710,23 +4710,23 @@ node_compress( ++len; if ((child = np->wn_child) != NULL) { - /* Compress the child first. This fills hashkey. */ + // Compress the child first. This fills hashkey. compressed += node_compress(spin, child, ht, tot); - /* Try to find an identical child. */ + // Try to find an identical child. hash = hash_hash(child->wn_u1.hashkey); hi = hash_lookup(ht, child->wn_u1.hashkey, hash); if (!HASHITEM_EMPTY(hi)) { - /* There are children we encountered before with a hash value - * identical to the current child. Now check if there is one - * that is really identical. */ + // There are children we encountered before with a hash value + // identical to the current child. Now check if there is one + // that is really identical. for (tp = HI2WN(hi); tp != NULL; tp = tp->wn_u2.next) if (node_equal(child, tp)) { - /* Found one! Now use that child in place of the - * current one. This means the current child and all - * its siblings is unlinked from the tree. */ + // Found one! Now use that child in place of the + // current one. This means the current child and all + // its siblings is unlinked from the tree. ++tp->wn_refs; compressed += deref_wordnode(spin, child); np->wn_child = tp; @@ -4734,21 +4734,21 @@ node_compress( } if (tp == NULL) { - /* No other child with this hash value equals the child of - * the node, add it to the linked list after the first - * item. */ + // No other child with this hash value equals the child of + // the node, add it to the linked list after the first + // item. tp = HI2WN(hi); child->wn_u2.next = tp->wn_u2.next; tp->wn_u2.next = child; } } else - /* No other child has this hash value, add it to the - * hashtable. */ + // No other child has this hash value, add it to the + // hashtable. hash_add_item(ht, hi, child->wn_u1.hashkey, hash); } } - *tot += len + 1; /* add one for the node that stores the length */ + *tot += len + 1; // add one for the node that stores the length /* * Make a hash key for the node and its siblings, so that we can quickly @@ -4760,15 +4760,15 @@ node_compress( for (np = node; np != NULL; np = np->wn_sibling) { if (np->wn_byte == NUL) - /* end node: use wn_flags, wn_region and wn_affixID */ + // end node: use wn_flags, wn_region and wn_affixID n = np->wn_flags + (np->wn_region << 8) + (np->wn_affixID << 16); else - /* byte node: use the byte value and the child pointer */ + // byte node: use the byte value and the child pointer n = (unsigned)(np->wn_byte + ((long_u)np->wn_child << 8)); nr = nr * 101 + n; } - /* Avoid NUL bytes, it terminates the hash key. */ + // Avoid NUL bytes, it terminates the hash key. n = nr & 0xff; node->wn_u1.hashkey[1] = n == 0 ? 1 : n; n = (nr >> 8) & 0xff; @@ -4779,7 +4779,7 @@ node_compress( node->wn_u1.hashkey[4] = n == 0 ? 1 : n; node->wn_u1.hashkey[5] = NUL; - /* Check for CTRL-C pressed now and then. */ + // Check for CTRL-C pressed now and then. fast_breakcheck(); return compressed; @@ -4840,8 +4840,8 @@ write_vim_spell(spellinfo_T *spin, char_ char_u *p; int rr; int retval = OK; - size_t fwv = 1; /* collect return value of fwrite() to avoid - warnings from picky compiler */ + size_t fwv = 1; // collect return value of fwrite() to avoid + // warnings from picky compiler fd = mch_fopen((char *)fname, "w"); if (fd == NULL) @@ -4850,64 +4850,63 @@ write_vim_spell(spellinfo_T *spin, char_ return FAIL; } - /* <HEADER>: <fileID> <versionnr> */ - /* <fileID> */ + // <HEADER>: <fileID> <versionnr> + // <fileID> fwv &= fwrite(VIMSPELLMAGIC, VIMSPELLMAGICL, (size_t)1, fd); if (fwv != (size_t)1) - /* Catch first write error, don't try writing more. */ + // Catch first write error, don't try writing more. goto theend; - putc(VIMSPELLVERSION, fd); /* <versionnr> */ + putc(VIMSPELLVERSION, fd); // <versionnr> /* * <SECTIONS>: <section> ... <sectionend> */ - /* SN_INFO: <infotext> */ + // SN_INFO: <infotext> if (spin->si_info != NULL) { - putc(SN_INFO, fd); /* <sectionID> */ - putc(0, fd); /* <sectionflags> */ + putc(SN_INFO, fd); // <sectionID> + putc(0, fd); // <sectionflags> i = (int)STRLEN(spin->si_info); - put_bytes(fd, (long_u)i, 4); /* <sectionlen> */ - fwv &= fwrite(spin->si_info, (size_t)i, (size_t)1, fd); /* <infotext> */ + put_bytes(fd, (long_u)i, 4); // <sectionlen> + fwv &= fwrite(spin->si_info, (size_t)i, (size_t)1, fd); // <infotext> } - /* SN_REGION: <regionname> ... - * Write the region names only if there is more than one. */ + // SN_REGION: <regionname> ... + // Write the region names only if there is more than one. if (spin->si_region_count > 1) { - putc(SN_REGION, fd); /* <sectionID> */ - putc(SNF_REQUIRED, fd); /* <sectionflags> */ + putc(SN_REGION, fd); // <sectionID> + putc(SNF_REQUIRED, fd); // <sectionflags> l = spin->si_region_count * 2; - put_bytes(fd, (long_u)l, 4); /* <sectionlen> */ + put_bytes(fd, (long_u)l, 4); // <sectionlen> fwv &= fwrite(spin->si_region_name, (size_t)l, (size_t)1, fd); - /* <regionname> ... */ + // <regionname> ... regionmask = (1 << spin->si_region_count) - 1; } else regionmask = 0; - /* SN_CHARFLAGS: <charflagslen> <charflags> <folcharslen> <folchars> - * - * The table with character flags and the table for case folding. - * This makes sure the same characters are recognized as word characters - * when generating an when using a spell file. - * Skip this for ASCII, the table may conflict with the one used for - * 'encoding'. - * Also skip this for an .add.spl file, the main spell file must contain - * the table (avoids that it conflicts). File is shorter too. - */ + // SN_CHARFLAGS: <charflagslen> <charflags> <folcharslen> <folchars> + // + // The table with character flags and the table for case folding. + // This makes sure the same characters are recognized as word characters + // when generating an when using a spell file. + // Skip this for ASCII, the table may conflict with the one used for + // 'encoding'. + // Also skip this for an .add.spl file, the main spell file must contain + // the table (avoids that it conflicts). File is shorter too. if (!spin->si_ascii && !spin->si_add) { char_u folchars[128 * 8]; int flags; - putc(SN_CHARFLAGS, fd); /* <sectionID> */ - putc(SNF_REQUIRED, fd); /* <sectionflags> */ - - /* Form the <folchars> string first, we need to know its length. */ + putc(SN_CHARFLAGS, fd); // <sectionID> + putc(SNF_REQUIRED, fd); // <sectionflags> + + // Form the <folchars> string first, we need to know its length. l = 0; for (i = 128; i < 256; ++i) { @@ -4916,9 +4915,9 @@ write_vim_spell(spellinfo_T *spin, char_ else folchars[l++] = spelltab.st_fold[i]; } - put_bytes(fd, (long_u)(1 + 128 + 2 + l), 4); /* <sectionlen> */ - - fputc(128, fd); /* <charflagslen> */ + put_bytes(fd, (long_u)(1 + 128 + 2 + l), 4); // <sectionlen> + + fputc(128, fd); // <charflagslen> for (i = 128; i < 256; ++i) { flags = 0; @@ -4926,51 +4925,51 @@ write_vim_spell(spellinfo_T *spin, char_ flags |= CF_WORD; if (spelltab.st_isu[i]) flags |= CF_UPPER; - fputc(flags, fd); /* <charflags> */ + fputc(flags, fd); // <charflags> } - put_bytes(fd, (long_u)l, 2); /* <folcharslen> */ - fwv &= fwrite(folchars, (size_t)l, (size_t)1, fd); /* <folchars> */ + put_bytes(fd, (long_u)l, 2); // <folcharslen> + fwv &= fwrite(folchars, (size_t)l, (size_t)1, fd); // <folchars> } - /* SN_MIDWORD: <midword> */ + // SN_MIDWORD: <midword> if (spin->si_midword != NULL) { - putc(SN_MIDWORD, fd); /* <sectionID> */ - putc(SNF_REQUIRED, fd); /* <sectionflags> */ + putc(SN_MIDWORD, fd); // <sectionID> + putc(SNF_REQUIRED, fd); // <sectionflags> i = (int)STRLEN(spin->si_midword); - put_bytes(fd, (long_u)i, 4); /* <sectionlen> */ + put_bytes(fd, (long_u)i, 4); // <sectionlen> fwv &= fwrite(spin->si_midword, (size_t)i, (size_t)1, fd); - /* <midword> */ + // <midword> } - /* SN_PREFCOND: <prefcondcnt> <prefcond> ... */ + // SN_PREFCOND: <prefcondcnt> <prefcond> ... if (spin->si_prefcond.ga_len > 0) { - putc(SN_PREFCOND, fd); /* <sectionID> */ - putc(SNF_REQUIRED, fd); /* <sectionflags> */ + putc(SN_PREFCOND, fd); // <sectionID> + putc(SNF_REQUIRED, fd); // <sectionflags> l = write_spell_prefcond(NULL, &spin->si_prefcond); - put_bytes(fd, (long_u)l, 4); /* <sectionlen> */ + put_bytes(fd, (long_u)l, 4); // <sectionlen> write_spell_prefcond(fd, &spin->si_prefcond); } - /* SN_REP: <repcount> <rep> ... - * SN_SAL: <salflags> <salcount> <sal> ... - * SN_REPSAL: <repcount> <rep> ... */ - - /* round 1: SN_REP section - * round 2: SN_SAL section (unless SN_SOFO is used) - * round 3: SN_REPSAL section */ + // SN_REP: <repcount> <rep> ... + // SN_SAL: <salflags> <salcount> <sal> ... + // SN_REPSAL: <repcount> <rep> ... + + // round 1: SN_REP section + // round 2: SN_SAL section (unless SN_SOFO is used) + // round 3: SN_REPSAL section for (round = 1; round <= 3; ++round) { if (round == 1) gap = &spin->si_rep; else if (round == 2) { - /* Don't write SN_SAL when using a SN_SOFO section */ + // Don't write SN_SAL when using a SN_SOFO section if (spin->si_sofofr != NULL && spin->si_sofoto != NULL) continue; gap = &spin->si_sal; @@ -4978,32 +4977,32 @@ write_vim_spell(spellinfo_T *spin, char_ else gap = &spin->si_repsal; - /* Don't write the section if there are no items. */ + // Don't write the section if there are no items. if (gap->ga_len == 0) continue; - /* Sort the REP/REPSAL items. */ + // Sort the REP/REPSAL items. if (round != 2) qsort(gap->ga_data, (size_t)gap->ga_len, sizeof(fromto_T), rep_compare); i = round == 1 ? SN_REP : (round == 2 ? SN_SAL : SN_REPSAL); - putc(i, fd); /* <sectionID> */ - - /* This is for making suggestions, section is not required. */ - putc(0, fd); /* <sectionflags> */ - - /* Compute the length of what follows. */ - l = 2; /* count <repcount> or <salcount> */ + putc(i, fd); // <sectionID> + + // This is for making suggestions, section is not required. + putc(0, fd); // <sectionflags> + + // Compute the length of what follows. + l = 2; // count <repcount> or <salcount> for (i = 0; i < gap->ga_len; ++i) { ftp = &((fromto_T *)gap->ga_data)[i]; - l += 1 + (int)STRLEN(ftp->ft_from); /* count <*fromlen> and <*from> */ - l += 1 + (int)STRLEN(ftp->ft_to); /* count <*tolen> and <*to> */ + l += 1 + (int)STRLEN(ftp->ft_from); // count <*fromlen> and <*from> + l += 1 + (int)STRLEN(ftp->ft_to); // count <*tolen> and <*to> } if (round == 2) - ++l; /* count <salflags> */ - put_bytes(fd, (long_u)l, 4); /* <sectionlen> */ + ++l; // count <salflags> + put_bytes(fd, (long_u)l, 4); // <sectionlen> if (round == 2) { @@ -5014,14 +5013,14 @@ write_vim_spell(spellinfo_T *spin, char_ i |= SAL_COLLAPSE; if (spin->si_rem_accents) i |= SAL_REM_ACCENTS; - putc(i, fd); /* <salflags> */ + putc(i, fd); // <salflags> } - put_bytes(fd, (long_u)gap->ga_len, 2); /* <repcount> or <salcount> */ + put_bytes(fd, (long_u)gap->ga_len, 2); // <repcount> or <salcount> for (i = 0; i < gap->ga_len; ++i) { - /* <rep> : <repfromlen> <repfrom> <reptolen> <repto> */ - /* <sal> : <salfromlen> <salfrom> <saltolen> <salto> */ + // <rep> : <repfromlen> <repfrom> <reptolen> <repto> + // <sal> : <salfromlen> <salfrom> <saltolen> <salto> ftp = &((fromto_T *)gap->ga_data)[i]; for (rr = 1; rr <= 2; ++rr) { @@ -5035,34 +5034,34 @@ write_vim_spell(spellinfo_T *spin, char_ } - /* SN_SOFO: <sofofromlen> <sofofrom> <sofotolen> <sofoto> - * This is for making suggestions, section is not required. */ + // SN_SOFO: <sofofromlen> <sofofrom> <sofotolen> <sofoto> + // This is for making suggestions, section is not required. if (spin->si_sofofr != NULL && spin->si_sofoto != NULL) { - putc(SN_SOFO, fd); /* <sectionID> */ - putc(0, fd); /* <sectionflags> */ + putc(SN_SOFO, fd); // <sectionID> + putc(0, fd); // <sectionflags> l = (int)STRLEN(spin->si_sofofr); put_bytes(fd, (long_u)(l + STRLEN(spin->si_sofoto) + 4), 4); - /* <sectionlen> */ - - put_bytes(fd, (long_u)l, 2); /* <sofofromlen> */ - fwv &= fwrite(spin->si_sofofr, l, (size_t)1, fd); /* <sofofrom> */ + // <sectionlen> + + put_bytes(fd, (long_u)l, 2); // <sofofromlen> + fwv &= fwrite(spin->si_sofofr, l, (size_t)1, fd); // <sofofrom> l = (int)STRLEN(spin->si_sofoto); - put_bytes(fd, (long_u)l, 2); /* <sofotolen> */ - fwv &= fwrite(spin->si_sofoto, l, (size_t)1, fd); /* <sofoto> */ + put_bytes(fd, (long_u)l, 2); // <sofotolen> + fwv &= fwrite(spin->si_sofoto, l, (size_t)1, fd); // <sofoto> } - /* SN_WORDS: <word> ... - * This is for making suggestions, section is not required. */ + // SN_WORDS: <word> ... + // This is for making suggestions, section is not required. if (spin->si_commonwords.ht_used > 0) { - putc(SN_WORDS, fd); /* <sectionID> */ - putc(0, fd); /* <sectionflags> */ - - /* round 1: count the bytes - * round 2: write the bytes */ + putc(SN_WORDS, fd); // <sectionID> + putc(0, fd); // <sectionflags> + + // round 1: count the bytes + // round 2: write the bytes for (round = 1; round <= 2; ++round) { int todo; @@ -5075,123 +5074,123 @@ write_vim_spell(spellinfo_T *spin, char_ { l = (int)STRLEN(hi->hi_key) + 1; len += l; - if (round == 2) /* <word> */ + if (round == 2) // <word> fwv &= fwrite(hi->hi_key, (size_t)l, (size_t)1, fd); --todo; } if (round == 1) - put_bytes(fd, (long_u)len, 4); /* <sectionlen> */ + put_bytes(fd, (long_u)len, 4); // <sectionlen> } } - /* SN_MAP: <mapstr> - * This is for making suggestions, section is not required. */ + // SN_MAP: <mapstr> + // This is for making suggestions, section is not required. if (spin->si_map.ga_len > 0) { - putc(SN_MAP, fd); /* <sectionID> */ - putc(0, fd); /* <sectionflags> */ + putc(SN_MAP, fd); // <sectionID> + putc(0, fd); // <sectionflags> l = spin->si_map.ga_len; - put_bytes(fd, (long_u)l, 4); /* <sectionlen> */ + put_bytes(fd, (long_u)l, 4); // <sectionlen> fwv &= fwrite(spin->si_map.ga_data, (size_t)l, (size_t)1, fd); - /* <mapstr> */ + // <mapstr> } - /* SN_SUGFILE: <timestamp> - * This is used to notify that a .sug file may be available and at the - * same time allows for checking that a .sug file that is found matches - * with this .spl file. That's because the word numbers must be exactly - * right. */ + // SN_SUGFILE: <timestamp> + // This is used to notify that a .sug file may be available and at the + // same time allows for checking that a .sug file that is found matches + // with this .spl file. That's because the word numbers must be exactly + // right. if (!spin->si_nosugfile && (spin->si_sal.ga_len > 0 || (spin->si_sofofr != NULL && spin->si_sofoto != NULL))) { - putc(SN_SUGFILE, fd); /* <sectionID> */ - putc(0, fd); /* <sectionflags> */ - put_bytes(fd, (long_u)8, 4); /* <sectionlen> */ - - /* Set si_sugtime and write it to the file. */ + putc(SN_SUGFILE, fd); // <sectionID> + putc(0, fd); // <sectionflags> + put_bytes(fd, (long_u)8, 4); // <sectionlen> + + // Set si_sugtime and write it to the file. spin->si_sugtime = time(NULL); - put_time(fd, spin->si_sugtime); /* <timestamp> */ + put_time(fd, spin->si_sugtime); // <timestamp> } - /* SN_NOSPLITSUGS: nothing - * This is used to notify that no suggestions with word splits are to be - * made. */ + // SN_NOSPLITSUGS: nothing + // This is used to notify that no suggestions with word splits are to be + // made. if (spin->si_nosplitsugs) { - putc(SN_NOSPLITSUGS, fd); /* <sectionID> */ - putc(0, fd); /* <sectionflags> */ - put_bytes(fd, (long_u)0, 4); /* <sectionlen> */ + putc(SN_NOSPLITSUGS, fd); // <sectionID> + putc(0, fd); // <sectionflags> + put_bytes(fd, (long_u)0, 4); // <sectionlen> } - /* SN_NOCOMPUNDSUGS: nothing - * This is used to notify that no suggestions with compounds are to be - * made. */ + // SN_NOCOMPUNDSUGS: nothing + // This is used to notify that no suggestions with compounds are to be + // made. if (spin->si_nocompoundsugs) { - putc(SN_NOCOMPOUNDSUGS, fd); /* <sectionID> */ - putc(0, fd); /* <sectionflags> */ - put_bytes(fd, (long_u)0, 4); /* <sectionlen> */ + putc(SN_NOCOMPOUNDSUGS, fd); // <sectionID> + putc(0, fd); // <sectionflags> + put_bytes(fd, (long_u)0, 4); // <sectionlen> } - /* SN_COMPOUND: compound info. - * We don't mark it required, when not supported all compound words will - * be bad words. */ + // SN_COMPOUND: compound info. + // We don't mark it required, when not supported all compound words will + // be bad words. if (spin->si_compflags != NULL) { - putc(SN_COMPOUND, fd); /* <sectionID> */ - putc(0, fd); /* <sectionflags> */ + putc(SN_COMPOUND, fd); // <sectionID> + putc(0, fd); // <sectionflags> l = (int)STRLEN(spin->si_compflags); for (i = 0; i < spin->si_comppat.ga_len; ++i) l += (int)STRLEN(((char_u **)(spin->si_comppat.ga_data))[i]) + 1; - put_bytes(fd, (long_u)(l + 7), 4); /* <sectionlen> */ - - putc(spin->si_compmax, fd); /* <compmax> */ - putc(spin->si_compminlen, fd); /* <compminlen> */ - putc(spin->si_compsylmax, fd); /* <compsylmax> */ - putc(0, fd); /* for Vim 7.0b compatibility */ - putc(spin->si_compoptions, fd); /* <compoptions> */ + put_bytes(fd, (long_u)(l + 7), 4); // <sectionlen> + + putc(spin->si_compmax, fd); // <compmax> + putc(spin->si_compminlen, fd); // <compminlen> + putc(spin->si_compsylmax, fd); // <compsylmax> + putc(0, fd); // for Vim 7.0b compatibility + putc(spin->si_compoptions, fd); // <compoptions> put_bytes(fd, (long_u)spin->si_comppat.ga_len, 2); - /* <comppatcount> */ + // <comppatcount> for (i = 0; i < spin->si_comppat.ga_len; ++i) { p = ((char_u **)(spin->si_comppat.ga_data))[i]; - putc((int)STRLEN(p), fd); /* <comppatlen> */ + putc((int)STRLEN(p), fd); // <comppatlen> fwv &= fwrite(p, (size_t)STRLEN(p), (size_t)1, fd); - /* <comppattext> */ + // <comppattext> } - /* <compflags> */ + // <compflags> fwv &= fwrite(spin->si_compflags, (size_t)STRLEN(spin->si_compflags), (size_t)1, fd); } - /* SN_NOBREAK: NOBREAK flag */ + // SN_NOBREAK: NOBREAK flag if (spin->si_nobreak) { - putc(SN_NOBREAK, fd); /* <sectionID> */ - putc(0, fd); /* <sectionflags> */ - - /* It's empty, the presence of the section flags the feature. */ - put_bytes(fd, (long_u)0, 4); /* <sectionlen> */ + putc(SN_NOBREAK, fd); // <sectionID> + putc(0, fd); // <sectionflags> + + // It's empty, the presence of the section flags the feature. + put_bytes(fd, (long_u)0, 4); // <sectionlen> } - /* SN_SYLLABLE: syllable info. - * We don't mark it required, when not supported syllables will not be - * counted. */ + // SN_SYLLABLE: syllable info. + // We don't mark it required, when not supported syllables will not be + // counted. if (spin->si_syllable != NULL) { - putc(SN_SYLLABLE, fd); /* <sectionID> */ - putc(0, fd); /* <sectionflags> */ + putc(SN_SYLLABLE, fd); // <sectionID> + putc(0, fd); // <sectionflags> l = (int)STRLEN(spin->si_syllable); - put_bytes(fd, (long_u)l, 4); /* <sectionlen> */ + put_bytes(fd, (long_u)l, 4); // <sectionlen> fwv &= fwrite(spin->si_syllable, (size_t)l, (size_t)1, fd); - /* <syllable> */ + // <syllable> } - /* end of <SECTIONS> */ - putc(SN_END, fd); /* <sectionend> */ + // end of <SECTIONS> + putc(SN_END, fd); // <sectionend> /* @@ -5207,23 +5206,23 @@ write_vim_spell(spellinfo_T *spin, char_ else tree = spin->si_prefroot->wn_sibling; - /* Clear the index and wnode fields in the tree. */ + // Clear the index and wnode fields in the tree. clear_node(tree); - /* Count the number of nodes. Needed to be able to allocate the - * memory when reading the nodes. Also fills in index for shared - * nodes. */ + // Count the number of nodes. Needed to be able to allocate the + // memory when reading the nodes. Also fills in index for shared + // nodes. nodecount = put_node(NULL, tree, 0, regionmask, round == 3); - /* number of nodes in 4 bytes */ - put_bytes(fd, (long_u)nodecount, 4); /* <nodecount> */ + // number of nodes in 4 bytes + put_bytes(fd, (long_u)nodecount, 4); // <nodecount> spin->si_memtot += nodecount + nodecount * sizeof(int); - /* Write the nodes. */ + // Write the nodes. (void)put_node(fd, tree, 0, regionmask, round == 3); } - /* Write another byte to check for errors (file system full). */ + // Write another byte to check for errors (file system full). if (putc(0, fd) == EOF) retval = FAIL; theend: @@ -5274,59 +5273,59 @@ clear_node(wordnode_T *node) */ static int put_node( - FILE *fd, /* NULL when only counting */ + FILE *fd, // NULL when only counting wordnode_T *node, int idx, int regionmask, - int prefixtree) /* TRUE for PREFIXTREE */ + int prefixtree) // TRUE for PREFIXTREE { int newindex = idx; int siblingcount = 0; wordnode_T *np; int flags; - /* If "node" is zero the tree is empty. */ + // If "node" is zero the tree is empty. if (node == NULL) return 0; - /* Store the index where this node is written. */ + // Store the index where this node is written. node->wn_u1.index = idx; - /* Count the number of siblings. */ + // Count the number of siblings. for (np = node; np != NULL; np = np->wn_sibling) ++siblingcount; - /* Write the sibling count. */ + // Write the sibling count. if (fd != NULL) - putc(siblingcount, fd); /* <siblingcount> */ - - /* Write each sibling byte and optionally extra info. */ + putc(siblingcount, fd); // <siblingcount> + + // Write each sibling byte and optionally extra info. for (np = node; np != NULL; np = np->wn_sibling) { if (np->wn_byte == 0) { if (fd != NULL) { - /* For a NUL byte (end of word) write the flags etc. */ + // For a NUL byte (end of word) write the flags etc. if (prefixtree) { - /* In PREFIXTREE write the required affixID and the - * associated condition nr (stored in wn_region). The - * byte value is misused to store the "rare" and "not - * combining" flags */ + // In PREFIXTREE write the required affixID and the + // associated condition nr (stored in wn_region). The + // byte value is misused to store the "rare" and "not + // combining" flags if (np->wn_flags == (short_u)PFX_FLAGS) - putc(BY_NOFLAGS, fd); /* <byte> */ + putc(BY_NOFLAGS, fd); // <byte> else { - putc(BY_FLAGS, fd); /* <byte> */ - putc(np->wn_flags, fd); /* <pflags> */ + putc(BY_FLAGS, fd); // <byte> + putc(np->wn_flags, fd); // <pflags> } - putc(np->wn_affixID, fd); /* <affixID> */ - put_bytes(fd, (long_u)np->wn_region, 2); /* <prefcondnr> */ + putc(np->wn_affixID, fd); // <affixID> + put_bytes(fd, (long_u)np->wn_region, 2); // <prefcondnr> } else { - /* For word trees we write the flag/region items. */ + // For word trees we write the flag/region items. flags = np->wn_flags; if (regionmask != 0 && np->wn_region != regionmask) flags |= WF_REGION; @@ -5334,26 +5333,26 @@ put_node( flags |= WF_AFX; if (flags == 0) { - /* word without flags or region */ - putc(BY_NOFLAGS, fd); /* <byte> */ + // word without flags or region + putc(BY_NOFLAGS, fd); // <byte> } else { if (np->wn_flags >= 0x100) { - putc(BY_FLAGS2, fd); /* <byte> */ - putc(flags, fd); /* <flags> */ - putc((unsigned)flags >> 8, fd); /* <flags2> */ + putc(BY_FLAGS2, fd); // <byte> + putc(flags, fd); // <flags> + putc((unsigned)flags >> 8, fd); // <flags2> } else { - putc(BY_FLAGS, fd); /* <byte> */ - putc(flags, fd); /* <flags> */ + putc(BY_FLAGS, fd); // <byte> + putc(flags, fd); // <flags> } if (flags & WF_REGION) - putc(np->wn_region, fd); /* <region> */ + putc(np->wn_region, fd); // <region> if (flags & WF_AFX) - putc(np->wn_affixID, fd); /* <affixID> */ + putc(np->wn_affixID, fd); // <affixID> } } } @@ -5363,20 +5362,20 @@ put_node( if (np->wn_child->wn_u1.index != 0 && np->wn_child->wn_u2.wnode != node) { - /* The child is written elsewhere, write the reference. */ + // The child is written elsewhere, write the reference. if (fd != NULL) { - putc(BY_INDEX, fd); /* <byte> */ - /* <nodeidx> */ + putc(BY_INDEX, fd); // <byte> + // <nodeidx> put_bytes(fd, (long_u)np->wn_child->wn_u1.index, 3); } } else if (np->wn_child->wn_u2.wnode == NULL) - /* We will write the child below and give it an index. */ + // We will write the child below and give it an index. np->wn_child->wn_u2.wnode = node; if (fd != NULL) - if (putc(np->wn_byte, fd) == EOF) /* <byte> or <xbyte> */ + if (putc(np->wn_byte, fd) == EOF) // <byte> or <xbyte> { emsg(_(e_write)); return 0; @@ -5384,11 +5383,11 @@ put_node( } } - /* Space used in the array when reading: one for each sibling and one for - * the count. */ + // Space used in the array when reading: one for each sibling and one for + // the count. newindex += siblingcount + 1; - /* Recursively dump the children of each sibling. */ + // Recursively dump the children of each sibling. for (np = node; np != NULL; np = np->wn_sibling) if (np->wn_byte != 0 && np->wn_child->wn_u2.wnode == node) newindex = put_node(fd, np->wn_child, newindex, regionmask, @@ -5416,7 +5415,7 @@ ex_mkspell(exarg_T *eap) arg = skipwhite(arg + 6); } - /* Expand all the remaining arguments (e.g., $VIMRUNTIME). */ + // Expand all the remaining arguments (e.g., $VIMRUNTIME). if (get_arglist_exp(arg, &fcount, &fnames, FALSE) == OK) { mkspell(fcount, fnames, ascii, eap->forceit, FALSE); @@ -5461,7 +5460,7 @@ spell_make_sugfile(spellinfo_T *spin, ch */ spin->si_blocks = NULL; spin->si_blocks_cnt = 0; - spin->si_compress_cnt = 0; /* will stay at 0 all the time*/ + spin->si_compress_cnt = 0; // will stay at 0 all the time spin->si_free_count = 0; spin->si_first_free = NULL; spin->si_foldwcount = 0; @@ -5531,12 +5530,12 @@ sug_filltree(spellinfo_T *spin, slang_T unsigned words_done = 0; int wordcount[MAXWLEN]; - /* We use si_foldroot for the soundfolded trie. */ + // We use si_foldroot for the soundfolded trie. spin->si_foldroot = wordtree_alloc(spin); if (spin->si_foldroot == NULL) return FAIL; - /* let tree_add_word() know we're adding to the soundfolded tree */ + // let tree_add_word() know we're adding to the soundfolded tree spin->si_sugtree = TRUE; /* @@ -5555,7 +5554,7 @@ sug_filltree(spellinfo_T *spin, slang_T { if (curi[depth] > byts[arridx[depth]]) { - /* Done all bytes at this node, go up one level. */ + // Done all bytes at this node, go up one level. idxs[arridx[depth]] = wordcount[depth]; if (depth > 0) wordcount[depth - 1] += wordcount[depth]; @@ -5566,19 +5565,19 @@ sug_filltree(spellinfo_T *spin, slang_T else { - /* Do one more byte at this node. */ + // Do one more byte at this node. n = arridx[depth] + curi[depth]; ++curi[depth]; c = byts[n]; if (c == 0) { - /* Sound-fold the word. */ + // Sound-fold the word. tword[depth] = NUL; spell_soundfold(slang, tword, TRUE, tsalword); - /* We use the "flags" field for the MSB of the wordnr, - * "region" for the LSB of the wordnr. */ + // We use the "flags" field for the MSB of the wordnr, + // "region" for the LSB of the wordnr. if (tree_add_word(spin, tsalword, spin->si_foldroot, words_done >> 16, words_done & 0xffff, 0) == FAIL) @@ -5587,12 +5586,12 @@ sug_filltree(spellinfo_T *spin, slang_T ++words_done; ++wordcount[depth]; - /* Reset the block count each time to avoid compression - * kicking in. */ + // Reset the block count each time to avoid compression + // kicking in. spin->si_blocks_cnt = 0; - /* Skip over any other NUL bytes (same word with different - * flags). */ + // Skip over any other NUL bytes (same word with different + // flags). while (byts[n + 1] == 0) { ++n; @@ -5601,7 +5600,7 @@ sug_filltree(spellinfo_T *spin, slang_T } else { - /* Normal char, go one level deeper. */ + // Normal char, go one level deeper. tword[depth++] = c; arridx[depth] = idxs[n]; curi[depth] = 1; @@ -5628,17 +5627,17 @@ sug_maketable(spellinfo_T *spin) garray_T ga; int res = OK; - /* Allocate a buffer, open a memline for it and create the swap file - * (uses a temp file, not a .swp file). */ + // Allocate a buffer, open a memline for it and create the swap file + // (uses a temp file, not a .swp file). spin->si_spellbuf = open_spellbuf(); if (spin->si_spellbuf == NULL) return FAIL; - /* Use a buffer to store the line info, avoids allocating many small - * pieces of memory. */ + // Use a buffer to store the line info, avoids allocating many small + // pieces of memory. ga_init2(&ga, 1, 100); - /* recursively go through the tree */ + // recursively go through the tree if (sug_filltable(spin, spin->si_foldroot->wn_sibling, 0, &ga) == -1) res = FAIL; @@ -5656,7 +5655,7 @@ sug_filltable( spellinfo_T *spin, wordnode_T *node, int startwordnr, - garray_T *gap) /* place to store line of numbers */ + garray_T *gap) // place to store line of numbers { wordnode_T *p, *np; int wordnr = startwordnr; @@ -5675,17 +5674,17 @@ sug_filltable( return -1; nr = (np->wn_flags << 16) + (np->wn_region & 0xffff); - /* Compute the offset from the previous nr and store the - * offset in a way that it takes a minimum number of bytes. - * It's a bit like utf-8, but without the need to mark - * following bytes. */ + // Compute the offset from the previous nr and store the + // offset in a way that it takes a minimum number of bytes. + // It's a bit like utf-8, but without the need to mark + // following bytes. nr -= prev_nr; prev_nr += nr; gap->ga_len += offset2bytes(nr, (char_u *)gap->ga_data + gap->ga_len); } - /* add the NUL byte */ + // add the NUL byte ((char_u *)gap->ga_data)[gap->ga_len++] = NUL; if (ml_append_buf(spin->si_spellbuf, (linenr_T)wordnr, @@ -5693,13 +5692,13 @@ sug_filltable( return -1; ++wordnr; - /* Remove extra NUL entries, we no longer need them. We don't - * bother freeing the nodes, the won't be reused anyway. */ + // Remove extra NUL entries, we no longer need them. We don't + // bother freeing the nodes, the won't be reused anyway. while (p->wn_sibling != NULL && p->wn_sibling->wn_byte == NUL) p->wn_sibling = p->wn_sibling->wn_sibling; - /* Clear the flags on the remaining NUL node, so that compression - * works a lot better. */ + // Clear the flags on the remaining NUL node, so that compression + // works a lot better. p->wn_flags = 0; p->wn_region = 0; } @@ -5724,7 +5723,7 @@ offset2bytes(int nr, char_u *buf) int rem; int b1, b2, b3, b4; - /* Split the number in parts of base 255. We need to avoid NUL bytes. */ + // Split the number in parts of base 255. We need to avoid NUL bytes. b1 = nr % 255 + 1; rem = nr / 255; b2 = rem % 255 + 1; @@ -5732,7 +5731,7 @@ offset2bytes(int nr, char_u *buf) b3 = rem % 255 + 1; b4 = rem / 255 + 1; - if (b4 > 1 || b3 > 0x1f) /* 4 bytes */ + if (b4 > 1 || b3 > 0x1f) // 4 bytes { buf[0] = 0xe0 + b4; buf[1] = b3; @@ -5740,20 +5739,20 @@ offset2bytes(int nr, char_u *buf) buf[3] = b1; return 4; } - if (b3 > 1 || b2 > 0x3f ) /* 3 bytes */ + if (b3 > 1 || b2 > 0x3f ) // 3 bytes { buf[0] = 0xc0 + b3; buf[1] = b2; buf[2] = b1; return 3; } - if (b2 > 1 || b1 > 0x7f ) /* 2 bytes */ + if (b2 > 1 || b1 > 0x7f ) // 2 bytes { buf[0] = 0x80 + b2; buf[1] = b1; return 2; } - /* 1 byte */ + // 1 byte buf[0] = b1; return 1; } @@ -5772,7 +5771,7 @@ sug_write(spellinfo_T *spin, char_u *fna linenr_T lnum; int len; - /* Create the file. Note that an existing file is silently overwritten! */ + // Create the file. Note that an existing file is silently overwritten! fd = mch_fopen((char *)fname, "w"); if (fd == NULL) { @@ -5787,15 +5786,15 @@ sug_write(spellinfo_T *spin, char_u *fna /* * <SUGHEADER>: <fileID> <versionnr> <timestamp> */ - if (fwrite(VIMSUGMAGIC, VIMSUGMAGICL, (size_t)1, fd) != 1) /* <fileID> */ + if (fwrite(VIMSUGMAGIC, VIMSUGMAGICL, (size_t)1, fd) != 1) // <fileID> { emsg(_(e_write)); goto theend; } - putc(VIMSUGVERSION, fd); /* <versionnr> */ - - /* Write si_sugtime to the file. */ - put_time(fd, spin->si_sugtime); /* <timestamp> */ + putc(VIMSUGVERSION, fd); // <versionnr> + + // Write si_sugtime to the file. + put_time(fd, spin->si_sugtime); // <timestamp> /* * <SUGWORDTREE> @@ -5803,30 +5802,30 @@ sug_write(spellinfo_T *spin, char_u *fna spin->si_memtot = 0; tree = spin->si_foldroot->wn_sibling; - /* Clear the index and wnode fields in the tree. */ + // Clear the index and wnode fields in the tree. clear_node(tree); - /* Count the number of nodes. Needed to be able to allocate the - * memory when reading the nodes. Also fills in index for shared - * nodes. */ + // Count the number of nodes. Needed to be able to allocate the + // memory when reading the nodes. Also fills in index for shared + // nodes. nodecount = put_node(NULL, tree, 0, 0, FALSE); - /* number of nodes in 4 bytes */ - put_bytes(fd, (long_u)nodecount, 4); /* <nodecount> */ + // number of nodes in 4 bytes + put_bytes(fd, (long_u)nodecount, 4); // <nodecount> spin->si_memtot += nodecount + nodecount * sizeof(int); - /* Write the nodes. */ + // Write the nodes. (void)put_node(fd, tree, 0, 0, FALSE); /* * <SUGTABLE>: <sugwcount> <sugline> ... */ wcount = spin->si_spellbuf->b_ml.ml_line_count; - put_bytes(fd, (long_u)wcount, 4); /* <sugwcount> */ + put_bytes(fd, (long_u)wcount, 4); // <sugwcount> for (lnum = 1; lnum <= (linenr_T)wcount; ++lnum) { - /* <sugline>: <sugnr> ... NUL */ + // <sugline>: <sugnr> ... NUL line = ml_get_buf(spin->si_spellbuf, lnum, FALSE); len = (int)STRLEN(line) + 1; if (fwrite(line, (size_t)len, (size_t)1, fd) == 0) @@ -5837,7 +5836,7 @@ sug_write(spellinfo_T *spin, char_u *fna spin->si_memtot += len; } - /* Write another byte to check for errors. */ + // Write another byte to check for errors. if (putc(0, fd) == EOF) emsg(_(e_write)); @@ -5846,7 +5845,7 @@ sug_write(spellinfo_T *spin, char_u *fna spell_message(spin, IObuff); theend: - /* close the file */ + // close the file fclose(fd); } @@ -5862,9 +5861,9 @@ theend: mkspell( int fcount, char_u **fnames, - int ascii, /* -ascii argument given */ - int over_write, /* overwrite existing output file */ - int added_word) /* invoked through "zg" */ + int ascii, // -ascii argument given + int over_write, // overwrite existing output file + int added_word) // invoked through "zg" { char_u *fname = NULL; char_u *wfname; @@ -5889,9 +5888,9 @@ mkspell( ga_init2(&spin.si_comppat, (int)sizeof(char_u *), 20); ga_init2(&spin.si_prefcond, (int)sizeof(char_u *), 50); hash_init(&spin.si_commonwords); - spin.si_newcompID = 127; /* start compound ID at first maximum */ - - /* default: fnames[0] is output file, following are input files */ + spin.si_newcompID = 127; // start compound ID at first maximum + + // default: fnames[0] is output file, following are input files innames = &fnames[1]; incount = fcount - 1; @@ -5904,15 +5903,15 @@ mkspell( len = (int)STRLEN(fnames[0]); if (fcount == 1 && len > 4 && STRCMP(fnames[0] + len - 4, ".add") == 0) { - /* For ":mkspell path/en.latin1.add" output file is - * "path/en.latin1.add.spl". */ + // For ":mkspell path/en.latin1.add" output file is + // "path/en.latin1.add.spl". innames = &fnames[0]; incount = 1; vim_snprintf((char *)wfname, MAXPATHL, "%s.spl", fnames[0]); } else if (fcount == 1) { - /* For ":mkspell path/vim" output file is "path/vim.latin1.spl". */ + // For ":mkspell path/vim" output file is "path/vim.latin1.spl". innames = &fnames[0]; incount = 1; vim_snprintf((char *)wfname, MAXPATHL, SPL_FNAME_TMPL, @@ -5920,33 +5919,33 @@ mkspell( } else if (len > 4 && STRCMP(fnames[0] + len - 4, ".spl") == 0) { - /* Name ends in ".spl", use as the file name. */ + // Name ends in ".spl", use as the file name. vim_strncpy(wfname, fnames[0], MAXPATHL - 1); } else - /* Name should be language, make the file name from it. */ + // Name should be language, make the file name from it. vim_snprintf((char *)wfname, MAXPATHL, SPL_FNAME_TMPL, fnames[0], spin.si_ascii ? (char_u *)"ascii" : spell_enc()); - /* Check for .ascii.spl. */ + // Check for .ascii.spl. if (strstr((char *)gettail(wfname), SPL_FNAME_ASCII) != NULL) spin.si_ascii = TRUE; - /* Check for .add.spl. */ + // Check for .add.spl. if (strstr((char *)gettail(wfname), SPL_FNAME_ADD) != NULL) spin.si_add = TRUE; } if (incount <= 0) - emsg(_(e_invarg)); /* need at least output and input names */ + emsg(_(e_invarg)); // need at least output and input names else if (vim_strchr(gettail(wfname), '_') != NULL) emsg(_("E751: Output file name must not have region name")); else if (incount > MAXREGIONS) semsg(_("E754: Only up to %d regions supported"), MAXREGIONS); else { - /* Check for overwriting before doing things that may take a lot of - * time. */ + // Check for overwriting before doing things that may take a lot of + // time. if (!over_write && mch_stat((char *)wfname, &st) >= 0) { emsg(_(e_exists)); @@ -5997,11 +5996,11 @@ mkspell( goto theend; } - /* When not producing a .add.spl file clear the character table when - * we encounter one in the .aff file. This means we dump the current - * one in the .spl file if the .aff file doesn't define one. That's - * better than guessing the contents, the table will match a - * previously loaded spell file. */ + // When not producing a .add.spl file clear the character table when + // we encounter one in the .aff file. This means we dump the current + // one in the .spl file if the .aff file doesn't define one. That's + // better than guessing the contents, the table will match a + // previously loaded spell file. if (!spin.si_add) spin.si_clear_chartab = TRUE; @@ -6018,14 +6017,14 @@ mkspell( vim_snprintf((char *)fname, MAXPATHL, "%s.aff", innames[i]); if (mch_stat((char *)fname, &st) >= 0) { - /* Read the .aff file. Will init "spin->si_conv" based on the - * "SET" line. */ + // Read the .aff file. Will init "spin->si_conv" based on the + // "SET" line. afile[i] = spell_read_aff(&spin, fname); if (afile[i] == NULL) error = TRUE; else { - /* Read the .dic file and store the words in the trees. */ + // Read the .dic file and store the words in the trees. vim_snprintf((char *)fname, MAXPATHL, "%s.dic", innames[i]); if (spell_read_dic(&spin, fname, afile[i]) == FAIL) @@ -6034,13 +6033,13 @@ mkspell( } else { - /* No .aff file, try reading the file as a word list. Store - * the words in the trees. */ + // No .aff file, try reading the file as a word list. Store + // the words in the trees. if (spell_read_wordfile(&spin, innames[i]) == FAIL) error = TRUE; } - /* Free any conversion stuff. */ + // Free any conversion stuff. convert_setup(&spin.si_conv, NULL, NULL); } @@ -6081,7 +6080,7 @@ mkspell( spell_reload_one(wfname, added_word); } - /* Free the allocated memory. */ + // Free the allocated memory. ga_clear(&spin.si_rep); ga_clear(&spin.si_repsal); ga_clear(&spin.si_sal); @@ -6090,12 +6089,12 @@ mkspell( ga_clear(&spin.si_prefcond); hash_clear_all(&spin.si_commonwords, 0); - /* Free the .aff file structures. */ + // Free the .aff file structures. for (i = 0; i < incount; ++i) if (afile[i] != NULL) spell_free_aff(afile[i]); - /* Free all the bits and pieces at once. */ + // Free all the bits and pieces at once. free_blocks(spin.si_blocks); /* @@ -6168,7 +6167,7 @@ spell_add_word( int i; char_u *spf; - if (idx == 0) /* use internal wordlist */ + if (idx == 0) // use internal wordlist { if (int_wordlist == NULL) { @@ -6180,7 +6179,7 @@ spell_add_word( } else { - /* If 'spellfile' isn't set figure out a good default value. */ + // If 'spellfile' isn't set figure out a good default value. if (*curwin->w_s->b_p_spf == NUL) { init_spellfile(); @@ -6209,7 +6208,7 @@ spell_add_word( } } - /* Check that the user isn't editing the .add file somewhere. */ + // Check that the user isn't editing the .add file somewhere. buf = buflist_findname_exp(fnamebuf); if (buf != NULL && buf->b_ml.ml_mfp == NULL) buf = NULL; @@ -6225,8 +6224,8 @@ spell_add_word( if (what == SPELL_ADD_BAD || undo) { - /* When the word appears as good word we need to remove that one, - * since its flags sort before the one with WF_BANNED. */ + // When the word appears as good word we need to remove that one, + // since its flags sort before the one with WF_BANNED. fd = mch_fopen((char *)fname, "r"); if (fd != NULL) { @@ -6237,9 +6236,9 @@ spell_add_word( if (STRNCMP(word, line, len) == 0 && (line[len] == '/' || line[len] < ' ')) { - /* Found duplicate word. Remove it by writing a '#' at - * the start of the line. Mixing reading and writing - * doesn't work for all systems, close the file first. */ + // Found duplicate word. Remove it by writing a '#' at + // the start of the line. Mixing reading and writing + // doesn't work for all systems, close the file first. fclose(fd); fd = mch_fopen((char *)fname, "r+"); if (fd == NULL) @@ -6269,16 +6268,16 @@ spell_add_word( { char_u *p; - /* We just initialized the 'spellfile' option and can't open the - * file. We may need to create the "spell" directory first. We - * already checked the runtime directory is writable in - * init_spellfile(). */ + // We just initialized the 'spellfile' option and can't open the + // file. We may need to create the "spell" directory first. We + // already checked the runtime directory is writable in + // init_spellfile(). if (!dir_of_file_exists(fname) && (p = gettail_sep(fname)) != fname) { int c = *p; - /* The directory doesn't exist. Try creating it and opening - * the file again. */ + // The directory doesn't exist. Try creating it and opening + // the file again. *p = NUL; vim_mkdir(fname, 0755); *p = c; @@ -6305,10 +6304,10 @@ spell_add_word( if (fd != NULL) { - /* Update the .add.spl file. */ + // Update the .add.spl file. mkspell(1, &fname, FALSE, TRUE, TRUE); - /* If the .add file is edited somewhere, reload it. */ + // If the .add file is edited somewhere, reload it. if (buf != NULL) buf_reload(buf, buf->b_orig_mode); @@ -6337,8 +6336,8 @@ init_spellfile(void) if (buf == NULL) return; - /* Find the end of the language name. Exclude the region. If there - * is a path separator remember the start of the tail. */ + // Find the end of the language name. Exclude the region. If there + // is a path separator remember the start of the tail. for (lend = curwin->w_s->b_p_spl; *lend != NUL && vim_strchr((char_u *)",._", *lend) == NULL; ++lend) if (vim_ispathsep(*lend)) @@ -6347,29 +6346,29 @@ init_spellfile(void) lstart = lend + 1; } - /* Loop over all entries in 'runtimepath'. Use the first one where we - * are allowed to write. */ + // Loop over all entries in 'runtimepath'. Use the first one where we + // are allowed to write. rtp = p_rtp; while (*rtp != NUL) { if (aspath) - /* Use directory of an entry with path, e.g., for - * "/dir/lg.utf-8.spl" use "/dir". */ + // Use directory of an entry with path, e.g., for + // "/dir/lg.utf-8.spl" use "/dir". vim_strncpy(buf, curbuf->b_s.b_p_spl, lstart - curbuf->b_s.b_p_spl - 1); else - /* Copy the path from 'runtimepath' to buf[]. */ + // Copy the path from 'runtimepath' to buf[]. copy_option_part(&rtp, buf, MAXPATHL, ","); if (filewritable(buf) == 2) { - /* Use the first language name from 'spelllang' and the - * encoding used in the first loaded .spl file. */ + // Use the first language name from 'spelllang' and the + // encoding used in the first loaded .spl file. if (aspath) vim_strncpy(buf, curbuf->b_s.b_p_spl, lend - curbuf->b_s.b_p_spl); else { - /* Create the "spell" directory if it doesn't exist yet. */ + // Create the "spell" directory if it doesn't exist yet. l = (int)STRLEN(buf); vim_snprintf((char *)buf + l, MAXPATHL - l, "/spell"); if (filewritable(buf) != 2) @@ -6404,8 +6403,8 @@ init_spellfile(void) static int set_spell_chartab(char_u *fol, char_u *low, char_u *upp) { - /* We build the new tables here first, so that we can compare with the - * previous one. */ + // We build the new tables here first, so that we can compare with the + // previous one. spelltab_T new_st; char_u *pf = fol, *pl = low, *pu = upp; int f, l, u; @@ -6423,7 +6422,7 @@ set_spell_chartab(char_u *fol, char_u *l l = mb_ptr2char_adv(&pl); u = mb_ptr2char_adv(&pu); - /* Every character that appears is a word character. */ + // Every character that appears is a word character. if (f < 256) new_st.st_isw[f] = TRUE; if (l < 256) @@ -6431,8 +6430,8 @@ set_spell_chartab(char_u *fol, char_u *l if (u < 256) new_st.st_isw[u] = TRUE; - /* if "LOW" and "FOL" are not the same the "LOW" char needs - * case-folding */ + // if "LOW" and "FOL" are not the same the "LOW" char needs + // case-folding if (l < 256 && l != f) { if (f >= 256) @@ -6443,9 +6442,9 @@ set_spell_chartab(char_u *fol, char_u *l new_st.st_fold[l] = f; } - /* if "UPP" and "FOL" are not the same the "UPP" char needs - * case-folding, it's upper case and the "UPP" is the upper case of - * "FOL" . */ + // if "UPP" and "FOL" are not the same the "UPP" char needs + // case-folding, it's upper case and the "UPP" is the upper case of + // "FOL" . if (u < 256 && u != f) { if (f >= 256) @@ -6474,11 +6473,11 @@ set_spell_chartab(char_u *fol, char_u *l static void set_spell_charflags( char_u *flags, - int cnt, /* length of "flags" */ + int cnt, // length of "flags" char_u *fol) { - /* We build the new tables here first, so that we can compare with the - * previous one. */ + // We build the new tables here first, so that we can compare with the + // previous one. spelltab_T new_st; int i; char_u *p = fol; @@ -6513,7 +6512,7 @@ set_spell_finish(spelltab_T *new_st) if (did_set_spelltab) { - /* check that it's the same table */ + // check that it's the same table for (i = 0; i < 256; ++i) { if (spelltab.st_isw[i] != new_st->st_isw[i] @@ -6528,7 +6527,7 @@ set_spell_finish(spelltab_T *new_st) } else { - /* copy the new spelltab into the one being used */ + // copy the new spelltab into the one being used spelltab = *new_st; did_set_spelltab = TRUE; } @@ -6547,16 +6546,16 @@ write_spell_prefcond(FILE *fd, garray_T char_u *p; int len; int totlen; - size_t x = 1; /* collect return value of fwrite() */ + size_t x = 1; // collect return value of fwrite() if (fd != NULL) - put_bytes(fd, (long_u)gap->ga_len, 2); /* <prefcondcnt> */ - - totlen = 2 + gap->ga_len; /* length of <prefcondcnt> and <condlen> bytes */ + put_bytes(fd, (long_u)gap->ga_len, 2); // <prefcondcnt> + + totlen = 2 + gap->ga_len; // length of <prefcondcnt> and <condlen> bytes for (i = 0; i < gap->ga_len; ++i) { - /* <prefcond> : <condlen> <condstr> */ + // <prefcond> : <condlen> <condstr> p = ((char_u **)gap->ga_data)[i]; if (p != NULL) { @@ -6594,7 +6593,7 @@ set_map_str(slang_T *lp, char_u *map) } lp->sl_has_map = TRUE; - /* Init the array and hash tables empty. */ + // Init the array and hash tables empty. for (i = 0; i < 256; ++i) lp->sl_map_array[i] = 0; hash_init(&lp->sl_map_hash); @@ -6614,9 +6613,9 @@ set_map_str(slang_T *lp, char_u *map) if (headc == 0) headc = c; - /* Characters above 255 don't fit in sl_map_array[], put them in - * the hash table. Each entry is the char, a NUL the headchar and - * a NUL. */ + // Characters above 255 don't fit in sl_map_array[], put them in + // the hash table. Each entry is the char, a NUL the headchar and + // a NUL. if (c >= 256) { int cl = mb_char2len(c); @@ -6638,8 +6637,8 @@ set_map_str(slang_T *lp, char_u *map) hash_add_item(&lp->sl_map_hash, hi, b, hash); else { - /* This should have been checked when generating the .spl - * file. */ + // This should have been checked when generating the .spl + // file. emsg(_("E783: duplicate char in MAP entry")); vim_free(b); } @@ -6651,4 +6650,4 @@ set_map_str(slang_T *lp, char_u *map) } -#endif /* FEAT_SPELL */ +#endif // FEAT_SPELL