kevin/neovim
1
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2024-12-19 02:34:59 -07:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
zeertzjq 2023-11-28 10:47:22 +08:00 committed by GitHub
parent 3a3474371b
commit 1a8f60c7d2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 230 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -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\

2
src/clint.py
View File

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

2
src/nvim/buffer_defs.h
View File

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

1
src/nvim/eval.c
View File

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

2
src/nvim/eval.h
View File

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

2
src/nvim/eval/typval_defs.h
View File

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

1
src/nvim/eval/userfunc.c
View File

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

9
src/nvim/eval/userfunc.h
View File

@ -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/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;

2
src/nvim/eval/vars.h
View File

@ -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

61
src/nvim/hashtab.h
View File

@ -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 \
|| (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
///

59
src/nvim/hashtab_defs.h Normal file
View File

@ -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;

310
src/nvim/spell_defs.h
View File

@ -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 <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
#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 <pflags>
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 <pflags>
#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 <compoptions>
enum {
COMP_CHECKDUP = 1, ///< CHECKCOMPOUNDDUP
COMP_CHECKREP = 2, ///< CHECKCOMPOUNDREP
COMP_CHECKCASE = 4, ///< CHECKCOMPOUNDCASE
COMP_CHECKTRIPLE = 8, ///< CHECKCOMPOUNDTRIPLE
};
// flags for <compoptions>
#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:
// <len> <byte1> <byte2> ...
// 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:
/// <len> <byte1> <byte2> ...
/// 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, };

3
src/nvim/spellsuggest.c
View File

@ -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) {