#include "postgres.h"
#include "catalog/pg_collation.h"
#include "miscadmin.h"
#include "tsearch/dicts/spell.h"
#include "tsearch/ts_locale.h"
#include "utils/formatting.h"
#include "utils/memutils.h"

Include dependency graph for spell.c:

Data Structures
struct	SplitVar

Macros
#define	tmpalloc(sz) MemoryContextAlloc(Conf->buildCxt, (sz))

#define	tmpalloc0(sz) MemoryContextAllocZero(Conf->buildCxt, (sz))

#define	COMPACT_ALLOC_CHUNK 8192 /* amount to get from palloc at once */

#define	COMPACT_MAX_REQ 1024 /* must be < COMPACT_ALLOC_CHUNK */

#define	cpalloc(size) compact_palloc0(Conf, size)

#define	cpalloc0(size) compact_palloc0(Conf, size)

#define	MAX_NORM 1024

#define	MAXNORMLEN 256

#define	STRNCMP(s, p) strncmp( (s), (p), strlen(p) )

#define	GETWCHAR(W, L, N, T) ( ((const uint8*)(W))[ ((T)==FF_PREFIX) ? (N) : ( (L) - 1 - (N) ) ] )

#define	GETCHAR(A, N, T) GETWCHAR( (A)->repl, (A)->replen, N, T )

#define	PAE_WAIT_MASK 0

#define	PAE_INMASK 1

#define	PAE_WAIT_FIND 2

#define	PAE_INFIND 3

#define	PAE_WAIT_REPL 4

#define	PAE_INREPL 5

#define	PAE_WAIT_TYPE 6

#define	PAE_WAIT_FLAG 7

Typedefs
typedef struct SplitVar	SplitVar

Functions
void	NIStartBuild (IspellDict *Conf)

void	NIFinishBuild (IspellDict *Conf)

static void *	compact_palloc0 (IspellDict *Conf, size_t size)

static char *	cpstrdup (IspellDict Conf, const char str)

static char *	lowerstr_ctx (IspellDict Conf, const char src)

static int	cmpspell (const void s1, const void s2)

static int	cmpspellaffix (const void s1, const void s2)

static int	cmpcmdflag (const void f1, const void f2)

static char *	findchar (char *str, int c)

static char *	findchar2 (char *str, int c1, int c2)

static int	strbcmp (const unsigned char s1, const unsigned char s2)

static int	strbncmp (const unsigned char s1, const unsigned char s2, size_t count)

static int	cmpaffix (const void s1, const void s2)

static void	getNextFlagFromString (IspellDict Conf, const char sflagset, char sflag)

static bool	IsAffixFlagInUse (IspellDict Conf, int affix, const char affixflag)

static void	NIAddSpell (IspellDict Conf, const char word, const char *flag)

void	NIImportDictionary (IspellDict Conf, const char filename)

static int	FindWord (IspellDict Conf, const char word, const char *affixflag, int flag)

static void	NIAddAffix (IspellDict Conf, const char flag, char flagflags, const char mask, const char find, const char *repl, int type)

static bool	get_nextfield (char *str, char next)

static int	parse_ooaffentry (char str, char type, char flag, char find, char repl, char mask)

static bool	parse_affentry (char str, char mask, char find, char repl)

static void	setCompoundAffixFlagValue (IspellDict Conf, CompoundAffixFlag entry, char *s, uint32 val)

static void	addCompoundAffixFlagValue (IspellDict Conf, char s, uint32 val)

static int	getCompoundAffixFlagValue (IspellDict Conf, const char s)

static const char *	getAffixFlagSet (IspellDict Conf, char s)

static void	NIImportOOAffixes (IspellDict Conf, const char filename)

void	NIImportAffixes (IspellDict Conf, const char filename)

static int	MergeAffix (IspellDict *Conf, int a1, int a2)

static uint32	makeCompoundFlags (IspellDict *Conf, int affix)

static SPNode *	mkSPNode (IspellDict *Conf, int low, int high, int level)

void	NISortDictionary (IspellDict *Conf)

static AffixNode *	mkANode (IspellDict *Conf, int low, int high, int level, int type)

static void	mkVoidAffix (IspellDict *Conf, bool issuffix, int startsuffix)

static bool	isAffixInUse (IspellDict Conf, const char affixflag)

void	NISortAffixes (IspellDict *Conf)

static AffixNodeData *	FindAffixes (AffixNode node, const char word, int wrdlen, int *level, int type)

static char *	CheckAffix (const char word, size_t len, AFFIX Affix, int flagflags, char newword, int baselen)

static int	addToResult (char forms, char cur, char *word)

static char **	NormalizeSubWord (IspellDict Conf, const char word, int flag)

static int	CheckCompoundAffixes (CMPDAffix *ptr, const char word, int len, bool CheckInPlace)

static SplitVar *	CopyVar (SplitVar *s, int makedup)

static void	AddStem (SplitVar v, char word)

static SplitVar *	SplitToVariants (IspellDict Conf, SPNode snode, SplitVar orig, const char word, int wordlen, int startpos, int minpos)

static void	addNorm (TSLexeme lres, TSLexeme lcur, char *word, int flags, uint16 NVariant)

TSLexeme *	NINormalizeWord (IspellDict Conf, const char word)

Variables
static const char *	VoidString = ""

Macro Definition Documentation

◆ COMPACT_ALLOC_CHUNK

#define COMPACT_ALLOC_CHUNK 8192 /* amount to get from palloc at once */

Definition at line 127 of file spell.c.

◆ COMPACT_MAX_REQ

#define COMPACT_MAX_REQ 1024 /* must be < COMPACT_ALLOC_CHUNK */

Definition at line 128 of file spell.c.

◆ cpalloc

#define cpalloc ( size ) compact_palloc0(Conf, size)

Definition at line 159 of file spell.c.

◆ cpalloc0

#define cpalloc0 ( size ) compact_palloc0(Conf, size)

Definition at line 160 of file spell.c.

◆ GETCHAR

#define GETCHAR	(	A,
		N,
		T
	)	GETWCHAR( (A)->repl, (A)->replen, N, T )

Definition at line 193 of file spell.c.

◆ GETWCHAR

#define GETWCHAR	(	W,
		L,
		N,
		T
	)	( ((const uint8*)(W))[ ((T)==FF_PREFIX) ? (N) : ( (L) - 1 - (N) ) ] )

Definition at line 192 of file spell.c.

◆ MAX_NORM

#define MAX_NORM 1024

Definition at line 188 of file spell.c.

◆ MAXNORMLEN

#define MAXNORMLEN 256

Definition at line 189 of file spell.c.

◆ PAE_INFIND

#define PAE_INFIND 3

Definition at line 777 of file spell.c.

◆ PAE_INMASK

#define PAE_INMASK 1

Definition at line 775 of file spell.c.

◆ PAE_INREPL

#define PAE_INREPL 5

Definition at line 779 of file spell.c.

◆ PAE_WAIT_FIND

#define PAE_WAIT_FIND 2

Definition at line 776 of file spell.c.

◆ PAE_WAIT_FLAG

#define PAE_WAIT_FLAG 7

Definition at line 781 of file spell.c.

◆ PAE_WAIT_MASK

#define PAE_WAIT_MASK 0

Definition at line 774 of file spell.c.

◆ PAE_WAIT_REPL

#define PAE_WAIT_REPL 4

Definition at line 778 of file spell.c.

◆ PAE_WAIT_TYPE

#define PAE_WAIT_TYPE 6

Definition at line 780 of file spell.c.

◆ STRNCMP

#define STRNCMP	(	s,
		p
	)	strncmp( (s), (p), strlen(p) )

Definition at line 191 of file spell.c.

◆ tmpalloc

#define tmpalloc ( sz ) MemoryContextAlloc(Conf->buildCxt, (sz))

Definition at line 80 of file spell.c.

◆ tmpalloc0

#define tmpalloc0 ( sz ) MemoryContextAllocZero(Conf->buildCxt, (sz))

Definition at line 81 of file spell.c.

Typedef Documentation

◆ SplitVar

typedef struct SplitVar SplitVar

Function Documentation

◆ addCompoundAffixFlagValue()

static void addCompoundAffixFlagValue	(	IspellDict *	Conf,
		char *	s,
		uint32	val
	)

static

Definition at line 1064 of file spell.c.

{
    CompoundAffixFlag *newValue;
    char        sbuf[BUFSIZ];
    char       *sflag;
 
    while (*s && isspace((unsigned char) *s))
        s += pg_mblen_cstr(s);
 
    if (!*s)
        ereport(ERROR,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("syntax error")));
 
    /* Get flag without \n */
    sflag = sbuf;
    while (*s && !isspace((unsigned char) *s) && *s != '\n')
    {
        int         clen = ts_copychar_cstr(sflag, s);
 
        sflag += clen;
        s += clen;
    }
    *sflag = '\0';
 
    /* Resize array or allocate memory for array CompoundAffixFlag */
    if (Conf->nCompoundAffixFlag >= Conf->mCompoundAffixFlag)
    {
        if (Conf->mCompoundAffixFlag)
        {
            Conf->mCompoundAffixFlag *= 2;
            Conf->CompoundAffixFlags = (CompoundAffixFlag *)
                repalloc(Conf->CompoundAffixFlags,
                         Conf->mCompoundAffixFlag * sizeof(CompoundAffixFlag));
        }
        else
        {
            Conf->mCompoundAffixFlag = 10;
            Conf->CompoundAffixFlags = (CompoundAffixFlag *)
                tmpalloc(Conf->mCompoundAffixFlag * sizeof(CompoundAffixFlag));
        }
    }
 
    newValue = Conf->CompoundAffixFlags + Conf->nCompoundAffixFlag;
 
    setCompoundAffixFlagValue(Conf, newValue, sbuf, val);
 
    Conf->usecompound = true;
    Conf->nCompoundAffixFlag++;
}

References ereport, errcode(), errmsg(), ERROR, fb(), pg_mblen_cstr(), repalloc(), setCompoundAffixFlagValue(), tmpalloc, ts_copychar_cstr(), and val.

Referenced by NIImportAffixes(), and NIImportOOAffixes().

◆ addNorm()

static void addNorm	(	TSLexeme **	lres,
		TSLexeme **	lcur,
		char *	word,
		int	flags,
		uint16	NVariant
	)

static

Definition at line 2522 of file spell.c.

{
    if (*lres == NULL)
        *lcur = *lres = palloc_array(TSLexeme, MAX_NORM);
 
    if (*lcur - *lres < MAX_NORM - 1)
    {
        (*lcur)->lexeme = word;
        (*lcur)->flags = flags;
        (*lcur)->nvariant = NVariant;
        (*lcur)++;
        (*lcur)->lexeme = NULL;
    }
}

References fb(), MAX_NORM, palloc_array, and word().

Referenced by NINormalizeWord().

◆ AddStem()

static void AddStem	(	SplitVar *	v,
		char *	word
	)

static

Definition at line 2359 of file spell.c.

{
    if (v->nstem >= v->lenstem)
    {
        v->lenstem *= 2;
        v->stem = (char **) repalloc(v->stem, sizeof(char *) * v->lenstem);
    }
 
    v->stem[v->nstem] = word;
    v->nstem++;
}

References SplitVar::lenstem, SplitVar::nstem, repalloc(), SplitVar::stem, and word().

Referenced by SplitToVariants().

◆ addToResult()

static int addToResult	(	char **	forms,
		char **	cur,
		char *	word
	)

static

Definition at line 2159 of file spell.c.

{
    if (cur - forms >= MAX_NORM - 1)
        return 0;
    if (forms == cur || strcmp(word, *(cur - 1)) != 0)
    {
        *cur = pstrdup(word);
        *(cur + 1) = NULL;
        return 1;
    }
 
    return 0;
}

References cur, fb(), MAX_NORM, pstrdup(), and word().

Referenced by NormalizeSubWord().

◆ CheckAffix()

static char * CheckAffix	(	const char *	word,
		size_t	len,
		AFFIX *	Affix,
		int	flagflags,
		char *	newword,
		int *	baselen
	)

static

Definition at line 2069 of file spell.c.

{
    /*
     * Check compound allow flags
     */
 
    if (flagflags == 0)
    {
        if (Affix->flagflags & FF_COMPOUNDONLY)
            return NULL;
    }
    else if (flagflags & FF_COMPOUNDBEGIN)
    {
        if (Affix->flagflags & FF_COMPOUNDFORBIDFLAG)
            return NULL;
        if ((Affix->flagflags & FF_COMPOUNDBEGIN) == 0)
            if (Affix->type == FF_SUFFIX)
                return NULL;
    }
    else if (flagflags & FF_COMPOUNDMIDDLE)
    {
        if ((Affix->flagflags & FF_COMPOUNDMIDDLE) == 0 ||
            (Affix->flagflags & FF_COMPOUNDFORBIDFLAG))
            return NULL;
    }
    else if (flagflags & FF_COMPOUNDLAST)
    {
        if (Affix->flagflags & FF_COMPOUNDFORBIDFLAG)
            return NULL;
        if ((Affix->flagflags & FF_COMPOUNDLAST) == 0)
            if (Affix->type == FF_PREFIX)
                return NULL;
    }
 
    /*
     * make replace pattern of affix
     */
    if (Affix->type == FF_SUFFIX)
    {
        strcpy(newword, word);
        strcpy(newword + len - Affix->replen, Affix->find);
        if (baselen)            /* store length of non-changed part of word */
            *baselen = len - Affix->replen;
    }
    else
    {
        /*
         * if prefix is an all non-changed part's length then all word
         * contains only prefix and suffix, so out
         */
        if (baselen && *baselen + strlen(Affix->find) <= Affix->replen)
            return NULL;
        strcpy(newword, Affix->find);
        strcat(newword, word + Affix->replen);
    }
 
    /*
     * check resulting word
     */
    if (Affix->issimple)
        return newword;
    else if (Affix->isregis)
    {
        if (RS_execute(&(Affix->reg.regis), newword))
            return newword;
    }
    else
    {
        pg_wchar   *data;
        size_t      data_len;
        int         newword_len;
 
        /* Convert data string to wide characters */
        newword_len = strlen(newword);
        data = palloc_array(pg_wchar, newword_len + 1);
        data_len = pg_mb2wchar_with_len(newword, data, newword_len);
 
        if (pg_regexec(Affix->reg.pregex, data, data_len,
                       0, NULL, 0, NULL, 0) == REG_OKAY)
        {
            pfree(data);
            return newword;
        }
        pfree(data);
    }
 
    return NULL;
}

References data, fb(), FF_COMPOUNDBEGIN, FF_COMPOUNDFORBIDFLAG, FF_COMPOUNDLAST, FF_COMPOUNDMIDDLE, FF_COMPOUNDONLY, FF_PREFIX, FF_SUFFIX, aff_struct::find, aff_struct::flagflags, aff_struct::isregis, aff_struct::issimple, len, palloc_array, pfree(), pg_mb2wchar_with_len(), pg_regexec(), aff_struct::pregex, aff_struct::reg, REG_OKAY, aff_struct::regis, aff_struct::replen, RS_execute(), aff_struct::type, and word().

Referenced by NormalizeSubWord().

◆ CheckCompoundAffixes()

static int CheckCompoundAffixes	(	CMPDAffix **	ptr,
		const char *	word,
		int	len,
		bool	CheckInPlace
	)

static

Definition at line 2292 of file spell.c.

{
    bool        issuffix;
 
    /* in case CompoundAffix is null: */
    if (*ptr == NULL)
        return -1;
 
    if (CheckInPlace)
    {
        while ((*ptr)->affix)
        {
            if (len > (*ptr)->len && strncmp((*ptr)->affix, word, (*ptr)->len) == 0)
            {
                len = (*ptr)->len;
                issuffix = (*ptr)->issuffix;
                (*ptr)++;
                return (issuffix) ? len : 0;
            }
            (*ptr)++;
        }
    }
    else
    {
        const char *affbegin;
 
        while ((*ptr)->affix)
        {
            if (len > (*ptr)->len && (affbegin = strstr(word, (*ptr)->affix)) != NULL)
            {
                len = (*ptr)->len + (affbegin - word);
                issuffix = (*ptr)->issuffix;
                (*ptr)++;
                return (issuffix) ? len : 0;
            }
            (*ptr)++;
        }
    }
    return -1;
}

References fb(), len, and word().

Referenced by SplitToVariants().

◆ cmpaffix()

static int cmpaffix	(	const void *	s1,
		const void *	s2
	)

static

Definition at line 312 of file spell.c.

{
    const AFFIX *a1 = (const AFFIX *) s1;
    const AFFIX *a2 = (const AFFIX *) s2;
 
    if (a1->type < a2->type)
        return -1;
    if (a1->type > a2->type)
        return 1;
    if (a1->type == FF_PREFIX)
        return strcmp(a1->repl, a2->repl);
    else
        return strbcmp((const unsigned char *) a1->repl,
                       (const unsigned char *) a2->repl);
}

References a1, a2, fb(), FF_PREFIX, s1, s2, and strbcmp().

Referenced by NISortAffixes().

◆ cmpcmdflag()

static int cmpcmdflag	(	const void *	f1,
		const void *	f2
	)

static

Definition at line 211 of file spell.c.

{
    const CompoundAffixFlag *fv1 = f1;
    const CompoundAffixFlag *fv2 = f2;
 
    Assert(fv1->flagMode == fv2->flagMode);
 
    if (fv1->flagMode == FM_NUM)
    {
        if (fv1->flag.i == fv2->flag.i)
            return 0;
 
        return (fv1->flag.i > fv2->flag.i) ? 1 : -1;
    }
 
    return strcmp(fv1->flag.s, fv2->flag.s);
}

References Assert, f1, f2, fb(), and FM_NUM.

Referenced by getCompoundAffixFlagValue(), and NIImportOOAffixes().

◆ cmpspell()

static int cmpspell	(	const void *	s1,
		const void *	s2
	)

static

Definition at line 198 of file spell.c.

{
    return strcmp((*(SPELL *const *) s1)->word, (*(SPELL *const *) s2)->word);
}

References fb(), s1, s2, and word().

Referenced by NISortDictionary().

◆ cmpspellaffix()

static int cmpspellaffix	(	const void *	s1,
		const void *	s2
	)

static

Definition at line 204 of file spell.c.

{
    return strcmp((*(SPELL *const *) s1)->p.flag,
                  (*(SPELL *const *) s2)->p.flag);
}

References fb(), s1, and s2.

Referenced by NISortDictionary().

◆ compact_palloc0()

static void * compact_palloc0	(	IspellDict *	Conf,
		size_t	size
	)

static

Definition at line 131 of file spell.c.

{
    void       *result;
 
    /* Should only be called during init */
    Assert(Conf->buildCxt != NULL);
 
    /* No point in this for large chunks */
    if (size > COMPACT_MAX_REQ)
        return palloc0(size);
 
    /* Keep everything maxaligned */
    size = MAXALIGN(size);
 
    /* Need more space? */
    if (size > Conf->avail)
    {
        Conf->firstfree = palloc0(COMPACT_ALLOC_CHUNK);
        Conf->avail = COMPACT_ALLOC_CHUNK;
    }
 
    result = Conf->firstfree;
    Conf->firstfree += size;
    Conf->avail -= size;
 
    return result;
}

References Assert, COMPACT_ALLOC_CHUNK, COMPACT_MAX_REQ, fb(), MAXALIGN, and palloc0().

◆ CopyVar()

static SplitVar * CopyVar	(	SplitVar *	s,
		int	makedup
	)

static

Definition at line 2334 of file spell.c.

{
    SplitVar   *v = palloc_object(SplitVar);
 
    v->next = NULL;
    if (s)
    {
        int         i;
 
        v->lenstem = s->lenstem;
        v->stem = palloc_array(char *, v->lenstem);
        v->nstem = s->nstem;
        for (i = 0; i < s->nstem; i++)
            v->stem[i] = (makedup) ? pstrdup(s->stem[i]) : s->stem[i];
    }
    else
    {
        v->lenstem = 16;
        v->stem = palloc_array(char *, v->lenstem);
        v->nstem = 0;
    }
    return v;
}

References fb(), i, SplitVar::lenstem, SplitVar::next, SplitVar::nstem, palloc_array, palloc_object, pstrdup(), and SplitVar::stem.

Referenced by SplitToVariants().

◆ cpstrdup()

static char * cpstrdup	(	IspellDict *	Conf,
		const char *	str
	)

static

Definition at line 163 of file spell.c.

{
    char       *res = cpalloc(strlen(str) + 1);
 
    strcpy(res, str);
    return res;
}

References cpalloc, fb(), and str.

Referenced by NIAddAffix(), NIAddSpell(), NIImportOOAffixes(), NISortDictionary(), and setCompoundAffixFlagValue().

◆ FindAffixes()

static AffixNodeData * FindAffixes	(	AffixNode *	node,
		const char *	word,
		int	wrdlen,
		int *	level,
		int	type
	)

static

Definition at line 2026 of file spell.c.

{
    AffixNodeData *StopLow,
               *StopHigh,
               *StopMiddle;
    uint8 symbol;
 
    if (node->isvoid)
    {                           /* search void affixes */
        if (node->data->naff)
            return node->data;
        node = node->data->node;
    }
 
    while (node && *level < wrdlen)
    {
        StopLow = node->data;
        StopHigh = node->data + node->length;
        while (StopLow < StopHigh)
        {
            StopMiddle = StopLow + ((StopHigh - StopLow) >> 1);
            symbol = GETWCHAR(word, wrdlen, *level, type);
 
            if (StopMiddle->val == symbol)
            {
                (*level)++;
                if (StopMiddle->naff)
                    return StopMiddle;
                node = StopMiddle->node;
                break;
            }
            else if (StopMiddle->val < symbol)
                StopLow = StopMiddle + 1;
            else
                StopHigh = StopMiddle;
        }
        if (StopLow >= StopHigh)
            break;
    }
    return NULL;
}

References AffixNode::data, fb(), GETWCHAR, AffixNode::isvoid, AffixNode::length, AffixNodeData::naff, AffixNodeData::node, type, and word().

Referenced by NormalizeSubWord().

◆ findchar()

static char * findchar	(	char *	str,
		int	c
	)

static

Definition at line 230 of file spell.c.

{
    while (*str)
    {
        if (t_iseq(str, c))
            return str;
        str += pg_mblen_cstr(str);
    }
 
    return NULL;
}

References fb(), pg_mblen_cstr(), str, and t_iseq.

Referenced by NIImportDictionary().

◆ findchar2()

static char * findchar2	(	char *	str,
		int	c1,
		int	c2
	)

static

Definition at line 243 of file spell.c.

{
    while (*str)
    {
        if (t_iseq(str, c1) || t_iseq(str, c2))
            return str;
        str += pg_mblen_cstr(str);
    }
 
    return NULL;
}

References fb(), pg_mblen_cstr(), str, and t_iseq.

Referenced by NIImportAffixes().

◆ FindWord()

static int FindWord	(	IspellDict *	Conf,
		const char *	word,
		const char *	affixflag,
		int	flag
	)

static

Definition at line 605 of file spell.c.

{
    SPNode     *node = Conf->Dictionary;
    SPNodeData *StopLow,
               *StopHigh,
               *StopMiddle;
    const uint8 *ptr = (const uint8 *) word;
 
    flag &= FF_COMPOUNDFLAGMASK;
 
    while (node && *ptr)
    {
        StopLow = node->data;
        StopHigh = node->data + node->length;
        while (StopLow < StopHigh)
        {
            StopMiddle = StopLow + ((StopHigh - StopLow) >> 1);
            if (StopMiddle->val == *ptr)
            {
                if (*(ptr + 1) == '\0' && StopMiddle->isword)
                {
                    if (flag == 0)
                    {
                        /*
                         * The word can be formed only with another word. And
                         * in the flag parameter there is not a sign that we
                         * search compound words.
                         */
                        if (StopMiddle->compoundflag & FF_COMPOUNDONLY)
                            return 0;
                    }
                    else if ((flag & StopMiddle->compoundflag) == 0)
                        return 0;
 
                    /*
                     * Check if this affix rule is presented in the affix set
                     * with index StopMiddle->affix.
                     */
                    if (IsAffixFlagInUse(Conf, StopMiddle->affix, affixflag))
                        return 1;
                }
                node = StopMiddle->node;
                ptr++;
                break;
            }
            else if (StopMiddle->val < *ptr)
                StopLow = StopMiddle + 1;
            else
                StopHigh = StopMiddle;
        }
        if (StopLow >= StopHigh)
            break;
    }
    return 0;
}

References SPNode::data, fb(), FF_COMPOUNDFLAGMASK, FF_COMPOUNDONLY, flag(), IsAffixFlagInUse(), SPNode::length, and word().

Referenced by NormalizeSubWord().

◆ get_nextfield()

static bool get_nextfield	(	char **	str,
		char *	next
	)

static

Definition at line 794 of file spell.c.

{
    int         state = PAE_WAIT_MASK;
    int         avail = BUFSIZ;
 
    while (**str)
    {
        int         clen = pg_mblen_cstr(*str);
 
        if (state == PAE_WAIT_MASK)
        {
            if (t_iseq(*str, '#'))
                return false;
            else if (!isspace((unsigned char) **str))
            {
                if (clen < avail)
                {
                    ts_copychar_with_len(next, *str, clen);
                    next += clen;
                    avail -= clen;
                }
                state = PAE_INMASK;
            }
        }
        else                    /* state == PAE_INMASK */
        {
            if (isspace((unsigned char) **str))
            {
                *next = '\0';
                return true;
            }
            else
            {
                if (clen < avail)
                {
                    ts_copychar_with_len(next, *str, clen);
                    next += clen;
                    avail -= clen;
                }
            }
        }
        *str += clen;
    }
 
    *next = '\0';
 
    return (state == PAE_INMASK);   /* OK if we got a nonempty field */
}

References fb(), next, PAE_INMASK, PAE_WAIT_MASK, pg_mblen_cstr(), str, t_iseq, and ts_copychar_with_len().

Referenced by parse_ooaffentry().

◆ getAffixFlagSet()

static const char * getAffixFlagSet	(	IspellDict *	Conf,
		char *	s
	)

static

Definition at line 1156 of file spell.c.

{
    if (Conf->useFlagAliases && *s != '\0')
    {
        int         curaffix;
        char       *end;
 
        errno = 0;
        curaffix = strtol(s, &end, 10);
        if (s == end || errno == ERANGE)
            ereport(ERROR,
                    (errcode(ERRCODE_CONFIG_FILE_ERROR),
                     errmsg("invalid affix alias \"%s\"", s)));
 
        if (curaffix > 0 && curaffix < Conf->nAffixData)
 
            /*
             * Do not subtract 1 from curaffix because empty string was added
             * in NIImportOOAffixes
             */
            return Conf->AffixData[curaffix];
        else if (curaffix > Conf->nAffixData)
            ereport(ERROR,
                    (errcode(ERRCODE_CONFIG_FILE_ERROR),
                     errmsg("invalid affix alias \"%s\"", s)));
        return VoidString;
    }
    else
        return s;
}

References ereport, errcode(), errmsg(), ERROR, fb(), and VoidString.

Referenced by NIImportOOAffixes().

◆ getCompoundAffixFlagValue()

static int getCompoundAffixFlagValue	(	IspellDict *	Conf,
		const char *	s
	)

static

Definition at line 1120 of file spell.c.

{
    uint32      flag = 0;
    CompoundAffixFlag *found,
                key;
    char        sflag[BUFSIZ];
    const char *flagcur;
 
    if (Conf->nCompoundAffixFlag == 0)
        return 0;
 
    flagcur = s;
    while (*flagcur)
    {
        getNextFlagFromString(Conf, &flagcur, sflag);
        setCompoundAffixFlagValue(Conf, &key, sflag, 0);
 
        found = (CompoundAffixFlag *)
            bsearch(&key, Conf->CompoundAffixFlags,
                    Conf->nCompoundAffixFlag, sizeof(CompoundAffixFlag),
                    cmpcmdflag);
        if (found != NULL)
            flag |= found->value;
    }
 
    return flag;
}

References cmpcmdflag(), fb(), flag(), getNextFlagFromString(), setCompoundAffixFlagValue(), and CompoundAffixFlag::value.

Referenced by makeCompoundFlags(), and NIImportOOAffixes().

◆ getNextFlagFromString()

static void getNextFlagFromString	(	IspellDict *	Conf,
		const char **	sflagset,
		char *	sflag
	)

static

Definition at line 350 of file spell.c.

{
    int32       s;
    char       *next;
    const char *sbuf = *sflagset;
    int         maxstep;
    int         clen;
    bool        stop = false;
    bool        met_comma = false;
 
    maxstep = (Conf->flagMode == FM_LONG) ? 2 : 1;
 
    while (**sflagset)
    {
        switch (Conf->flagMode)
        {
            case FM_LONG:
            case FM_CHAR:
                clen = ts_copychar_cstr(sflag, *sflagset);
                sflag += clen;
 
                /* Go to start of the next flag */
                *sflagset += clen;
 
                /* Check if we get all characters of flag */
                maxstep--;
                stop = (maxstep == 0);
                break;
            case FM_NUM:
                errno = 0;
                s = strtol(*sflagset, &next, 10);
                if (*sflagset == next || errno == ERANGE)
                    ereport(ERROR,
                            (errcode(ERRCODE_CONFIG_FILE_ERROR),
                             errmsg("invalid affix flag \"%s\"", *sflagset)));
                if (s < 0 || s > FLAGNUM_MAXSIZE)
                    ereport(ERROR,
                            (errcode(ERRCODE_CONFIG_FILE_ERROR),
                             errmsg("affix flag \"%s\" is out of range",
                                    *sflagset)));
                sflag += sprintf(sflag, "%0d", s);
 
                /* Go to start of the next flag */
                *sflagset = next;
                while (**sflagset)
                {
                    if (isdigit((unsigned char) **sflagset))
                    {
                        if (!met_comma)
                            ereport(ERROR,
                                    (errcode(ERRCODE_CONFIG_FILE_ERROR),
                                     errmsg("invalid affix flag \"%s\"",
                                            *sflagset)));
                        break;
                    }
                    else if (t_iseq(*sflagset, ','))
                    {
                        if (met_comma)
                            ereport(ERROR,
                                    (errcode(ERRCODE_CONFIG_FILE_ERROR),
                                     errmsg("invalid affix flag \"%s\"",
                                            *sflagset)));
                        met_comma = true;
                    }
                    else if (!isspace((unsigned char) **sflagset))
                    {
                        ereport(ERROR,
                                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                                 errmsg("invalid character in affix flag \"%s\"",
                                        *sflagset)));
                    }
 
                    *sflagset += pg_mblen_cstr(*sflagset);
                }
                stop = true;
                break;
            default:
                elog(ERROR, "unrecognized type of Conf->flagMode: %d",
                     Conf->flagMode);
        }
 
        if (stop)
            break;
    }
 
    if (Conf->flagMode == FM_LONG && maxstep > 0)
        ereport(ERROR,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("invalid affix flag \"%s\" with \"long\" flag value",
                        sbuf)));
 
    *sflag = '\0';
}

References elog, ereport, errcode(), errmsg(), ERROR, fb(), FLAGNUM_MAXSIZE, FM_CHAR, FM_LONG, FM_NUM, next, pg_mblen_cstr(), sprintf, t_iseq, and ts_copychar_cstr().

Referenced by getCompoundAffixFlagValue(), and IsAffixFlagInUse().

◆ IsAffixFlagInUse()

static bool IsAffixFlagInUse	(	IspellDict *	Conf,
		int	affix,
		const char *	affixflag
	)

static

Definition at line 457 of file spell.c.

{
    const char *flagcur;
    char        flag[BUFSIZ];
 
    if (*affixflag == 0)
        return true;
 
    Assert(affix < Conf->nAffixData);
 
    flagcur = Conf->AffixData[affix];
 
    while (*flagcur)
    {
        getNextFlagFromString(Conf, &flagcur, flag);
        /* Compare first affix flag in flagcur with affixflag */
        if (strcmp(flag, affixflag) == 0)
            return true;
    }
 
    /* Could not find affixflag */
    return false;
}

References Assert, fb(), flag(), and getNextFlagFromString().

Referenced by FindWord(), and isAffixInUse().

◆ isAffixInUse()

static bool isAffixInUse	(	IspellDict *	Conf,
		const char *	affixflag
	)

static

Definition at line 1959 of file spell.c.

{
    int         i;
 
    for (i = 0; i < Conf->nAffixData; i++)
        if (IsAffixFlagInUse(Conf, i, affixflag))
            return true;
 
    return false;
}

References fb(), i, and IsAffixFlagInUse().

Referenced by NISortAffixes().

◆ lowerstr_ctx()

static char * lowerstr_ctx	(	IspellDict *	Conf,
		const char *	src
	)

static

Definition at line 176 of file spell.c.

{
    MemoryContext saveCtx;
    char       *dst;
 
    saveCtx = MemoryContextSwitchTo(Conf->buildCxt);
    dst = str_tolower(src, strlen(src), DEFAULT_COLLATION_OID);
    MemoryContextSwitchTo(saveCtx);
 
    return dst;
}

References fb(), MemoryContextSwitchTo(), and str_tolower().

Referenced by NIImportDictionary(), and NIImportOOAffixes().

◆ makeCompoundFlags()

static uint32 makeCompoundFlags	(	IspellDict *	Conf,
		int	affix
	)

static

Definition at line 1620 of file spell.c.

{
    Assert(affix < Conf->nAffixData);
 
    return (getCompoundAffixFlagValue(Conf, Conf->AffixData[affix]) &
            FF_COMPOUNDFLAGMASK);
}

References Assert, fb(), FF_COMPOUNDFLAGMASK, and getCompoundAffixFlagValue().

Referenced by mkSPNode().

◆ MergeAffix()

static int MergeAffix	(	IspellDict *	Conf,
		int	a1,
		int	a2
	)

static

Definition at line 1569 of file spell.c.

{
    const char **ptr;
 
    Assert(a1 < Conf->nAffixData && a2 < Conf->nAffixData);
 
    /* Do not merge affix flags if one of affix flags is empty */
    if (*Conf->AffixData[a1] == '\0')
        return a2;
    else if (*Conf->AffixData[a2] == '\0')
        return a1;
 
    /* Double the size of AffixData if there's not enough space */
    if (Conf->nAffixData + 1 >= Conf->lenAffixData)
    {
        Conf->lenAffixData *= 2;
        Conf->AffixData = (const char **) repalloc(Conf->AffixData,
                                                   sizeof(char *) * Conf->lenAffixData);
    }
 
    ptr = Conf->AffixData + Conf->nAffixData;
    if (Conf->flagMode == FM_NUM)
    {
        char       *p = cpalloc(strlen(Conf->AffixData[a1]) +
                                strlen(Conf->AffixData[a2]) +
                                1 /* comma */ + 1 /* \0 */ );
 
        sprintf(p, "%s,%s", Conf->AffixData[a1], Conf->AffixData[a2]);
        *ptr = p;
    }
    else
    {
        char       *p = cpalloc(strlen(Conf->AffixData[a1]) +
                                strlen(Conf->AffixData[a2]) +
                                1 /* \0 */ );
 
        sprintf(p, "%s%s", Conf->AffixData[a1], Conf->AffixData[a2]);
        *ptr = p;
    }
    ptr++;
    *ptr = NULL;
    Conf->nAffixData++;
 
    return Conf->nAffixData - 1;
}

References a1, a2, Assert, cpalloc, fb(), FM_NUM, repalloc(), and sprintf.

Referenced by mkSPNode().

◆ mkANode()

static AffixNode * mkANode	(	IspellDict *	Conf,
		int	low,
		int	high,
		int	level,
		int	type
	)

static

Definition at line 1828 of file spell.c.

{
    int         i;
    int         nchar = 0;
    uint8       lastchar = '\0';
    AffixNode  *rs;
    AffixNodeData *data;
    int         lownew = low;
    int         naff;
    AFFIX     **aff;
 
    for (i = low; i < high; i++)
        if (Conf->Affix[i].replen > level && lastchar != GETCHAR(Conf->Affix + i, level, type))
        {
            nchar++;
            lastchar = GETCHAR(Conf->Affix + i, level, type);
        }
 
    if (!nchar)
        return NULL;
 
    aff = (AFFIX **) tmpalloc(sizeof(AFFIX *) * (high - low + 1));
    naff = 0;
 
    rs = (AffixNode *) cpalloc0(ANHRDSZ + nchar * sizeof(AffixNodeData));
    rs->length = nchar;
    data = rs->data;
 
    lastchar = '\0';
    for (i = low; i < high; i++)
        if (Conf->Affix[i].replen > level)
        {
            if (lastchar != GETCHAR(Conf->Affix + i, level, type))
            {
                if (lastchar)
                {
                    /* Next level of the prefix tree */
                    data->node = mkANode(Conf, lownew, i, level + 1, type);
                    if (naff)
                    {
                        data->naff = naff;
                        data->aff = (AFFIX **) cpalloc(sizeof(AFFIX *) * naff);
                        memcpy(data->aff, aff, sizeof(AFFIX *) * naff);
                        naff = 0;
                    }
                    data++;
                    lownew = i;
                }
                lastchar = GETCHAR(Conf->Affix + i, level, type);
            }
            data->val = GETCHAR(Conf->Affix + i, level, type);
            if (Conf->Affix[i].replen == level + 1)
            {                   /* affix stopped */
                aff[naff++] = Conf->Affix + i;
            }
        }
 
    /* Next level of the prefix tree */
    data->node = mkANode(Conf, lownew, high, level + 1, type);
    if (naff)
    {
        data->naff = naff;
        data->aff = (AFFIX **) cpalloc(sizeof(AFFIX *) * naff);
        memcpy(data->aff, aff, sizeof(AFFIX *) * naff);
        naff = 0;
    }
 
    pfree(aff);
 
    return rs;
}

References ANHRDSZ, cpalloc, cpalloc0, AffixNode::data, data, fb(), GETCHAR, i, AffixNode::length, mkANode(), AffixNodeData::node, pfree(), tmpalloc, and type.

Referenced by mkANode(), and NISortAffixes().

◆ mkSPNode()

static SPNode * mkSPNode	(	IspellDict *	Conf,
		int	low,
		int	high,
		int	level
	)

static

Definition at line 1637 of file spell.c.

{
    int         i;
    int         nchar = 0;
    char        lastchar = '\0';
    SPNode     *rs;
    SPNodeData *data;
    int         lownew = low;
 
    for (i = low; i < high; i++)
        if (Conf->Spell[i]->p.d.len > level && lastchar != Conf->Spell[i]->word[level])
        {
            nchar++;
            lastchar = Conf->Spell[i]->word[level];
        }
 
    if (!nchar)
        return NULL;
 
    rs = (SPNode *) cpalloc0(SPNHDRSZ + nchar * sizeof(SPNodeData));
    rs->length = nchar;
    data = rs->data;
 
    lastchar = '\0';
    for (i = low; i < high; i++)
        if (Conf->Spell[i]->p.d.len > level)
        {
            if (lastchar != Conf->Spell[i]->word[level])
            {
                if (lastchar)
                {
                    /* Next level of the prefix tree */
                    data->node = mkSPNode(Conf, lownew, i, level + 1);
                    lownew = i;
                    data++;
                }
                lastchar = Conf->Spell[i]->word[level];
            }
            data->val = ((uint8 *) (Conf->Spell[i]->word))[level];
            if (Conf->Spell[i]->p.d.len == level + 1)
            {
                bool        clearCompoundOnly = false;
 
                if (data->isword && data->affix != Conf->Spell[i]->p.d.affix)
                {
                    /*
                     * MergeAffix called a few times. If one of word is
                     * allowed to be in compound word and another isn't, then
                     * clear FF_COMPOUNDONLY flag.
                     */
 
                    clearCompoundOnly = (FF_COMPOUNDONLY & data->compoundflag
                                         & makeCompoundFlags(Conf, Conf->Spell[i]->p.d.affix))
                        ? false : true;
                    data->affix = MergeAffix(Conf, data->affix, Conf->Spell[i]->p.d.affix);
                }
                else
                    data->affix = Conf->Spell[i]->p.d.affix;
                data->isword = 1;
 
                data->compoundflag = makeCompoundFlags(Conf, data->affix);
 
                if ((data->compoundflag & FF_COMPOUNDONLY) &&
                    (data->compoundflag & FF_COMPOUNDFLAG) == 0)
                    data->compoundflag |= FF_COMPOUNDFLAG;
 
                if (clearCompoundOnly)
                    data->compoundflag &= ~FF_COMPOUNDONLY;
            }
        }
 
    /* Next level of the prefix tree */
    data->node = mkSPNode(Conf, lownew, high, level + 1);
 
    return rs;
}

References cpalloc0, SPNode::data, data, fb(), FF_COMPOUNDFLAG, FF_COMPOUNDONLY, i, SPNode::length, makeCompoundFlags(), MergeAffix(), mkSPNode(), SPNodeData::node, and SPNHDRSZ.

Referenced by mkSPNode(), and NISortDictionary().

◆ mkVoidAffix()

static void mkVoidAffix	(	IspellDict *	Conf,
		bool	issuffix,
		int	startsuffix
	)

static

Definition at line 1905 of file spell.c.

{
    int         i,
                cnt = 0;
    int         start = (issuffix) ? startsuffix : 0;
    int         end = (issuffix) ? Conf->naffixes : startsuffix;
    AffixNode  *Affix = (AffixNode *) palloc0(ANHRDSZ + sizeof(AffixNodeData));
 
    Affix->length = 1;
    Affix->isvoid = 1;
 
    if (issuffix)
    {
        Affix->data->node = Conf->Suffix;
        Conf->Suffix = Affix;
    }
    else
    {
        Affix->data->node = Conf->Prefix;
        Conf->Prefix = Affix;
    }
 
    /* Count affixes with empty replace string */
    for (i = start; i < end; i++)
        if (Conf->Affix[i].replen == 0)
            cnt++;
 
    /* There is not affixes with empty replace string */
    if (cnt == 0)
        return;
 
    Affix->data->aff = (AFFIX **) cpalloc(sizeof(AFFIX *) * cnt);
    Affix->data->naff = (uint32) cnt;
 
    cnt = 0;
    for (i = start; i < end; i++)
        if (Conf->Affix[i].replen == 0)
        {
            Affix->data->aff[cnt] = Conf->Affix + i;
            cnt++;
        }
}

References AffixNodeData::aff, ANHRDSZ, cpalloc, AffixNode::data, fb(), i, AffixNode::isvoid, AffixNode::length, AffixNodeData::naff, AffixNodeData::node, palloc0(), and start.

Referenced by NISortAffixes().

◆ NIAddAffix()

static void NIAddAffix	(	IspellDict *	Conf,
		const char *	flag,
		char	flagflags,
		const char *	mask,
		const char *	find,
		const char *	repl,
		int	type
	)

static

Definition at line 680 of file spell.c.

{
    AFFIX      *Affix;
 
    if (Conf->naffixes >= Conf->maffixes)
    {
        if (Conf->maffixes)
        {
            Conf->maffixes *= 2;
            Conf->Affix = (AFFIX *) repalloc(Conf->Affix, Conf->maffixes * sizeof(AFFIX));
        }
        else
        {
            Conf->maffixes = 16;
            Conf->Affix = palloc_array(AFFIX, Conf->maffixes);
        }
    }
 
    Affix = Conf->Affix + Conf->naffixes;
 
    /* This affix rule can be applied for words with any ending */
    if (strcmp(mask, ".") == 0 || *mask == '\0')
    {
        Affix->issimple = 1;
        Affix->isregis = 0;
    }
    /* This affix rule will use regis to search word ending */
    else if (RS_isRegis(mask))
    {
        Affix->issimple = 0;
        Affix->isregis = 1;
        RS_compile(&(Affix->reg.regis), (type == FF_SUFFIX),
                   *mask ? mask : VoidString);
    }
    /* This affix rule will use regex_t to search word ending */
    else
    {
        int         masklen;
        int         wmasklen;
        int         err;
        pg_wchar   *wmask;
        char       *tmask;
 
        Affix->issimple = 0;
        Affix->isregis = 0;
        tmask = (char *) tmpalloc(strlen(mask) + 3);
        if (type == FF_SUFFIX)
            sprintf(tmask, "%s$", mask);
        else
            sprintf(tmask, "^%s", mask);
 
        masklen = strlen(tmask);
        wmask = (pg_wchar *) tmpalloc((masklen + 1) * sizeof(pg_wchar));
        wmasklen = pg_mb2wchar_with_len(tmask, wmask, masklen);
 
        /*
         * The regex and all internal state created by pg_regcomp are
         * allocated in the dictionary's memory context, and will be freed
         * automatically when it is destroyed.
         */
        Affix->reg.pregex = palloc_object(regex_t);
        err = pg_regcomp(Affix->reg.pregex, wmask, wmasklen,
                         REG_ADVANCED | REG_NOSUB,
                         DEFAULT_COLLATION_OID);
        if (err)
        {
            char        errstr[100];
 
            pg_regerror(err, Affix->reg.pregex, errstr, sizeof(errstr));
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
                     errmsg("invalid regular expression: %s", errstr)));
        }
    }
 
    Affix->flagflags = flagflags;
    if ((Affix->flagflags & FF_COMPOUNDONLY) || (Affix->flagflags & FF_COMPOUNDPERMITFLAG))
    {
        if ((Affix->flagflags & FF_COMPOUNDFLAG) == 0)
            Affix->flagflags |= FF_COMPOUNDFLAG;
    }
    Affix->flag = cpstrdup(Conf, flag);
    Affix->type = type;
 
    Affix->find = (find && *find) ? cpstrdup(Conf, find) : VoidString;
    if ((Affix->replen = strlen(repl)) > 0)
        Affix->repl = cpstrdup(Conf, repl);
    else
        Affix->repl = VoidString;
    Conf->naffixes++;
}

References cpstrdup(), ereport, err(), errcode(), errmsg(), ERROR, fb(), FF_COMPOUNDFLAG, FF_COMPOUNDONLY, FF_COMPOUNDPERMITFLAG, FF_SUFFIX, find(), aff_struct::find, aff_struct::flag, flag(), aff_struct::flagflags, aff_struct::isregis, aff_struct::issimple, palloc_array, palloc_object, pg_mb2wchar_with_len(), pg_regcomp(), pg_regerror(), aff_struct::pregex, aff_struct::reg, REG_ADVANCED, REG_NOSUB, regex_t, aff_struct::regis, repalloc(), aff_struct::repl, aff_struct::replen, RS_compile(), RS_isRegis(), sprintf, tmpalloc, type, aff_struct::type, and VoidString.

Referenced by NIImportAffixes(), and NIImportOOAffixes().

◆ NIAddSpell()

static void NIAddSpell	(	IspellDict *	Conf,
		const char *	word,
		const char *	flag
	)

static

Definition at line 489 of file spell.c.

{
    if (Conf->nspell >= Conf->mspell)
    {
        if (Conf->mspell)
        {
            Conf->mspell *= 2;
            Conf->Spell = (SPELL **) repalloc(Conf->Spell, Conf->mspell * sizeof(SPELL *));
        }
        else
        {
            Conf->mspell = 1024 * 20;
            Conf->Spell = (SPELL **) tmpalloc(Conf->mspell * sizeof(SPELL *));
        }
    }
    Conf->Spell[Conf->nspell] = (SPELL *) tmpalloc(SPELLHDRSZ + strlen(word) + 1);
    strcpy(Conf->Spell[Conf->nspell]->word, word);
    Conf->Spell[Conf->nspell]->p.flag = (*flag != '\0')
        ? cpstrdup(Conf, flag) : VoidString;
    Conf->nspell++;
}

References cpstrdup(), fb(), flag(), repalloc(), SPELLHDRSZ, tmpalloc, VoidString, and word().

Referenced by NIImportDictionary().

◆ NIFinishBuild()

void NIFinishBuild ( IspellDict * Conf )

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
	)

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
	)

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().

◆ NIImportOOAffixes()

static void NIImportOOAffixes	(	IspellDict *	Conf,
		const char *	filename
	)

static

Definition at line 1194 of file spell.c.

{
    char        type[BUFSIZ],
               *ptype = NULL;
    char        sflag[BUFSIZ];
    char        mask[BUFSIZ],
               *pmask;
    char        find[BUFSIZ],
               *pfind;
    char        repl[BUFSIZ],
               *prepl;
    bool        isSuffix = false;
    int         naffix = 0,
                curaffix = 0;
    int         sflaglen = 0;
    char        flagflags = 0;
    tsearch_readline_state trst;
    char       *recoded;
 
    /* read file to find any flag */
    Conf->usecompound = false;
    Conf->useFlagAliases = false;
    Conf->flagMode = FM_CHAR;
 
    if (!tsearch_readline_begin(&trst, filename))
        ereport(ERROR,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("could not open affix file \"%s\": %m",
                        filename)));
 
    while ((recoded = tsearch_readline(&trst)) != NULL)
    {
        if (*recoded == '\0' || isspace((unsigned char) *recoded) || t_iseq(recoded, '#'))
        {
            pfree(recoded);
            continue;
        }
 
        if (STRNCMP(recoded, "COMPOUNDFLAG") == 0)
            addCompoundAffixFlagValue(Conf, recoded + strlen("COMPOUNDFLAG"),
                                      FF_COMPOUNDFLAG);
        else if (STRNCMP(recoded, "COMPOUNDBEGIN") == 0)
            addCompoundAffixFlagValue(Conf, recoded + strlen("COMPOUNDBEGIN"),
                                      FF_COMPOUNDBEGIN);
        else if (STRNCMP(recoded, "COMPOUNDLAST") == 0)
            addCompoundAffixFlagValue(Conf, recoded + strlen("COMPOUNDLAST"),
                                      FF_COMPOUNDLAST);
        /* COMPOUNDLAST and COMPOUNDEND are synonyms */
        else if (STRNCMP(recoded, "COMPOUNDEND") == 0)
            addCompoundAffixFlagValue(Conf, recoded + strlen("COMPOUNDEND"),
                                      FF_COMPOUNDLAST);
        else if (STRNCMP(recoded, "COMPOUNDMIDDLE") == 0)
            addCompoundAffixFlagValue(Conf, recoded + strlen("COMPOUNDMIDDLE"),
                                      FF_COMPOUNDMIDDLE);
        else if (STRNCMP(recoded, "ONLYINCOMPOUND") == 0)
            addCompoundAffixFlagValue(Conf, recoded + strlen("ONLYINCOMPOUND"),
                                      FF_COMPOUNDONLY);
        else if (STRNCMP(recoded, "COMPOUNDPERMITFLAG") == 0)
            addCompoundAffixFlagValue(Conf,
                                      recoded + strlen("COMPOUNDPERMITFLAG"),
                                      FF_COMPOUNDPERMITFLAG);
        else if (STRNCMP(recoded, "COMPOUNDFORBIDFLAG") == 0)
            addCompoundAffixFlagValue(Conf,
                                      recoded + strlen("COMPOUNDFORBIDFLAG"),
                                      FF_COMPOUNDFORBIDFLAG);
        else if (STRNCMP(recoded, "FLAG") == 0)
        {
            char       *s = recoded + strlen("FLAG");
 
            while (*s && isspace((unsigned char) *s))
                s += pg_mblen_cstr(s);
 
            if (*s)
            {
                if (STRNCMP(s, "long") == 0)
                    Conf->flagMode = FM_LONG;
                else if (STRNCMP(s, "num") == 0)
                    Conf->flagMode = FM_NUM;
                else if (STRNCMP(s, "default") != 0)
                    ereport(ERROR,
                            (errcode(ERRCODE_CONFIG_FILE_ERROR),
                             errmsg("Ispell dictionary supports only "
                                    "\"default\", \"long\", "
                                    "and \"num\" flag values")));
            }
        }
 
        pfree(recoded);
    }
    tsearch_readline_end(&trst);
 
    if (Conf->nCompoundAffixFlag > 1)
        qsort(Conf->CompoundAffixFlags, Conf->nCompoundAffixFlag,
              sizeof(CompoundAffixFlag), cmpcmdflag);
 
    if (!tsearch_readline_begin(&trst, filename))
        ereport(ERROR,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("could not open affix file \"%s\": %m",
                        filename)));
 
    while ((recoded = tsearch_readline(&trst)) != NULL)
    {
        int         fields_read;
 
        if (*recoded == '\0' || isspace((unsigned char) *recoded) || t_iseq(recoded, '#'))
            goto nextline;
 
        fields_read = parse_ooaffentry(recoded, type, sflag, find, repl, mask);
 
        if (ptype)
            pfree(ptype);
        ptype = lowerstr_ctx(Conf, type);
 
        /* First try to parse AF parameter (alias compression) */
        if (STRNCMP(ptype, "af") == 0)
        {
            /* First line is the number of aliases */
            if (!Conf->useFlagAliases)
            {
                Conf->useFlagAliases = true;
                naffix = atoi(sflag);
                if (naffix <= 0)
                    ereport(ERROR,
                            (errcode(ERRCODE_CONFIG_FILE_ERROR),
                             errmsg("invalid number of flag vector aliases")));
 
                /* Also reserve place for empty flag set */
                naffix++;
 
                Conf->AffixData = palloc0_array(const char *, naffix);
                Conf->lenAffixData = Conf->nAffixData = naffix;
 
                /* Add empty flag set into AffixData */
                Conf->AffixData[curaffix] = VoidString;
                curaffix++;
            }
            /* Other lines are aliases */
            else
            {
                if (curaffix < naffix)
                {
                    Conf->AffixData[curaffix] = cpstrdup(Conf, sflag);
                    curaffix++;
                }
                else
                    ereport(ERROR,
                            (errcode(ERRCODE_CONFIG_FILE_ERROR),
                             errmsg("number of aliases exceeds specified number %d",
                                    naffix - 1)));
            }
            goto nextline;
        }
        /* Else try to parse prefixes and suffixes */
        if (fields_read < 4 ||
            (STRNCMP(ptype, "sfx") != 0 && STRNCMP(ptype, "pfx") != 0))
            goto nextline;
 
        sflaglen = strlen(sflag);
        if (sflaglen == 0
            || (sflaglen > 1 && Conf->flagMode == FM_CHAR)
            || (sflaglen > 2 && Conf->flagMode == FM_LONG))
            goto nextline;
 
        /*--------
         * Affix header. For example:
         * SFX \ N 1
         *--------
         */
        if (fields_read == 4)
        {
            isSuffix = (STRNCMP(ptype, "sfx") == 0);
            if (t_iseq(find, 'y') || t_iseq(find, 'Y'))
                flagflags = FF_CROSSPRODUCT;
            else
                flagflags = 0;
        }
        /*--------
         * Affix fields. For example:
         * SFX \   0    Y/L [^Y]
         *--------
         */
        else
        {
            char       *ptr;
            int         aflg = 0;
 
            /* Get flags after '/' (flags are case sensitive) */
            if ((ptr = strchr(repl, '/')) != NULL)
                aflg |= getCompoundAffixFlagValue(Conf,
                                                  getAffixFlagSet(Conf,
                                                                  ptr + 1));
            /* Get lowercased version of string before '/' */
            prepl = lowerstr_ctx(Conf, repl);
            if ((ptr = strchr(prepl, '/')) != NULL)
                *ptr = '\0';
            pfind = lowerstr_ctx(Conf, find);
            pmask = lowerstr_ctx(Conf, mask);
            if (t_iseq(find, '0'))
                *pfind = '\0';
            if (t_iseq(repl, '0'))
                *prepl = '\0';
 
            NIAddAffix(Conf, sflag, flagflags | aflg, pmask, pfind, prepl,
                       isSuffix ? FF_SUFFIX : FF_PREFIX);
            pfree(prepl);
            pfree(pfind);
            pfree(pmask);
        }
 
nextline:
        pfree(recoded);
    }
 
    tsearch_readline_end(&trst);
    if (ptype)
        pfree(ptype);
}

References addCompoundAffixFlagValue(), cmpcmdflag(), cpstrdup(), ereport, errcode(), errmsg(), ERROR, fb(), FF_COMPOUNDBEGIN, FF_COMPOUNDFLAG, FF_COMPOUNDFORBIDFLAG, FF_COMPOUNDLAST, FF_COMPOUNDMIDDLE, FF_COMPOUNDONLY, FF_COMPOUNDPERMITFLAG, FF_CROSSPRODUCT, FF_PREFIX, FF_SUFFIX, filename, find(), FM_CHAR, FM_LONG, FM_NUM, getAffixFlagSet(), getCompoundAffixFlagValue(), lowerstr_ctx(), NIAddAffix(), palloc0_array, parse_ooaffentry(), pfree(), pg_mblen_cstr(), qsort, STRNCMP, t_iseq, tsearch_readline(), tsearch_readline_begin(), tsearch_readline_end(), type, and VoidString.

Referenced by NIImportAffixes().

◆ NINormalizeWord()

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

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 )

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 )

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 )

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().

◆ NormalizeSubWord()

static char ** NormalizeSubWord	(	IspellDict *	Conf,
		const char *	word,
		int	flag
	)

static

Definition at line 2174 of file spell.c.

{
    AffixNodeData *suffix = NULL,
               *prefix = NULL;
    int         slevel = 0,
                plevel = 0;
    int         wrdlen = strlen(word),
                swrdlen;
    char      **forms;
    char      **cur;
    char        newword[2 * MAXNORMLEN] = "";
    char        pnewword[2 * MAXNORMLEN] = "";
    AffixNode  *snode = Conf->Suffix,
               *pnode;
    int         i,
                j;
 
    if (wrdlen > MAXNORMLEN)
        return NULL;
    cur = forms = palloc_array(char *, MAX_NORM);
    *cur = NULL;
 
 
    /* Check that the word itself is normal form */
    if (FindWord(Conf, word, VoidString, flag))
    {
        *cur = pstrdup(word);
        cur++;
        *cur = NULL;
    }
 
    /* Find all other NORMAL forms of the 'word' (check only prefix) */
    pnode = Conf->Prefix;
    plevel = 0;
    while (pnode)
    {
        prefix = FindAffixes(pnode, word, wrdlen, &plevel, FF_PREFIX);
        if (!prefix)
            break;
        for (j = 0; j < prefix->naff; j++)
        {
            if (CheckAffix(word, wrdlen, prefix->aff[j], flag, newword, NULL))
            {
                /* prefix success */
                if (FindWord(Conf, newword, prefix->aff[j]->flag, flag))
                    cur += addToResult(forms, cur, newword);
            }
        }
        pnode = prefix->node;
    }
 
    /*
     * Find all other NORMAL forms of the 'word' (check suffix and then
     * prefix)
     */
    while (snode)
    {
        int         baselen = 0;
 
        /* find possible suffix */
        suffix = FindAffixes(snode, word, wrdlen, &slevel, FF_SUFFIX);
        if (!suffix)
            break;
        /* foreach suffix check affix */
        for (i = 0; i < suffix->naff; i++)
        {
            if (CheckAffix(word, wrdlen, suffix->aff[i], flag, newword, &baselen))
            {
                /* suffix success */
                if (FindWord(Conf, newword, suffix->aff[i]->flag, flag))
                    cur += addToResult(forms, cur, newword);
 
                /* now we will look changed word with prefixes */
                pnode = Conf->Prefix;
                plevel = 0;
                swrdlen = strlen(newword);
                while (pnode)
                {
                    prefix = FindAffixes(pnode, newword, swrdlen, &plevel, FF_PREFIX);
                    if (!prefix)
                        break;
                    for (j = 0; j < prefix->naff; j++)
                    {
                        if (CheckAffix(newword, swrdlen, prefix->aff[j], flag, pnewword, &baselen))
                        {
                            /* prefix success */
                            const char *ff = (prefix->aff[j]->flagflags & suffix->aff[i]->flagflags & FF_CROSSPRODUCT) ?
                                VoidString : prefix->aff[j]->flag;
 
                            if (FindWord(Conf, pnewword, ff, flag))
                                cur += addToResult(forms, cur, pnewword);
                        }
                    }
                    pnode = prefix->node;
                }
            }
        }
 
        snode = suffix->node;
    }
 
    if (cur == forms)
    {
        pfree(forms);
        return NULL;
    }
    return forms;
}

References addToResult(), AffixNodeData::aff, CheckAffix(), cur, fb(), FF_CROSSPRODUCT, FF_PREFIX, FF_SUFFIX, FindAffixes(), FindWord(), aff_struct::flag, flag(), aff_struct::flagflags, i, j, MAX_NORM, MAXNORMLEN, AffixNodeData::naff, AffixNodeData::node, palloc_array, pfree(), pstrdup(), VoidString, and word().

Referenced by NINormalizeWord(), and SplitToVariants().

◆ parse_affentry()

static bool parse_affentry	(	char *	str,
		char *	mask,
		char *	find,
		char *	repl
	)

static

Definition at line 914 of file spell.c.

{
    int         state = PAE_WAIT_MASK;
    char       *pmask = mask,
               *pfind = find,
               *prepl = repl;
 
    *mask = *find = *repl = '\0';
 
    while (*str)
    {
        int         clen = pg_mblen_cstr(str);
 
        if (state == PAE_WAIT_MASK)
        {
            if (t_iseq(str, '#'))
                return false;
            else if (!isspace((unsigned char) *str))
            {
                pmask += ts_copychar_with_len(pmask, str, clen);
                state = PAE_INMASK;
            }
        }
        else if (state == PAE_INMASK)
        {
            if (t_iseq(str, '>'))
            {
                *pmask = '\0';
                state = PAE_WAIT_FIND;
            }
            else if (!isspace((unsigned char) *str))
            {
                pmask += ts_copychar_with_len(pmask, str, clen);
            }
        }
        else if (state == PAE_WAIT_FIND)
        {
            if (t_iseq(str, '-'))
            {
                state = PAE_INFIND;
            }
            else if (t_isalpha_cstr(str) || t_iseq(str, '\'') /* english 's */ )
            {
                prepl += ts_copychar_with_len(prepl, str, clen);
                state = PAE_INREPL;
            }
            else if (!isspace((unsigned char) *str))
                ereport(ERROR,
                        (errcode(ERRCODE_CONFIG_FILE_ERROR),
                         errmsg("syntax error")));
        }
        else if (state == PAE_INFIND)
        {
            if (t_iseq(str, ','))
            {
                *pfind = '\0';
                state = PAE_WAIT_REPL;
            }
            else if (t_isalpha_cstr(str))
            {
                pfind += ts_copychar_with_len(pfind, str, clen);
            }
            else if (!isspace((unsigned char) *str))
                ereport(ERROR,
                        (errcode(ERRCODE_CONFIG_FILE_ERROR),
                         errmsg("syntax error")));
        }
        else if (state == PAE_WAIT_REPL)
        {
            if (t_iseq(str, '-'))
            {
                break;          /* void repl */
            }
            else if (t_isalpha_cstr(str))
            {
                prepl += ts_copychar_with_len(prepl, str, clen);
                state = PAE_INREPL;
            }
            else if (!isspace((unsigned char) *str))
                ereport(ERROR,
                        (errcode(ERRCODE_CONFIG_FILE_ERROR),
                         errmsg("syntax error")));
        }
        else if (state == PAE_INREPL)
        {
            if (t_iseq(str, '#'))
            {
                *prepl = '\0';
                break;
            }
            else if (t_isalpha_cstr(str))
            {
                prepl += ts_copychar_with_len(prepl, str, clen);
            }
            else if (!isspace((unsigned char) *str))
                ereport(ERROR,
                        (errcode(ERRCODE_CONFIG_FILE_ERROR),
                         errmsg("syntax error")));
        }
        else
            elog(ERROR, "unrecognized state in parse_affentry: %d", state);
 
        str += clen;
    }
 
    *pmask = *pfind = *prepl = '\0';
 
    return (*mask && (*find || *repl));
}

References elog, ereport, errcode(), errmsg(), ERROR, fb(), find(), PAE_INFIND, PAE_INMASK, PAE_INREPL, PAE_WAIT_FIND, PAE_WAIT_MASK, PAE_WAIT_REPL, pg_mblen_cstr(), str, t_iseq, and ts_copychar_with_len().

Referenced by NIImportAffixes().

◆ parse_ooaffentry()

static int parse_ooaffentry	(	char *	str,
		char *	type,
		char *	flag,
		char *	find,
		char *	repl,
		char *	mask
	)

static

Definition at line 858 of file spell.c.

{
    int         state = PAE_WAIT_TYPE;
    int         fields_read = 0;
    bool        valid = false;
 
    *type = *flag = *find = *repl = *mask = '\0';
 
    while (*str)
    {
        switch (state)
        {
            case PAE_WAIT_TYPE:
                valid = get_nextfield(&str, type);
                state = PAE_WAIT_FLAG;
                break;
            case PAE_WAIT_FLAG:
                valid = get_nextfield(&str, flag);
                state = PAE_WAIT_FIND;
                break;
            case PAE_WAIT_FIND:
                valid = get_nextfield(&str, find);
                state = PAE_WAIT_REPL;
                break;
            case PAE_WAIT_REPL:
                valid = get_nextfield(&str, repl);
                state = PAE_WAIT_MASK;
                break;
            case PAE_WAIT_MASK:
                valid = get_nextfield(&str, mask);
                state = -1;     /* force loop exit */
                break;
            default:
                elog(ERROR, "unrecognized state in parse_ooaffentry: %d",
                     state);
                break;
        }
        if (valid)
            fields_read++;
        else
            break;              /* early EOL */
        if (state < 0)
            break;              /* got all fields */
    }
 
    return fields_read;
}

References elog, ERROR, fb(), find(), flag(), get_nextfield(), PAE_WAIT_FIND, PAE_WAIT_FLAG, PAE_WAIT_MASK, PAE_WAIT_REPL, PAE_WAIT_TYPE, str, and type.

Referenced by NIImportOOAffixes().

◆ setCompoundAffixFlagValue()

static void setCompoundAffixFlagValue	(	IspellDict *	Conf,
		CompoundAffixFlag *	entry,
		char *	s,
		uint32	val
	)

static

Definition at line 1028 of file spell.c.

{
    if (Conf->flagMode == FM_NUM)
    {
        char       *next;
        int         i;
 
        errno = 0;
        i = strtol(s, &next, 10);
        if (s == next || errno == ERANGE)
            ereport(ERROR,
                    (errcode(ERRCODE_CONFIG_FILE_ERROR),
                     errmsg("invalid affix flag \"%s\"", s)));
        if (i < 0 || i > FLAGNUM_MAXSIZE)
            ereport(ERROR,
                    (errcode(ERRCODE_CONFIG_FILE_ERROR),
                     errmsg("affix flag \"%s\" is out of range", s)));
 
        entry->flag.i = i;
    }
    else
        entry->flag.s = cpstrdup(Conf, s);
 
    entry->flagMode = Conf->flagMode;
    entry->value = val;
}

References cpstrdup(), ereport, errcode(), errmsg(), ERROR, fb(), CompoundAffixFlag::flag, CompoundAffixFlag::flagMode, FLAGNUM_MAXSIZE, FM_NUM, i, CompoundAffixFlag::i, next, CompoundAffixFlag::s, val, and CompoundAffixFlag::value.

Referenced by addCompoundAffixFlagValue(), and getCompoundAffixFlagValue().

◆ SplitToVariants()

static SplitVar * SplitToVariants	(	IspellDict *	Conf,
		SPNode *	snode,
		SplitVar *	orig,
		const char *	word,
		int	wordlen,
		int	startpos,
		int	minpos
	)

static

Definition at line 2372 of file spell.c.

{
    SplitVar   *var = NULL;
    SPNodeData *StopLow,
               *StopHigh,
               *StopMiddle = NULL;
    SPNode     *node = (snode) ? snode : Conf->Dictionary;
    int         level = (snode) ? minpos : startpos;    /* recursive
                                                         * minpos==level */
    int         lenaff;
    CMPDAffix  *caff;
    char       *notprobed;
    int         compoundflag = 0;
 
    /* since this function recurses, it could be driven to stack overflow */
    check_stack_depth();
 
    notprobed = (char *) palloc(wordlen);
    memset(notprobed, 1, wordlen);
    var = CopyVar(orig, 1);
 
    while (level < wordlen)
    {
        /* find word with epenthetic or/and compound affix */
        caff = Conf->CompoundAffix;
        while (level > startpos && (lenaff = CheckCompoundAffixes(&caff, word + level, wordlen - level, (node) ? true : false)) >= 0)
        {
            /*
             * there is one of compound affixes, so check word for existings
             */
            char        buf[MAXNORMLEN];
            char      **subres;
 
            lenaff = level - startpos + lenaff;
 
            if (!notprobed[startpos + lenaff - 1])
                continue;
 
            if (level + lenaff - 1 <= minpos)
                continue;
 
            if (lenaff >= MAXNORMLEN)
                continue;       /* skip too big value */
            if (lenaff > 0)
                memcpy(buf, word + startpos, lenaff);
            buf[lenaff] = '\0';
 
            if (level == 0)
                compoundflag = FF_COMPOUNDBEGIN;
            else if (level == wordlen - 1)
                compoundflag = FF_COMPOUNDLAST;
            else
                compoundflag = FF_COMPOUNDMIDDLE;
            subres = NormalizeSubWord(Conf, buf, compoundflag);
            if (subres)
            {
                /* Yes, it was a word from dictionary */
                SplitVar   *new = CopyVar(var, 0);
                SplitVar   *ptr = var;
                char      **sptr = subres;
 
                notprobed[startpos + lenaff - 1] = 0;
 
                while (*sptr)
                {
                    AddStem(new, *sptr);
                    sptr++;
                }
                pfree(subres);
 
                while (ptr->next)
                    ptr = ptr->next;
                ptr->next = SplitToVariants(Conf, NULL, new, word, wordlen, startpos + lenaff, startpos + lenaff);
 
                pfree(new->stem);
                pfree(new);
            }
        }
 
        if (!node)
            break;
 
        StopLow = node->data;
        StopHigh = node->data + node->length;
        while (StopLow < StopHigh)
        {
            StopMiddle = StopLow + ((StopHigh - StopLow) >> 1);
            if (StopMiddle->val == ((const uint8 *) (word))[level])
                break;
            else if (StopMiddle->val < ((const uint8 *) (word))[level])
                StopLow = StopMiddle + 1;
            else
                StopHigh = StopMiddle;
        }
 
        if (StopLow < StopHigh)
        {
            if (startpos == 0)
                compoundflag = FF_COMPOUNDBEGIN;
            else if (level == wordlen - 1)
                compoundflag = FF_COMPOUNDLAST;
            else
                compoundflag = FF_COMPOUNDMIDDLE;
 
            /* find infinitive */
            if (StopMiddle->isword &&
                (StopMiddle->compoundflag & compoundflag) &&
                notprobed[level])
            {
                /* ok, we found full compoundallowed word */
                if (level > minpos)
                {
                    /* and its length more than minimal */
                    if (wordlen == level + 1)
                    {
                        /* well, it was last word */
                        AddStem(var, pnstrdup(word + startpos, wordlen - startpos));
                        pfree(notprobed);
                        return var;
                    }
                    else
                    {
                        /* then we will search more big word at the same point */
                        SplitVar   *ptr = var;
 
                        while (ptr->next)
                            ptr = ptr->next;
                        ptr->next = SplitToVariants(Conf, node, var, word, wordlen, startpos, level);
                        /* we can find next word */
                        level++;
                        AddStem(var, pnstrdup(word + startpos, level - startpos));
                        node = Conf->Dictionary;
                        startpos = level;
                        continue;
                    }
                }
            }
            node = StopMiddle->node;
        }
        else
            node = NULL;
        level++;
    }
 
    AddStem(var, pnstrdup(word + startpos, wordlen - startpos));
    pfree(notprobed);
    return var;
}

References AddStem(), buf, check_stack_depth(), CheckCompoundAffixes(), CopyVar(), SPNode::data, fb(), FF_COMPOUNDBEGIN, FF_COMPOUNDLAST, FF_COMPOUNDMIDDLE, SPNode::length, MAXNORMLEN, SplitVar::next, NormalizeSubWord(), palloc(), pfree(), pnstrdup(), SplitToVariants(), startpos, and word().

Referenced by NINormalizeWord(), and SplitToVariants().

◆ strbcmp()

static int strbcmp	(	const unsigned char *	s1,
		const unsigned char *	s2
	)

static

Definition at line 258 of file spell.c.

{
    int         l1 = strlen((const char *) s1) - 1,
                l2 = strlen((const char *) s2) - 1;
 
    while (l1 >= 0 && l2 >= 0)
    {
        if (s1[l1] < s2[l2])
            return -1;
        if (s1[l1] > s2[l2])
            return 1;
        l1--;
        l2--;
    }
    if (l1 < l2)
        return -1;
    if (l1 > l2)
        return 1;
 
    return 0;
}

References fb(), s1, and s2.

Referenced by cmpaffix().

◆ strbncmp()

static int strbncmp	(	const unsigned char *	s1,
		const unsigned char *	s2,
		size_t	count
	)

static

Definition at line 281 of file spell.c.

{
    int         l1 = strlen((const char *) s1) - 1,
                l2 = strlen((const char *) s2) - 1,
                l = count;
 
    while (l1 >= 0 && l2 >= 0 && l > 0)
    {
        if (s1[l1] < s2[l2])
            return -1;
        if (s1[l1] > s2[l2])
            return 1;
        l1--;
        l2--;
        l--;
    }
    if (l == 0)
        return 0;
    if (l1 < l2)
        return -1;
    if (l1 > l2)
        return 1;
    return 0;
}

References fb(), s1, and s2.

Referenced by NISortAffixes().

Variable Documentation

◆ VoidString

const char* VoidString = ""

static

Definition at line 195 of file spell.c.

Referenced by getAffixFlagSet(), NIAddAffix(), NIAddSpell(), NIImportOOAffixes(), and NormalizeSubWord().

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ COMPACT_ALLOC_CHUNK

◆ COMPACT_MAX_REQ

◆ cpalloc

◆ cpalloc0

◆ GETCHAR

◆ GETWCHAR

◆ MAX_NORM

◆ MAXNORMLEN

◆ PAE_INFIND

◆ PAE_INMASK

◆ PAE_INREPL

◆ PAE_WAIT_FIND

◆ PAE_WAIT_FLAG

◆ PAE_WAIT_MASK

◆ PAE_WAIT_REPL

◆ PAE_WAIT_TYPE

◆ STRNCMP

◆ tmpalloc

◆ tmpalloc0

Typedef Documentation

◆ SplitVar

Function Documentation

◆ addCompoundAffixFlagValue()

◆ addNorm()

◆ AddStem()

◆ addToResult()

◆ CheckAffix()

◆ CheckCompoundAffixes()

◆ cmpaffix()

◆ cmpcmdflag()

◆ cmpspell()

◆ cmpspellaffix()

◆ compact_palloc0()

◆ CopyVar()

◆ cpstrdup()

◆ FindAffixes()

◆ findchar()

◆ findchar2()

◆ FindWord()

◆ get_nextfield()

◆ getAffixFlagSet()

◆ getCompoundAffixFlagValue()

◆ getNextFlagFromString()

◆ IsAffixFlagInUse()

◆ isAffixInUse()

◆ lowerstr_ctx()

◆ makeCompoundFlags()

◆ MergeAffix()

◆ mkANode()

◆ mkSPNode()

◆ mkVoidAffix()

◆ NIAddAffix()

◆ NIAddSpell()

◆ NIFinishBuild()

◆ NIImportAffixes()

◆ NIImportDictionary()

◆ NIImportOOAffixes()

◆ NINormalizeWord()

◆ NISortAffixes()

◆ NISortDictionary()

◆ NIStartBuild()

◆ NormalizeSubWord()

◆ parse_affentry()

◆ parse_ooaffentry()

◆ setCompoundAffixFlagValue()

◆ SplitToVariants()

◆ strbcmp()

◆ strbncmp()

Variable Documentation

◆ VoidString