refactor: move hashtab types to hashtab_defs.h (#26262)

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\

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",

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"

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"

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"

src/nvim/eval/typval_defs.h

@@ -4,7 +4,7 @@
 #include <limits.h>
 
 #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"

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"

src/nvim/eval/userfunc.h

@@ -3,14 +3,13 @@
 #include <stdbool.h>
 #include <stddef.h>
 
-#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/ex_cmds_defs.h"  // IWYU pragma: keep
-#include "nvim/garray_defs.h"
+#include "nvim/hashtab_defs.h"  // IWYU pragma: keep
-#include "nvim/hashtab.h"
 #include "nvim/pos_defs.h"
-#include "nvim/types_defs.h"
+#include "nvim/types_defs.h"  // IWYU pragma: keep
 
 struct funccal_entry;
 

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
 

src/nvim/hashtab.h

@@ -2,72 +2,17 @@
 
 #include <stddef.h>
 
+#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 \
+#define HASHITEM_EMPTY(hi) ((hi)->hi_key == NULL || (hi)->hi_key == &hash_removed)
-                            || (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;
 
 /// Iterate over a hashtab
 ///

src/nvim/hashtab_defs.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <stddef.h>
+
+/// 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;

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.
+/// Assume max. word len is this many bytes.
-                                // Some places assume a word length fits in a
+/// Some places assume a word length fits in a byte, thus it can't be above 255.
-                                // byte, thus it can't be above 255.
+enum { MAXWLEN = 254, };
 
-// Number of regions supported.
+/// Number of regions supported.
-#define MAXREGIONS 8
+enum { MAXREGIONS = 8, };
 
-// Type used for indexes in the word tree need to be at least 4 bytes.  If int
+/// 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?
+/// 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
+/// Flags used for a word.  Only the lowest byte can be used, the region byte
-// comes above it.
+/// comes above it.
-#define WF_REGION   0x01        // region byte follows
+enum {
-#define WF_ONECAP   0x02        // word with one capital (or all capitals)
+  WF_REGION  = 0x01,  ///< region byte follows
-#define WF_ALLCAP   0x04        // word must be all capitals
+  WF_ONECAP  = 0x02,  ///< word with one capital (or all capitals)
-#define WF_RARE     0x08        // rare word
+  WF_ALLCAP  = 0x04,  ///< word must be all capitals
-#define WF_BANNED   0x10        // bad word
+  WF_RARE    = 0x08,  ///< rare word
-#define WF_AFX      0x20        // affix ID follows
+  WF_BANNED  = 0x10,  ///< bad word
-#define WF_FIXCAP   0x40        // keep-case word, allcap not allowed
+  WF_AFX     = 0x20,  ///< affix ID follows
-#define WF_KEEPCAP  0x80        // keep-case word
+  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 <flags2>, 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 <flags2>, shifted up one byte to be used in wn_flags
+/// flags for <pflags>
-#define WF_HAS_AFF  0x0100      // word includes affix
+enum {
-#define WF_NEEDCOMP 0x0200      // word only valid in compound
+  WFP_RARE       = 0x01,  ///< rare prefix
-#define WF_NOSUGGEST 0x0400     // word not to be suggested
+  WFP_NC         = 0x02,  ///< prefix is not combining
-#define WF_COMPROOT 0x0800      // already compounded word, COMPOUNDROOT
+  WFP_UP         = 0x04,  ///< to-upper prefix
-#define WF_NOCOMPBEF 0x1000     // no compounding before this word
+  WFP_COMPPERMIT = 0x08,  ///< prefix with COMPOUNDPERMITFLAG
-#define WF_NOCOMPAFT 0x2000     // no compounding after this word
+  WFP_COMPFORBID = 0x10,  ///< prefix with COMPOUNDFORBIDFLAG
+};
 
-// flags for <pflags>
+/// Flags for postponed prefixes in "sl_pidxs".  Must be above affixID (one
-#define WFP_RARE            0x01        // rare prefix
+/// byte) and prefcondnr (two bytes).
-#define WFP_NC              0x02        // prefix is not combining
+enum {
-#define WFP_UP              0x04        // to-upper prefix
+  WF_RAREPFX        = WFP_RARE << 24,        ///< rare postponed prefix
-#define WFP_COMPPERMIT      0x08        // prefix with COMPOUNDPERMITFLAG
+  WF_PFX_NC         = WFP_NC << 24,          ///< non-combining postponed prefix
-#define WFP_COMPFORBID      0x10        // prefix with COMPOUNDFORBIDFLAG
+  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
+/// flags for <compoptions>
-// byte) and prefcondnr (two bytes).
+enum {
-#define WF_RAREPFX  (WFP_RARE << 24)    // rare postponed prefix
+  COMP_CHECKDUP    = 1,  ///< CHECKCOMPOUNDDUP
-#define WF_PFX_NC   (WFP_NC << 24)      // non-combining postponed prefix
+  COMP_CHECKREP    = 2,  ///< CHECKCOMPOUNDREP
-#define WF_PFX_UP   (WFP_UP << 24)      // to-upper postponed prefix
+  COMP_CHECKCASE   = 4,  ///< CHECKCOMPOUNDCASE
-#define WF_PFX_COMPPERMIT (WFP_COMPPERMIT << 24)  // postponed prefix with
+  COMP_CHECKTRIPLE = 8,  ///< CHECKCOMPOUNDTRIPLE
-                                                  // COMPOUNDPERMITFLAG
+};
-#define WF_PFX_COMPFORBID (WFP_COMPFORBID << 24)  // postponed prefix with
-                                                  // COMPOUNDFORBIDFLAG
 
-// flags for <compoptions>
+/// Info from "REP", "REPSAL" and "SAL" entries in ".aff" file used in si_rep,
-#define COMP_CHECKDUP           1       // CHECKCOMPOUNDDUP
+/// si_repsal, sl_rep, and si_sal.  Not for sl_sal!
-#define COMP_CHECKREP           2       // CHECKCOMPOUNDREP
+/// One replacement: from "ft_from" to "ft_to".
-#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".
 typedef struct fromto_S {
   char *ft_from;
   char *ft_to;
 } fromto_T;
 
-// Info from "SAL" entries in ".aff" file used in sl_sal.
+/// Info from "SAL" entries in ".aff" file used in sl_sal.
-// The info is split for quick processing by spell_soundfold().
+/// The info is split for quick processing by spell_soundfold().
-// Note that "sm_oneof" and "sm_rules" point into sm_lead.
+/// Note that "sm_oneof" and "sm_rules" point into sm_lead.
 typedef struct salitem_S {
-  char *sm_lead;        // leading letters
+  char *sm_lead;    ///< leading letters
-  int sm_leadlen;       // length of "sm_lead"
+  int sm_leadlen;   ///< length of "sm_lead"
-  char *sm_oneof;       // letters from () or NULL
+  char *sm_oneof;   ///< letters from () or NULL
-  char *sm_rules;       // rules like ^, $, priority
+  char *sm_rules;   ///< rules like ^, $, priority
-  char *sm_to;          // replacement.
+  char *sm_to;      ///< replacement.
-  int *sm_lead_w;       // wide character copy of "sm_lead"
+  int *sm_lead_w;   ///< wide character copy of "sm_lead"
-  int *sm_oneof_w;      // wide character copy of "sm_oneof"
+  int *sm_oneof_w;  ///< wide character copy of "sm_oneof"
-  int *sm_to_w;         // wide character copy of "sm_to"
+  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
+/// Values for SP_*ERROR are negative, positive values are used by
-// read_cnt_string().
+/// read_cnt_string().
-#define SP_TRUNCERROR   (-1)    // spell file truncated error
+enum {
-#define SP_FORMERROR    (-2)    // format error in spell file
+  SP_TRUNCERROR = -1,  ///< spell file truncated error
-#define SP_OTHERERROR   (-3)    // other error while reading spell file
+  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
+/// Structure used to store words and other info for one language, loaded from
-// a .spl file.
+/// a .spl file.
-// The main access is through the tree in "sl_fbyts/sl_fidxs", storing the
+/// 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.
+/// 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 "byts" array stores the possible bytes in each tree node, preceded by
-// the number of possible bytes, sorted on byte value:
+/// the number of possible bytes, sorted on byte value:
-//      <len> <byte1> <byte2> ...
+///      <len> <byte1> <byte2> ...
-// The "idxs" array stores the index of the child node corresponding to the
+/// The "idxs" array stores the index of the child node corresponding to the
-// byte in "byts".
+/// byte in "byts".
-// Exception: when the byte is zero, the word may end here and "idxs" holds
+/// 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
+/// the flags, region mask and affixID for the word.  There may be several
-// zeros in sequence for alternative flag/region/affixID combinations.
+/// zeros in sequence for alternative flag/region/affixID combinations.
 typedef struct slang_S slang_T;
 
 struct slang_S {
-  slang_T *sl_next;         // next language
+  slang_T *sl_next;   ///< next language
-  char *sl_name;            // language name "en", "en.rare", "nl", etc.
+  char *sl_name;      ///< language name "en", "en.rare", "nl", etc.
-  char *sl_fname;           // name of .spl file
+  char *sl_fname;     ///< name of .spl file
-  bool sl_add;              // true if it's a .add file.
+  bool sl_add;        ///< true if it's a .add file.
 
-  uint8_t *sl_fbyts;        // case-folded word bytes
+  uint8_t *sl_fbyts;  ///< case-folded word bytes
-  int sl_fbyts_len;         // length of sl_fbyts
+  int sl_fbyts_len;   ///< length of sl_fbyts
-  idx_T *sl_fidxs;          // case-folded word indexes
+  idx_T *sl_fidxs;    ///< case-folded word indexes
-  uint8_t *sl_kbyts;        // keep-case word bytes
+  uint8_t *sl_kbyts;  ///< keep-case word bytes
-  idx_T *sl_kidxs;          // keep-case word indexes
+  idx_T *sl_kidxs;    ///< keep-case word indexes
-  uint8_t *sl_pbyts;        // prefix tree word bytes
+  uint8_t *sl_pbyts;  ///< prefix tree word bytes
-  idx_T *sl_pidxs;          // prefix tree word indexes
+  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_compmax;                ///< COMPOUNDWORDMAX (default: MAXWLEN)
-  int sl_compminlen;            // COMPOUNDMIN (default: 0)
+  int sl_compminlen;             ///< COMPOUNDMIN (default: 0)
-  int sl_compsylmax;            // COMPOUNDSYLMAX (default: MAXWLEN)
+  int sl_compsylmax;             ///< COMPOUNDSYLMAX (default: MAXWLEN)
-  int sl_compoptions;           // COMP_* flags
+  int sl_compoptions;            ///< COMP_* flags
-  garray_T sl_comppat;          // CHECKCOMPOUNDPATTERN items
+  garray_T sl_comppat;           ///< CHECKCOMPOUNDPATTERN items
-  regprog_T *sl_compprog;       // COMPOUNDRULE turned into a regexp progrm
+  regprog_T *sl_compprog;        ///< COMPOUNDRULE turned into a regexp progrm
-                                // (NULL when no compounding)
+                                 ///< (NULL when no compounding)
-  uint8_t *sl_comprules;        // all COMPOUNDRULE concatenated (or NULL)
+  uint8_t *sl_comprules;         ///< all COMPOUNDRULE concatenated (or NULL)
-  uint8_t *sl_compstartflags;   // flags for first compound word
+  uint8_t *sl_compstartflags;    ///< flags for first compound word
-  uint8_t *sl_compallflags;     // all flags for compound words
+  uint8_t *sl_compallflags;      ///< all flags for compound words
-  bool sl_nobreak;              // When true: no spaces between words
+  bool sl_nobreak;               ///< When true: no spaces between words
-  char *sl_syllable;            // SYLLABLE repeatable chars or NULL
+  char *sl_syllable;             ///< SYLLABLE repeatable chars or NULL
-  garray_T sl_syl_items;        // syllable items
+  garray_T sl_syl_items;         ///< syllable items
 
-  int sl_prefixcnt;             // number of items in "sl_prefprog"
+  int sl_prefixcnt;              ///< number of items in "sl_prefprog"
-  regprog_T **sl_prefprog;    // table with regprogs for prefixes
+  regprog_T **sl_prefprog;       ///< table with regprogs for prefixes
 
-  garray_T sl_rep;              // list of fromto_T entries from REP lines
+  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
+  int16_t sl_rep_first[256];     ///< indexes where byte first appears, -1 if there is none
-                                    // there is none
+  garray_T sl_sal;               ///< list of salitem_T entries from SAL lines
-  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
-  salfirst_T sl_sal_first[256];     // indexes where byte first appears, -1 if
+  bool sl_followup;              ///< SAL followup
-                                    // there is none
+  bool sl_collapse;              ///< SAL collapse_result
-  bool sl_followup;             // SAL followup
+  bool sl_rem_accents;           ///< SAL remove_accents
-  bool sl_collapse;             // SAL collapse_result
+  bool sl_sofo;                  ///< SOFOFROM and SOFOTO instead of SAL items:
-  bool sl_rem_accents;          // SAL remove_accents
+                                 ///< "sl_sal_first" maps chars
-  bool sl_sofo;                 // SOFOFROM and SOFOTO instead of SAL items:
+                                 ///< "sl_sal" is a list of wide char lists.
-                                // "sl_sal_first" maps chars
+  garray_T sl_repsal;            ///< list of fromto_T entries from REPSAL lines
-                                // "sl_sal" is a list of wide char lists.
+  int16_t sl_repsal_first[256];  ///< sl_rep_first for REPSAL lines
-  garray_T sl_repsal;           // list of fromto_T entries from REPSAL lines
+  bool sl_nosplitsugs;           ///< don't suggest splitting a word
-  int16_t sl_repsal_first[256];    // sl_rep_first for REPSAL lines
+  bool sl_nocompoundsugs;        ///< don't suggest compounding
-  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
+  time_t sl_sugtime;       ///< timestamp for .sug file
-  uint8_t *sl_sbyts;      // soundfolded word bytes
+  uint8_t *sl_sbyts;       ///< soundfolded word bytes
-  idx_T *sl_sidxs;        // soundfolded word indexes
+  idx_T *sl_sidxs;         ///< soundfolded word indexes
-  buf_T *sl_sugbuf;       // buffer with word number table
+  buf_T *sl_sugbuf;        ///< buffer with word number table
-  bool sl_sugloaded;            // true when .sug file was loaded or failed to
+  bool sl_sugloaded;       ///< true when .sug file was loaded or failed to load
-                                // load
 
-  bool sl_has_map;              // true, if there is a MAP line
+  bool sl_has_map;         ///< true, if there is a MAP line
-  hashtab_T sl_map_hash;        // MAP for multi-byte chars
+  hashtab_T sl_map_hash;   ///< MAP for multi-byte chars
-  int sl_map_array[256];        // MAP for first 256 chars
+  int sl_map_array[256];   ///< MAP for first 256 chars
-  hashtab_T sl_sounddone;       // table with soundfolded words that have
+  hashtab_T sl_sounddone;  ///< table with soundfolded words that have
-                                // handled, see add_sound_suggest()
+                           ///< 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_slang;    ///< info for this language
-  slang_T *lp_sallang;      // language used for sound folding or NULL
+  slang_T *lp_sallang;  ///< language used for sound folding or NULL
-  slang_T *lp_replang;      // language used for REP items or NULL
+  slang_T *lp_replang;  ///< language used for REP items or NULL
-  int lp_region;                // bitmask for region or REGION_ALL
+  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.
+/// The tables used for recognizing word characters according to spelling.
-// These are only used for the first 256 characters of 'encoding'.
+/// These are only used for the first 256 characters of 'encoding'.
 typedef struct {
-  bool st_isw[256];           // flags: is word char
+  bool st_isw[256];       ///< flags: is word char
-  bool st_isu[256];           // flags: is uppercase char
+  bool st_isu[256];       ///< flags: is uppercase char
-  uint8_t st_fold[256];        // chars: folded case
+  uint8_t st_fold[256];   ///< chars: folded case
-  uint8_t st_upper[256];       // chars: upper 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
+  uint16_t wc_count;  ///< nr of times word was seen
-  char wc_word[];                   ///< word
+  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, };

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,
+    xstrlcpy(longword + len, su->su_badptr + stp[i].st_orglen, MAXWLEN + 1 - (size_t)len);
-             (size_t)(MAXWLEN - len + 1));
     hlf_T attr = HLF_COUNT;
     (void)spell_check(curwin, longword, &attr, NULL, false);
     if (attr != HLF_COUNT) {