From 1a8f60c7d2699826b51f23b040b83b1d96a14930 Mon Sep 17 00:00:00 2001 From: zeertzjq Date: Tue, 28 Nov 2023 10:47:22 +0800 Subject: [PATCH] refactor: move hashtab types to hashtab_defs.h (#26262) --- Makefile | 2 - src/clint.py | 2 - src/nvim/buffer_defs.h | 2 +- src/nvim/eval.c | 1 + src/nvim/eval.h | 2 +- src/nvim/eval/typval_defs.h | 2 +- src/nvim/eval/userfunc.c | 1 - src/nvim/eval/userfunc.h | 9 +- src/nvim/eval/vars.h | 2 +- src/nvim/hashtab.h | 61 +------ src/nvim/hashtab_defs.h | 59 +++++++ src/nvim/spell_defs.h | 310 ++++++++++++++++++------------------ src/nvim/spellsuggest.c | 3 +- 13 files changed, 230 insertions(+), 226 deletions(-) create mode 100644 src/nvim/hashtab_defs.h diff --git a/Makefile b/Makefile index 5fb5b9958d..ea494e05ed 100644 --- a/Makefile +++ b/Makefile @@ -172,7 +172,6 @@ iwyu: build/.ran-cmake |src/nvim/eval/typval_defs.h\ |src/nvim/eval/typval_encode.h\ |src/nvim/eval/userfunc.h\ - |src/nvim/eval/vars.h\ |src/nvim/eval/window.h\ |src/nvim/event/libuv_process.h\ |src/nvim/event/loop.h\ @@ -236,7 +235,6 @@ iwyu: build/.ran-cmake |src/nvim/popupmenu.h\ |src/nvim/search.h\ |src/nvim/spell.h\ - |src/nvim/spell_defs.h\ |src/nvim/statusline.h\ |src/nvim/statusline_defs.h\ |src/nvim/strings.h\ diff --git a/src/clint.py b/src/clint.py index c9e6ca9973..812464b753 100755 --- a/src/clint.py +++ b/src/clint.py @@ -927,7 +927,6 @@ def CheckIncludes(filename, lines, error): "src/nvim/eval/typval_defs.h", "src/nvim/eval/typval_encode.h", "src/nvim/eval/userfunc.h", - "src/nvim/eval/vars.h", "src/nvim/eval/window.h", "src/nvim/event/libuv_process.h", "src/nvim/event/loop.h", @@ -991,7 +990,6 @@ def CheckIncludes(filename, lines, error): "src/nvim/popupmenu.h", "src/nvim/search.h", "src/nvim/spell.h", - "src/nvim/spell_defs.h", "src/nvim/statusline.h", "src/nvim/statusline_defs.h", "src/nvim/strings.h", diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h index d3b80c8891..0269060c2f 100644 --- a/src/nvim/buffer_defs.h +++ b/src/nvim/buffer_defs.h @@ -21,7 +21,7 @@ typedef struct { #include "nvim/extmark_defs.h" #include "nvim/garray_defs.h" #include "nvim/grid_defs.h" -#include "nvim/hashtab.h" +#include "nvim/hashtab_defs.h" #include "nvim/highlight_defs.h" #include "nvim/map.h" #include "nvim/mapping_defs.h" diff --git a/src/nvim/eval.c b/src/nvim/eval.c index 02e0be9a94..e7fe7e17bc 100644 --- a/src/nvim/eval.c +++ b/src/nvim/eval.c @@ -42,6 +42,7 @@ #include "nvim/gettext.h" #include "nvim/globals.h" #include "nvim/grid_defs.h" +#include "nvim/hashtab.h" #include "nvim/highlight_group.h" #include "nvim/insexpand.h" #include "nvim/keycodes.h" diff --git a/src/nvim/eval.h b/src/nvim/eval.h index 8d2e34b842..b4d6c34405 100644 --- a/src/nvim/eval.h +++ b/src/nvim/eval.h @@ -11,7 +11,7 @@ #include "nvim/event/time.h" #include "nvim/ex_cmds_defs.h" #include "nvim/globals.h" -#include "nvim/hashtab.h" +#include "nvim/hashtab_defs.h" #include "nvim/macros.h" #include "nvim/os/fileio.h" #include "nvim/os/stdpaths_defs.h" diff --git a/src/nvim/eval/typval_defs.h b/src/nvim/eval/typval_defs.h index ea5d70bf19..c6bd11ccdb 100644 --- a/src/nvim/eval/typval_defs.h +++ b/src/nvim/eval/typval_defs.h @@ -4,7 +4,7 @@ #include #include "nvim/garray_defs.h" -#include "nvim/hashtab.h" +#include "nvim/hashtab_defs.h" #include "nvim/lib/queue.h" #include "nvim/pos_defs.h" #include "nvim/types_defs.h" diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c index c095dace92..a859b8a94d 100644 --- a/src/nvim/eval/userfunc.c +++ b/src/nvim/eval/userfunc.c @@ -25,7 +25,6 @@ #include "nvim/ex_getln.h" #include "nvim/func_attr.h" #include "nvim/garray.h" -#include "nvim/garray_defs.h" #include "nvim/getchar.h" #include "nvim/gettext.h" #include "nvim/globals.h" diff --git a/src/nvim/eval/userfunc.h b/src/nvim/eval/userfunc.h index 5ad5db80b7..8050caab2b 100644 --- a/src/nvim/eval/userfunc.h +++ b/src/nvim/eval/userfunc.h @@ -3,14 +3,13 @@ #include #include -#include "nvim/cmdexpand_defs.h" +#include "nvim/cmdexpand_defs.h" // IWYU pragma: keep #include "nvim/eval.h" #include "nvim/eval/typval_defs.h" -#include "nvim/ex_cmds_defs.h" -#include "nvim/garray_defs.h" -#include "nvim/hashtab.h" +#include "nvim/ex_cmds_defs.h" // IWYU pragma: keep +#include "nvim/hashtab_defs.h" // IWYU pragma: keep #include "nvim/pos_defs.h" -#include "nvim/types_defs.h" +#include "nvim/types_defs.h" // IWYU pragma: keep struct funccal_entry; diff --git a/src/nvim/eval/vars.h b/src/nvim/eval/vars.h index 3512152184..6ddf449ff1 100644 --- a/src/nvim/eval/vars.h +++ b/src/nvim/eval/vars.h @@ -4,7 +4,7 @@ #include "nvim/ex_cmds_defs.h" // IWYU pragma: keep #include "nvim/garray_defs.h" // IWYU pragma: keep -#include "nvim/hashtab.h" +#include "nvim/hashtab_defs.h" // IWYU pragma: keep #include "nvim/option_defs.h" // IWYU pragma: keep #include "nvim/types_defs.h" // IWYU pragma: keep diff --git a/src/nvim/hashtab.h b/src/nvim/hashtab.h index bf109ecae8..d14eb6944e 100644 --- a/src/nvim/hashtab.h +++ b/src/nvim/hashtab.h @@ -2,72 +2,17 @@ #include +#include "nvim/hashtab_defs.h" // IWYU pragma: export + /// Magic number used for hashitem "hi_key" value indicating a deleted item /// /// Only the address is used. extern char hash_removed; -/// Type for hash number (hash calculation result). -typedef size_t hash_T; - /// The address of "hash_removed" is used as a magic number /// for hi_key to indicate a removed item. #define HI_KEY_REMOVED (&hash_removed) -#define HASHITEM_EMPTY(hi) ((hi)->hi_key == NULL \ - || (hi)->hi_key == &hash_removed) - -/// Hashtable item. -/// -/// Each item has a NUL terminated string key. -/// A key can appear only once in the table. -/// -/// A hash number is computed from the key for quick lookup. When the hashes -/// of two different keys point to the same entry an algorithm is used to -/// iterate over other entries in the table until the right one is found. -/// To make the iteration work removed keys are different from entries where a -/// key was never present. -/// -/// Note that this does not contain a pointer to the key and another pointer to -/// the value. Instead, it is assumed that the key is contained within the -/// value, so that you can get a pointer to the value subtracting an offset from -/// the pointer to the key. -/// This reduces the size of this item by 1/3. -typedef struct hashitem_S { - /// Cached hash number for hi_key. - hash_T hi_hash; - - /// Item key. - /// - /// Possible values mean the following: - /// NULL : Item was never used. - /// HI_KEY_REMOVED : Item was removed. - /// (Any other pointer value) : Item is currently being used. - char *hi_key; -} hashitem_T; - -/// Initial size for a hashtable. -/// Our items are relatively small and growing is expensive, thus start with 16. -/// Must be a power of 2. -/// This allows for storing 10 items (2/3 of 16) before a resize is needed. -#define HT_INIT_SIZE 16 - -/// An array-based hashtable. -/// -/// Keys are NUL terminated strings. They cannot be repeated within a table. -/// Values are of any type. -/// -/// The hashtable grows to accommodate more entries when needed. -typedef struct hashtable_S { - hash_T ht_mask; ///< mask used for hash value - ///< (nr of items in array is "ht_mask" + 1) - size_t ht_used; ///< number of items used - size_t ht_filled; ///< number of items used or removed - int ht_changed; ///< incremented when adding or removing an item - int ht_locked; ///< counter for hash_lock() - hashitem_T *ht_array; ///< points to the array, allocated when it's - ///< not "ht_smallarray" - hashitem_T ht_smallarray[HT_INIT_SIZE]; ///< initial array -} hashtab_T; +#define HASHITEM_EMPTY(hi) ((hi)->hi_key == NULL || (hi)->hi_key == &hash_removed) /// Iterate over a hashtab /// diff --git a/src/nvim/hashtab_defs.h b/src/nvim/hashtab_defs.h new file mode 100644 index 0000000000..089838fcae --- /dev/null +++ b/src/nvim/hashtab_defs.h @@ -0,0 +1,59 @@ +#pragma once + +#include + +/// Type for hash number (hash calculation result). +typedef size_t hash_T; + +/// Hashtable item. +/// +/// Each item has a NUL terminated string key. +/// A key can appear only once in the table. +/// +/// A hash number is computed from the key for quick lookup. When the hashes +/// of two different keys point to the same entry an algorithm is used to +/// iterate over other entries in the table until the right one is found. +/// To make the iteration work removed keys are different from entries where a +/// key was never present. +/// +/// Note that this does not contain a pointer to the key and another pointer to +/// the value. Instead, it is assumed that the key is contained within the +/// value, so that you can get a pointer to the value subtracting an offset from +/// the pointer to the key. +/// This reduces the size of this item by 1/3. +typedef struct hashitem_S { + /// Cached hash number for hi_key. + hash_T hi_hash; + + /// Item key. + /// + /// Possible values mean the following: + /// NULL : Item was never used. + /// HI_KEY_REMOVED : Item was removed. + /// (Any other pointer value) : Item is currently being used. + char *hi_key; +} hashitem_T; + +/// Initial size for a hashtable. +/// Our items are relatively small and growing is expensive, thus start with 16. +/// Must be a power of 2. +/// This allows for storing 10 items (2/3 of 16) before a resize is needed. +enum { HT_INIT_SIZE = 16, }; + +/// An array-based hashtable. +/// +/// Keys are NUL terminated strings. They cannot be repeated within a table. +/// Values are of any type. +/// +/// The hashtable grows to accommodate more entries when needed. +typedef struct hashtable_S { + hash_T ht_mask; ///< mask used for hash value + ///< (nr of items in array is "ht_mask" + 1) + size_t ht_used; ///< number of items used + size_t ht_filled; ///< number of items used or removed + int ht_changed; ///< incremented when adding or removing an item + int ht_locked; ///< counter for hash_lock() + hashitem_T *ht_array; ///< points to the array, allocated when it's + ///< not "ht_smallarray" + hashitem_T ht_smallarray[HT_INIT_SIZE]; ///< initial array +} hashtab_T; diff --git a/src/nvim/spell_defs.h b/src/nvim/spell_defs.h index bb5ebb8ec4..dfa399750f 100644 --- a/src/nvim/spell_defs.h +++ b/src/nvim/spell_defs.h @@ -5,191 +5,197 @@ #include "nvim/buffer_defs.h" #include "nvim/garray_defs.h" -#include "nvim/hashtab.h" +#include "nvim/hashtab_defs.h" #include "nvim/regexp_defs.h" -#define MAXWLEN 254 // Assume max. word len is this many bytes. - // Some places assume a word length fits in a - // byte, thus it can't be above 255. +/// Assume max. word len is this many bytes. +/// Some places assume a word length fits in a byte, thus it can't be above 255. +enum { MAXWLEN = 254, }; -// Number of regions supported. -#define MAXREGIONS 8 +/// Number of regions supported. +enum { MAXREGIONS = 8, }; -// Type used for indexes in the word tree need to be at least 4 bytes. If int -// is 8 bytes we could use something smaller, but what? +/// Type used for indexes in the word tree need to be at least 4 bytes. If int +/// is 8 bytes we could use something smaller, but what? typedef int idx_T; #define SPL_FNAME_TMPL "%s.%s.spl" #define SPL_FNAME_ADD ".add." #define SPL_FNAME_ASCII ".ascii." -// Flags used for a word. Only the lowest byte can be used, the region byte -// comes above it. -#define WF_REGION 0x01 // region byte follows -#define WF_ONECAP 0x02 // word with one capital (or all capitals) -#define WF_ALLCAP 0x04 // word must be all capitals -#define WF_RARE 0x08 // rare word -#define WF_BANNED 0x10 // bad word -#define WF_AFX 0x20 // affix ID follows -#define WF_FIXCAP 0x40 // keep-case word, allcap not allowed -#define WF_KEEPCAP 0x80 // keep-case word +/// Flags used for a word. Only the lowest byte can be used, the region byte +/// comes above it. +enum { + WF_REGION = 0x01, ///< region byte follows + WF_ONECAP = 0x02, ///< word with one capital (or all capitals) + WF_ALLCAP = 0x04, ///< word must be all capitals + WF_RARE = 0x08, ///< rare word + WF_BANNED = 0x10, ///< bad word + WF_AFX = 0x20, ///< affix ID follows + WF_FIXCAP = 0x40, ///< keep-case word, allcap not allowed + WF_KEEPCAP = 0x80, ///< keep-case word + WF_CAPMASK = (WF_ONECAP | WF_ALLCAP | WF_KEEPCAP | WF_FIXCAP), +}; -#define WF_CAPMASK (WF_ONECAP | WF_ALLCAP | WF_KEEPCAP | WF_FIXCAP) +/// for , shifted up one byte to be used in wn_flags +enum { + WF_HAS_AFF = 0x0100, ///< word includes affix + WF_NEEDCOMP = 0x0200, ///< word only valid in compound + WF_NOSUGGEST = 0x0400, ///< word not to be suggested + WF_COMPROOT = 0x0800, ///< already compounded word, COMPOUNDROOT + WF_NOCOMPBEF = 0x1000, ///< no compounding before this word + WF_NOCOMPAFT = 0x2000, ///< no compounding after this word +}; -// for , shifted up one byte to be used in wn_flags -#define WF_HAS_AFF 0x0100 // word includes affix -#define WF_NEEDCOMP 0x0200 // word only valid in compound -#define WF_NOSUGGEST 0x0400 // word not to be suggested -#define WF_COMPROOT 0x0800 // already compounded word, COMPOUNDROOT -#define WF_NOCOMPBEF 0x1000 // no compounding before this word -#define WF_NOCOMPAFT 0x2000 // no compounding after this word +/// flags for +enum { + WFP_RARE = 0x01, ///< rare prefix + WFP_NC = 0x02, ///< prefix is not combining + WFP_UP = 0x04, ///< to-upper prefix + WFP_COMPPERMIT = 0x08, ///< prefix with COMPOUNDPERMITFLAG + WFP_COMPFORBID = 0x10, ///< prefix with COMPOUNDFORBIDFLAG +}; -// flags for -#define WFP_RARE 0x01 // rare prefix -#define WFP_NC 0x02 // prefix is not combining -#define WFP_UP 0x04 // to-upper prefix -#define WFP_COMPPERMIT 0x08 // prefix with COMPOUNDPERMITFLAG -#define WFP_COMPFORBID 0x10 // prefix with COMPOUNDFORBIDFLAG +/// Flags for postponed prefixes in "sl_pidxs". Must be above affixID (one +/// byte) and prefcondnr (two bytes). +enum { + WF_RAREPFX = WFP_RARE << 24, ///< rare postponed prefix + WF_PFX_NC = WFP_NC << 24, ///< non-combining postponed prefix + WF_PFX_UP = WFP_UP << 24, ///< to-upper postponed prefix + WF_PFX_COMPPERMIT = WFP_COMPPERMIT << 24, ///< postponed prefix with COMPOUNDPERMITFLAG + WF_PFX_COMPFORBID = WFP_COMPFORBID << 24, ///< postponed prefix with COMPOUNDFORBIDFLAG +}; -// Flags for postponed prefixes in "sl_pidxs". Must be above affixID (one -// byte) and prefcondnr (two bytes). -#define WF_RAREPFX (WFP_RARE << 24) // rare postponed prefix -#define WF_PFX_NC (WFP_NC << 24) // non-combining postponed prefix -#define WF_PFX_UP (WFP_UP << 24) // to-upper postponed prefix -#define WF_PFX_COMPPERMIT (WFP_COMPPERMIT << 24) // postponed prefix with - // COMPOUNDPERMITFLAG -#define WF_PFX_COMPFORBID (WFP_COMPFORBID << 24) // postponed prefix with - // COMPOUNDFORBIDFLAG +/// flags for +enum { + COMP_CHECKDUP = 1, ///< CHECKCOMPOUNDDUP + COMP_CHECKREP = 2, ///< CHECKCOMPOUNDREP + COMP_CHECKCASE = 4, ///< CHECKCOMPOUNDCASE + COMP_CHECKTRIPLE = 8, ///< CHECKCOMPOUNDTRIPLE +}; -// flags for -#define COMP_CHECKDUP 1 // CHECKCOMPOUNDDUP -#define COMP_CHECKREP 2 // CHECKCOMPOUNDREP -#define COMP_CHECKCASE 4 // CHECKCOMPOUNDCASE -#define COMP_CHECKTRIPLE 8 // CHECKCOMPOUNDTRIPLE - -// Info from "REP", "REPSAL" and "SAL" entries in ".aff" file used in si_rep, -// si_repsal, sl_rep, and si_sal. Not for sl_sal! -// One replacement: from "ft_from" to "ft_to". +/// Info from "REP", "REPSAL" and "SAL" entries in ".aff" file used in si_rep, +/// si_repsal, sl_rep, and si_sal. Not for sl_sal! +/// One replacement: from "ft_from" to "ft_to". typedef struct fromto_S { char *ft_from; char *ft_to; } fromto_T; -// Info from "SAL" entries in ".aff" file used in sl_sal. -// The info is split for quick processing by spell_soundfold(). -// Note that "sm_oneof" and "sm_rules" point into sm_lead. +/// Info from "SAL" entries in ".aff" file used in sl_sal. +/// The info is split for quick processing by spell_soundfold(). +/// Note that "sm_oneof" and "sm_rules" point into sm_lead. typedef struct salitem_S { - char *sm_lead; // leading letters - int sm_leadlen; // length of "sm_lead" - char *sm_oneof; // letters from () or NULL - char *sm_rules; // rules like ^, $, priority - char *sm_to; // replacement. - int *sm_lead_w; // wide character copy of "sm_lead" - int *sm_oneof_w; // wide character copy of "sm_oneof" - int *sm_to_w; // wide character copy of "sm_to" + char *sm_lead; ///< leading letters + int sm_leadlen; ///< length of "sm_lead" + char *sm_oneof; ///< letters from () or NULL + char *sm_rules; ///< rules like ^, $, priority + char *sm_to; ///< replacement. + int *sm_lead_w; ///< wide character copy of "sm_lead" + int *sm_oneof_w; ///< wide character copy of "sm_oneof" + int *sm_to_w; ///< wide character copy of "sm_to" } salitem_T; typedef int salfirst_T; -// Values for SP_*ERROR are negative, positive values are used by -// read_cnt_string(). -#define SP_TRUNCERROR (-1) // spell file truncated error -#define SP_FORMERROR (-2) // format error in spell file -#define SP_OTHERERROR (-3) // other error while reading spell file +/// Values for SP_*ERROR are negative, positive values are used by +/// read_cnt_string(). +enum { + SP_TRUNCERROR = -1, ///< spell file truncated error + SP_FORMERROR = -2, ///< format error in spell file + SP_OTHERERROR = -3, ///< other error while reading spell file +}; -// Structure used to store words and other info for one language, loaded from -// a .spl file. -// The main access is through the tree in "sl_fbyts/sl_fidxs", storing the -// case-folded words. "sl_kbyts/sl_kidxs" is for keep-case words. -// -// The "byts" array stores the possible bytes in each tree node, preceded by -// the number of possible bytes, sorted on byte value: -// ... -// The "idxs" array stores the index of the child node corresponding to the -// byte in "byts". -// Exception: when the byte is zero, the word may end here and "idxs" holds -// the flags, region mask and affixID for the word. There may be several -// zeros in sequence for alternative flag/region/affixID combinations. +/// Structure used to store words and other info for one language, loaded from +/// a .spl file. +/// The main access is through the tree in "sl_fbyts/sl_fidxs", storing the +/// case-folded words. "sl_kbyts/sl_kidxs" is for keep-case words. +/// +/// The "byts" array stores the possible bytes in each tree node, preceded by +/// the number of possible bytes, sorted on byte value: +/// ... +/// The "idxs" array stores the index of the child node corresponding to the +/// byte in "byts". +/// Exception: when the byte is zero, the word may end here and "idxs" holds +/// the flags, region mask and affixID for the word. There may be several +/// zeros in sequence for alternative flag/region/affixID combinations. typedef struct slang_S slang_T; struct slang_S { - slang_T *sl_next; // next language - char *sl_name; // language name "en", "en.rare", "nl", etc. - char *sl_fname; // name of .spl file - bool sl_add; // true if it's a .add file. + slang_T *sl_next; ///< next language + char *sl_name; ///< language name "en", "en.rare", "nl", etc. + char *sl_fname; ///< name of .spl file + bool sl_add; ///< true if it's a .add file. - uint8_t *sl_fbyts; // case-folded word bytes - int sl_fbyts_len; // length of sl_fbyts - idx_T *sl_fidxs; // case-folded word indexes - uint8_t *sl_kbyts; // keep-case word bytes - idx_T *sl_kidxs; // keep-case word indexes - uint8_t *sl_pbyts; // prefix tree word bytes - idx_T *sl_pidxs; // prefix tree word indexes + uint8_t *sl_fbyts; ///< case-folded word bytes + int sl_fbyts_len; ///< length of sl_fbyts + idx_T *sl_fidxs; ///< case-folded word indexes + uint8_t *sl_kbyts; ///< keep-case word bytes + idx_T *sl_kidxs; ///< keep-case word indexes + uint8_t *sl_pbyts; ///< prefix tree word bytes + idx_T *sl_pidxs; ///< prefix tree word indexes - char *sl_info; // infotext string or NULL + char *sl_info; ///< infotext string or NULL + /// table with up to 8 region names plus NUL char sl_regions[MAXREGIONS * 2 + 1]; - // table with up to 8 region names plus NUL - char *sl_midword; // MIDWORD string or NULL + char *sl_midword; ///< MIDWORD string or NULL - hashtab_T sl_wordcount; // hashtable with word count, wordcount_T + hashtab_T sl_wordcount; ///< hashtable with word count, wordcount_T - int sl_compmax; // COMPOUNDWORDMAX (default: MAXWLEN) - int sl_compminlen; // COMPOUNDMIN (default: 0) - int sl_compsylmax; // COMPOUNDSYLMAX (default: MAXWLEN) - int sl_compoptions; // COMP_* flags - garray_T sl_comppat; // CHECKCOMPOUNDPATTERN items - regprog_T *sl_compprog; // COMPOUNDRULE turned into a regexp progrm - // (NULL when no compounding) - uint8_t *sl_comprules; // all COMPOUNDRULE concatenated (or NULL) - uint8_t *sl_compstartflags; // flags for first compound word - uint8_t *sl_compallflags; // all flags for compound words - bool sl_nobreak; // When true: no spaces between words - char *sl_syllable; // SYLLABLE repeatable chars or NULL - garray_T sl_syl_items; // syllable items + int sl_compmax; ///< COMPOUNDWORDMAX (default: MAXWLEN) + int sl_compminlen; ///< COMPOUNDMIN (default: 0) + int sl_compsylmax; ///< COMPOUNDSYLMAX (default: MAXWLEN) + int sl_compoptions; ///< COMP_* flags + garray_T sl_comppat; ///< CHECKCOMPOUNDPATTERN items + regprog_T *sl_compprog; ///< COMPOUNDRULE turned into a regexp progrm + ///< (NULL when no compounding) + uint8_t *sl_comprules; ///< all COMPOUNDRULE concatenated (or NULL) + uint8_t *sl_compstartflags; ///< flags for first compound word + uint8_t *sl_compallflags; ///< all flags for compound words + bool sl_nobreak; ///< When true: no spaces between words + char *sl_syllable; ///< SYLLABLE repeatable chars or NULL + garray_T sl_syl_items; ///< syllable items - int sl_prefixcnt; // number of items in "sl_prefprog" - regprog_T **sl_prefprog; // table with regprogs for prefixes + int sl_prefixcnt; ///< number of items in "sl_prefprog" + regprog_T **sl_prefprog; ///< table with regprogs for prefixes - garray_T sl_rep; // list of fromto_T entries from REP lines - int16_t sl_rep_first[256]; // indexes where byte first appears, -1 if - // there is none - garray_T sl_sal; // list of salitem_T entries from SAL lines - salfirst_T sl_sal_first[256]; // indexes where byte first appears, -1 if - // there is none - bool sl_followup; // SAL followup - bool sl_collapse; // SAL collapse_result - bool sl_rem_accents; // SAL remove_accents - bool sl_sofo; // SOFOFROM and SOFOTO instead of SAL items: - // "sl_sal_first" maps chars - // "sl_sal" is a list of wide char lists. - garray_T sl_repsal; // list of fromto_T entries from REPSAL lines - int16_t sl_repsal_first[256]; // sl_rep_first for REPSAL lines - bool sl_nosplitsugs; // don't suggest splitting a word - bool sl_nocompoundsugs; // don't suggest compounding + garray_T sl_rep; ///< list of fromto_T entries from REP lines + int16_t sl_rep_first[256]; ///< indexes where byte first appears, -1 if there is none + garray_T sl_sal; ///< list of salitem_T entries from SAL lines + salfirst_T sl_sal_first[256]; ///< indexes where byte first appears, -1 if there is none + bool sl_followup; ///< SAL followup + bool sl_collapse; ///< SAL collapse_result + bool sl_rem_accents; ///< SAL remove_accents + bool sl_sofo; ///< SOFOFROM and SOFOTO instead of SAL items: + ///< "sl_sal_first" maps chars + ///< "sl_sal" is a list of wide char lists. + garray_T sl_repsal; ///< list of fromto_T entries from REPSAL lines + int16_t sl_repsal_first[256]; ///< sl_rep_first for REPSAL lines + bool sl_nosplitsugs; ///< don't suggest splitting a word + bool sl_nocompoundsugs; ///< don't suggest compounding // Info from the .sug file. Loaded on demand. - time_t sl_sugtime; // timestamp for .sug file - uint8_t *sl_sbyts; // soundfolded word bytes - idx_T *sl_sidxs; // soundfolded word indexes - buf_T *sl_sugbuf; // buffer with word number table - bool sl_sugloaded; // true when .sug file was loaded or failed to - // load + time_t sl_sugtime; ///< timestamp for .sug file + uint8_t *sl_sbyts; ///< soundfolded word bytes + idx_T *sl_sidxs; ///< soundfolded word indexes + buf_T *sl_sugbuf; ///< buffer with word number table + bool sl_sugloaded; ///< true when .sug file was loaded or failed to load - bool sl_has_map; // true, if there is a MAP line - hashtab_T sl_map_hash; // MAP for multi-byte chars - int sl_map_array[256]; // MAP for first 256 chars - hashtab_T sl_sounddone; // table with soundfolded words that have - // handled, see add_sound_suggest() + bool sl_has_map; ///< true, if there is a MAP line + hashtab_T sl_map_hash; ///< MAP for multi-byte chars + int sl_map_array[256]; ///< MAP for first 256 chars + hashtab_T sl_sounddone; ///< table with soundfolded words that have + ///< handled, see add_sound_suggest() }; -// Structure used in "b_langp", filled from 'spelllang'. +/// Structure used in "b_langp", filled from 'spelllang'. typedef struct langp_S { - slang_T *lp_slang; // info for this language - slang_T *lp_sallang; // language used for sound folding or NULL - slang_T *lp_replang; // language used for REP items or NULL - int lp_region; // bitmask for region or REGION_ALL + slang_T *lp_slang; ///< info for this language + slang_T *lp_sallang; ///< language used for sound folding or NULL + slang_T *lp_replang; ///< language used for REP items or NULL + int lp_region; ///< bitmask for region or REGION_ALL } langp_T; #define LANGP_ENTRY(ga, i) (((langp_T *)(ga).ga_data) + (i)) @@ -198,15 +204,15 @@ typedef struct langp_S { #define VIMSUGMAGICL 6 #define VIMSUGVERSION 1 -#define REGION_ALL 0xff // word valid in all regions +enum { REGION_ALL = 0xff, }; ///< word valid in all regions -// The tables used for recognizing word characters according to spelling. -// These are only used for the first 256 characters of 'encoding'. +/// The tables used for recognizing word characters according to spelling. +/// These are only used for the first 256 characters of 'encoding'. typedef struct { - bool st_isw[256]; // flags: is word char - bool st_isu[256]; // flags: is uppercase char - uint8_t st_fold[256]; // chars: folded case - uint8_t st_upper[256]; // chars: upper case + bool st_isw[256]; ///< flags: is word char + bool st_isu[256]; ///< flags: is uppercase char + uint8_t st_fold[256]; ///< chars: folded case + uint8_t st_upper[256]; ///< chars: upper case } spelltab_T; // Use our own character-case definitions, because the current locale may @@ -221,7 +227,7 @@ typedef struct { #define SPELL_ISUPPER(c) ((c) >= 128 ? mb_isupper(c) : spelltab.st_isu[c]) -// Values for "what" argument of spell_add_word() +/// Values for "what" argument of spell_add_word() typedef enum { SPELL_ADD_GOOD = 0, SPELL_ADD_BAD = 1, @@ -229,10 +235,10 @@ typedef enum { } SpellAddType; typedef struct wordcount_S { - uint16_t wc_count; ///< nr of times word was seen - char wc_word[]; ///< word + uint16_t wc_count; ///< nr of times word was seen + char wc_word[]; ///< word } wordcount_T; #define WC_KEY_OFF offsetof(wordcount_T, wc_word) #define HI2WC(hi) ((wordcount_T *)((hi)->hi_key - WC_KEY_OFF)) -#define MAXWORDCOUNT 0xffff +enum { MAXWORDCOUNT = 0xffff, }; diff --git a/src/nvim/spellsuggest.c b/src/nvim/spellsuggest.c index 1852f75432..af9f4db45a 100644 --- a/src/nvim/spellsuggest.c +++ b/src/nvim/spellsuggest.c @@ -3141,8 +3141,7 @@ static void check_suggestions(suginfo_T *su, garray_T *gap) // Need to append what follows to check for "the the". xstrlcpy(longword, stp[i].st_word, MAXWLEN + 1); int len = stp[i].st_wordlen; - xstrlcpy(longword + len, su->su_badptr + stp[i].st_orglen, - (size_t)(MAXWLEN - len + 1)); + xstrlcpy(longword + len, su->su_badptr + stp[i].st_orglen, MAXWLEN + 1 - (size_t)len); hlf_T attr = HLF_COUNT; (void)spell_check(curwin, longword, &attr, NULL, false); if (attr != HLF_COUNT) {