y.tab.c

Go to the documentation of this file.
00001 /* A Bison parser, made by GNU Bison 2.3.  */
00002 
00003 /* Skeleton implementation for Bison's Yacc-like parsers in C
00004 
00005    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
00006    Free Software Foundation, Inc.
00007 
00008    This program is free software; you can redistribute it and/or modify
00009    it under the terms of the GNU General Public License as published by
00010    the Free Software Foundation; either version 2, or (at your option)
00011    any later version.
00012 
00013    This program is distributed in the hope that it will be useful,
00014    but WITHOUT ANY WARRANTY; without even the implied warranty of
00015    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016    GNU General Public License for more details.
00017 
00018    You should have received a copy of the GNU General Public License
00019    along with this program; if not, write to the Free Software
00020    Foundation, Inc., 51 Franklin Street, Fifth Floor,
00021    Boston, MA 02110-1301, USA.  */
00022 
00023 /* As a special exception, you may create a larger work that contains
00024    part or all of the Bison parser skeleton and distribute that work
00025    under terms of your choice, so long as that work isn't itself a
00026    parser generator using the skeleton or a modified version thereof
00027    as a parser skeleton.  Alternatively, if you modify or redistribute
00028    the parser skeleton itself, you may (at your option) remove this
00029    special exception, which will cause the skeleton and the resulting
00030    Bison output files to be licensed under the GNU General Public
00031    License without this special exception.
00032 
00033    This special exception was added by the Free Software Foundation in
00034    version 2.2 of Bison.  */
00035 
00036 /* C LALR(1) parser skeleton written by Richard Stallman, by
00037    simplifying the original so-called "semantic" parser.  */
00038 
00039 /* All symbols defined below should begin with yy or YY, to avoid
00040    infringing on user name space.  This should be done even for local
00041    variables, as they might otherwise be expanded by user macros.
00042    There are some unavoidable exceptions within include files to
00043    define necessary library symbols; they are noted "INFRINGES ON
00044    USER NAME SPACE" below.  */
00045 
00046 /* Identify Bison output.  */
00047 #define YYBISON 1
00048 
00049 /* Bison version.  */
00050 #define YYBISON_VERSION "2.3"
00051 
00052 /* Skeleton name.  */
00053 #define YYSKELETON_NAME "yacc.c"
00054 
00055 /* Pure parsers.  */
00056 #define YYPURE 0
00057 
00058 /* Using locations.  */
00059 #define YYLSP_NEEDED 0
00060 
00061 
00062 
00063 /* Tokens.  */
00064 #ifndef YYTOKENTYPE
00065 # define YYTOKENTYPE
00066    /* Put the tokens into the symbol table, so that GDB and other debuggers
00067       know about them.  */
00068    enum yytokentype {
00069      COMPARISON_OPERATOR = 258,
00070      NAME = 259,
00071      STRING = 260,
00072      INTNUM = 261,
00073      FLOATNUM = 262,
00074      ADD = 263,
00075      COLUMN = 264,
00076      EQUAL = 265,
00077      SELECT = 266,
00078      FROM = 267,
00079      WHERE = 268,
00080      DELETE = 269,
00081      INSERT = 270,
00082      INTO = 271,
00083      VALUES = 272,
00084      UPDATE = 273,
00085      SET = 274,
00086      AND = 275,
00087      OR = 276,
00088      NOT = 277,
00089      ALTER = 278,
00090      TABLE = 279,
00091      CREATE = 280,
00092      DROP = 281,
00093      NULL_VALUE = 282,
00094      VARCHAR = 283,
00095      INT = 284,
00096      INTEGER = 285,
00097      DOUBLE = 286,
00098      PRECISION = 287,
00099      DATE = 288,
00100      TIME = 289,
00101      ORDER = 290,
00102      BY = 291,
00103      IS = 292
00104    };
00105 #endif
00106 /* Tokens.  */
00107 #define COMPARISON_OPERATOR 258
00108 #define NAME 259
00109 #define STRING 260
00110 #define INTNUM 261
00111 #define FLOATNUM 262
00112 #define ADD 263
00113 #define COLUMN 264
00114 #define EQUAL 265
00115 #define SELECT 266
00116 #define FROM 267
00117 #define WHERE 268
00118 #define DELETE 269
00119 #define INSERT 270
00120 #define INTO 271
00121 #define VALUES 272
00122 #define UPDATE 273
00123 #define SET 274
00124 #define AND 275
00125 #define OR 276
00126 #define NOT 277
00127 #define ALTER 278
00128 #define TABLE 279
00129 #define CREATE 280
00130 #define DROP 281
00131 #define NULL_VALUE 282
00132 #define VARCHAR 283
00133 #define INT 284
00134 #define INTEGER 285
00135 #define DOUBLE 286
00136 #define PRECISION 287
00137 #define DATE 288
00138 #define TIME 289
00139 #define ORDER 290
00140 #define BY 291
00141 #define IS 292
00142 
00143 
00144 
00145 
00146 /* Copy the first part of user declarations.  */
00147 #line 21 "yac.y"
00148 
00149 #include <stdlib.h>
00150 #include <string.h>
00151 #include <math.h>
00152 #include <grass/sqlp.h>
00153 
00154 #define YYDEBUG 1
00155 
00156 
00157 
00158 /* Enabling traces.  */
00159 #ifndef YYDEBUG
00160 # define YYDEBUG 0
00161 #endif
00162 
00163 /* Enabling verbose error messages.  */
00164 #ifdef YYERROR_VERBOSE
00165 # undef YYERROR_VERBOSE
00166 # define YYERROR_VERBOSE 1
00167 #else
00168 # define YYERROR_VERBOSE 0
00169 #endif
00170 
00171 /* Enabling the token table.  */
00172 #ifndef YYTOKEN_TABLE
00173 # define YYTOKEN_TABLE 0
00174 #endif
00175 
00176 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00177 typedef union YYSTYPE
00178 #line 33 "yac.y"
00179 {
00180         int    intval;
00181         double floatval;
00182         char   *strval;
00183         int    subtok;
00184         SQLPNODE   *node;
00185 }
00186 /* Line 187 of yacc.c.  */
00187 #line 188 "y.tab.c"
00188         YYSTYPE;
00189 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00190 # define YYSTYPE_IS_DECLARED 1
00191 # define YYSTYPE_IS_TRIVIAL 1
00192 #endif
00193 
00194 
00195 
00196 /* Copy the second part of user declarations.  */
00197 #line 85 "yac.y"
00198 
00199  
00200 extern int yylex(void);
00201 
00202 
00203 
00204 /* Line 216 of yacc.c.  */
00205 #line 206 "y.tab.c"
00206 
00207 #ifdef short
00208 # undef short
00209 #endif
00210 
00211 #ifdef YYTYPE_UINT8
00212 typedef YYTYPE_UINT8 yytype_uint8;
00213 #else
00214 typedef unsigned char yytype_uint8;
00215 #endif
00216 
00217 #ifdef YYTYPE_INT8
00218 typedef YYTYPE_INT8 yytype_int8;
00219 #elif (defined __STDC__ || defined __C99__FUNC__ \
00220      || defined __cplusplus || defined _MSC_VER)
00221 typedef signed char yytype_int8;
00222 #else
00223 typedef short int yytype_int8;
00224 #endif
00225 
00226 #ifdef YYTYPE_UINT16
00227 typedef YYTYPE_UINT16 yytype_uint16;
00228 #else
00229 typedef unsigned short int yytype_uint16;
00230 #endif
00231 
00232 #ifdef YYTYPE_INT16
00233 typedef YYTYPE_INT16 yytype_int16;
00234 #else
00235 typedef short int yytype_int16;
00236 #endif
00237 
00238 #ifndef YYSIZE_T
00239 # ifdef __SIZE_TYPE__
00240 #  define YYSIZE_T __SIZE_TYPE__
00241 # elif defined size_t
00242 #  define YYSIZE_T size_t
00243 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
00244      || defined __cplusplus || defined _MSC_VER)
00245 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00246 #  define YYSIZE_T size_t
00247 # else
00248 #  define YYSIZE_T unsigned int
00249 # endif
00250 #endif
00251 
00252 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
00253 
00254 #ifndef YY_
00255 # if YYENABLE_NLS
00256 #  if ENABLE_NLS
00257 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
00258 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
00259 #  endif
00260 # endif
00261 # ifndef YY_
00262 #  define YY_(msgid) msgid
00263 # endif
00264 #endif
00265 
00266 /* Suppress unused-variable warnings by "using" E.  */
00267 #if ! defined lint || defined __GNUC__
00268 # define YYUSE(e) ((void) (e))
00269 #else
00270 # define YYUSE(e) /* empty */
00271 #endif
00272 
00273 /* Identity function, used to suppress warnings about constant conditions.  */
00274 #ifndef lint
00275 # define YYID(n) (n)
00276 #else
00277 #if (defined __STDC__ || defined __C99__FUNC__ \
00278      || defined __cplusplus || defined _MSC_VER)
00279 static int
00280 YYID (int i)
00281 #else
00282 static int
00283 YYID (i)
00284     int i;
00285 #endif
00286 {
00287   return i;
00288 }
00289 #endif
00290 
00291 #if ! defined yyoverflow || YYERROR_VERBOSE
00292 
00293 /* The parser invokes alloca or malloc; define the necessary symbols.  */
00294 
00295 # ifdef YYSTACK_USE_ALLOCA
00296 #  if YYSTACK_USE_ALLOCA
00297 #   ifdef __GNUC__
00298 #    define YYSTACK_ALLOC __builtin_alloca
00299 #   elif defined __BUILTIN_VA_ARG_INCR
00300 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
00301 #   elif defined _AIX
00302 #    define YYSTACK_ALLOC __alloca
00303 #   elif defined _MSC_VER
00304 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
00305 #    define alloca _alloca
00306 #   else
00307 #    define YYSTACK_ALLOC alloca
00308 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00309      || defined __cplusplus || defined _MSC_VER)
00310 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00311 #     ifndef _STDLIB_H
00312 #      define _STDLIB_H 1
00313 #     endif
00314 #    endif
00315 #   endif
00316 #  endif
00317 # endif
00318 
00319 # ifdef YYSTACK_ALLOC
00320    /* Pacify GCC's `empty if-body' warning.  */
00321 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
00322 #  ifndef YYSTACK_ALLOC_MAXIMUM
00323     /* The OS might guarantee only one guard page at the bottom of the stack,
00324        and a page size can be as small as 4096 bytes.  So we cannot safely
00325        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
00326        to allow for a few compiler-allocated temporary stack slots.  */
00327 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
00328 #  endif
00329 # else
00330 #  define YYSTACK_ALLOC YYMALLOC
00331 #  define YYSTACK_FREE YYFREE
00332 #  ifndef YYSTACK_ALLOC_MAXIMUM
00333 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
00334 #  endif
00335 #  if (defined __cplusplus && ! defined _STDLIB_H \
00336        && ! ((defined YYMALLOC || defined malloc) \
00337              && (defined YYFREE || defined free)))
00338 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00339 #   ifndef _STDLIB_H
00340 #    define _STDLIB_H 1
00341 #   endif
00342 #  endif
00343 #  ifndef YYMALLOC
00344 #   define YYMALLOC malloc
00345 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00346      || defined __cplusplus || defined _MSC_VER)
00347 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
00348 #   endif
00349 #  endif
00350 #  ifndef YYFREE
00351 #   define YYFREE free
00352 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00353      || defined __cplusplus || defined _MSC_VER)
00354 void free (void *); /* INFRINGES ON USER NAME SPACE */
00355 #   endif
00356 #  endif
00357 # endif
00358 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
00359 
00360 
00361 #if (! defined yyoverflow \
00362      && (! defined __cplusplus \
00363          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
00364 
00365 /* A type that is properly aligned for any stack member.  */
00366 union yyalloc
00367 {
00368   yytype_int16 yyss;
00369   YYSTYPE yyvs;
00370   };
00371 
00372 /* The size of the maximum gap between one aligned stack and the next.  */
00373 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
00374 
00375 /* The size of an array large to enough to hold all stacks, each with
00376    N elements.  */
00377 # define YYSTACK_BYTES(N) \
00378      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
00379       + YYSTACK_GAP_MAXIMUM)
00380 
00381 /* Copy COUNT objects from FROM to TO.  The source and destination do
00382    not overlap.  */
00383 # ifndef YYCOPY
00384 #  if defined __GNUC__ && 1 < __GNUC__
00385 #   define YYCOPY(To, From, Count) \
00386       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00387 #  else
00388 #   define YYCOPY(To, From, Count)              \
00389       do                                        \
00390         {                                       \
00391           YYSIZE_T yyi;                         \
00392           for (yyi = 0; yyi < (Count); yyi++)   \
00393             (To)[yyi] = (From)[yyi];            \
00394         }                                       \
00395       while (YYID (0))
00396 #  endif
00397 # endif
00398 
00399 /* Relocate STACK from its old location to the new one.  The
00400    local variables YYSIZE and YYSTACKSIZE give the old and new number of
00401    elements in the stack, and YYPTR gives the new location of the
00402    stack.  Advance YYPTR to a properly aligned location for the next
00403    stack.  */
00404 # define YYSTACK_RELOCATE(Stack)                                        \
00405     do                                                                  \
00406       {                                                                 \
00407         YYSIZE_T yynewbytes;                                            \
00408         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
00409         Stack = &yyptr->Stack;                                          \
00410         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
00411         yyptr += yynewbytes / sizeof (*yyptr);                          \
00412       }                                                                 \
00413     while (YYID (0))
00414 
00415 #endif
00416 
00417 /* YYFINAL -- State number of the termination state.  */
00418 #define YYFINAL  27
00419 /* YYLAST -- Last index in YYTABLE.  */
00420 #define YYLAST   144
00421 
00422 /* YYNTOKENS -- Number of terminals.  */
00423 #define YYNTOKENS  46
00424 /* YYNNTS -- Number of nonterminals.  */
00425 #define YYNNTS  30
00426 /* YYNRULES -- Number of rules.  */
00427 #define YYNRULES  82
00428 /* YYNRULES -- Number of states.  */
00429 #define YYNSTATES  150
00430 
00431 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
00432 #define YYUNDEFTOK  2
00433 #define YYMAXUTOK   292
00434 
00435 #define YYTRANSLATE(YYX)                                                \
00436   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
00437 
00438 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
00439 static const yytype_uint8 yytranslate[] =
00440 {
00441        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00442        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00443        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00444        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00445       39,    40,    42,    44,    41,    43,     2,    45,     2,     2,
00446        2,     2,     2,     2,     2,     2,     2,     2,     2,    38,
00447        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00448        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00449        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00450        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00451        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00452        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00453        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00454        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00455        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00456        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00457        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00458        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00459        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00460        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00461        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00462        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00463        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00464        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00465        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00466        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
00467        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
00468       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
00469       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
00470       35,    36,    37
00471 };
00472 
00473 #if YYDEBUG
00474 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
00475    YYRHS.  */
00476 static const yytype_uint16 yyprhs[] =
00477 {
00478        0,     0,     3,     5,     7,     9,    11,    13,    15,    17,
00479       20,    27,    33,    40,    44,    49,    56,    64,    74,    78,
00480       84,    89,    97,   102,   109,   111,   115,   121,   124,   127,
00481      130,   134,   137,   140,   142,   144,   146,   150,   152,   157,
00482      159,   161,   163,   166,   168,   171,   175,   179,   183,   188,
00483      192,   197,   199,   203,   207,   211,   213,   215,   219,   221,
00484      225,   227,   231,   234,   238,   242,   246,   250,   252,   256,
00485      260,   262,   266,   270,   272,   275,   277,   279,   283,   285,
00486      287,   289,   291
00487 };
00488 
00489 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
00490 static const yytype_int8 yyrhs[] =
00491 {
00492       47,     0,    -1,    48,    -1,    49,    -1,    50,    -1,    53,
00493       -1,    51,    -1,    54,    -1,    52,    -1,    47,    38,    -1,
00494       23,    24,    59,     8,     9,    56,    -1,    23,    24,    59,
00495        8,    56,    -1,    25,    24,    59,    39,    55,    40,    -1,
00496       26,    24,    59,    -1,    11,    57,    12,    59,    -1,    11,
00497       57,    12,    59,    13,    64,    -1,    11,    57,    12,    59,
00498       35,    36,    75,    -1,    11,    57,    12,    59,    13,    64,
00499       35,    36,    75,    -1,    14,    12,    59,    -1,    14,    12,
00500       59,    13,    64,    -1,    15,    16,    59,    60,    -1,    15,
00501       16,    59,    39,    57,    40,    60,    -1,    18,    59,    19,
00502       62,    -1,    18,    59,    19,    62,    13,    64,    -1,    56,
00503       -1,    55,    41,    56,    -1,     4,    28,    39,     6,    40,
00504       -1,     4,    29,    -1,     4,    30,    -1,     4,    31,    -1,
00505        4,    31,    32,    -1,     4,    33,    -1,     4,    34,    -1,
00506       42,    -1,    58,    -1,     4,    -1,    58,    41,     4,    -1,
00507        4,    -1,    17,    39,    61,    40,    -1,    27,    -1,     5,
00508       -1,     6,    -1,    43,     6,    -1,     7,    -1,    43,     7,
00509       -1,    61,    41,    27,    -1,    61,    41,     5,    -1,    61,
00510       41,     6,    -1,    61,    41,    43,     6,    -1,    61,    41,
00511        7,    -1,    61,    41,    43,     7,    -1,    63,    -1,    62,
00512       41,    63,    -1,     4,    10,    27,    -1,     4,    10,    69,
00513       -1,    65,    -1,    66,    -1,    65,    21,    66,    -1,    67,
00514       -1,    66,    20,    67,    -1,    68,    -1,    39,    65,    40,
00515       -1,    22,    67,    -1,    69,    10,    69,    -1,    69,     3,
00516       69,    -1,    69,    37,    27,    -1,    69,    22,    27,    -1,
00517       70,    -1,    69,    44,    70,    -1,    69,    43,    70,    -1,
00518       71,    -1,    70,    42,    71,    -1,    70,    45,    71,    -1,
00519       72,    -1,    43,    71,    -1,    73,    -1,    74,    -1,    39,
00520       69,    40,    -1,     5,    -1,     6,    -1,     7,    -1,     4,
00521       -1,     4,    -1
00522 };
00523 
00524 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
00525 static const yytype_uint16 yyrline[] =
00526 {
00527        0,    94,    94,    95,    96,    97,    98,    99,   100,   101,
00528      105,   106,   110,   114,   118,   119,   120,   121,   125,   126,
00529      130,   131,   135,   136,   141,   142,   146,   147,   148,   149,
00530      150,   151,   152,   156,   157,   161,   162,   166,   170,   174,
00531      175,   176,   177,   178,   179,   180,   181,   182,   183,   184,
00532      185,   189,   190,   194,   198,   202,   209,   210,   214,   215,
00533      219,   220,   221,   226,   229,   232,   235,   242,   243,   246,
00534      252,   253,   256,   262,   263,   269,   270,   271,   276,   277,
00535      278,   283,   287
00536 };
00537 #endif
00538 
00539 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
00540 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
00541    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
00542 static const char *const yytname[] =
00543 {
00544   "$end", "error", "$undefined", "COMPARISON_OPERATOR", "NAME", "STRING",
00545   "INTNUM", "FLOATNUM", "ADD", "COLUMN", "EQUAL", "SELECT", "FROM",
00546   "WHERE", "DELETE", "INSERT", "INTO", "VALUES", "UPDATE", "SET", "AND",
00547   "OR", "NOT", "ALTER", "TABLE", "CREATE", "DROP", "NULL_VALUE", "VARCHAR",
00548   "INT", "INTEGER", "DOUBLE", "PRECISION", "DATE", "TIME", "ORDER", "BY",
00549   "IS", "';'", "'('", "')'", "','", "'*'", "'-'", "'+'", "'/'", "$accept",
00550   "y_sql", "y_alter", "y_create", "y_drop", "y_select", "y_delete",
00551   "y_insert", "y_update", "y_columndefs", "y_columndef", "y_columns",
00552   "y_column_list", "y_table", "y_values", "y_value_list", "y_assignments",
00553   "y_assignment", "y_condition", "y_sub_condition", "y_sub_condition2",
00554   "y_boolean", "y_comparison", "y_expression", "y_product", "y_term",
00555   "y_atom", "y_value", "y_column", "y_order", 0
00556 };
00557 #endif
00558 
00559 # ifdef YYPRINT
00560 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
00561    token YYLEX-NUM.  */
00562 static const yytype_uint16 yytoknum[] =
00563 {
00564        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
00565      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
00566      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
00567      285,   286,   287,   288,   289,   290,   291,   292,    59,    40,
00568       41,    44,    42,    45,    43,    47
00569 };
00570 # endif
00571 
00572 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
00573 static const yytype_uint8 yyr1[] =
00574 {
00575        0,    46,    47,    47,    47,    47,    47,    47,    47,    47,
00576       48,    48,    49,    50,    51,    51,    51,    51,    52,    52,
00577       53,    53,    54,    54,    55,    55,    56,    56,    56,    56,
00578       56,    56,    56,    57,    57,    58,    58,    59,    60,    61,
00579       61,    61,    61,    61,    61,    61,    61,    61,    61,    61,
00580       61,    62,    62,    63,    63,    64,    65,    65,    66,    66,
00581       67,    67,    67,    68,    68,    68,    68,    69,    69,    69,
00582       70,    70,    70,    71,    71,    72,    72,    72,    73,    73,
00583       73,    74,    75
00584 };
00585 
00586 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
00587 static const yytype_uint8 yyr2[] =
00588 {
00589        0,     2,     1,     1,     1,     1,     1,     1,     1,     2,
00590        6,     5,     6,     3,     4,     6,     7,     9,     3,     5,
00591        4,     7,     4,     6,     1,     3,     5,     2,     2,     2,
00592        3,     2,     2,     1,     1,     1,     3,     1,     4,     1,
00593        1,     1,     2,     1,     2,     3,     3,     3,     4,     3,
00594        4,     1,     3,     3,     3,     1,     1,     3,     1,     3,
00595        1,     3,     2,     3,     3,     3,     3,     1,     3,     3,
00596        1,     3,     3,     1,     2,     1,     1,     3,     1,     1,
00597        1,     1,     1
00598 };
00599 
00600 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
00601    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
00602    means the default is an error.  */
00603 static const yytype_uint8 yydefact[] =
00604 {
00605        0,     0,     0,     0,     0,     0,     0,     0,     0,     2,
00606        3,     4,     6,     8,     5,     7,    35,    33,     0,    34,
00607        0,     0,    37,     0,     0,     0,     0,     1,     9,     0,
00608        0,    18,     0,     0,     0,     0,    13,    14,    36,     0,
00609        0,     0,    20,     0,    22,    51,     0,     0,     0,     0,
00610       81,    78,    79,    80,     0,     0,     0,    19,    55,    56,
00611       58,    60,     0,    67,    70,    73,    75,    76,     0,     0,
00612        0,     0,     0,     0,     0,    11,     0,    24,    15,     0,
00613       62,     0,     0,     0,    74,     0,     0,     0,     0,     0,
00614        0,     0,     0,     0,     0,    40,    41,    43,    39,     0,
00615        0,     0,    53,    54,    23,    52,     0,    27,    28,    29,
00616       31,    32,    10,    12,     0,     0,    82,    16,    61,    77,
00617        0,    57,    59,    64,    63,    66,    65,    69,    68,    71,
00618       72,    42,    44,    38,     0,    21,     0,    30,    25,     0,
00619       46,    47,    49,    45,     0,     0,    17,    48,    50,    26
00620 };
00621 
00622 /* YYDEFGOTO[NTERM-NUM].  */
00623 static const yytype_int8 yydefgoto[] =
00624 {
00625       -1,     8,     9,    10,    11,    12,    13,    14,    15,    76,
00626       75,    18,    19,    23,    42,   100,    44,    45,    57,    58,
00627       59,    60,    61,    62,    63,    64,    65,    66,    67,   117
00628 };
00629 
00630 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
00631    STATE-NUM.  */
00632 #define YYPACT_NINF -51
00633 static const yytype_int16 yypact[] =
00634 {
00635       68,     3,     9,    -1,    66,    37,    50,    53,     2,   -51,
00636      -51,   -51,   -51,   -51,   -51,   -51,   -51,   -51,    78,    76,
00637       66,    66,   -51,    90,    66,    66,    66,   -51,   -51,    66,
00638      112,   105,    36,   115,   113,    81,   -51,    41,   -51,     7,
00639       84,     3,   -51,   114,    -8,   -51,    83,   118,     7,    89,
00640      -51,   -51,   -51,   -51,     7,     7,    19,   -51,   107,   109,
00641      -51,   -51,     0,   -36,   -51,   -51,   -51,   -51,    25,    86,
00642       12,     7,   115,    77,   118,   -51,    32,   -51,    92,   126,
00643      -51,    38,    -2,    19,   -51,     7,     7,    19,    19,   104,
00644      108,    19,    19,    19,    19,   -51,   -51,   -51,   -51,    74,
00645       57,   116,   -51,    59,   -51,   -51,    93,   -51,   -51,   102,
00646      -51,   -51,   -51,   -51,   118,   100,   -51,   -51,   -51,   -51,
00647       20,   109,   -51,    59,    59,   -51,   -51,   -36,   -36,   -51,
00648      -51,   -51,   -51,   -51,    42,   -51,   131,   -51,   -51,   126,
00649      -51,   -51,   -51,   -51,   106,    98,   -51,   -51,   -51,   -51
00650 };
00651 
00652 /* YYPGOTO[NTERM-NUM].  */
00653 static const yytype_int8 yypgoto[] =
00654 {
00655      -51,   -51,   -51,   -51,   -51,   -51,   -51,   -51,   -51,   -51,
00656      -47,    99,   -51,    75,    40,   -51,   -51,    67,   -14,    87,
00657       58,   -50,   -51,     1,    23,   -28,   -51,   -51,   -51,     5
00658 };
00659 
00660 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
00661    positive, shift that token.  If negative, reduce the rule which
00662    number is the opposite.  If zero, do what YYDEFACT says.
00663    If YYTABLE_NINF, syntax error.  */
00664 #define YYTABLE_NINF -1
00665 static const yytype_uint8 yytable[] =
00666 {
00667       77,    87,    27,    87,    80,    71,    93,    16,    88,    94,
00668       88,    50,    51,    52,    53,    21,    50,    51,    52,    53,
00669       89,    20,    89,    50,    51,    52,    53,   112,    84,    54,
00670       95,    96,    97,    72,    78,    90,   122,    90,   119,   102,
00671       28,    91,    92,    91,    92,    17,    55,   140,   141,   142,
00672       56,    83,    98,    40,    48,    56,    82,   104,    83,    85,
00673      119,    24,    56,    91,    92,   129,   130,   138,    99,   143,
00674       22,   103,   113,   114,    25,    41,    49,    26,   118,     1,
00675      131,   132,     2,     3,   120,   144,     4,    73,   123,   124,
00676       29,     5,    74,     6,     7,    31,    32,   133,   134,    34,
00677       35,    36,    91,    92,    37,   106,   107,   108,   109,    33,
00678      110,   111,   147,   148,   127,   128,    38,    30,    39,    43,
00679       47,    46,    73,    68,    70,    79,   101,   115,    85,    86,
00680      116,   125,   136,    40,   137,   126,   139,   145,   149,   105,
00681       69,   135,    81,   121,   146
00682 };
00683 
00684 static const yytype_uint8 yycheck[] =
00685 {
00686       47,     3,     0,     3,    54,    13,    42,     4,    10,    45,
00687       10,     4,     5,     6,     7,    16,     4,     5,     6,     7,
00688       22,    12,    22,     4,     5,     6,     7,    74,    56,    22,
00689        5,     6,     7,    41,    48,    37,    86,    37,    40,    27,
00690       38,    43,    44,    43,    44,    42,    39,     5,     6,     7,
00691       43,    39,    27,    17,    13,    43,    55,    71,    39,    21,
00692       40,    24,    43,    43,    44,    93,    94,   114,    43,    27,
00693        4,    70,    40,    41,    24,    39,    35,    24,    40,    11,
00694        6,     7,    14,    15,    83,    43,    18,     4,    87,    88,
00695       12,    23,     9,    25,    26,    20,    21,    40,    41,    24,
00696       25,    26,    43,    44,    29,    28,    29,    30,    31,    19,
00697       33,    34,     6,     7,    91,    92,     4,    41,    13,     4,
00698       39,     8,     4,    39,    10,    36,    40,    35,    21,    20,
00699        4,    27,    39,    17,    32,    27,    36,     6,    40,    72,
00700       41,   101,    55,    85,   139
00701 };
00702 
00703 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
00704    symbol of state STATE-NUM.  */
00705 static const yytype_uint8 yystos[] =
00706 {
00707        0,    11,    14,    15,    18,    23,    25,    26,    47,    48,
00708       49,    50,    51,    52,    53,    54,     4,    42,    57,    58,
00709       12,    16,     4,    59,    24,    24,    24,     0,    38,    12,
00710       41,    59,    59,    19,    59,    59,    59,    59,     4,    13,
00711       17,    39,    60,     4,    62,    63,     8,    39,    13,    35,
00712        4,     5,     6,     7,    22,    39,    43,    64,    65,    66,
00713       67,    68,    69,    70,    71,    72,    73,    74,    39,    57,
00714       10,    13,    41,     4,     9,    56,    55,    56,    64,    36,
00715       67,    65,    69,    39,    71,    21,    20,     3,    10,    22,
00716       37,    43,    44,    42,    45,     5,     6,     7,    27,    43,
00717       61,    40,    27,    69,    64,    63,    28,    29,    30,    31,
00718       33,    34,    56,    40,    41,    35,     4,    75,    40,    40,
00719       69,    66,    67,    69,    69,    27,    27,    70,    70,    71,
00720       71,     6,     7,    40,    41,    60,    39,    32,    56,    36,
00721        5,     6,     7,    27,    43,     6,    75,     6,     7,    40
00722 };
00723 
00724 #define yyerrok         (yyerrstatus = 0)
00725 #define yyclearin       (yychar = YYEMPTY)
00726 #define YYEMPTY         (-2)
00727 #define YYEOF           0
00728 
00729 #define YYACCEPT        goto yyacceptlab
00730 #define YYABORT         goto yyabortlab
00731 #define YYERROR         goto yyerrorlab
00732 
00733 
00734 /* Like YYERROR except do call yyerror.  This remains here temporarily
00735    to ease the transition to the new meaning of YYERROR, for GCC.
00736    Once GCC version 2 has supplanted version 1, this can go.  */
00737 
00738 #define YYFAIL          goto yyerrlab
00739 
00740 #define YYRECOVERING()  (!!yyerrstatus)
00741 
00742 #define YYBACKUP(Token, Value)                                  \
00743 do                                                              \
00744   if (yychar == YYEMPTY && yylen == 1)                          \
00745     {                                                           \
00746       yychar = (Token);                                         \
00747       yylval = (Value);                                         \
00748       yytoken = YYTRANSLATE (yychar);                           \
00749       YYPOPSTACK (1);                                           \
00750       goto yybackup;                                            \
00751     }                                                           \
00752   else                                                          \
00753     {                                                           \
00754       yyerror (YY_("syntax error: cannot back up")); \
00755       YYERROR;                                                  \
00756     }                                                           \
00757 while (YYID (0))
00758 
00759 
00760 #define YYTERROR        1
00761 #define YYERRCODE       256
00762 
00763 
00764 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
00765    If N is 0, then set CURRENT to the empty location which ends
00766    the previous symbol: RHS[0] (always defined).  */
00767 
00768 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
00769 #ifndef YYLLOC_DEFAULT
00770 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
00771     do                                                                  \
00772       if (YYID (N))                                                    \
00773         {                                                               \
00774           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
00775           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
00776           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
00777           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
00778         }                                                               \
00779       else                                                              \
00780         {                                                               \
00781           (Current).first_line   = (Current).last_line   =              \
00782             YYRHSLOC (Rhs, 0).last_line;                                \
00783           (Current).first_column = (Current).last_column =              \
00784             YYRHSLOC (Rhs, 0).last_column;                              \
00785         }                                                               \
00786     while (YYID (0))
00787 #endif
00788 
00789 
00790 /* YY_LOCATION_PRINT -- Print the location on the stream.
00791    This macro was not mandated originally: define only if we know
00792    we won't break user code: when these are the locations we know.  */
00793 
00794 #ifndef YY_LOCATION_PRINT
00795 # if YYLTYPE_IS_TRIVIAL
00796 #  define YY_LOCATION_PRINT(File, Loc)                  \
00797      fprintf (File, "%d.%d-%d.%d",                      \
00798               (Loc).first_line, (Loc).first_column,     \
00799               (Loc).last_line,  (Loc).last_column)
00800 # else
00801 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
00802 # endif
00803 #endif
00804 
00805 
00806 /* YYLEX -- calling `yylex' with the right arguments.  */
00807 
00808 #ifdef YYLEX_PARAM
00809 # define YYLEX yylex (YYLEX_PARAM)
00810 #else
00811 # define YYLEX yylex ()
00812 #endif
00813 
00814 /* Enable debugging if requested.  */
00815 #if YYDEBUG
00816 
00817 # ifndef YYFPRINTF
00818 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
00819 #  define YYFPRINTF fprintf
00820 # endif
00821 
00822 # define YYDPRINTF(Args)                        \
00823 do {                                            \
00824   if (yydebug)                                  \
00825     YYFPRINTF Args;                             \
00826 } while (YYID (0))
00827 
00828 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
00829 do {                                                                      \
00830   if (yydebug)                                                            \
00831     {                                                                     \
00832       YYFPRINTF (stderr, "%s ", Title);                                   \
00833       yy_symbol_print (stderr,                                            \
00834                   Type, Value); \
00835       YYFPRINTF (stderr, "\n");                                           \
00836     }                                                                     \
00837 } while (YYID (0))
00838 
00839 
00840 /*--------------------------------.
00841 | Print this symbol on YYOUTPUT.  |
00842 `--------------------------------*/
00843 
00844 /*ARGSUSED*/
00845 #if (defined __STDC__ || defined __C99__FUNC__ \
00846      || defined __cplusplus || defined _MSC_VER)
00847 static void
00848 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
00849 #else
00850 static void
00851 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
00852     FILE *yyoutput;
00853     int yytype;
00854     YYSTYPE const * const yyvaluep;
00855 #endif
00856 {
00857   if (!yyvaluep)
00858     return;
00859 # ifdef YYPRINT
00860   if (yytype < YYNTOKENS)
00861     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
00862 # else
00863   YYUSE (yyoutput);
00864 # endif
00865   switch (yytype)
00866     {
00867       default:
00868         break;
00869     }
00870 }
00871 
00872 
00873 /*--------------------------------.
00874 | Print this symbol on YYOUTPUT.  |
00875 `--------------------------------*/
00876 
00877 #if (defined __STDC__ || defined __C99__FUNC__ \
00878      || defined __cplusplus || defined _MSC_VER)
00879 static void
00880 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
00881 #else
00882 static void
00883 yy_symbol_print (yyoutput, yytype, yyvaluep)
00884     FILE *yyoutput;
00885     int yytype;
00886     YYSTYPE const * const yyvaluep;
00887 #endif
00888 {
00889   if (yytype < YYNTOKENS)
00890     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
00891   else
00892     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
00893 
00894   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
00895   YYFPRINTF (yyoutput, ")");
00896 }
00897 
00898 /*------------------------------------------------------------------.
00899 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
00900 | TOP (included).                                                   |
00901 `------------------------------------------------------------------*/
00902 
00903 #if (defined __STDC__ || defined __C99__FUNC__ \
00904      || defined __cplusplus || defined _MSC_VER)
00905 static void
00906 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
00907 #else
00908 static void
00909 yy_stack_print (bottom, top)
00910     yytype_int16 *bottom;
00911     yytype_int16 *top;
00912 #endif
00913 {
00914   YYFPRINTF (stderr, "Stack now");
00915   for (; bottom <= top; ++bottom)
00916     YYFPRINTF (stderr, " %d", *bottom);
00917   YYFPRINTF (stderr, "\n");
00918 }
00919 
00920 # define YY_STACK_PRINT(Bottom, Top)                            \
00921 do {                                                            \
00922   if (yydebug)                                                  \
00923     yy_stack_print ((Bottom), (Top));                           \
00924 } while (YYID (0))
00925 
00926 
00927 /*------------------------------------------------.
00928 | Report that the YYRULE is going to be reduced.  |
00929 `------------------------------------------------*/
00930 
00931 #if (defined __STDC__ || defined __C99__FUNC__ \
00932      || defined __cplusplus || defined _MSC_VER)
00933 static void
00934 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
00935 #else
00936 static void
00937 yy_reduce_print (yyvsp, yyrule)
00938     YYSTYPE *yyvsp;
00939     int yyrule;
00940 #endif
00941 {
00942   int yynrhs = yyr2[yyrule];
00943   int yyi;
00944   unsigned long int yylno = yyrline[yyrule];
00945   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
00946              yyrule - 1, yylno);
00947   /* The symbols being reduced.  */
00948   for (yyi = 0; yyi < yynrhs; yyi++)
00949     {
00950       fprintf (stderr, "   $%d = ", yyi + 1);
00951       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
00952                        &(yyvsp[(yyi + 1) - (yynrhs)])
00953                                        );
00954       fprintf (stderr, "\n");
00955     }
00956 }
00957 
00958 # define YY_REDUCE_PRINT(Rule)          \
00959 do {                                    \
00960   if (yydebug)                          \
00961     yy_reduce_print (yyvsp, Rule); \
00962 } while (YYID (0))
00963 
00964 /* Nonzero means print parse trace.  It is left uninitialized so that
00965    multiple parsers can coexist.  */
00966 int yydebug;
00967 #else /* !YYDEBUG */
00968 # define YYDPRINTF(Args)
00969 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
00970 # define YY_STACK_PRINT(Bottom, Top)
00971 # define YY_REDUCE_PRINT(Rule)
00972 #endif /* !YYDEBUG */
00973 
00974 
00975 /* YYINITDEPTH -- initial size of the parser's stacks.  */
00976 #ifndef YYINITDEPTH
00977 # define YYINITDEPTH 200
00978 #endif
00979 
00980 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
00981    if the built-in stack extension method is used).
00982 
00983    Do not make this value too large; the results are undefined if
00984    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
00985    evaluated with infinite-precision integer arithmetic.  */
00986 
00987 #ifndef YYMAXDEPTH
00988 # define YYMAXDEPTH 10000
00989 #endif
00990 
00991 
00992 
00993 #if YYERROR_VERBOSE
00994 
00995 # ifndef yystrlen
00996 #  if defined __GLIBC__ && defined _STRING_H
00997 #   define yystrlen strlen
00998 #  else
00999 /* Return the length of YYSTR.  */
01000 #if (defined __STDC__ || defined __C99__FUNC__ \
01001      || defined __cplusplus || defined _MSC_VER)
01002 static YYSIZE_T
01003 yystrlen (const char *yystr)
01004 #else
01005 static YYSIZE_T
01006 yystrlen (yystr)
01007     const char *yystr;
01008 #endif
01009 {
01010   YYSIZE_T yylen;
01011   for (yylen = 0; yystr[yylen]; yylen++)
01012     continue;
01013   return yylen;
01014 }
01015 #  endif
01016 # endif
01017 
01018 # ifndef yystpcpy
01019 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
01020 #   define yystpcpy stpcpy
01021 #  else
01022 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
01023    YYDEST.  */
01024 #if (defined __STDC__ || defined __C99__FUNC__ \
01025      || defined __cplusplus || defined _MSC_VER)
01026 static char *
01027 yystpcpy (char *yydest, const char *yysrc)
01028 #else
01029 static char *
01030 yystpcpy (yydest, yysrc)
01031     char *yydest;
01032     const char *yysrc;
01033 #endif
01034 {
01035   char *yyd = yydest;
01036   const char *yys = yysrc;
01037 
01038   while ((*yyd++ = *yys++) != '\0')
01039     continue;
01040 
01041   return yyd - 1;
01042 }
01043 #  endif
01044 # endif
01045 
01046 # ifndef yytnamerr
01047 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
01048    quotes and backslashes, so that it's suitable for yyerror.  The
01049    heuristic is that double-quoting is unnecessary unless the string
01050    contains an apostrophe, a comma, or backslash (other than
01051    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
01052    null, do not copy; instead, return the length of what the result
01053    would have been.  */
01054 static YYSIZE_T
01055 yytnamerr (char *yyres, const char *yystr)
01056 {
01057   if (*yystr == '"')
01058     {
01059       YYSIZE_T yyn = 0;
01060       char const *yyp = yystr;
01061 
01062       for (;;)
01063         switch (*++yyp)
01064           {
01065           case '\'':
01066           case ',':
01067             goto do_not_strip_quotes;
01068 
01069           case '\\':
01070             if (*++yyp != '\\')
01071               goto do_not_strip_quotes;
01072             /* Fall through.  */
01073           default:
01074             if (yyres)
01075               yyres[yyn] = *yyp;
01076             yyn++;
01077             break;
01078 
01079           case '"':
01080             if (yyres)
01081               yyres[yyn] = '\0';
01082             return yyn;
01083           }
01084     do_not_strip_quotes: ;
01085     }
01086 
01087   if (! yyres)
01088     return yystrlen (yystr);
01089 
01090   return yystpcpy (yyres, yystr) - yyres;
01091 }
01092 # endif
01093 
01094 /* Copy into YYRESULT an error message about the unexpected token
01095    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
01096    including the terminating null byte.  If YYRESULT is null, do not
01097    copy anything; just return the number of bytes that would be
01098    copied.  As a special case, return 0 if an ordinary "syntax error"
01099    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
01100    size calculation.  */
01101 static YYSIZE_T
01102 yysyntax_error (char *yyresult, int yystate, int yychar)
01103 {
01104   int yyn = yypact[yystate];
01105 
01106   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
01107     return 0;
01108   else
01109     {
01110       int yytype = YYTRANSLATE (yychar);
01111       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
01112       YYSIZE_T yysize = yysize0;
01113       YYSIZE_T yysize1;
01114       int yysize_overflow = 0;
01115       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
01116       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
01117       int yyx;
01118 
01119 # if 0
01120       /* This is so xgettext sees the translatable formats that are
01121          constructed on the fly.  */
01122       YY_("syntax error, unexpected %s");
01123       YY_("syntax error, unexpected %s, expecting %s");
01124       YY_("syntax error, unexpected %s, expecting %s or %s");
01125       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
01126       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
01127 # endif
01128       char *yyfmt;
01129       char const *yyf;
01130       static char const yyunexpected[] = "syntax error, unexpected %s";
01131       static char const yyexpecting[] = ", expecting %s";
01132       static char const yyor[] = " or %s";
01133       char yyformat[sizeof yyunexpected
01134                     + sizeof yyexpecting - 1
01135                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
01136                        * (sizeof yyor - 1))];
01137       char const *yyprefix = yyexpecting;
01138 
01139       /* Start YYX at -YYN if negative to avoid negative indexes in
01140          YYCHECK.  */
01141       int yyxbegin = yyn < 0 ? -yyn : 0;
01142 
01143       /* Stay within bounds of both yycheck and yytname.  */
01144       int yychecklim = YYLAST - yyn + 1;
01145       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
01146       int yycount = 1;
01147 
01148       yyarg[0] = yytname[yytype];
01149       yyfmt = yystpcpy (yyformat, yyunexpected);
01150 
01151       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
01152         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
01153           {
01154             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
01155               {
01156                 yycount = 1;
01157                 yysize = yysize0;
01158                 yyformat[sizeof yyunexpected - 1] = '\0';
01159                 break;
01160               }
01161             yyarg[yycount++] = yytname[yyx];
01162             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
01163             yysize_overflow |= (yysize1 < yysize);
01164             yysize = yysize1;
01165             yyfmt = yystpcpy (yyfmt, yyprefix);
01166             yyprefix = yyor;
01167           }
01168 
01169       yyf = YY_(yyformat);
01170       yysize1 = yysize + yystrlen (yyf);
01171       yysize_overflow |= (yysize1 < yysize);
01172       yysize = yysize1;
01173 
01174       if (yysize_overflow)
01175         return YYSIZE_MAXIMUM;
01176 
01177       if (yyresult)
01178         {
01179           /* Avoid sprintf, as that infringes on the user's name space.
01180              Don't have undefined behavior even if the translation
01181              produced a string with the wrong number of "%s"s.  */
01182           char *yyp = yyresult;
01183           int yyi = 0;
01184           while ((*yyp = *yyf) != '\0')
01185             {
01186               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
01187                 {
01188                   yyp += yytnamerr (yyp, yyarg[yyi++]);
01189                   yyf += 2;
01190                 }
01191               else
01192                 {
01193                   yyp++;
01194                   yyf++;
01195                 }
01196             }
01197         }
01198       return yysize;
01199     }
01200 }
01201 #endif /* YYERROR_VERBOSE */
01202 
01203 
01204 /*-----------------------------------------------.
01205 | Release the memory associated to this symbol.  |
01206 `-----------------------------------------------*/
01207 
01208 /*ARGSUSED*/
01209 #if (defined __STDC__ || defined __C99__FUNC__ \
01210      || defined __cplusplus || defined _MSC_VER)
01211 static void
01212 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
01213 #else
01214 static void
01215 yydestruct (yymsg, yytype, yyvaluep)
01216     const char *yymsg;
01217     int yytype;
01218     YYSTYPE *yyvaluep;
01219 #endif
01220 {
01221   YYUSE (yyvaluep);
01222 
01223   if (!yymsg)
01224     yymsg = "Deleting";
01225   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
01226 
01227   switch (yytype)
01228     {
01229 
01230       default:
01231         break;
01232     }
01233 }
01234 
01235 
01236 /* Prevent warnings from -Wmissing-prototypes.  */
01237 
01238 #ifdef YYPARSE_PARAM
01239 #if defined __STDC__ || defined __cplusplus
01240 int yyparse (void *YYPARSE_PARAM);
01241 #else
01242 int yyparse ();
01243 #endif
01244 #else /* ! YYPARSE_PARAM */
01245 #if defined __STDC__ || defined __cplusplus
01246 int yyparse (void);
01247 #else
01248 int yyparse ();
01249 #endif
01250 #endif /* ! YYPARSE_PARAM */
01251 
01252 
01253 
01254 /* The look-ahead symbol.  */
01255 int yychar;
01256 
01257 /* The semantic value of the look-ahead symbol.  */
01258 YYSTYPE yylval;
01259 
01260 /* Number of syntax errors so far.  */
01261 int yynerrs;
01262 
01263 
01264 
01265 /*----------.
01266 | yyparse.  |
01267 `----------*/
01268 
01269 #ifdef YYPARSE_PARAM
01270 #if (defined __STDC__ || defined __C99__FUNC__ \
01271      || defined __cplusplus || defined _MSC_VER)
01272 int
01273 yyparse (void *YYPARSE_PARAM)
01274 #else
01275 int
01276 yyparse (YYPARSE_PARAM)
01277     void *YYPARSE_PARAM;
01278 #endif
01279 #else /* ! YYPARSE_PARAM */
01280 #if (defined __STDC__ || defined __C99__FUNC__ \
01281      || defined __cplusplus || defined _MSC_VER)
01282 int
01283 yyparse (void)
01284 #else
01285 int
01286 yyparse ()
01287 
01288 #endif
01289 #endif
01290 {
01291   
01292   int yystate;
01293   int yyn;
01294   int yyresult;
01295   /* Number of tokens to shift before error messages enabled.  */
01296   int yyerrstatus;
01297   /* Look-ahead token as an internal (translated) token number.  */
01298   int yytoken = 0;
01299 #if YYERROR_VERBOSE
01300   /* Buffer for error messages, and its allocated size.  */
01301   char yymsgbuf[128];
01302   char *yymsg = yymsgbuf;
01303   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
01304 #endif
01305 
01306   /* Three stacks and their tools:
01307      `yyss': related to states,
01308      `yyvs': related to semantic values,
01309      `yyls': related to locations.
01310 
01311      Refer to the stacks thru separate pointers, to allow yyoverflow
01312      to reallocate them elsewhere.  */
01313 
01314   /* The state stack.  */
01315   yytype_int16 yyssa[YYINITDEPTH];
01316   yytype_int16 *yyss = yyssa;
01317   yytype_int16 *yyssp;
01318 
01319   /* The semantic value stack.  */
01320   YYSTYPE yyvsa[YYINITDEPTH];
01321   YYSTYPE *yyvs = yyvsa;
01322   YYSTYPE *yyvsp;
01323 
01324 
01325 
01326 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
01327 
01328   YYSIZE_T yystacksize = YYINITDEPTH;
01329 
01330   /* The variables used to return semantic value and location from the
01331      action routines.  */
01332   YYSTYPE yyval;
01333 
01334 
01335   /* The number of symbols on the RHS of the reduced rule.
01336      Keep to zero when no symbol should be popped.  */
01337   int yylen = 0;
01338 
01339   YYDPRINTF ((stderr, "Starting parse\n"));
01340 
01341   yystate = 0;
01342   yyerrstatus = 0;
01343   yynerrs = 0;
01344   yychar = YYEMPTY;             /* Cause a token to be read.  */
01345 
01346   /* Initialize stack pointers.
01347      Waste one element of value and location stack
01348      so that they stay on the same level as the state stack.
01349      The wasted elements are never initialized.  */
01350 
01351   yyssp = yyss;
01352   yyvsp = yyvs;
01353 
01354   goto yysetstate;
01355 
01356 /*------------------------------------------------------------.
01357 | yynewstate -- Push a new state, which is found in yystate.  |
01358 `------------------------------------------------------------*/
01359  yynewstate:
01360   /* In all cases, when you get here, the value and location stacks
01361      have just been pushed.  So pushing a state here evens the stacks.  */
01362   yyssp++;
01363 
01364  yysetstate:
01365   *yyssp = yystate;
01366 
01367   if (yyss + yystacksize - 1 <= yyssp)
01368     {
01369       /* Get the current used size of the three stacks, in elements.  */
01370       YYSIZE_T yysize = yyssp - yyss + 1;
01371 
01372 #ifdef yyoverflow
01373       {
01374         /* Give user a chance to reallocate the stack.  Use copies of
01375            these so that the &'s don't force the real ones into
01376            memory.  */
01377         YYSTYPE *yyvs1 = yyvs;
01378         yytype_int16 *yyss1 = yyss;
01379 
01380 
01381         /* Each stack pointer address is followed by the size of the
01382            data in use in that stack, in bytes.  This used to be a
01383            conditional around just the two extra args, but that might
01384            be undefined if yyoverflow is a macro.  */
01385         yyoverflow (YY_("memory exhausted"),
01386                     &yyss1, yysize * sizeof (*yyssp),
01387                     &yyvs1, yysize * sizeof (*yyvsp),
01388 
01389                     &yystacksize);
01390 
01391         yyss = yyss1;
01392         yyvs = yyvs1;
01393       }
01394 #else /* no yyoverflow */
01395 # ifndef YYSTACK_RELOCATE
01396       goto yyexhaustedlab;
01397 # else
01398       /* Extend the stack our own way.  */
01399       if (YYMAXDEPTH <= yystacksize)
01400         goto yyexhaustedlab;
01401       yystacksize *= 2;
01402       if (YYMAXDEPTH < yystacksize)
01403         yystacksize = YYMAXDEPTH;
01404 
01405       {
01406         yytype_int16 *yyss1 = yyss;
01407         union yyalloc *yyptr =
01408           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
01409         if (! yyptr)
01410           goto yyexhaustedlab;
01411         YYSTACK_RELOCATE (yyss);
01412         YYSTACK_RELOCATE (yyvs);
01413 
01414 #  undef YYSTACK_RELOCATE
01415         if (yyss1 != yyssa)
01416           YYSTACK_FREE (yyss1);
01417       }
01418 # endif
01419 #endif /* no yyoverflow */
01420 
01421       yyssp = yyss + yysize - 1;
01422       yyvsp = yyvs + yysize - 1;
01423 
01424 
01425       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
01426                   (unsigned long int) yystacksize));
01427 
01428       if (yyss + yystacksize - 1 <= yyssp)
01429         YYABORT;
01430     }
01431 
01432   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
01433 
01434   goto yybackup;
01435 
01436 /*-----------.
01437 | yybackup.  |
01438 `-----------*/
01439 yybackup:
01440 
01441   /* Do appropriate processing given the current state.  Read a
01442      look-ahead token if we need one and don't already have one.  */
01443 
01444   /* First try to decide what to do without reference to look-ahead token.  */
01445   yyn = yypact[yystate];
01446   if (yyn == YYPACT_NINF)
01447     goto yydefault;
01448 
01449   /* Not known => get a look-ahead token if don't already have one.  */
01450 
01451   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
01452   if (yychar == YYEMPTY)
01453     {
01454       YYDPRINTF ((stderr, "Reading a token: "));
01455       yychar = YYLEX;
01456     }
01457 
01458   if (yychar <= YYEOF)
01459     {
01460       yychar = yytoken = YYEOF;
01461       YYDPRINTF ((stderr, "Now at end of input.\n"));
01462     }
01463   else
01464     {
01465       yytoken = YYTRANSLATE (yychar);
01466       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
01467     }
01468 
01469   /* If the proper action on seeing token YYTOKEN is to reduce or to
01470      detect an error, take that action.  */
01471   yyn += yytoken;
01472   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
01473     goto yydefault;
01474   yyn = yytable[yyn];
01475   if (yyn <= 0)
01476     {
01477       if (yyn == 0 || yyn == YYTABLE_NINF)
01478         goto yyerrlab;
01479       yyn = -yyn;
01480       goto yyreduce;
01481     }
01482 
01483   if (yyn == YYFINAL)
01484     YYACCEPT;
01485 
01486   /* Count tokens shifted since error; after three, turn off error
01487      status.  */
01488   if (yyerrstatus)
01489     yyerrstatus--;
01490 
01491   /* Shift the look-ahead token.  */
01492   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
01493 
01494   /* Discard the shifted token unless it is eof.  */
01495   if (yychar != YYEOF)
01496     yychar = YYEMPTY;
01497 
01498   yystate = yyn;
01499   *++yyvsp = yylval;
01500 
01501   goto yynewstate;
01502 
01503 
01504 /*-----------------------------------------------------------.
01505 | yydefault -- do the default action for the current state.  |
01506 `-----------------------------------------------------------*/
01507 yydefault:
01508   yyn = yydefact[yystate];
01509   if (yyn == 0)
01510     goto yyerrlab;
01511   goto yyreduce;
01512 
01513 
01514 /*-----------------------------.
01515 | yyreduce -- Do a reduction.  |
01516 `-----------------------------*/
01517 yyreduce:
01518   /* yyn is the number of a rule to reduce with.  */
01519   yylen = yyr2[yyn];
01520 
01521   /* If YYLEN is nonzero, implement the default value of the action:
01522      `$$ = $1'.
01523 
01524      Otherwise, the following line sets YYVAL to garbage.
01525      This behavior is undocumented and Bison
01526      users should not rely upon it.  Assigning to YYVAL
01527      unconditionally makes the parser a bit smaller, and it avoids a
01528      GCC warning that YYVAL may be used uninitialized.  */
01529   yyval = yyvsp[1-yylen];
01530 
01531 
01532   YY_REDUCE_PRINT (yyn);
01533   switch (yyn)
01534     {
01535         case 10:
01536 #line 105 "yac.y"
01537     { sqpCommand(SQLP_ADD_COLUMN); }
01538     break;
01539 
01540   case 11:
01541 #line 106 "yac.y"
01542     { sqpCommand(SQLP_ADD_COLUMN); }
01543     break;
01544 
01545   case 12:
01546 #line 110 "yac.y"
01547     { sqpCommand(SQLP_CREATE); }
01548     break;
01549 
01550   case 13:
01551 #line 114 "yac.y"
01552     { sqpCommand(SQLP_DROP); }
01553     break;
01554 
01555   case 14:
01556 #line 118 "yac.y"
01557     { sqpCommand(SQLP_SELECT); }
01558     break;
01559 
01560   case 15:
01561 #line 119 "yac.y"
01562     { sqpCommand(SQLP_SELECT); }
01563     break;
01564 
01565   case 16:
01566 #line 120 "yac.y"
01567     { sqpCommand(SQLP_SELECT); }
01568     break;
01569 
01570   case 17:
01571 #line 121 "yac.y"
01572     { sqpCommand(SQLP_SELECT); }
01573     break;
01574 
01575   case 18:
01576 #line 125 "yac.y"
01577     { sqpCommand(SQLP_DELETE); }
01578     break;
01579 
01580   case 19:
01581 #line 126 "yac.y"
01582     { sqpCommand(SQLP_DELETE); }
01583     break;
01584 
01585   case 20:
01586 #line 130 "yac.y"
01587     { sqpCommand(SQLP_INSERT); }
01588     break;
01589 
01590   case 21:
01591 #line 131 "yac.y"
01592     { sqpCommand(SQLP_INSERT); }
01593     break;
01594 
01595   case 22:
01596 #line 135 "yac.y"
01597     { sqpCommand(SQLP_UPDATE); }
01598     break;
01599 
01600   case 23:
01601 #line 136 "yac.y"
01602     { sqpCommand(SQLP_UPDATE); }
01603     break;
01604 
01605   case 26:
01606 #line 146 "yac.y"
01607     { sqpColumnDef( (yyvsp[(1) - (5)].strval), SQLP_VARCHAR, (yyvsp[(4) - (5)].intval), 0 ); }
01608     break;
01609 
01610   case 27:
01611 #line 147 "yac.y"
01612     { sqpColumnDef( (yyvsp[(1) - (2)].strval), SQLP_INTEGER,  0, 0 ); }
01613     break;
01614 
01615   case 28:
01616 #line 148 "yac.y"
01617     { sqpColumnDef( (yyvsp[(1) - (2)].strval), SQLP_INTEGER,  0, 0 ); }
01618     break;
01619 
01620   case 29:
01621 #line 149 "yac.y"
01622     { sqpColumnDef( (yyvsp[(1) - (2)].strval), SQLP_DOUBLE,   0, 0 ); }
01623     break;
01624 
01625   case 30:
01626 #line 150 "yac.y"
01627     { sqpColumnDef( (yyvsp[(1) - (3)].strval), SQLP_DOUBLE,   0, 0 ); }
01628     break;
01629 
01630   case 31:
01631 #line 151 "yac.y"
01632     { sqpColumnDef( (yyvsp[(1) - (2)].strval), SQLP_DATE,     0, 0 ); }
01633     break;
01634 
01635   case 32:
01636 #line 152 "yac.y"
01637     { sqpColumnDef( (yyvsp[(1) - (2)].strval), SQLP_TIME,     0, 0 ); }
01638     break;
01639 
01640   case 35:
01641 #line 161 "yac.y"
01642     { sqpColumn( (yyvsp[(1) - (1)].strval) ); }
01643     break;
01644 
01645   case 36:
01646 #line 162 "yac.y"
01647     { sqpColumn( (yyvsp[(3) - (3)].strval) ); }
01648     break;
01649 
01650   case 37:
01651 #line 166 "yac.y"
01652     { sqpTable( (yyvsp[(1) - (1)].strval) ); }
01653     break;
01654 
01655   case 39:
01656 #line 174 "yac.y"
01657     { sqpValue( NULL,  0, 0.0, SQLP_NULL ); }
01658     break;
01659 
01660   case 40:
01661 #line 175 "yac.y"
01662     { sqpValue( (yyvsp[(1) - (1)].strval),    0, 0.0, SQLP_S ); }
01663     break;
01664 
01665   case 41:
01666 #line 176 "yac.y"
01667     { sqpValue( NULL, (yyvsp[(1) - (1)].intval), 0.0, SQLP_I ); }
01668     break;
01669 
01670   case 42:
01671 #line 177 "yac.y"
01672     { sqpValue( NULL, -(yyvsp[(2) - (2)].intval), 0.0, SQLP_I ); }
01673     break;
01674 
01675   case 43:
01676 #line 178 "yac.y"
01677     { sqpValue( NULL,  0,  (yyvsp[(1) - (1)].floatval), SQLP_D ); }
01678     break;
01679 
01680   case 44:
01681 #line 179 "yac.y"
01682     { sqpValue( NULL, 0, -(yyvsp[(2) - (2)].floatval), SQLP_D ); }
01683     break;
01684 
01685   case 45:
01686 #line 180 "yac.y"
01687     { sqpValue( NULL,  0, 0.0, SQLP_NULL ); }
01688     break;
01689 
01690   case 46:
01691 #line 181 "yac.y"
01692     { sqpValue( (yyvsp[(3) - (3)].strval),    0, 0.0, SQLP_S ); }
01693     break;
01694 
01695   case 47:
01696 #line 182 "yac.y"
01697     { sqpValue( NULL, (yyvsp[(3) - (3)].intval), 0.0, SQLP_I ); }
01698     break;
01699 
01700   case 48:
01701 #line 183 "yac.y"
01702     { sqpValue( NULL, -(yyvsp[(4) - (4)].intval), 0.0, SQLP_I ); }
01703     break;
01704 
01705   case 49:
01706 #line 184 "yac.y"
01707     { sqpValue( NULL,  0,  (yyvsp[(3) - (3)].floatval), SQLP_D ); }
01708     break;
01709 
01710   case 50:
01711 #line 185 "yac.y"
01712     { sqpValue( NULL, 0, -(yyvsp[(4) - (4)].floatval), SQLP_D ); }
01713     break;
01714 
01715   case 53:
01716 #line 194 "yac.y"
01717     { sqpAssignment( (yyvsp[(1) - (3)].strval), NULL,  0, 0.0, NULL, SQLP_NULL ); }
01718     break;
01719 
01720   case 54:
01721 #line 198 "yac.y"
01722     { sqpAssignment( (yyvsp[(1) - (3)].strval), NULL, 0, 0.0, (yyvsp[(3) - (3)].node), SQLP_EXPR ); }
01723     break;
01724 
01725   case 55:
01726 #line 202 "yac.y"
01727     { 
01728                     (yyval.node) = (yyvsp[(1) - (1)].node);
01729                     sqlpStmt->upperNodeptr = (yyval.node); 
01730                 }
01731     break;
01732 
01733   case 56:
01734 #line 209 "yac.y"
01735     { (yyval.node) = (yyvsp[(1) - (1)].node); }
01736     break;
01737 
01738   case 57:
01739 #line 210 "yac.y"
01740     { (yyval.node) = sqpNewExpressionNode (SQLP_OR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); }
01741     break;
01742 
01743   case 58:
01744 #line 214 "yac.y"
01745     { (yyval.node) = (yyvsp[(1) - (1)].node); }
01746     break;
01747 
01748   case 59:
01749 #line 215 "yac.y"
01750     { (yyval.node) = sqpNewExpressionNode (SQLP_AND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); }
01751     break;
01752 
01753   case 60:
01754 #line 219 "yac.y"
01755     { (yyval.node) = (yyvsp[(1) - (1)].node); }
01756     break;
01757 
01758   case 61:
01759 #line 220 "yac.y"
01760     { (yyval.node) = (yyvsp[(2) - (3)].node); }
01761     break;
01762 
01763   case 62:
01764 #line 221 "yac.y"
01765     { (yyval.node) = sqpNewExpressionNode ( SQLP_NOT, NULL, (yyvsp[(2) - (2)].node)); }
01766     break;
01767 
01768   case 63:
01769 #line 226 "yac.y"
01770     {
01771                     (yyval.node) = sqpNewExpressionNode ( SQLP_EQ, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
01772                 }
01773     break;
01774 
01775   case 64:
01776 #line 229 "yac.y"
01777     {
01778                     (yyval.node) = sqpNewExpressionNode ( sqpOperatorCode((yyvsp[(2) - (3)].strval)), (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
01779                 }
01780     break;
01781 
01782   case 65:
01783 #line 232 "yac.y"
01784     {
01785                     (yyval.node) = sqpNewExpressionNode ( SQLP_ISNULL, NULL, (yyvsp[(1) - (3)].node));
01786                 }
01787     break;
01788 
01789   case 66:
01790 #line 235 "yac.y"
01791     {
01792                     (yyval.node) = sqpNewExpressionNode ( SQLP_NOTNULL, NULL, (yyvsp[(1) - (3)].node));
01793                 }
01794     break;
01795 
01796   case 67:
01797 #line 242 "yac.y"
01798     { (yyval.node) = (yyvsp[(1) - (1)].node); }
01799     break;
01800 
01801   case 68:
01802 #line 243 "yac.y"
01803     {
01804                     (yyval.node) = sqpNewExpressionNode ( sqpOperatorCode("+"), (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node) );
01805                 }
01806     break;
01807 
01808   case 69:
01809 #line 246 "yac.y"
01810     {
01811                     (yyval.node) = sqpNewExpressionNode ( sqpOperatorCode("-"), (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node) );
01812                 }
01813     break;
01814 
01815   case 70:
01816 #line 252 "yac.y"
01817     { (yyval.node) = (yyvsp[(1) - (1)].node); }
01818     break;
01819 
01820   case 71:
01821 #line 253 "yac.y"
01822     {
01823                     (yyval.node) = sqpNewExpressionNode ( sqpOperatorCode("*"), (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node) );
01824                 }
01825     break;
01826 
01827   case 72:
01828 #line 256 "yac.y"
01829     {
01830                     (yyval.node) = sqpNewExpressionNode ( sqpOperatorCode("/"), (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node) );
01831                 }
01832     break;
01833 
01834   case 73:
01835 #line 262 "yac.y"
01836     { (yyval.node) = (yyvsp[(1) - (1)].node); }
01837     break;
01838 
01839   case 74:
01840 #line 263 "yac.y"
01841     {
01842                     (yyval.node) = sqpNewExpressionNode ( sqpOperatorCode("-"), sqpNewValueNode ( NULL, 0, 0.0,  SQLP_I ), (yyvsp[(2) - (2)].node) );
01843                 }
01844     break;
01845 
01846   case 75:
01847 #line 269 "yac.y"
01848     { (yyval.node) = (yyvsp[(1) - (1)].node); }
01849     break;
01850 
01851   case 76:
01852 #line 270 "yac.y"
01853     { (yyval.node) = (yyvsp[(1) - (1)].node); }
01854     break;
01855 
01856   case 77:
01857 #line 271 "yac.y"
01858     { (yyval.node) = (yyvsp[(2) - (3)].node); }
01859     break;
01860 
01861   case 78:
01862 #line 276 "yac.y"
01863     { (yyval.node) = sqpNewValueNode (   (yyvsp[(1) - (1)].strval),  0, 0.0,  SQLP_S ); }
01864     break;
01865 
01866   case 79:
01867 #line 277 "yac.y"
01868     { (yyval.node) = sqpNewValueNode ( NULL, (yyvsp[(1) - (1)].intval), 0.0,  SQLP_I ); }
01869     break;
01870 
01871   case 80:
01872 #line 278 "yac.y"
01873     { (yyval.node) = sqpNewValueNode ( NULL,  0,  (yyvsp[(1) - (1)].floatval),  SQLP_D ); }
01874     break;
01875 
01876   case 81:
01877 #line 283 "yac.y"
01878     {(yyval.node) = sqpNewColumnNode (  (yyvsp[(1) - (1)].strval) );}
01879     break;
01880 
01881   case 82:
01882 #line 287 "yac.y"
01883     { sqpOrderColumn( (yyvsp[(1) - (1)].strval) ); }
01884     break;
01885 
01886 
01887 /* Line 1267 of yacc.c.  */
01888 #line 1889 "y.tab.c"
01889       default: break;
01890     }
01891   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
01892 
01893   YYPOPSTACK (yylen);
01894   yylen = 0;
01895   YY_STACK_PRINT (yyss, yyssp);
01896 
01897   *++yyvsp = yyval;
01898 
01899 
01900   /* Now `shift' the result of the reduction.  Determine what state
01901      that goes to, based on the state we popped back to and the rule
01902      number reduced by.  */
01903 
01904   yyn = yyr1[yyn];
01905 
01906   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
01907   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
01908     yystate = yytable[yystate];
01909   else
01910     yystate = yydefgoto[yyn - YYNTOKENS];
01911 
01912   goto yynewstate;
01913 
01914 
01915 /*------------------------------------.
01916 | yyerrlab -- here on detecting error |
01917 `------------------------------------*/
01918 yyerrlab:
01919   /* If not already recovering from an error, report this error.  */
01920   if (!yyerrstatus)
01921     {
01922       ++yynerrs;
01923 #if ! YYERROR_VERBOSE
01924       yyerror (YY_("syntax error"));
01925 #else
01926       {
01927         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
01928         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
01929           {
01930             YYSIZE_T yyalloc = 2 * yysize;
01931             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
01932               yyalloc = YYSTACK_ALLOC_MAXIMUM;
01933             if (yymsg != yymsgbuf)
01934               YYSTACK_FREE (yymsg);
01935             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
01936             if (yymsg)
01937               yymsg_alloc = yyalloc;
01938             else
01939               {
01940                 yymsg = yymsgbuf;
01941                 yymsg_alloc = sizeof yymsgbuf;
01942               }
01943           }
01944 
01945         if (0 < yysize && yysize <= yymsg_alloc)
01946           {
01947             (void) yysyntax_error (yymsg, yystate, yychar);
01948             yyerror (yymsg);
01949           }
01950         else
01951           {
01952             yyerror (YY_("syntax error"));
01953             if (yysize != 0)
01954               goto yyexhaustedlab;
01955           }
01956       }
01957 #endif
01958     }
01959 
01960 
01961 
01962   if (yyerrstatus == 3)
01963     {
01964       /* If just tried and failed to reuse look-ahead token after an
01965          error, discard it.  */
01966 
01967       if (yychar <= YYEOF)
01968         {
01969           /* Return failure if at end of input.  */
01970           if (yychar == YYEOF)
01971             YYABORT;
01972         }
01973       else
01974         {
01975           yydestruct ("Error: discarding",
01976                       yytoken, &yylval);
01977           yychar = YYEMPTY;
01978         }
01979     }
01980 
01981   /* Else will try to reuse look-ahead token after shifting the error
01982      token.  */
01983   goto yyerrlab1;
01984 
01985 
01986 /*---------------------------------------------------.
01987 | yyerrorlab -- error raised explicitly by YYERROR.  |
01988 `---------------------------------------------------*/
01989 yyerrorlab:
01990 
01991   /* Pacify compilers like GCC when the user code never invokes
01992      YYERROR and the label yyerrorlab therefore never appears in user
01993      code.  */
01994   if (/*CONSTCOND*/ 0)
01995      goto yyerrorlab;
01996 
01997   /* Do not reclaim the symbols of the rule which action triggered
01998      this YYERROR.  */
01999   YYPOPSTACK (yylen);
02000   yylen = 0;
02001   YY_STACK_PRINT (yyss, yyssp);
02002   yystate = *yyssp;
02003   goto yyerrlab1;
02004 
02005 
02006 /*-------------------------------------------------------------.
02007 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
02008 `-------------------------------------------------------------*/
02009 yyerrlab1:
02010   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
02011 
02012   for (;;)
02013     {
02014       yyn = yypact[yystate];
02015       if (yyn != YYPACT_NINF)
02016         {
02017           yyn += YYTERROR;
02018           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
02019             {
02020               yyn = yytable[yyn];
02021               if (0 < yyn)
02022                 break;
02023             }
02024         }
02025 
02026       /* Pop the current state because it cannot handle the error token.  */
02027       if (yyssp == yyss)
02028         YYABORT;
02029 
02030 
02031       yydestruct ("Error: popping",
02032                   yystos[yystate], yyvsp);
02033       YYPOPSTACK (1);
02034       yystate = *yyssp;
02035       YY_STACK_PRINT (yyss, yyssp);
02036     }
02037 
02038   if (yyn == YYFINAL)
02039     YYACCEPT;
02040 
02041   *++yyvsp = yylval;
02042 
02043 
02044   /* Shift the error token.  */
02045   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
02046 
02047   yystate = yyn;
02048   goto yynewstate;
02049 
02050 
02051 /*-------------------------------------.
02052 | yyacceptlab -- YYACCEPT comes here.  |
02053 `-------------------------------------*/
02054 yyacceptlab:
02055   yyresult = 0;
02056   goto yyreturn;
02057 
02058 /*-----------------------------------.
02059 | yyabortlab -- YYABORT comes here.  |
02060 `-----------------------------------*/
02061 yyabortlab:
02062   yyresult = 1;
02063   goto yyreturn;
02064 
02065 #ifndef yyoverflow
02066 /*-------------------------------------------------.
02067 | yyexhaustedlab -- memory exhaustion comes here.  |
02068 `-------------------------------------------------*/
02069 yyexhaustedlab:
02070   yyerror (YY_("memory exhausted"));
02071   yyresult = 2;
02072   /* Fall through.  */
02073 #endif
02074 
02075 yyreturn:
02076   if (yychar != YYEOF && yychar != YYEMPTY)
02077      yydestruct ("Cleanup: discarding lookahead",
02078                  yytoken, &yylval);
02079   /* Do not reclaim the symbols of the rule which action triggered
02080      this YYABORT or YYACCEPT.  */
02081   YYPOPSTACK (yylen);
02082   YY_STACK_PRINT (yyss, yyssp);
02083   while (yyssp != yyss)
02084     {
02085       yydestruct ("Cleanup: popping",
02086                   yystos[*yyssp], yyvsp);
02087       YYPOPSTACK (1);
02088     }
02089 #ifndef yyoverflow
02090   if (yyss != yyssa)
02091     YYSTACK_FREE (yyss);
02092 #endif
02093 #if YYERROR_VERBOSE
02094   if (yymsg != yymsgbuf)
02095     YYSTACK_FREE (yymsg);
02096 #endif
02097   /* Make sure YYID is used.  */
02098   return YYID (yyresult);
02099 }
02100 
02101 
02102 #line 289 "yac.y"
02103 
02104 
02105 
02106 

Generated on Sun Apr 6 17:31:38 2008 for GRASS by  doxygen 1.5.5