regis.c File Reference

#include "postgres.h"
#include "tsearch/dicts/regis.h"
#include "tsearch/ts_locale.h"

Include dependency graph for regis.c:

Go to the source code of this file.

Macros
#define	RS_IN_ONEOF   1
#define	RS_IN_ONEOF_IN   2
#define	RS_IN_NONEOF   3
#define	RS_IN_WAIT   4

Functions
bool	RS_isRegis (const char *str)
static RegisNode *	newRegisNode (RegisNode *prev, int len)
void	RS_compile (Regis *r, bool issuffix, const char *str)
void	RS_free (Regis *r)
static bool	mb_strchr (char *str, char *c)
bool	RS_execute (Regis *r, char *str)

Macro Definition Documentation

RS_IN_NONEOF

#define RS_IN_NONEOF   3

Definition at line 22 of file regis.c.

RS_IN_ONEOF

#define RS_IN_ONEOF   1

Definition at line 20 of file regis.c.

RS_IN_ONEOF_IN

#define RS_IN_ONEOF_IN   2

Definition at line 21 of file regis.c.

RS_IN_WAIT

#define RS_IN_WAIT   4

Definition at line 23 of file regis.c.

Function Documentation

mb_strchr()

static bool mb_strchr ( char *  str, char *  c  )

static

Definition at line 182 of file regis.c.

{
    int         clen,
                plen,
                i;
    char       *ptr = str;
    bool        res = false;
 
    clen = pg_mblen(c);
    while (*ptr && !res)
    {
        plen = pg_mblen(ptr);
        if (plen == clen)
        {
            i = plen;
            res = true;
            while (i--)
                if (*(ptr + i) != *(c + i))
                {
                    res = false;
                    break;
                }
        }
 
        ptr += plen;
    }
 
    return res;
}

References i, pg_mblen(), res, and str.

Referenced by RS_execute().

newRegisNode()

static RegisNode* newRegisNode ( RegisNode *  prev, int  len  )

static

Definition at line 74 of file regis.c.

{
    RegisNode  *ptr;
 
    ptr = (RegisNode *) palloc0(RNHDRSZ + len + 1);
    if (prev)
        prev->next = ptr;
    return ptr;
}

References len, RegisNode::next, palloc0(), and RNHDRSZ.

Referenced by RS_compile().

RS_compile()

void RS_compile	(	Regis *	r,
		bool	issuffix,
		const char *	str
	)

Definition at line 85 of file regis.c.

{
    int         len = strlen(str);
    int         state = RS_IN_WAIT;
    const char *c = str;
    RegisNode  *ptr = NULL;
 
    memset(r, 0, sizeof(Regis));
    r->issuffix = (issuffix) ? 1 : 0;
 
    while (*c)
    {
        if (state == RS_IN_WAIT)
        {
            if (t_isalpha(c))
            {
                if (ptr)
                    ptr = newRegisNode(ptr, len);
                else
                    ptr = r->node = newRegisNode(NULL, len);
                COPYCHAR(ptr->data, c);
                ptr->type = RSF_ONEOF;
                ptr->len = pg_mblen(c);
            }
            else if (t_iseq(c, '['))
            {
                if (ptr)
                    ptr = newRegisNode(ptr, len);
                else
                    ptr = r->node = newRegisNode(NULL, len);
                ptr->type = RSF_ONEOF;
                state = RS_IN_ONEOF;
            }
            else                /* shouldn't get here */
                elog(ERROR, "invalid regis pattern: \"%s\"", str);
        }
        else if (state == RS_IN_ONEOF)
        {
            if (t_iseq(c, '^'))
            {
                ptr->type = RSF_NONEOF;
                state = RS_IN_NONEOF;
            }
            else if (t_isalpha(c))
            {
                COPYCHAR(ptr->data, c);
                ptr->len = pg_mblen(c);
                state = RS_IN_ONEOF_IN;
            }
            else                /* shouldn't get here */
                elog(ERROR, "invalid regis pattern: \"%s\"", str);
        }
        else if (state == RS_IN_ONEOF_IN || state == RS_IN_NONEOF)
        {
            if (t_isalpha(c))
            {
                COPYCHAR(ptr->data + ptr->len, c);
                ptr->len += pg_mblen(c);
            }
            else if (t_iseq(c, ']'))
                state = RS_IN_WAIT;
            else                /* shouldn't get here */
                elog(ERROR, "invalid regis pattern: \"%s\"", str);
        }
        else
            elog(ERROR, "internal error in RS_compile: state %d", state);
        c += pg_mblen(c);
    }
 
    if (state != RS_IN_WAIT)    /* shouldn't get here */
        elog(ERROR, "invalid regis pattern: \"%s\"", str);
 
    ptr = r->node;
    while (ptr)
    {
        r->nchar++;
        ptr = ptr->next;
    }
}

References COPYCHAR, RegisNode::data, elog, ERROR, Regis::issuffix, RegisNode::len, len, Regis::nchar, newRegisNode(), RegisNode::next, Regis::node, pg_mblen(), RS_IN_NONEOF, RS_IN_ONEOF, RS_IN_ONEOF_IN, RS_IN_WAIT, RSF_NONEOF, RSF_ONEOF, str, t_isalpha(), t_iseq, and RegisNode::type.

Referenced by NIAddAffix().

RS_execute()

bool RS_execute	(	Regis *	r,
		char *	str
	)

Definition at line 213 of file regis.c.

{
    RegisNode  *ptr = r->node;
    char       *c = str;
    int         len = 0;
 
    while (*c)
    {
        len++;
        c += pg_mblen(c);
    }
 
    if (len < r->nchar)
        return 0;
 
    c = str;
    if (r->issuffix)
    {
        len -= r->nchar;
        while (len-- > 0)
            c += pg_mblen(c);
    }
 
 
    while (ptr)
    {
        switch (ptr->type)
        {
            case RSF_ONEOF:
                if (!mb_strchr((char *) ptr->data, c))
                    return false;
                break;
            case RSF_NONEOF:
                if (mb_strchr((char *) ptr->data, c))
                    return false;
                break;
            default:
                elog(ERROR, "unrecognized regis node type: %d", ptr->type);
        }
        ptr = ptr->next;
        c += pg_mblen(c);
    }
 
    return true;
}

References RegisNode::data, elog, ERROR, Regis::issuffix, len, mb_strchr(), Regis::nchar, RegisNode::next, Regis::node, pg_mblen(), RSF_NONEOF, RSF_ONEOF, str, and RegisNode::type.

Referenced by CheckAffix().

RS_free()

void RS_free

(

Regis *

r

)

Definition at line 166 of file regis.c.

{
    RegisNode  *ptr = r->node,
               *tmp;
 
    while (ptr)
    {
        tmp = ptr->next;
        pfree(ptr);
        ptr = tmp;
    }
 
    r->node = NULL;
}

References RegisNode::next, Regis::node, and pfree().

RS_isRegis()

bool RS_isRegis

(

const char *

str

)

Definition at line 31 of file regis.c.

{
    int         state = RS_IN_WAIT;
    const char *c = str;
 
    while (*c)
    {
        if (state == RS_IN_WAIT)
        {
            if (t_isalpha(c))
                 /* okay */ ;
            else if (t_iseq(c, '['))
                state = RS_IN_ONEOF;
            else
                return false;
        }
        else if (state == RS_IN_ONEOF)
        {
            if (t_iseq(c, '^'))
                state = RS_IN_NONEOF;
            else if (t_isalpha(c))
                state = RS_IN_ONEOF_IN;
            else
                return false;
        }
        else if (state == RS_IN_ONEOF_IN || state == RS_IN_NONEOF)
        {
            if (t_isalpha(c))
                 /* okay */ ;
            else if (t_iseq(c, ']'))
                state = RS_IN_WAIT;
            else
                return false;
        }
        else
            elog(ERROR, "internal error in RS_isRegis: state %d", state);
        c += pg_mblen(c);
    }
 
    return (state == RS_IN_WAIT);
}

References elog, ERROR, pg_mblen(), RS_IN_NONEOF, RS_IN_ONEOF, RS_IN_ONEOF_IN, RS_IN_WAIT, str, t_isalpha(), and t_iseq.

Referenced by NIAddAffix().