/*-------------------------------------------------------------------------

 *

 * regis.c

 *    Fast regex subset

 *

 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group

 *

 *

 * IDENTIFICATION

 *    src/backend/tsearch/regis.c

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include "tsearch/dicts/regis.h"

#include "tsearch/ts_locale.h"

#define RS_IN_ONEOF 1

#define RS_IN_ONEOF_IN  2

#define RS_IN_NONEOF  3

#define RS_IN_WAIT  4

/*

 * Test whether a regex is of the subset supported here.

 * Keep this in sync with RS_compile!

 */

bool

RS_isRegis(const char *str)

{

  int     state = RS_IN_WAIT;

  const char *c = str;

  while (*c)

  {

    if (state == RS_IN_WAIT)

    {

      if (t_isalpha_cstr(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_cstr(c))

        state = RS_IN_ONEOF_IN;

      else

        return false;

    }

    else if (state == RS_IN_ONEOF_IN || state == RS_IN_NONEOF)

    {

      if (t_isalpha_cstr(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_cstr(c);

  }

  return (state == RS_IN_WAIT);

}

static RegisNode *

newRegisNode(RegisNode *prev, int len)

{

  RegisNode  *ptr;

  ptr = (RegisNode *) palloc0(RNHDRSZ + len + 1);

  if (prev)

    prev->next = ptr;

  return ptr;

}

void

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

{

  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_cstr(c))

      {

        if (ptr)

          ptr = newRegisNode(ptr, len);

        else

          ptr = r->node = newRegisNode(NULL, len);

        ptr->type = RSF_ONEOF;

        ptr->len = ts_copychar_cstr(ptr->data, 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_cstr(c))

      {

        ptr->len = ts_copychar_cstr(ptr->data, 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_cstr(c))

        ptr->len += ts_copychar_cstr(ptr->data + ptr->len, 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_cstr(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;

  }

}

void

RS_free(Regis *r)

{

  RegisNode  *ptr = r->node,

         *tmp;

  while (ptr)

  {

    tmp = ptr->next;

    pfree(ptr);

    ptr = tmp;

  }

  r->node = NULL;

}

static bool

mb_strchr(char *str, char *c)

{

  int     clen,

        plen,

        i;

  char     *ptr = str;

  bool    res = false;

  clen = pg_mblen_cstr(c);

  while (*ptr && !res)

  {

    plen = pg_mblen_cstr(ptr);

    if (plen == clen)

    {

      i = plen;

      res = true;

      while (i--)

        if (*(ptr + i) != *(c + i))

        {

          res = false;

          break;

        }

    }

    ptr += plen;

  }

  return res;

}

bool

RS_execute(Regis *r, char *str)

{

  RegisNode  *ptr = r->node;

  char     *c = str;

  int     len = 0;

  while (*c)

  {

    len++;

    c += pg_mblen_cstr(c);

  }

  if (len < r->nchar)

    return 0;

  c = str;

  if (r->issuffix)

  {

    len -= r->nchar;

    while (len-- > 0)

      c += pg_mblen_cstr(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_cstr(c);

  }

  return true;

}