spell.h File Reference

#include "regex/regex.h"
#include "tsearch/dicts/regis.h"
#include "tsearch/ts_public.h"

Include dependency graph for spell.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	SPNodeData
struct	SPNode
struct	spell_struct
struct	aff_struct
struct	AffixNodeData
struct	AffixNode
struct	CMPDAffix
struct	CompoundAffixFlag
struct	IspellDict

Macros
#define	FF_COMPOUNDONLY   0x01
#define	FF_COMPOUNDBEGIN   0x02
#define	FF_COMPOUNDMIDDLE   0x04
#define	FF_COMPOUNDLAST   0x08
#define	FF_COMPOUNDFLAG
#define	FF_COMPOUNDFLAGMASK   0x0f
#define	SPNHDRSZ   (offsetof(SPNode,data))
#define	SPELLHDRSZ   (offsetof(SPELL, word))
#define	FF_COMPOUNDPERMITFLAG   0x10
#define	FF_COMPOUNDFORBIDFLAG   0x20
#define	FF_CROSSPRODUCT   0x40
#define	FF_SUFFIX   1
#define	FF_PREFIX   0
#define	ANHRDSZ   (offsetof(AffixNode, data))
#define	FLAGNUM_MAXSIZE   (1 << 16)

Typedefs
typedef struct SPNode	SPNode
typedef struct spell_struct	SPELL
typedef struct aff_struct	AFFIX
typedef struct AffixNode	AffixNode
typedef struct CompoundAffixFlag	CompoundAffixFlag

Enumerations
enum	FlagMode { FM_CHAR , FM_LONG , FM_NUM }

Functions
TSLexeme *	NINormalizeWord (IspellDict *Conf, const char *word)
void	NIStartBuild (IspellDict *Conf)
void	NIImportAffixes (IspellDict *Conf, const char *filename)
void	NIImportDictionary (IspellDict *Conf, const char *filename)
void	NISortDictionary (IspellDict *Conf)
void	NISortAffixes (IspellDict *Conf)
void	NIFinishBuild (IspellDict *Conf)

Macro Definition Documentation

ANHRDSZ

#define ANHRDSZ   (offsetof(AffixNode, data))

Definition at line 145 of file spell.h.

FF_COMPOUNDBEGIN

#define FF_COMPOUNDBEGIN   0x02

Definition at line 43 of file spell.h.

FF_COMPOUNDFLAG

#define FF_COMPOUNDFLAG

Value:

                            ( FF_COMPOUNDBEGIN | FF_COMPOUNDMIDDLE | \
                            FF_COMPOUNDLAST )

Definition at line 46 of file spell.h.

{
    uint32      length;
    SPNodeData  data[FLEXIBLE_ARRAY_MEMBER];
} SPNode;
 
#define SPNHDRSZ    (offsetof(SPNode,data))
 
/*
 * Represents an entry in a words list.
 */
typedef struct spell_struct
{
    union
    {
        /*
         * flag is filled in by NIImportDictionary(). After
         * NISortDictionary(), d is used instead of flag.
         */
        const char *flag;
        /* d is used in mkSPNode() */
        struct
        {
            /* Reference to an entry of the AffixData field */
            int         affix;
            /* Length of the word */
            int         len;
        }           d;
    }           p;
    char        word[FLEXIBLE_ARRAY_MEMBER];
} SPELL;
 
#define SPELLHDRSZ  (offsetof(SPELL, word))
 
/*
 * Represents an entry in an affix list.
 */
typedef struct aff_struct
{
    const char *flag;
    /* FF_SUFFIX or FF_PREFIX */
    uint32      type:1,
                flagflags:7,
                issimple:1,
                isregis:1,
                replen:14;
    const char *find;
    const char *repl;
    union
    {
        /*
         * Arrays of AFFIX are moved and sorted.  We'll use a pointer to
         * regex_t to keep this struct small, and avoid assuming that regex_t
         * is movable.
         */
        regex_t    *pregex;
        Regis       regis;
    }           reg;
} AFFIX;
 
/*
 * affixes use dictionary flags too
 */
#define FF_COMPOUNDPERMITFLAG   0x10
#define FF_COMPOUNDFORBIDFLAG   0x20
#define FF_CROSSPRODUCT         0x40
 
/*
 * Don't change the order of these. Initialization sorts by these,
 * and expects prefixes to come first after sorting.
 */
#define FF_SUFFIX               1
#define FF_PREFIX               0
 
/*
 * AffixNode and AffixNodeData are used to represent prefix tree (Trie) to store
 * an affix list.
 */
struct AffixNode;
 
typedef struct
{
    uint32      val:8,
                naff:24;
    AFFIX     **aff;
    struct AffixNode *node;
} AffixNodeData;
 
typedef struct AffixNode
{
    uint32      isvoid:1,
                length:31;
    AffixNodeData data[FLEXIBLE_ARRAY_MEMBER];
} AffixNode;
 
#define ANHRDSZ        (offsetof(AffixNode, data))
 
typedef struct
{
    const char *affix;
    int         len;
    bool        issuffix;
} CMPDAffix;
 
/*
 * Type of encoding affix flags in Hunspell dictionaries
 */
typedef enum
{
    FM_CHAR,                    /* one character (like ispell) */
    FM_LONG,                    /* two characters */
    FM_NUM,                     /* number, >= 0 and < 65536 */
} FlagMode;
 
/*
 * Structure to store Hunspell options. Flag representation depends on flag
 * type. These flags are about support of compound words.
 */
typedef struct CompoundAffixFlag
{
    union
    {
        /* Flag name if flagMode is FM_CHAR or FM_LONG */
        const char *s;
        /* Flag name if flagMode is FM_NUM */
        uint32      i;
    }           flag;
    /* we don't have a bsearch_arg version, so, copy FlagMode */
    FlagMode    flagMode;
    uint32      value;
} CompoundAffixFlag;
 
#define FLAGNUM_MAXSIZE     (1 << 16)
 
typedef struct
{
    int         maffixes;
    int         naffixes;
    AFFIX      *Affix;
 
    AffixNode  *Suffix;
    AffixNode  *Prefix;
 
    SPNode     *Dictionary;
    /* Array of sets of affixes */
    const char **AffixData;
    int         lenAffixData;
    int         nAffixData;
    bool        useFlagAliases;
 
    CMPDAffix  *CompoundAffix;
 
    bool        usecompound;
    FlagMode    flagMode;
 
    /*
     * All follow fields are actually needed only for initialization
     */
 
    /* Array of Hunspell options in affix file */
    CompoundAffixFlag *CompoundAffixFlags;
    /* number of entries in CompoundAffixFlags array */
    int         nCompoundAffixFlag;
    /* allocated length of CompoundAffixFlags array */
    int         mCompoundAffixFlag;
 
    /*
     * Remaining fields are only used during dictionary construction; they are
     * set up by NIStartBuild and cleared by NIFinishBuild.
     */
    MemoryContext buildCxt;     /* temp context for construction */
 
    /* Temporary array of all words in the dict file */
    SPELL     **Spell;
    int         nspell;         /* number of valid entries in Spell array */
    int         mspell;         /* allocated length of Spell array */
 
    /* These are used to allocate "compact" data without palloc overhead */
    char       *firstfree;      /* first free address (always maxaligned) */
    size_t      avail;          /* free space remaining at firstfree */
} IspellDict;
 
extern TSLexeme *NINormalizeWord(IspellDict *Conf, const char *word);
 
extern void NIStartBuild(IspellDict *Conf);
extern void NIImportAffixes(IspellDict *Conf, const char *filename);
extern void NIImportDictionary(IspellDict *Conf, const char *filename);
extern void NISortDictionary(IspellDict *Conf);
extern void NISortAffixes(IspellDict *Conf);
extern void NIFinishBuild(IspellDict *Conf);
 
#endif

FF_COMPOUNDFLAGMASK

#define FF_COMPOUNDFLAGMASK   0x0f

Definition at line 48 of file spell.h.

FF_COMPOUNDFORBIDFLAG

#define FF_COMPOUNDFORBIDFLAG   0x20

Definition at line 114 of file spell.h.

FF_COMPOUNDLAST

#define FF_COMPOUNDLAST   0x08

Definition at line 45 of file spell.h.

FF_COMPOUNDMIDDLE

#define FF_COMPOUNDMIDDLE   0x04

Definition at line 44 of file spell.h.

FF_COMPOUNDONLY

#define FF_COMPOUNDONLY   0x01

Definition at line 42 of file spell.h.

FF_COMPOUNDPERMITFLAG

#define FF_COMPOUNDPERMITFLAG   0x10

Definition at line 113 of file spell.h.

FF_CROSSPRODUCT

#define FF_CROSSPRODUCT   0x40

Definition at line 115 of file spell.h.

FF_PREFIX

#define FF_PREFIX   0

Definition at line 122 of file spell.h.

FF_SUFFIX

#define FF_SUFFIX   1

Definition at line 121 of file spell.h.

FLAGNUM_MAXSIZE

#define FLAGNUM_MAXSIZE   (1 << 16)

Definition at line 182 of file spell.h.

SPELLHDRSZ

#define SPELLHDRSZ   (offsetof(SPELL, word))

Definition at line 82 of file spell.h.

SPNHDRSZ

#define SPNHDRSZ   (offsetof(SPNode,data))

Definition at line 56 of file spell.h.

Typedef Documentation

AFFIX

typedef struct aff_struct AFFIX

AffixNode

typedef struct AffixNode AffixNode

CompoundAffixFlag

typedef struct CompoundAffixFlag CompoundAffixFlag

SPELL

typedef struct spell_struct SPELL

SPNode

typedef struct SPNode SPNode

Enumeration Type Documentation

FlagMode

enum FlagMode

Enumerator
FM_CHAR
FM_LONG
FM_NUM

Definition at line 157 of file spell.h.

{
    FM_CHAR,                    /* one character (like ispell) */
    FM_LONG,                    /* two characters */
    FM_NUM,                     /* number, >= 0 and < 65536 */
} FlagMode;

Function Documentation

NIFinishBuild()

void NIFinishBuild ( IspellDict *  Conf )

extern

Definition at line 104 of file spell.c.

{
    /* Release no-longer-needed temp memory */
    MemoryContextDelete(Conf->buildCxt);
    /* Just for cleanliness, zero the now-dangling pointers */
    Conf->buildCxt = NULL;
    Conf->Spell = NULL;
    Conf->firstfree = NULL;
    Conf->CompoundAffixFlags = NULL;
}

References fb(), and MemoryContextDelete().

Referenced by dispell_init().

NIImportAffixes()

void NIImportAffixes ( IspellDict *  Conf, const char *  filename  )

extern

Definition at line 1423 of file spell.c.

{
    char       *pstr = NULL;
    char        flag[BUFSIZ];
    char        mask[BUFSIZ];
    char        find[BUFSIZ];
    char        repl[BUFSIZ];
    char       *s;
    bool        suffixes = false;
    bool        prefixes = false;
    char        flagflags = 0;
    tsearch_readline_state trst;
    bool        oldformat = false;
    char       *recoded = NULL;
 
    if (!tsearch_readline_begin(&trst, filename))
        ereport(ERROR,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("could not open affix file \"%s\": %m",
                        filename)));
 
    Conf->usecompound = false;
    Conf->useFlagAliases = false;
    Conf->flagMode = FM_CHAR;
 
    while ((recoded = tsearch_readline(&trst)) != NULL)
    {
        pstr = str_tolower(recoded, strlen(recoded), DEFAULT_COLLATION_OID);
 
        /* Skip comments and empty lines */
        if (*pstr == '#' || *pstr == '\n')
            goto nextline;
 
        if (STRNCMP(pstr, "compoundwords") == 0)
        {
            /* Find case-insensitive L flag in non-lowercased string */
            s = findchar2(recoded, 'l', 'L');
            if (s)
            {
                while (*s && !isspace((unsigned char) *s))
                    s += pg_mblen_cstr(s);
                while (*s && isspace((unsigned char) *s))
                    s += pg_mblen_cstr(s);
 
                if (*s && pg_mblen_cstr(s) == 1)
                {
                    addCompoundAffixFlagValue(Conf, s, FF_COMPOUNDFLAG);
                    Conf->usecompound = true;
                }
                oldformat = true;
                goto nextline;
            }
        }
        if (STRNCMP(pstr, "suffixes") == 0)
        {
            suffixes = true;
            prefixes = false;
            oldformat = true;
            goto nextline;
        }
        if (STRNCMP(pstr, "prefixes") == 0)
        {
            suffixes = false;
            prefixes = true;
            oldformat = true;
            goto nextline;
        }
        if (STRNCMP(pstr, "flag") == 0)
        {
            s = recoded + 4;    /* we need non-lowercased string */
            flagflags = 0;
 
            while (*s && isspace((unsigned char) *s))
                s += pg_mblen_cstr(s);
 
            if (*s == '*')
            {
                flagflags |= FF_CROSSPRODUCT;
                s++;
            }
            else if (*s == '~')
            {
                flagflags |= FF_COMPOUNDONLY;
                s++;
            }
 
            if (*s == '\\')
                s++;
 
            /*
             * An old-format flag is a single ASCII character; we expect it to
             * be followed by EOL, whitespace, or ':'.  Otherwise this is a
             * new-format flag command.
             */
            if (*s && pg_mblen_cstr(s) == 1)
            {
                flag[0] = *s++;
                flag[1] = '\0';
 
                if (*s == '\0' || *s == '#' || *s == '\n' || *s == ':' ||
                    isspace((unsigned char) *s))
                {
                    oldformat = true;
                    goto nextline;
                }
            }
            goto isnewformat;
        }
        if (STRNCMP(recoded, "COMPOUNDFLAG") == 0 ||
            STRNCMP(recoded, "COMPOUNDMIN") == 0 ||
            STRNCMP(recoded, "PFX") == 0 ||
            STRNCMP(recoded, "SFX") == 0)
            goto isnewformat;
 
        if ((!suffixes) && (!prefixes))
            goto nextline;
 
        if (!parse_affentry(pstr, mask, find, repl))
            goto nextline;
 
        NIAddAffix(Conf, flag, flagflags, mask, find, repl, suffixes ? FF_SUFFIX : FF_PREFIX);
 
nextline:
        pfree(recoded);
        pfree(pstr);
    }
    tsearch_readline_end(&trst);
    return;
 
isnewformat:
    if (oldformat)
        ereport(ERROR,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("affix file contains both old-style and new-style commands")));
    tsearch_readline_end(&trst);
 
    NIImportOOAffixes(Conf, filename);
}

References addCompoundAffixFlagValue(), ereport, errcode(), errmsg(), ERROR, fb(), FF_COMPOUNDFLAG, FF_COMPOUNDONLY, FF_CROSSPRODUCT, FF_PREFIX, FF_SUFFIX, filename, find(), findchar2(), flag(), FM_CHAR, NIAddAffix(), NIImportOOAffixes(), parse_affentry(), pfree(), pg_mblen_cstr(), prefixes(), str_tolower(), STRNCMP, tsearch_readline(), tsearch_readline_begin(), and tsearch_readline_end().

Referenced by dispell_init().

NIImportDictionary()

void NIImportDictionary ( IspellDict *  Conf, const char *  filename  )

extern

Definition at line 520 of file spell.c.

{
    tsearch_readline_state trst;
    char       *line;
 
    if (!tsearch_readline_begin(&trst, filename))
        ereport(ERROR,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("could not open dictionary file \"%s\": %m",
                        filename)));
 
    while ((line = tsearch_readline(&trst)) != NULL)
    {
        char       *s,
                   *pstr;
 
        /* Set of affix flags */
        const char *flag;
 
        /* Extract flag from the line */
        flag = NULL;
        if ((s = findchar(line, '/')))
        {
            *s++ = '\0';
            flag = s;
            while (*s)
            {
                /* we allow only single encoded flags for faster works */
                if (pg_mblen_cstr(s) == 1 && isprint((unsigned char) *s) && !isspace((unsigned char) *s))
                    s++;
                else
                {
                    *s = '\0';
                    break;
                }
            }
        }
        else
            flag = "";
 
        /* Remove trailing spaces */
        s = line;
        while (*s)
        {
            if (isspace((unsigned char) *s))
            {
                *s = '\0';
                break;
            }
            s += pg_mblen_cstr(s);
        }
        pstr = lowerstr_ctx(Conf, line);
 
        NIAddSpell(Conf, pstr, flag);
        pfree(pstr);
 
        pfree(line);
    }
    tsearch_readline_end(&trst);
}

References ereport, errcode(), errmsg(), ERROR, fb(), filename, findchar(), flag(), lowerstr_ctx(), NIAddSpell(), pfree(), pg_mblen_cstr(), tsearch_readline(), tsearch_readline_begin(), and tsearch_readline_end().

Referenced by dispell_init().

NINormalizeWord()

TSLexeme * NINormalizeWord ( IspellDict *  Conf, const char *  word  )

extern

Definition at line 2538 of file spell.c.

{
    char      **res;
    TSLexeme   *lcur = NULL,
               *lres = NULL;
    uint16      NVariant = 1;
 
    res = NormalizeSubWord(Conf, word, 0);
 
    if (res)
    {
        char      **ptr = res;
 
        while (*ptr && (lcur - lres) < MAX_NORM)
        {
            addNorm(&lres, &lcur, *ptr, 0, NVariant++);
            ptr++;
        }
        pfree(res);
    }
 
    if (Conf->usecompound)
    {
        int         wordlen = strlen(word);
        SplitVar   *ptr,
                   *var = SplitToVariants(Conf, NULL, NULL, word, wordlen, 0, -1);
        int         i;
 
        while (var)
        {
            if (var->nstem > 1)
            {
                char      **subres = NormalizeSubWord(Conf, var->stem[var->nstem - 1], FF_COMPOUNDLAST);
 
                if (subres)
                {
                    char      **subptr = subres;
 
                    while (*subptr)
                    {
                        for (i = 0; i < var->nstem - 1; i++)
                        {
                            addNorm(&lres, &lcur, (subptr == subres) ? var->stem[i] : pstrdup(var->stem[i]), 0, NVariant);
                        }
 
                        addNorm(&lres, &lcur, *subptr, 0, NVariant);
                        subptr++;
                        NVariant++;
                    }
 
                    pfree(subres);
                    var->stem[0] = NULL;
                    pfree(var->stem[var->nstem - 1]);
                }
            }
 
            for (i = 0; i < var->nstem && var->stem[i]; i++)
                pfree(var->stem[i]);
            ptr = var->next;
            pfree(var->stem);
            pfree(var);
            var = ptr;
        }
    }
 
    return lres;
}

References addNorm(), fb(), FF_COMPOUNDLAST, i, MAX_NORM, SplitVar::next, NormalizeSubWord(), SplitVar::nstem, pfree(), pstrdup(), SplitToVariants(), SplitVar::stem, and word().

Referenced by dispell_lexize().

NISortAffixes()

void NISortAffixes ( IspellDict *  Conf )

extern

Definition at line 1974 of file spell.c.

{
    AFFIX      *Affix;
    size_t      i;
    CMPDAffix  *ptr;
    int         firstsuffix = Conf->naffixes;
 
    if (Conf->naffixes == 0)
        return;
 
    /* Store compound affixes in the Conf->CompoundAffix array */
    if (Conf->naffixes > 1)
        qsort(Conf->Affix, Conf->naffixes, sizeof(AFFIX), cmpaffix);
    Conf->CompoundAffix = ptr = palloc_array(CMPDAffix, Conf->naffixes);
    ptr->affix = NULL;
 
    for (i = 0; i < Conf->naffixes; i++)
    {
        Affix = &(((AFFIX *) Conf->Affix)[i]);
        if (Affix->type == FF_SUFFIX && i < firstsuffix)
            firstsuffix = i;
 
        if ((Affix->flagflags & FF_COMPOUNDFLAG) && Affix->replen > 0 &&
            isAffixInUse(Conf, Affix->flag))
        {
            bool        issuffix = (Affix->type == FF_SUFFIX);
 
            if (ptr == Conf->CompoundAffix ||
                issuffix != (ptr - 1)->issuffix ||
                strbncmp((const unsigned char *) (ptr - 1)->affix,
                         (const unsigned char *) Affix->repl,
                         (ptr - 1)->len))
            {
                /* leave only unique and minimal suffixes */
                ptr->affix = Affix->repl;
                ptr->len = Affix->replen;
                ptr->issuffix = issuffix;
                ptr++;
            }
        }
    }
    ptr->affix = NULL;
    Conf->CompoundAffix = (CMPDAffix *) repalloc(Conf->CompoundAffix, sizeof(CMPDAffix) * (ptr - Conf->CompoundAffix + 1));
 
    /* Start build a prefix tree */
    Conf->Prefix = mkANode(Conf, 0, firstsuffix, 0, FF_PREFIX);
    Conf->Suffix = mkANode(Conf, firstsuffix, Conf->naffixes, 0, FF_SUFFIX);
    mkVoidAffix(Conf, true, firstsuffix);
    mkVoidAffix(Conf, false, firstsuffix);
}

References CMPDAffix::affix, cmpaffix(), fb(), FF_COMPOUNDFLAG, FF_PREFIX, FF_SUFFIX, aff_struct::flag, aff_struct::flagflags, i, isAffixInUse(), CMPDAffix::issuffix, CMPDAffix::len, mkANode(), mkVoidAffix(), palloc_array, qsort, repalloc(), aff_struct::repl, aff_struct::replen, strbncmp(), and aff_struct::type.

Referenced by dispell_init().

NISortDictionary()

void NISortDictionary ( IspellDict *  Conf )

extern

Definition at line 1719 of file spell.c.

{
    int         i;
    int         naffix;
    int         curaffix;
 
    /* compress affixes */
 
    /*
     * If we use flag aliases then we need to use Conf->AffixData filled in
     * the NIImportOOAffixes().
     */
    if (Conf->useFlagAliases)
    {
        for (i = 0; i < Conf->nspell; i++)
        {
            char       *end;
 
            if (*Conf->Spell[i]->p.flag != '\0')
            {
                errno = 0;
                curaffix = strtol(Conf->Spell[i]->p.flag, &end, 10);
                if (Conf->Spell[i]->p.flag == end || errno == ERANGE)
                    ereport(ERROR,
                            (errcode(ERRCODE_CONFIG_FILE_ERROR),
                             errmsg("invalid affix alias \"%s\"",
                                    Conf->Spell[i]->p.flag)));
                if (curaffix < 0 || curaffix >= Conf->nAffixData)
                    ereport(ERROR,
                            (errcode(ERRCODE_CONFIG_FILE_ERROR),
                             errmsg("invalid affix alias \"%s\"",
                                    Conf->Spell[i]->p.flag)));
                if (*end != '\0' && !isdigit((unsigned char) *end) && !isspace((unsigned char) *end))
                    ereport(ERROR,
                            (errcode(ERRCODE_CONFIG_FILE_ERROR),
                             errmsg("invalid affix alias \"%s\"",
                                    Conf->Spell[i]->p.flag)));
            }
            else
            {
                /*
                 * If Conf->Spell[i]->p.flag is empty, then get empty value of
                 * Conf->AffixData (0 index).
                 */
                curaffix = 0;
            }
 
            Conf->Spell[i]->p.d.affix = curaffix;
            Conf->Spell[i]->p.d.len = strlen(Conf->Spell[i]->word);
        }
    }
    /* Otherwise fill Conf->AffixData here */
    else
    {
        /* Count the number of different flags used in the dictionary */
        qsort(Conf->Spell, Conf->nspell, sizeof(SPELL *),
              cmpspellaffix);
 
        naffix = 0;
        for (i = 0; i < Conf->nspell; i++)
        {
            if (i == 0 ||
                strcmp(Conf->Spell[i]->p.flag, Conf->Spell[i - 1]->p.flag) != 0)
                naffix++;
        }
 
        /*
         * Fill in Conf->AffixData with the affixes that were used in the
         * dictionary. Replace textual flag-field of Conf->Spell entries with
         * indexes into Conf->AffixData array.
         */
        Conf->AffixData = palloc0_array(const char *, naffix);
 
        curaffix = -1;
        for (i = 0; i < Conf->nspell; i++)
        {
            if (i == 0 ||
                strcmp(Conf->Spell[i]->p.flag, Conf->AffixData[curaffix]) != 0)
            {
                curaffix++;
                Assert(curaffix < naffix);
                Conf->AffixData[curaffix] = cpstrdup(Conf,
                                                     Conf->Spell[i]->p.flag);
            }
 
            Conf->Spell[i]->p.d.affix = curaffix;
            Conf->Spell[i]->p.d.len = strlen(Conf->Spell[i]->word);
        }
 
        Conf->lenAffixData = Conf->nAffixData = naffix;
    }
 
    /* Start build a prefix tree */
    qsort(Conf->Spell, Conf->nspell, sizeof(SPELL *), cmpspell);
    Conf->Dictionary = mkSPNode(Conf, 0, Conf->nspell, 0);
}

References Assert, cmpspell(), cmpspellaffix(), cpstrdup(), ereport, errcode(), errmsg(), ERROR, fb(), i, mkSPNode(), palloc0_array, and qsort.

Referenced by dispell_init().

NIStartBuild()

void NIStartBuild ( IspellDict *  Conf )

extern

Definition at line 89 of file spell.c.

{
    /*
     * The temp context is a child of CurTransactionContext, so that it will
     * go away automatically on error.
     */
    Conf->buildCxt = AllocSetContextCreate(CurTransactionContext,
                                           "Ispell dictionary init context",
                                           ALLOCSET_DEFAULT_SIZES);
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, CurTransactionContext, and fb().

Referenced by dispell_init().