YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

/* A Bison parser, made by GNU Bison 3.4.1.  */

/* Bison implementation for Yacc-like parsers in C

   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation,

   Inc.

   This program is free software: you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation, either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

/* As a special exception, you may create a larger work that contains

   part or all of the Bison parser skeleton and distribute that work

   under terms of your choice, so long as that work isn't itself a

   parser generator using the skeleton or a modified version thereof

   as a parser skeleton.  Alternatively, if you modify or redistribute

   the parser skeleton itself, you may (at your option) remove this

   special exception, which will cause the skeleton and the resulting

   Bison output files to be licensed under the GNU General Public

   License without this special exception.

   This special exception was added by the Free Software Foundation in

   version 2.2 of Bison.  */

/* C LALR(1) parser skeleton written by Richard Stallman, by

   simplifying the original so-called "semantic" parser.  */

/* All symbols defined below should begin with yy or YY, to avoid

   infringing on user name space.  This should be done even for local

   variables, as they might otherwise be expanded by user macros.

   There are some unavoidable exceptions within include files to

   define necessary library symbols; they are noted "INFRINGES ON

   USER NAME SPACE" below.  */

/* Undocumented macros, especially those whose name start with YY_,

   are private implementation details.  Do not rely on them.  */

/* Identify Bison output.  */

#define YYBISON 1

/* Bison version.  */

#define YYBISON_VERSION "3.4.1"

/* Skeleton name.  */

#define YYSKELETON_NAME "yacc.c"

/* Pure parsers.  */

#define YYPURE 0

/* Push parsers.  */

#define YYPUSH 0

/* Pull parsers.  */

#define YYPULL 1

/* Substitute the variable and function names.  */

#define yyparse         base_yyparse

#define yylex           base_yylex

#define yyerror         base_yyerror

#define yydebug         base_yydebug

#define yynerrs         base_yynerrs

#define yylval          base_yylval

#define yychar          base_yychar

#define yylloc          base_yylloc

/* First part of user prologue.  */

#line 5 "preproc.y"

#include "postgres_fe.h"

#include "extern.h"

#include "ecpg_config.h"

#include <unistd.h>

/* Location tracking support --- simpler than bison's default */

#define YYLLOC_DEFAULT(Current, Rhs, N) \

  do { \

    if (N)            \

      (Current) = (Rhs)[1]; \

    else            \

      (Current) = (Rhs)[0]; \

  } while (0)

/*

 * The %name-prefix option below will make bison call base_yylex, but we

 * really want it to call filtered_base_yylex (see parser.c).

 */

#define base_yylex filtered_base_yylex

/*

 * This is only here so the string gets into the POT.  Bison uses it

 * internally.

 */

#define bison_gettext_dummy gettext_noop("syntax error")

/*

 * Variables containing simple states.

 */

int struct_level = 0;

int braces_open; /* brace level counter */

char *current_function;

int ecpg_internal_var = 0;

char  *connection = NULL;

char  *input_filename = NULL;

static int  FoundInto = 0;

static int  initializer = 0;

static int  pacounter = 1;

static char pacounter_buffer[sizeof(int) * CHAR_BIT * 10 / 3]; /* a rough guess at the size we need */

static struct this_type actual_type[STRUCT_DEPTH];

static char *actual_startline[STRUCT_DEPTH];

static int  varchar_counter = 1;

/* temporarily store struct members while creating the data structure */

struct ECPGstruct_member *struct_member_list[STRUCT_DEPTH] = { NULL };

/* also store struct type so we can do a sizeof() later */

static char *ECPGstruct_sizeof = NULL;

/* for forward declarations we have to store some data as well */

static char *forward_name = NULL;

struct ECPGtype ecpg_no_indicator = {ECPGt_NO_INDICATOR, NULL, NULL, NULL, {NULL}, 0};

struct variable no_indicator = {"no_indicator", &ecpg_no_indicator, 0, NULL};

static struct ECPGtype ecpg_query = {ECPGt_char_variable, NULL, NULL, NULL, {NULL}, 0};

static void vmmerror(int error_code, enum errortype type, const char *error, va_list ap) pg_attribute_printf(3, 0);

/*

 * Handle parsing errors and warnings

 */

static void

vmmerror(int error_code, enum errortype type, const char *error, va_list ap)

{

  /* localize the error message string */

  error = _(error);

  fprintf(stderr, "%s:%d: ", input_filename, base_yylineno);

  switch(type)

  {

    case ET_WARNING:

      fprintf(stderr, _("WARNING: "));

      break;

    case ET_ERROR:

      fprintf(stderr, _("ERROR: "));

      break;

  }

  vfprintf(stderr, error, ap);

  fprintf(stderr, "\n");

  switch(type)

  {

    case ET_WARNING:

      break;

    case ET_ERROR:

      ret_value = error_code;

      break;

  }

}

void

mmerror(int error_code, enum errortype type, const char *error, ...)

{

  va_list   ap;

  va_start(ap, error);

  vmmerror(error_code, type, error, ap);

  va_end(ap);

}

void

mmfatal(int error_code, const char *error, ...)

{

  va_list   ap;

  va_start(ap, error);

  vmmerror(error_code, ET_ERROR, error, ap);

  va_end(ap);

  if (base_yyin)

    fclose(base_yyin);

  if (base_yyout)

    fclose(base_yyout);

  if (strcmp(output_filename, "-") != 0 && unlink(output_filename) != 0)

    fprintf(stderr, _("could not remove output file \"%s\"\n"), output_filename);

  exit(error_code);

}

/*

 * string concatenation

 */

static char *

cat2_str(char *str1, char *str2)

{

  char * res_str  = (char *)mm_alloc(strlen(str1) + strlen(str2) + 2);

  strcpy(res_str, str1);

  if (strlen(str1) != 0 && strlen(str2) != 0)

    strcat(res_str, " ");

  strcat(res_str, str2);

  free(str1);

  free(str2);

  return res_str;

}

static char *

cat_str(int count, ...)

{

  va_list   args;

  int     i;

  char    *res_str;

  va_start(args, count);

  res_str = va_arg(args, char *);

  /* now add all other strings */

  for (i = 1; i < count; i++)

    res_str = cat2_str(res_str, va_arg(args, char *));

  va_end(args);

  return res_str;

}

static char *

make2_str(char *str1, char *str2)

{

  char * res_str  = (char *)mm_alloc(strlen(str1) + strlen(str2) + 1);

  strcpy(res_str, str1);

  strcat(res_str, str2);

  free(str1);

  free(str2);

  return res_str;

}

static char *

make3_str(char *str1, char *str2, char *str3)

{

  char * res_str  = (char *)mm_alloc(strlen(str1) + strlen(str2) +strlen(str3) + 1);

  strcpy(res_str, str1);

  strcat(res_str, str2);

  strcat(res_str, str3);

  free(str1);

  free(str2);

  free(str3);

  return res_str;

}

/* and the rest */

static char *

make_name(void)

{

  return mm_strdup(base_yytext);

}

static char *

create_questionmarks(char *name, bool array)

{

  struct variable *p = find_variable(name);

  int count;

  char *result = EMPTY;

  /* In case we have a struct, we have to print as many "?" as there are attributes in the struct

   * An array is only allowed together with an element argument

   * This is essentially only used for inserts, but using a struct as input parameter is an error anywhere else

   * so we don't have to worry here. */

  if (p->type->type == ECPGt_struct || (array && p->type->type == ECPGt_array && p->type->u.element->type == ECPGt_struct))

  {

    struct ECPGstruct_member *m;

    if (p->type->type == ECPGt_struct)

      m = p->type->u.members;

    else

      m = p->type->u.element->u.members;

    for (count = 0; m != NULL; m=m->next, count++);

  }

  else

    count = 1;

  for (; count > 0; count --)

  {

    sprintf(pacounter_buffer, "$%d", pacounter++);

    result = cat_str(3, result, mm_strdup(pacounter_buffer), mm_strdup(" , "));

  }

  /* removed the trailing " ," */

  result[strlen(result)-3] = '\0';

  return result;

}

static char *

adjust_outofscope_cursor_vars(struct cursor *cur)

{

  /* Informix accepts DECLARE with variables that are out of scope when OPEN is called.

   * For instance you can DECLARE a cursor in one function, and OPEN/FETCH/CLOSE

   * it in another functions. This is very useful for e.g. event-driver programming,

   * but may also lead to dangerous programming. The limitation when this is allowed

   * and doesn't cause problems have to be documented, like the allocated variables

   * must not be realloc()'ed.

   *

   * We have to change the variables to our own struct and just store the pointer

   * instead of the variable. Do it only for local variables, not for globals.

   */

  char *result = EMPTY;

  int insert;

  for (insert = 1; insert >= 0; insert--)

  {

    struct arguments *list;

    struct arguments *ptr;

    struct arguments *newlist = NULL;

    struct variable *newvar, *newind;

    list = (insert ? cur->argsinsert : cur->argsresult);

    for (ptr = list; ptr != NULL; ptr = ptr->next)

    {

      char var_text[20];

      char *original_var;

      bool skip_set_var = false;

      bool var_ptr = false;

      /* change variable name to "ECPGget_var(<counter>)" */

      original_var = ptr->variable->name;

      sprintf(var_text, "%d))", ecpg_internal_var);

      /* Don't emit ECPGset_var() calls for global variables */

      if (ptr->variable->brace_level == 0)

      {

        newvar = ptr->variable;

        skip_set_var = true;

      }

      else if ((ptr->variable->type->type == ECPGt_char_variable)

           && (strncmp(ptr->variable->name, "ECPGprepared_statement", strlen("ECPGprepared_statement")) == 0))

      {

        newvar = ptr->variable;

        skip_set_var = true;

      }

      else if ((ptr->variable->type->type != ECPGt_varchar

            && ptr->variable->type->type != ECPGt_char

            && ptr->variable->type->type != ECPGt_unsigned_char

            && ptr->variable->type->type != ECPGt_string)

           && atoi(ptr->variable->type->size) > 1)

      {

        newvar = new_variable(cat_str(4, mm_strdup("("),

                        mm_strdup(ecpg_type_name(ptr->variable->type->u.element->type)),

                        mm_strdup(" *)(ECPGget_var("),

                        mm_strdup(var_text)),

                    ECPGmake_array_type(ECPGmake_simple_type(ptr->variable->type->u.element->type,

                                         mm_strdup("1"),

                                         ptr->variable->type->u.element->counter),

                              ptr->variable->type->size),

                    0);

      }

      else if ((ptr->variable->type->type == ECPGt_varchar

            || ptr->variable->type->type == ECPGt_char

            || ptr->variable->type->type == ECPGt_unsigned_char

            || ptr->variable->type->type == ECPGt_string)

           && atoi(ptr->variable->type->size) > 1)

      {

        newvar = new_variable(cat_str(4, mm_strdup("("),

                        mm_strdup(ecpg_type_name(ptr->variable->type->type)),

                        mm_strdup(" *)(ECPGget_var("),

                        mm_strdup(var_text)),

                    ECPGmake_simple_type(ptr->variable->type->type,

                               ptr->variable->type->size,

                               ptr->variable->type->counter),

                    0);

        if (ptr->variable->type->type == ECPGt_varchar)

          var_ptr = true;

      }

      else if (ptr->variable->type->type == ECPGt_struct

           || ptr->variable->type->type == ECPGt_union)

      {

        newvar = new_variable(cat_str(5, mm_strdup("(*("),

                        mm_strdup(ptr->variable->type->type_name),

                        mm_strdup(" *)(ECPGget_var("),

                        mm_strdup(var_text),

                        mm_strdup(")")),

                    ECPGmake_struct_type(ptr->variable->type->u.members,

                               ptr->variable->type->type,

                               ptr->variable->type->type_name,

                               ptr->variable->type->struct_sizeof),

                    0);

        var_ptr = true;

      }

      else if (ptr->variable->type->type == ECPGt_array)

      {

        if (ptr->variable->type->u.element->type == ECPGt_struct

          || ptr->variable->type->u.element->type == ECPGt_union)

        {

          newvar = new_variable(cat_str(5, mm_strdup("(*("),

                        mm_strdup(ptr->variable->type->u.element->type_name),

                        mm_strdup(" *)(ECPGget_var("),

                        mm_strdup(var_text),

                        mm_strdup(")")),

                      ECPGmake_struct_type(ptr->variable->type->u.element->u.members,

                                 ptr->variable->type->u.element->type,

                                 ptr->variable->type->u.element->type_name,

                                 ptr->variable->type->u.element->struct_sizeof),

                      0);

        }

        else

        {

          newvar = new_variable(cat_str(4, mm_strdup("("),

                          mm_strdup(ecpg_type_name(ptr->variable->type->u.element->type)),

                          mm_strdup(" *)(ECPGget_var("),

                          mm_strdup(var_text)),

                      ECPGmake_array_type(ECPGmake_simple_type(ptr->variable->type->u.element->type,

                                           ptr->variable->type->u.element->size,

                                           ptr->variable->type->u.element->counter),

                                ptr->variable->type->size),

                      0);

          var_ptr = true;

        }

      }

      else

      {

        newvar = new_variable(cat_str(4, mm_strdup("*("),

                        mm_strdup(ecpg_type_name(ptr->variable->type->type)),

                        mm_strdup(" *)(ECPGget_var("),

                        mm_strdup(var_text)),

                    ECPGmake_simple_type(ptr->variable->type->type,

                               ptr->variable->type->size,

                               ptr->variable->type->counter),

                    0);

        var_ptr = true;

      }

      /* create call to "ECPGset_var(<counter>, <connection>, <pointer>. <line number>)" */

      if (!skip_set_var)

      {

        sprintf(var_text, "%d, %s", ecpg_internal_var++, var_ptr ? "&(" : "(");

        result = cat_str(5, result, mm_strdup("ECPGset_var("),

                 mm_strdup(var_text), mm_strdup(original_var),

                 mm_strdup("), __LINE__);\n"));

      }

      /* now the indicator if there is one and it's not a global variable */

      if ((ptr->indicator->type->type == ECPGt_NO_INDICATOR) || (ptr->indicator->brace_level == 0))

      {

        newind = ptr->indicator;

      }

      else

      {

        /* change variable name to "ECPGget_var(<counter>)" */

        original_var = ptr->indicator->name;

        sprintf(var_text, "%d))", ecpg_internal_var);

        var_ptr = false;

        if (ptr->indicator->type->type == ECPGt_struct

          || ptr->indicator->type->type == ECPGt_union)

        {

          newind = new_variable(cat_str(5, mm_strdup("(*("),

                        mm_strdup(ptr->indicator->type->type_name),

                        mm_strdup(" *)(ECPGget_var("),

                        mm_strdup(var_text),

                        mm_strdup(")")),

                      ECPGmake_struct_type(ptr->indicator->type->u.members,

                                 ptr->indicator->type->type,

                                 ptr->indicator->type->type_name,

                                 ptr->indicator->type->struct_sizeof),

                      0);

          var_ptr = true;

        }

        else if (ptr->indicator->type->type == ECPGt_array)

        {

          if (ptr->indicator->type->u.element->type == ECPGt_struct

            || ptr->indicator->type->u.element->type == ECPGt_union)

          {

            newind = new_variable(cat_str(5, mm_strdup("(*("),

                        mm_strdup(ptr->indicator->type->u.element->type_name),

                        mm_strdup(" *)(ECPGget_var("),

                        mm_strdup(var_text),

                        mm_strdup(")")),

                        ECPGmake_struct_type(ptr->indicator->type->u.element->u.members,

                                   ptr->indicator->type->u.element->type,

                                   ptr->indicator->type->u.element->type_name,

                                   ptr->indicator->type->u.element->struct_sizeof),

                        0);

          }

          else

          {

            newind = new_variable(cat_str(4, mm_strdup("("),

                            mm_strdup(ecpg_type_name(ptr->indicator->type->u.element->type)),

                            mm_strdup(" *)(ECPGget_var("), mm_strdup(var_text)),

                        ECPGmake_array_type(ECPGmake_simple_type(ptr->indicator->type->u.element->type,

                                             ptr->indicator->type->u.element->size,

                                             ptr->indicator->type->u.element->counter),

                                  ptr->indicator->type->size),

                        0);

            var_ptr = true;

          }

        }

        else if (atoi(ptr->indicator->type->size) > 1)

        {

          newind = new_variable(cat_str(4, mm_strdup("("),

                          mm_strdup(ecpg_type_name(ptr->indicator->type->type)),

                          mm_strdup(" *)(ECPGget_var("),

                          mm_strdup(var_text)),

                      ECPGmake_simple_type(ptr->indicator->type->type,

                                 ptr->indicator->type->size,

                                 ptr->variable->type->counter),

                      0);

        }

        else

        {

          newind = new_variable(cat_str(4, mm_strdup("*("),

                          mm_strdup(ecpg_type_name(ptr->indicator->type->type)),

                          mm_strdup(" *)(ECPGget_var("),

                          mm_strdup(var_text)),

                      ECPGmake_simple_type(ptr->indicator->type->type,

                                 ptr->indicator->type->size,

                                 ptr->variable->type->counter),

                      0);

          var_ptr = true;

        }

        /* create call to "ECPGset_var(<counter>, <pointer>. <line number>)" */

        sprintf(var_text, "%d, %s", ecpg_internal_var++, var_ptr ? "&(" : "(");

        result = cat_str(5, result, mm_strdup("ECPGset_var("),

                 mm_strdup(var_text), mm_strdup(original_var),

                 mm_strdup("), __LINE__);\n"));

      }

      add_variable_to_tail(&newlist, newvar, newind);

    }

    if (insert)

      cur->argsinsert_oos = newlist;

    else

      cur->argsresult_oos = newlist;

  }

  return result;

}

/* This tests whether the cursor was declared and opened in the same function. */

#define SAMEFUNC(cur) \

  ((cur->function == NULL) ||   \

   (cur->function != NULL && strcmp(cur->function, current_function) == 0))

static struct cursor *

add_additional_variables(char *name, bool insert)

{

  struct cursor *ptr;

  struct arguments *p;

  int (* strcmp_fn)(const char *, const char *) = ((name[0] == ':' || name[0] == '"') ? strcmp : pg_strcasecmp);

  for (ptr = cur; ptr != NULL; ptr=ptr->next)

  {

    if (strcmp_fn(ptr->name, name) == 0)

      break;

  }

  if (ptr == NULL)

  {

    mmerror(PARSE_ERROR, ET_ERROR, "cursor \"%s\" does not exist", name);

    return NULL;

  }

  if (insert)

  {

    /* add all those input variables that were given earlier

     * note that we have to append here but have to keep the existing order */

    for (p = (SAMEFUNC(ptr) ? ptr->argsinsert : ptr->argsinsert_oos); p; p = p->next)

      add_variable_to_tail(&argsinsert, p->variable, p->indicator);

  }

  /* add all those output variables that were given earlier */

  for (p = (SAMEFUNC(ptr) ? ptr->argsresult : ptr->argsresult_oos); p; p = p->next)

    add_variable_to_tail(&argsresult, p->variable, p->indicator);

  return ptr;

}

static void

add_typedef(char *name, char *dimension, char *length, enum ECPGttype type_enum,

      char *type_dimension, char *type_index, int initializer, int array)

{

  /* add entry to list */

  struct typedefs *ptr, *this;

  if ((type_enum == ECPGt_struct ||

     type_enum == ECPGt_union) &&

    initializer == 1)

    mmerror(PARSE_ERROR, ET_ERROR, "initializer not allowed in type definition");

  else if (INFORMIX_MODE && strcmp(name, "string") == 0)

    mmerror(PARSE_ERROR, ET_ERROR, "type name \"string\" is reserved in Informix mode");

  else

  {

    for (ptr = types; ptr != NULL; ptr = ptr->next)

    {

      if (strcmp(name, ptr->name) == 0)

        /* re-definition is a bug */

        mmerror(PARSE_ERROR, ET_ERROR, "type \"%s\" is already defined", name);

    }

    adjust_array(type_enum, &dimension, &length, type_dimension, type_index, array, true);

    this = (struct typedefs *) mm_alloc(sizeof(struct typedefs));

    /* initial definition */

    this->next = types;

    this->name = name;

    this->brace_level = braces_open;

    this->type = (struct this_type *) mm_alloc(sizeof(struct this_type));

    this->type->type_enum = type_enum;

    this->type->type_str = mm_strdup(name);

    this->type->type_dimension = dimension; /* dimension of array */

    this->type->type_index = length;  /* length of string */

    this->type->type_sizeof = ECPGstruct_sizeof;

    this->struct_member_list = (type_enum == ECPGt_struct || type_enum == ECPGt_union) ?

    ECPGstruct_member_dup(struct_member_list[struct_level]) : NULL;

    if (type_enum != ECPGt_varchar &&

      type_enum != ECPGt_char &&

      type_enum != ECPGt_unsigned_char &&

      type_enum != ECPGt_string &&

      atoi(this->type->type_index) >= 0)

      mmerror(PARSE_ERROR, ET_ERROR, "multidimensional arrays for simple data types are not supported");

    types = this;

  }

}

#line 651 "preproc.c"

# ifndef YY_NULLPTR

#  if defined __cplusplus

#   if 201103L <= __cplusplus

#    define YY_NULLPTR nullptr

#   else

#    define YY_NULLPTR 0

#   endif

#  else

#   define YY_NULLPTR ((void*)0)

#  endif

# endif

/* Enabling verbose error messages.  */

#ifdef YYERROR_VERBOSE

# undef YYERROR_VERBOSE

# define YYERROR_VERBOSE 1

#else

# define YYERROR_VERBOSE 0

#endif

/* Use api.header.include to #include this header

   instead of duplicating it here.  */

#ifndef YY_BASE_YY_PREPROC_H_INCLUDED

# define YY_BASE_YY_PREPROC_H_INCLUDED

/* Debug traces.  */

#ifndef YYDEBUG

# define YYDEBUG 0

#endif

#if YYDEBUG

extern int base_yydebug;

#endif

/* Token type.  */

#ifndef YYTOKENTYPE

# define YYTOKENTYPE

  enum yytokentype

  {

    SQL_ALLOCATE = 258,

    SQL_AUTOCOMMIT = 259,

    SQL_BOOL = 260,

    SQL_BREAK = 261,

    SQL_CARDINALITY = 262,

    SQL_CONNECT = 263,

    SQL_COUNT = 264,

    SQL_DATETIME_INTERVAL_CODE = 265,

    SQL_DATETIME_INTERVAL_PRECISION = 266,

    SQL_DESCRIBE = 267,

    SQL_DESCRIPTOR = 268,

    SQL_DISCONNECT = 269,

    SQL_FOUND = 270,

    SQL_FREE = 271,

    SQL_GET = 272,

    SQL_GO = 273,

    SQL_GOTO = 274,

    SQL_IDENTIFIED = 275,

    SQL_INDICATOR = 276,

    SQL_KEY_MEMBER = 277,

    SQL_LENGTH = 278,

    SQL_LONG = 279,

    SQL_NULLABLE = 280,

    SQL_OCTET_LENGTH = 281,

    SQL_OPEN = 282,

    SQL_OUTPUT = 283,

    SQL_REFERENCE = 284,

    SQL_RETURNED_LENGTH = 285,

    SQL_RETURNED_OCTET_LENGTH = 286,

    SQL_SCALE = 287,

    SQL_SECTION = 288,

    SQL_SHORT = 289,

    SQL_SIGNED = 290,

    SQL_SQLERROR = 291,

    SQL_SQLPRINT = 292,

    SQL_SQLWARNING = 293,

    SQL_START = 294,

    SQL_STOP = 295,

    SQL_STRUCT = 296,

    SQL_UNSIGNED = 297,

    SQL_VAR = 298,

    SQL_WHENEVER = 299,

    S_ADD = 300,

    S_AND = 301,

    S_ANYTHING = 302,

    S_AUTO = 303,

    S_CONST = 304,

    S_DEC = 305,

    S_DIV = 306,

    S_DOTPOINT = 307,

    S_EQUAL = 308,

    S_EXTERN = 309,

    S_INC = 310,

    S_LSHIFT = 311,

    S_MEMPOINT = 312,

    S_MEMBER = 313,

    S_MOD = 314,

    S_MUL = 315,

    S_NEQUAL = 316,

    S_OR = 317,

    S_REGISTER = 318,

    S_RSHIFT = 319,

    S_STATIC = 320,

    S_SUB = 321,

    S_VOLATILE = 322,

    S_TYPEDEF = 323,

    CSTRING = 324,

    CVARIABLE = 325,

    CPP_LINE = 326,

    IP = 327,

    DOLCONST = 328,

    ECONST = 329,

    NCONST = 330,

    UCONST = 331,

    UIDENT = 332,

    IDENT = 333,

    FCONST = 334,

    SCONST = 335,

    BCONST = 336,

    XCONST = 337,

    Op = 338,

    ICONST = 339,

    PARAM = 340,

    TYPECAST = 341,

    DOT_DOT = 342,

    COLON_EQUALS = 343,

    EQUALS_GREATER = 344,

    LESS_EQUALS = 345,

    GREATER_EQUALS = 346,

    NOT_EQUALS = 347,

    ABORT_P = 348,

    ABSOLUTE_P = 349,

    ACCESS = 350,

    ACTION = 351,

    ADD_P = 352,

    ADMIN = 353,

    AFTER = 354,

    AGGREGATE = 355,

    ALL = 356,

    ALSO = 357,

    ALTER = 358,

    ALWAYS = 359,

    ANALYSE = 360,

    ANALYZE = 361,

    AND = 362,

    ANY = 363,

    ARRAY = 364,

    AS = 365,

    ASC = 366,

    ASSERTION = 367,

    ASSIGNMENT = 368,

    ASYMMETRIC = 369,

    AT = 370,

    ATTACH = 371,

    ATTRIBUTE = 372,

    AUTHORIZATION = 373,

    BACKFILL = 374,

    BACKWARD = 375,

    BEFORE = 376,

    BEGIN_P = 377,

    BETWEEN = 378,

    BIGINT = 379,

    BINARY = 380,

    BIT = 381,

    BOOLEAN_P = 382,

    BOTH = 383,

    BY = 384,

    CACHE = 385,

    CALL = 386,

    CALLED = 387,

    CASCADE = 388,

    CASCADED = 389,

    CASE = 390,

    CAST = 391,

    CATALOG_P = 392,

    CHAIN = 393,

    CHAR_P = 394,

    CHARACTER = 395,

    CHARACTERISTICS = 396,

    CHECK = 397,

    CHECKPOINT = 398,

    CLASS = 399,

    CLOSE = 400,

    CLUSTER = 401,

    COALESCE = 402,

    COLLATE = 403,

    COLLATION = 404,

    COLOCATED = 405,

    COLUMN = 406,

    COLUMNS = 407,

    COMMENT = 408,

    COMMENTS = 409,

    COMMIT = 410,

    COMMITTED = 411,

    CONCURRENTLY = 412,

    CONFIGURATION = 413,

    CONFLICT = 414,

    CONNECTION = 415,

    CONSTRAINT = 416,

    CONSTRAINTS = 417,

    CONTENT_P = 418,

    CONTINUE_P = 419,

    CONVERSION_P = 420,

    COPY = 421,

    COST = 422,

    CREATE = 423,

    CROSS = 424,

    CSV = 425,

    CUBE = 426,

    CURRENT_P = 427,

    CURRENT_CATALOG = 428,

    CURRENT_DATE = 429,

    CURRENT_ROLE = 430,

    CURRENT_SCHEMA = 431,

    CURRENT_TIME = 432,

    CURRENT_TIMESTAMP = 433,

    CURRENT_USER = 434,

    CURSOR = 435,

    CYCLE = 436,

    DATA_P = 437,

    DATABASE = 438,

    DAY_P = 439,

    DEALLOCATE = 440,

    DEC = 441,

    DECIMAL_P = 442,

    DECLARE = 443,

    DEFAULT = 444,

    DEFAULTS = 445,

    DEFERRABLE = 446,

    DEFERRED = 447,

    DEFINER = 448,

    DELETE_P = 449,

    DELIMITER = 450,

    DELIMITERS = 451,

    DEPENDS = 452,

    DESC = 453,

    DETACH = 454,

    DICTIONARY = 455,

    DISABLE_P = 456,

    DISCARD = 457,

    DISTINCT = 458,

    DO = 459,

    DOCUMENT_P = 460,

    DOMAIN_P = 461,

    DOUBLE_P = 462,

    DROP = 463,

    EACH = 464,

    ELSE = 465,

    ENABLE_P = 466,

    ENCODING = 467,

    ENCRYPTED = 468,

    END_P = 469,

    ENUM_P = 470,

    ESCAPE = 471,

    EVENT = 472,

    EXCEPT = 473,

    EXCLUDE = 474,

    EXCLUDING = 475,

    EXCLUSIVE = 476,

    EXECUTE = 477,

    EXISTS = 478,

    EXPLAIN = 479,

    EXTENSION = 480,

    EXTERNAL = 481,

    EXTRACT = 482,

    FALSE_P = 483,

    FAMILY = 484,

    FETCH = 485,

    FILTER = 486,

    FIRST_P = 487,

    FLOAT_P = 488,

    FOLLOWING = 489,

    FOR = 490,

    FORCE = 491,

    FOREIGN = 492,

    FORWARD = 493,

    FREEZE = 494,

    FROM = 495,

    FULL = 496,

    FUNCTION = 497,

    FUNCTIONS = 498,

    GENERATED = 499,

    GLOBAL = 500,

    GRANT = 501,

    GRANTED = 502,

    GREATEST = 503,

    GROUP_P = 504,

    GROUPING = 505,

    GROUPS = 506,

    HANDLER = 507,

    HASH = 508,

    HAVING = 509,

    HEADER_P = 510,

    HOLD = 511,

    HOUR_P = 512,

    IDENTITY_P = 513,

    IF_P = 514,

    ILIKE = 515,

    IMMEDIATE = 516,

    IMMUTABLE = 517,

    IMPLICIT_P = 518,

    IMPORT_P = 519,

    IN_P = 520,

    INCLUDE = 521,

    INCLUDING = 522,

    INCREMENT = 523,

    INDEX = 524,

    INDEXES = 525,

    INHERIT = 526,

    INHERITS = 527,

    INITIALLY = 528,

    INLINE_P = 529,

    INNER_P = 530,

    INOUT = 531,

    INPUT_P = 532,

    INSENSITIVE = 533,

    INSERT = 534,

    INSTEAD = 535,

    INT_P = 536,

    INTEGER = 537,

    INTERSECT = 538,

    INTERVAL = 539,

    INTO = 540,

    INVOKER = 541,

    IS = 542,

    ISNULL = 543,

    ISOLATION = 544,

    JOIN = 545,

    KEY = 546,

    LABEL = 547,

    LANGUAGE = 548,

    LARGE_P = 549,

    LAST_P = 550,

    LATERAL_P = 551,

    LEADING = 552,