tsvector_parser.c File Reference

#include "postgres.h"
#include "tsearch/ts_locale.h"
#include "tsearch/ts_utils.h"

Include dependency graph for tsvector_parser.c:

Go to the source code of this file.

Data Structures
struct	TSVectorParseStateData

Macros
#define	RESIZEPRSBUF
#define	RETURN_TOKEN
#define	WAITWORD   1
#define	WAITENDWORD   2
#define	WAITNEXTCHAR   3
#define	WAITENDCMPLX   4
#define	WAITPOSINFO   5
#define	INPOSINFO   6
#define	WAITPOSDELIM   7
#define	WAITCHARCMPLX   8
#define	PRSSYNTAXERROR   return prssyntaxerror(state)

Functions
TSVectorParseState	init_tsvector_parser (char *input, int flags, Node *escontext)
void	reset_tsvector_parser (TSVectorParseState state, char *input)
void	close_tsvector_parser (TSVectorParseState state)
static bool	prssyntaxerror (TSVectorParseState state)
bool	gettoken_tsvector (TSVectorParseState state, char **strval, int *lenval, WordEntryPos **pos_ptr, int *poslen, char **endptr)

Macro Definition Documentation

INPOSINFO

#define INPOSINFO   6

Definition at line 135 of file tsvector_parser.c.

PRSSYNTAXERROR

#define PRSSYNTAXERROR   return prssyntaxerror(state)

Definition at line 139 of file tsvector_parser.c.

RESIZEPRSBUF

#define RESIZEPRSBUF

Value:

do { \
    int clen = curpos - state->word; \
	if ( clen + state->eml >= state->len ) \
    { \
        state->len *= 2; \
        state->word = (char *) repalloc(state->word, state->len); \
        curpos = state->word + clen; \
    } \
} while (0)

Definition at line 97 of file tsvector_parser.c.

   { \
    int clen = curpos - state->word; \
	if ( clen + state->eml >= state->len ) \
    { \
        state->len *= 2; \
        state->word = (char *) repalloc(state->word, state->len); \
        curpos = state->word + clen; \
    } \
} while (0)

RETURN_TOKEN

#define RETURN_TOKEN

Value:

do { \
	if (pos_ptr != NULL) \
    { \
        *pos_ptr = pos; \
        *poslen = npos; \
    } \
    else if (pos != NULL) \
		pfree(pos); \
	\
	if (strval != NULL) \
        *strval = state->word; \
	if (lenval != NULL) \
        *lenval = curpos - state->word; \
	if (endptr != NULL) \
        *endptr = state->prsbuf; \
    return true; \
} while(0)

Definition at line 109 of file tsvector_parser.c.

   { \
	if (pos_ptr != NULL) \
    { \
        *pos_ptr = pos; \
        *poslen = npos; \
    } \
    else if (pos != NULL) \
		pfree(pos); \
	\
	if (strval != NULL) \
        *strval = state->word; \
	if (lenval != NULL) \
        *lenval = curpos - state->word; \
	if (endptr != NULL) \
        *endptr = state->prsbuf; \
    return true; \
} while(0)

WAITCHARCMPLX

#define WAITCHARCMPLX   8

Definition at line 137 of file tsvector_parser.c.

WAITENDCMPLX

#define WAITENDCMPLX   4

Definition at line 133 of file tsvector_parser.c.

WAITENDWORD

#define WAITENDWORD   2

Definition at line 131 of file tsvector_parser.c.

WAITNEXTCHAR

#define WAITNEXTCHAR   3

Definition at line 132 of file tsvector_parser.c.

WAITPOSDELIM

#define WAITPOSDELIM   7

Definition at line 136 of file tsvector_parser.c.

WAITPOSINFO

#define WAITPOSINFO   5

Definition at line 134 of file tsvector_parser.c.

WAITWORD

#define WAITWORD   1

Definition at line 130 of file tsvector_parser.c.

Function Documentation

close_tsvector_parser()

void close_tsvector_parser

(

TSVectorParseState

state

)

Definition at line 90 of file tsvector_parser.c.

{
    pfree(state->word);
    pfree(state);
}

References pfree().

Referenced by parse_tsquery(), and tsvectorin().

gettoken_tsvector()

bool gettoken_tsvector	(	TSVectorParseState	state,
		char **	strval,
		int *	lenval,
		WordEntryPos **	pos_ptr,
		int *	poslen,
		char **	endptr
	)

Definition at line 176 of file tsvector_parser.c.

{
    int         oldstate = 0;
    char       *curpos = state->word;
    int         statecode = WAITWORD;
 
    /*
     * pos is for collecting the comma delimited list of positions followed by
     * the actual token.
     */
    WordEntryPos *pos = NULL;
    int         npos = 0;       /* elements of pos used */
    int         posalen = 0;    /* allocated size of pos */
 
    while (1)
    {
        if (statecode == WAITWORD)
        {
            if (*(state->prsbuf) == '\0')
                return false;
            else if (!state->is_web && t_iseq(state->prsbuf, '\''))
                statecode = WAITENDCMPLX;
            else if (!state->is_web && t_iseq(state->prsbuf, '\\'))
            {
                statecode = WAITNEXTCHAR;
                oldstate = WAITENDWORD;
            }
            else if ((state->oprisdelim && ISOPERATOR(state->prsbuf)) ||
                     (state->is_web && t_iseq(state->prsbuf, '"')))
                PRSSYNTAXERROR;
            else if (!isspace((unsigned char) *state->prsbuf))
            {
                curpos += ts_copychar_cstr(curpos, state->prsbuf);
                statecode = WAITENDWORD;
            }
        }
        else if (statecode == WAITNEXTCHAR)
        {
            if (*(state->prsbuf) == '\0')
                ereturn(state->escontext, false,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("there is no escaped character: \"%s\"",
                                state->bufstart)));
            else
            {
                RESIZEPRSBUF;
                curpos += ts_copychar_cstr(curpos, state->prsbuf);
                Assert(oldstate != 0);
                statecode = oldstate;
            }
        }
        else if (statecode == WAITENDWORD)
        {
            if (!state->is_web && t_iseq(state->prsbuf, '\\'))
            {
                statecode = WAITNEXTCHAR;
                oldstate = WAITENDWORD;
            }
            else if (isspace((unsigned char) *state->prsbuf) || *(state->prsbuf) == '\0' ||
                     (state->oprisdelim && ISOPERATOR(state->prsbuf)) ||
                     (state->is_web && t_iseq(state->prsbuf, '"')))
            {
                RESIZEPRSBUF;
                if (curpos == state->word)
                    PRSSYNTAXERROR;
                *(curpos) = '\0';
                RETURN_TOKEN;
            }
            else if (t_iseq(state->prsbuf, ':'))
            {
                if (curpos == state->word)
                    PRSSYNTAXERROR;
                *(curpos) = '\0';
                if (state->oprisdelim)
                    RETURN_TOKEN;
                else
                    statecode = INPOSINFO;
            }
            else
            {
                RESIZEPRSBUF;
                curpos += ts_copychar_cstr(curpos, state->prsbuf);
            }
        }
        else if (statecode == WAITENDCMPLX)
        {
            if (!state->is_web && t_iseq(state->prsbuf, '\''))
            {
                statecode = WAITCHARCMPLX;
            }
            else if (!state->is_web && t_iseq(state->prsbuf, '\\'))
            {
                statecode = WAITNEXTCHAR;
                oldstate = WAITENDCMPLX;
            }
            else if (*(state->prsbuf) == '\0')
                PRSSYNTAXERROR;
            else
            {
                RESIZEPRSBUF;
                curpos += ts_copychar_cstr(curpos, state->prsbuf);
            }
        }
        else if (statecode == WAITCHARCMPLX)
        {
            if (!state->is_web && t_iseq(state->prsbuf, '\''))
            {
                RESIZEPRSBUF;
                curpos += ts_copychar_cstr(curpos, state->prsbuf);
                statecode = WAITENDCMPLX;
            }
            else
            {
                RESIZEPRSBUF;
                *(curpos) = '\0';
                if (curpos == state->word)
                    PRSSYNTAXERROR;
                if (state->oprisdelim)
                {
                    /* state->prsbuf+=pg_mblen_cstr(state->prsbuf); */
                    RETURN_TOKEN;
                }
                else
                    statecode = WAITPOSINFO;
                continue;       /* recheck current character */
            }
        }
        else if (statecode == WAITPOSINFO)
        {
            if (t_iseq(state->prsbuf, ':'))
                statecode = INPOSINFO;
            else
                RETURN_TOKEN;
        }
        else if (statecode == INPOSINFO)
        {
            if (isdigit((unsigned char) *state->prsbuf))
            {
                if (posalen == 0)
                {
                    posalen = 4;
                    pos = palloc_array(WordEntryPos, posalen);
                    npos = 0;
                }
                else if (npos + 1 >= posalen)
                {
                    posalen *= 2;
                    pos = repalloc_array(pos, WordEntryPos, posalen);
                }
                npos++;
                WEP_SETPOS(pos[npos - 1], LIMITPOS(atoi(state->prsbuf)));
                /* we cannot get here in tsquery, so no need for 2 errmsgs */
                if (WEP_GETPOS(pos[npos - 1]) == 0)
                    ereturn(state->escontext, false,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("wrong position info in tsvector: \"%s\"",
                                    state->bufstart)));
                WEP_SETWEIGHT(pos[npos - 1], 0);
                statecode = WAITPOSDELIM;
            }
            else
                PRSSYNTAXERROR;
        }
        else if (statecode == WAITPOSDELIM)
        {
            if (t_iseq(state->prsbuf, ','))
                statecode = INPOSINFO;
            else if (t_iseq(state->prsbuf, 'a') || t_iseq(state->prsbuf, 'A') || t_iseq(state->prsbuf, '*'))
            {
                if (WEP_GETWEIGHT(pos[npos - 1]))
                    PRSSYNTAXERROR;
                WEP_SETWEIGHT(pos[npos - 1], 3);
            }
            else if (t_iseq(state->prsbuf, 'b') || t_iseq(state->prsbuf, 'B'))
            {
                if (WEP_GETWEIGHT(pos[npos - 1]))
                    PRSSYNTAXERROR;
                WEP_SETWEIGHT(pos[npos - 1], 2);
            }
            else if (t_iseq(state->prsbuf, 'c') || t_iseq(state->prsbuf, 'C'))
            {
                if (WEP_GETWEIGHT(pos[npos - 1]))
                    PRSSYNTAXERROR;
                WEP_SETWEIGHT(pos[npos - 1], 1);
            }
            else if (t_iseq(state->prsbuf, 'd') || t_iseq(state->prsbuf, 'D'))
            {
                if (WEP_GETWEIGHT(pos[npos - 1]))
                    PRSSYNTAXERROR;
                WEP_SETWEIGHT(pos[npos - 1], 0);
            }
            else if (isspace((unsigned char) *state->prsbuf) ||
                     *(state->prsbuf) == '\0')
                RETURN_TOKEN;
            else if (!isdigit((unsigned char) *state->prsbuf))
                PRSSYNTAXERROR;
        }
        else                    /* internal error */
            elog(ERROR, "unrecognized state in gettoken_tsvector: %d",
                 statecode);
 
        /* get next char */
        state->prsbuf += pg_mblen_cstr(state->prsbuf);
    }
}

References Assert, elog, ereturn, errcode(), errmsg(), ERROR, fb(), INPOSINFO, ISOPERATOR, LIMITPOS, palloc_array, pg_mblen_cstr(), PRSSYNTAXERROR, repalloc_array, RESIZEPRSBUF, RETURN_TOKEN, t_iseq, ts_copychar_cstr(), WAITCHARCMPLX, WAITENDCMPLX, WAITENDWORD, WAITNEXTCHAR, WAITPOSDELIM, WAITPOSINFO, WAITWORD, WEP_GETPOS, WEP_GETWEIGHT, WEP_SETPOS, and WEP_SETWEIGHT.

Referenced by gettoken_query_standard(), gettoken_query_websearch(), and tsvectorin().

init_tsvector_parser()

TSVectorParseState init_tsvector_parser	(	char *	input,
		int	flags,
		Node *	escontext
	)

Definition at line 57 of file tsvector_parser.c.

{
    TSVectorParseState state;
 
    state = palloc_object(struct TSVectorParseStateData);
    state->prsbuf = input;
    state->bufstart = input;
    state->len = 32;
    state->word = (char *) palloc(state->len);
    state->eml = pg_database_encoding_max_length();
    state->oprisdelim = (flags & P_TSV_OPR_IS_DELIM) != 0;
    state->is_tsquery = (flags & P_TSV_IS_TSQUERY) != 0;
    state->is_web = (flags & P_TSV_IS_WEB) != 0;
    state->escontext = escontext;
 
    return state;
}

References input, P_TSV_IS_TSQUERY, P_TSV_IS_WEB, P_TSV_OPR_IS_DELIM, palloc(), palloc_object, and pg_database_encoding_max_length().

Referenced by parse_tsquery(), and tsvectorin().

prssyntaxerror()

static bool prssyntaxerror ( TSVectorParseState  state )

static

Definition at line 142 of file tsvector_parser.c.

{
    errsave(state->escontext,
            (errcode(ERRCODE_SYNTAX_ERROR),
             state->is_tsquery ?
             errmsg("syntax error in tsquery: \"%s\"", state->bufstart) :
             errmsg("syntax error in tsvector: \"%s\"", state->bufstart)));
    /* In soft error situation, return false as convenience for caller */
    return false;
}

References errcode(), errmsg(), errsave, and fb().

reset_tsvector_parser()

void reset_tsvector_parser	(	TSVectorParseState	state,
		char *	input
	)

Definition at line 81 of file tsvector_parser.c.

{
    state->prsbuf = input;
}

References input.

Referenced by gettoken_query_standard(), and gettoken_query_websearch().