Drizzled Public API Documentation

pars0grm.cc
00001 
00002 /* A Bison parser, made by GNU Bison 2.4.1.  */
00003 
00004 /* Skeleton implementation for Bison's Yacc-like parsers in C
00005    
00006       Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
00007    Free Software Foundation, Inc.
00008    
00009    This program is free software: you can redistribute it and/or modify
00010    it under the terms of the GNU General Public License as published by
00011    the Free Software Foundation, either version 3 of the License, or
00012    (at your option) any later version.
00013    
00014    This program is distributed in the hope that it will be useful,
00015    but WITHOUT ANY WARRANTY; without even the implied warranty of
00016    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00017    GNU General Public License for more details.
00018    
00019    You should have received a copy of the GNU General Public License
00020    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
00021 
00022 /* As a special exception, you may create a larger work that contains
00023    part or all of the Bison parser skeleton and distribute that work
00024    under terms of your choice, so long as that work isn't itself a
00025    parser generator using the skeleton or a modified version thereof
00026    as a parser skeleton.  Alternatively, if you modify or redistribute
00027    the parser skeleton itself, you may (at your option) remove this
00028    special exception, which will cause the skeleton and the resulting
00029    Bison output files to be licensed under the GNU General Public
00030    License without this special exception.
00031    
00032    This special exception was added by the Free Software Foundation in
00033    version 2.2 of Bison.  */
00034 
00035 /* C LALR(1) parser skeleton written by Richard Stallman, by
00036    simplifying the original so-called "semantic" parser.  */
00037 
00038 /* All symbols defined below should begin with yy or YY, to avoid
00039    infringing on user name space.  This should be done even for local
00040    variables, as they might otherwise be expanded by user macros.
00041    There are some unavoidable exceptions within include files to
00042    define necessary library symbols; they are noted "INFRINGES ON
00043    USER NAME SPACE" below.  */
00044 
00045 /* Identify Bison output.  */
00046 #define YYBISON 1
00047 
00048 /* Bison version.  */
00049 #define YYBISON_VERSION "2.4.1"
00050 
00051 /* Skeleton name.  */
00052 #define YYSKELETON_NAME "yacc.c"
00053 
00054 /* Pure parsers.  */
00055 #define YYPURE 0
00056 
00057 /* Push parsers.  */
00058 #define YYPUSH 0
00059 
00060 /* Pull parsers.  */
00061 #define YYPULL 1
00062 
00063 /* Using locations.  */
00064 #define YYLSP_NEEDED 0
00065 
00066 
00067 
00068 /* Copy the first part of user declarations.  */
00069 
00070 /* Line 189 of yacc.c  */
00071 #line 25 "plugin/innobase/pars/pars0grm.y"
00072 
00073 /* The value of the semantic attribute is a pointer to a query tree node
00074 que_node_t */
00075 
00076 #include "univ.i"
00077 #include <math.h>       /* Can't be before univ.i */
00078 #include "pars0pars.h"
00079 #include "mem0mem.h"
00080 #include "que0types.h"
00081 #include "que0que.h"
00082 #include "row0sel.h"
00083 
00084 #define YYSTYPE que_node_t*
00085 #define YYENABLE_NLS 0
00086 #define YYLTYPE_IS_TRIVIAL 0
00087 
00088 /* #define __STDC__ */
00089 
00090 extern "C" int yylex(void);
00091 
00092 
00093 /* Line 189 of yacc.c  */
00094 #line 95 "plugin/innobase/pars/pars0grm.cc"
00095 
00096 /* Enabling traces.  */
00097 #ifndef YYDEBUG
00098 # define YYDEBUG 0
00099 #endif
00100 
00101 /* Enabling verbose error messages.  */
00102 #ifdef YYERROR_VERBOSE
00103 # undef YYERROR_VERBOSE
00104 # define YYERROR_VERBOSE 1
00105 #else
00106 # define YYERROR_VERBOSE 0
00107 #endif
00108 
00109 /* Enabling the token table.  */
00110 #ifndef YYTOKEN_TABLE
00111 # define YYTOKEN_TABLE 0
00112 #endif
00113 
00114 
00115 /* Tokens.  */
00116 #ifndef YYTOKENTYPE
00117 # define YYTOKENTYPE
00118    /* Put the tokens into the symbol table, so that GDB and other debuggers
00119       know about them.  */
00120    enum yytokentype {
00121      PARS_INT_LIT = 258,
00122      PARS_FLOAT_LIT = 259,
00123      PARS_STR_LIT = 260,
00124      PARS_FIXBINARY_LIT = 261,
00125      PARS_BLOB_LIT = 262,
00126      PARS_NULL_LIT = 263,
00127      PARS_ID_TOKEN = 264,
00128      PARS_AND_TOKEN = 265,
00129      PARS_OR_TOKEN = 266,
00130      PARS_NOT_TOKEN = 267,
00131      PARS_GE_TOKEN = 268,
00132      PARS_LE_TOKEN = 269,
00133      PARS_NE_TOKEN = 270,
00134      PARS_PROCEDURE_TOKEN = 271,
00135      PARS_IN_TOKEN = 272,
00136      PARS_OUT_TOKEN = 273,
00137      PARS_BINARY_TOKEN = 274,
00138      PARS_BLOB_TOKEN = 275,
00139      PARS_INT_TOKEN = 276,
00140      PARS_INTEGER_TOKEN = 277,
00141      PARS_FLOAT_TOKEN = 278,
00142      PARS_CHAR_TOKEN = 279,
00143      PARS_IS_TOKEN = 280,
00144      PARS_BEGIN_TOKEN = 281,
00145      PARS_END_TOKEN = 282,
00146      PARS_IF_TOKEN = 283,
00147      PARS_THEN_TOKEN = 284,
00148      PARS_ELSE_TOKEN = 285,
00149      PARS_ELSIF_TOKEN = 286,
00150      PARS_LOOP_TOKEN = 287,
00151      PARS_WHILE_TOKEN = 288,
00152      PARS_RETURN_TOKEN = 289,
00153      PARS_SELECT_TOKEN = 290,
00154      PARS_SUM_TOKEN = 291,
00155      PARS_COUNT_TOKEN = 292,
00156      PARS_DISTINCT_TOKEN = 293,
00157      PARS_FROM_TOKEN = 294,
00158      PARS_WHERE_TOKEN = 295,
00159      PARS_FOR_TOKEN = 296,
00160      PARS_DDOT_TOKEN = 297,
00161      PARS_READ_TOKEN = 298,
00162      PARS_ORDER_TOKEN = 299,
00163      PARS_BY_TOKEN = 300,
00164      PARS_ASC_TOKEN = 301,
00165      PARS_DESC_TOKEN = 302,
00166      PARS_INSERT_TOKEN = 303,
00167      PARS_INTO_TOKEN = 304,
00168      PARS_VALUES_TOKEN = 305,
00169      PARS_UPDATE_TOKEN = 306,
00170      PARS_SET_TOKEN = 307,
00171      PARS_DELETE_TOKEN = 308,
00172      PARS_CURRENT_TOKEN = 309,
00173      PARS_OF_TOKEN = 310,
00174      PARS_CREATE_TOKEN = 311,
00175      PARS_TABLE_TOKEN = 312,
00176      PARS_INDEX_TOKEN = 313,
00177      PARS_UNIQUE_TOKEN = 314,
00178      PARS_CLUSTERED_TOKEN = 315,
00179      PARS_DOES_NOT_FIT_IN_MEM_TOKEN = 316,
00180      PARS_ON_TOKEN = 317,
00181      PARS_ASSIGN_TOKEN = 318,
00182      PARS_DECLARE_TOKEN = 319,
00183      PARS_CURSOR_TOKEN = 320,
00184      PARS_SQL_TOKEN = 321,
00185      PARS_OPEN_TOKEN = 322,
00186      PARS_FETCH_TOKEN = 323,
00187      PARS_CLOSE_TOKEN = 324,
00188      PARS_NOTFOUND_TOKEN = 325,
00189      PARS_TO_CHAR_TOKEN = 326,
00190      PARS_TO_NUMBER_TOKEN = 327,
00191      PARS_TO_BINARY_TOKEN = 328,
00192      PARS_BINARY_TO_NUMBER_TOKEN = 329,
00193      PARS_SUBSTR_TOKEN = 330,
00194      PARS_REPLSTR_TOKEN = 331,
00195      PARS_CONCAT_TOKEN = 332,
00196      PARS_INSTR_TOKEN = 333,
00197      PARS_LENGTH_TOKEN = 334,
00198      PARS_SYSDATE_TOKEN = 335,
00199      PARS_PRINTF_TOKEN = 336,
00200      PARS_ASSERT_TOKEN = 337,
00201      PARS_RND_TOKEN = 338,
00202      PARS_RND_STR_TOKEN = 339,
00203      PARS_ROW_PRINTF_TOKEN = 340,
00204      PARS_COMMIT_TOKEN = 341,
00205      PARS_ROLLBACK_TOKEN = 342,
00206      PARS_WORK_TOKEN = 343,
00207      PARS_UNSIGNED_TOKEN = 344,
00208      PARS_EXIT_TOKEN = 345,
00209      PARS_FUNCTION_TOKEN = 346,
00210      PARS_LOCK_TOKEN = 347,
00211      PARS_SHARE_TOKEN = 348,
00212      PARS_MODE_TOKEN = 349,
00213      NEG = 350
00214    };
00215 #endif
00216 /* Tokens.  */
00217 #define PARS_INT_LIT 258
00218 #define PARS_FLOAT_LIT 259
00219 #define PARS_STR_LIT 260
00220 #define PARS_FIXBINARY_LIT 261
00221 #define PARS_BLOB_LIT 262
00222 #define PARS_NULL_LIT 263
00223 #define PARS_ID_TOKEN 264
00224 #define PARS_AND_TOKEN 265
00225 #define PARS_OR_TOKEN 266
00226 #define PARS_NOT_TOKEN 267
00227 #define PARS_GE_TOKEN 268
00228 #define PARS_LE_TOKEN 269
00229 #define PARS_NE_TOKEN 270
00230 #define PARS_PROCEDURE_TOKEN 271
00231 #define PARS_IN_TOKEN 272
00232 #define PARS_OUT_TOKEN 273
00233 #define PARS_BINARY_TOKEN 274
00234 #define PARS_BLOB_TOKEN 275
00235 #define PARS_INT_TOKEN 276
00236 #define PARS_INTEGER_TOKEN 277
00237 #define PARS_FLOAT_TOKEN 278
00238 #define PARS_CHAR_TOKEN 279
00239 #define PARS_IS_TOKEN 280
00240 #define PARS_BEGIN_TOKEN 281
00241 #define PARS_END_TOKEN 282
00242 #define PARS_IF_TOKEN 283
00243 #define PARS_THEN_TOKEN 284
00244 #define PARS_ELSE_TOKEN 285
00245 #define PARS_ELSIF_TOKEN 286
00246 #define PARS_LOOP_TOKEN 287
00247 #define PARS_WHILE_TOKEN 288
00248 #define PARS_RETURN_TOKEN 289
00249 #define PARS_SELECT_TOKEN 290
00250 #define PARS_SUM_TOKEN 291
00251 #define PARS_COUNT_TOKEN 292
00252 #define PARS_DISTINCT_TOKEN 293
00253 #define PARS_FROM_TOKEN 294
00254 #define PARS_WHERE_TOKEN 295
00255 #define PARS_FOR_TOKEN 296
00256 #define PARS_DDOT_TOKEN 297
00257 #define PARS_READ_TOKEN 298
00258 #define PARS_ORDER_TOKEN 299
00259 #define PARS_BY_TOKEN 300
00260 #define PARS_ASC_TOKEN 301
00261 #define PARS_DESC_TOKEN 302
00262 #define PARS_INSERT_TOKEN 303
00263 #define PARS_INTO_TOKEN 304
00264 #define PARS_VALUES_TOKEN 305
00265 #define PARS_UPDATE_TOKEN 306
00266 #define PARS_SET_TOKEN 307
00267 #define PARS_DELETE_TOKEN 308
00268 #define PARS_CURRENT_TOKEN 309
00269 #define PARS_OF_TOKEN 310
00270 #define PARS_CREATE_TOKEN 311
00271 #define PARS_TABLE_TOKEN 312
00272 #define PARS_INDEX_TOKEN 313
00273 #define PARS_UNIQUE_TOKEN 314
00274 #define PARS_CLUSTERED_TOKEN 315
00275 #define PARS_DOES_NOT_FIT_IN_MEM_TOKEN 316
00276 #define PARS_ON_TOKEN 317
00277 #define PARS_ASSIGN_TOKEN 318
00278 #define PARS_DECLARE_TOKEN 319
00279 #define PARS_CURSOR_TOKEN 320
00280 #define PARS_SQL_TOKEN 321
00281 #define PARS_OPEN_TOKEN 322
00282 #define PARS_FETCH_TOKEN 323
00283 #define PARS_CLOSE_TOKEN 324
00284 #define PARS_NOTFOUND_TOKEN 325
00285 #define PARS_TO_CHAR_TOKEN 326
00286 #define PARS_TO_NUMBER_TOKEN 327
00287 #define PARS_TO_BINARY_TOKEN 328
00288 #define PARS_BINARY_TO_NUMBER_TOKEN 329
00289 #define PARS_SUBSTR_TOKEN 330
00290 #define PARS_REPLSTR_TOKEN 331
00291 #define PARS_CONCAT_TOKEN 332
00292 #define PARS_INSTR_TOKEN 333
00293 #define PARS_LENGTH_TOKEN 334
00294 #define PARS_SYSDATE_TOKEN 335
00295 #define PARS_PRINTF_TOKEN 336
00296 #define PARS_ASSERT_TOKEN 337
00297 #define PARS_RND_TOKEN 338
00298 #define PARS_RND_STR_TOKEN 339
00299 #define PARS_ROW_PRINTF_TOKEN 340
00300 #define PARS_COMMIT_TOKEN 341
00301 #define PARS_ROLLBACK_TOKEN 342
00302 #define PARS_WORK_TOKEN 343
00303 #define PARS_UNSIGNED_TOKEN 344
00304 #define PARS_EXIT_TOKEN 345
00305 #define PARS_FUNCTION_TOKEN 346
00306 #define PARS_LOCK_TOKEN 347
00307 #define PARS_SHARE_TOKEN 348
00308 #define PARS_MODE_TOKEN 349
00309 #define NEG 350
00310 
00311 
00312 
00313 
00314 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00315 typedef int YYSTYPE;
00316 # define YYSTYPE_IS_TRIVIAL 1
00317 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00318 # define YYSTYPE_IS_DECLARED 1
00319 #endif
00320 
00321 
00322 /* Copy the second part of user declarations.  */
00323 
00324 
00325 /* Line 264 of yacc.c  */
00326 #line 327 "plugin/innobase/pars/pars0grm.cc"
00327 
00328 #ifdef short
00329 # undef short
00330 #endif
00331 
00332 #ifdef YYTYPE_UINT8
00333 typedef YYTYPE_UINT8 yytype_uint8;
00334 #else
00335 typedef unsigned char yytype_uint8;
00336 #endif
00337 
00338 #ifdef YYTYPE_INT8
00339 typedef YYTYPE_INT8 yytype_int8;
00340 #elif (defined __STDC__ || defined __C99__FUNC__ \
00341      || defined __cplusplus || defined _MSC_VER)
00342 typedef signed char yytype_int8;
00343 #else
00344 typedef short int yytype_int8;
00345 #endif
00346 
00347 #ifdef YYTYPE_UINT16
00348 typedef YYTYPE_UINT16 yytype_uint16;
00349 #else
00350 typedef unsigned short int yytype_uint16;
00351 #endif
00352 
00353 #ifdef YYTYPE_INT16
00354 typedef YYTYPE_INT16 yytype_int16;
00355 #else
00356 typedef short int yytype_int16;
00357 #endif
00358 
00359 #ifndef YYSIZE_T
00360 # ifdef __SIZE_TYPE__
00361 #  define YYSIZE_T __SIZE_TYPE__
00362 # elif defined size_t
00363 #  define YYSIZE_T size_t
00364 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
00365      || defined __cplusplus || defined _MSC_VER)
00366 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00367 #  define YYSIZE_T size_t
00368 # else
00369 #  define YYSIZE_T unsigned int
00370 # endif
00371 #endif
00372 
00373 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
00374 
00375 #ifndef YY_
00376 # if YYENABLE_NLS
00377 #  if ENABLE_NLS
00378 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
00379 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
00380 #  endif
00381 # endif
00382 # ifndef YY_
00383 #  define YY_(msgid) msgid
00384 # endif
00385 #endif
00386 
00387 /* Suppress unused-variable warnings by "using" E.  */
00388 #if ! defined lint || defined __GNUC__
00389 # define YYUSE(e) ((void) (e))
00390 #else
00391 # define YYUSE(e) /* empty */
00392 #endif
00393 
00394 /* Identity function, used to suppress warnings about constant conditions.  */
00395 #ifndef lint
00396 # define YYID(n) (n)
00397 #else
00398 #if (defined __STDC__ || defined __C99__FUNC__ \
00399      || defined __cplusplus || defined _MSC_VER)
00400 static int
00401 YYID (int yyi)
00402 #else
00403 static int
00404 YYID (yyi)
00405     int yyi;
00406 #endif
00407 {
00408   return yyi;
00409 }
00410 #endif
00411 
00412 #if ! defined yyoverflow || YYERROR_VERBOSE
00413 
00414 /* The parser invokes alloca or malloc; define the necessary symbols.  */
00415 
00416 # ifdef YYSTACK_USE_ALLOCA
00417 #  if YYSTACK_USE_ALLOCA
00418 #   ifdef __GNUC__
00419 #    define YYSTACK_ALLOC __builtin_alloca
00420 #   elif defined __BUILTIN_VA_ARG_INCR
00421 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
00422 #   elif defined _AIX
00423 #    define YYSTACK_ALLOC __alloca
00424 #   elif defined _MSC_VER
00425 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
00426 #    define alloca _alloca
00427 #   else
00428 #    define YYSTACK_ALLOC alloca
00429 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00430      || defined __cplusplus || defined _MSC_VER)
00431 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00432 #     ifndef _STDLIB_H
00433 #      define _STDLIB_H 1
00434 #     endif
00435 #    endif
00436 #   endif
00437 #  endif
00438 # endif
00439 
00440 # ifdef YYSTACK_ALLOC
00441    /* Pacify GCC's `empty if-body' warning.  */
00442 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
00443 #  ifndef YYSTACK_ALLOC_MAXIMUM
00444     /* The OS might guarantee only one guard page at the bottom of the stack,
00445        and a page size can be as small as 4096 bytes.  So we cannot safely
00446        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
00447        to allow for a few compiler-allocated temporary stack slots.  */
00448 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
00449 #  endif
00450 # else
00451 #  define YYSTACK_ALLOC YYMALLOC
00452 #  define YYSTACK_FREE YYFREE
00453 #  ifndef YYSTACK_ALLOC_MAXIMUM
00454 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
00455 #  endif
00456 #  if (defined __cplusplus && ! defined _STDLIB_H \
00457        && ! ((defined YYMALLOC || defined malloc) \
00458        && (defined YYFREE || defined free)))
00459 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00460 #   ifndef _STDLIB_H
00461 #    define _STDLIB_H 1
00462 #   endif
00463 #  endif
00464 #  ifndef YYMALLOC
00465 #   define YYMALLOC malloc
00466 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00467      || defined __cplusplus || defined _MSC_VER)
00468 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
00469 #   endif
00470 #  endif
00471 #  ifndef YYFREE
00472 #   define YYFREE free
00473 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00474      || defined __cplusplus || defined _MSC_VER)
00475 void free (void *); /* INFRINGES ON USER NAME SPACE */
00476 #   endif
00477 #  endif
00478 # endif
00479 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
00480 
00481 
00482 #if (! defined yyoverflow \
00483      && (! defined __cplusplus \
00484    || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
00485 
00486 /* A type that is properly aligned for any stack member.  */
00487 union yyalloc
00488 {
00489   yytype_int16 yyss_alloc;
00490   YYSTYPE yyvs_alloc;
00491 };
00492 
00493 /* The size of the maximum gap between one aligned stack and the next.  */
00494 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
00495 
00496 /* The size of an array large to enough to hold all stacks, each with
00497    N elements.  */
00498 # define YYSTACK_BYTES(N) \
00499      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
00500       + YYSTACK_GAP_MAXIMUM)
00501 
00502 /* Copy COUNT objects from FROM to TO.  The source and destination do
00503    not overlap.  */
00504 # ifndef YYCOPY
00505 #  if defined __GNUC__ && 1 < __GNUC__
00506 #   define YYCOPY(To, From, Count) \
00507       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00508 #  else
00509 #   define YYCOPY(To, From, Count)    \
00510       do          \
00511   {         \
00512     YYSIZE_T yyi;       \
00513     for (yyi = 0; yyi < (Count); yyi++) \
00514       (To)[yyi] = (From)[yyi];    \
00515   }         \
00516       while (YYID (0))
00517 #  endif
00518 # endif
00519 
00520 /* Relocate STACK from its old location to the new one.  The
00521    local variables YYSIZE and YYSTACKSIZE give the old and new number of
00522    elements in the stack, and YYPTR gives the new location of the
00523    stack.  Advance YYPTR to a properly aligned location for the next
00524    stack.  */
00525 # define YYSTACK_RELOCATE(Stack_alloc, Stack)       \
00526     do                  \
00527       {                 \
00528   YYSIZE_T yynewbytes;            \
00529   YYCOPY (&yyptr->Stack_alloc, Stack, yysize);      \
00530   Stack = &yyptr->Stack_alloc;          \
00531   yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
00532   yyptr += yynewbytes / sizeof (*yyptr);        \
00533       }                 \
00534     while (YYID (0))
00535 
00536 #endif
00537 
00538 /* YYFINAL -- State number of the termination state.  */
00539 #define YYFINAL  5
00540 /* YYLAST -- Last index in YYTABLE.  */
00541 #define YYLAST   752
00542 
00543 /* YYNTOKENS -- Number of terminals.  */
00544 #define YYNTOKENS  111
00545 /* YYNNTS -- Number of nonterminals.  */
00546 #define YYNNTS  70
00547 /* YYNRULES -- Number of rules.  */
00548 #define YYNRULES  175
00549 /* YYNRULES -- Number of states.  */
00550 #define YYNSTATES  339
00551 
00552 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
00553 #define YYUNDEFTOK  2
00554 #define YYMAXUTOK   350
00555 
00556 #define YYTRANSLATE(YYX)            \
00557   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
00558 
00559 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
00560 static const yytype_uint8 yytranslate[] =
00561 {
00562        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00563        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00564        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00565        2,     2,     2,     2,     2,     2,     2,   103,     2,     2,
00566      105,   106,   100,    99,   108,    98,     2,   101,     2,     2,
00567        2,     2,     2,     2,     2,     2,     2,     2,     2,   104,
00568       96,    95,    97,   107,     2,     2,     2,     2,     2,     2,
00569        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00570        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00571        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00572        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00573        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00574        2,     2,     2,   109,     2,   110,     2,     2,     2,     2,
00575        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00576        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00577        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00578        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00579        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00580        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00581        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00582        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00583        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00584        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00585        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00586        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00587        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
00588        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
00589       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
00590       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
00591       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
00592       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
00593       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
00594       65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
00595       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
00596       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
00597      102
00598 };
00599 
00600 #if YYDEBUG
00601 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
00602    YYRHS.  */
00603 static const yytype_uint16 yyprhs[] =
00604 {
00605        0,     0,     3,     6,     8,    11,    14,    17,    20,    23,
00606       26,    29,    32,    35,    38,    41,    44,    47,    50,    53,
00607       56,    59,    62,    65,    68,    71,    73,    76,    78,    83,
00608       85,    87,    89,    91,    93,    95,    97,   101,   105,   109,
00609      113,   116,   120,   124,   128,   132,   136,   140,   144,   148,
00610      152,   155,   159,   163,   165,   167,   169,   171,   173,   175,
00611      177,   179,   181,   183,   185,   186,   188,   192,   199,   204,
00612      206,   208,   210,   214,   216,   220,   221,   223,   227,   228,
00613      230,   234,   236,   241,   247,   252,   253,   255,   259,   261,
00614      265,   267,   268,   271,   272,   275,   276,   281,   282,   284,
00615      286,   287,   292,   301,   305,   311,   314,   318,   320,   324,
00616      329,   334,   337,   340,   344,   347,   350,   353,   357,   362,
00617      364,   367,   368,   371,   373,   381,   388,   399,   401,   403,
00618      406,   409,   414,   419,   425,   427,   431,   432,   436,   437,
00619      439,   440,   443,   444,   446,   454,   456,   460,   461,   463,
00620      464,   466,   477,   480,   483,   485,   487,   489,   491,   493,
00621      497,   501,   502,   504,   508,   512,   513,   515,   518,   525,
00622      530,   532,   534,   535,   537,   540
00623 };
00624 
00625 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
00626 static const yytype_int16 yyrhs[] =
00627 {
00628      112,     0,    -1,   180,   104,    -1,   118,    -1,   119,   104,
00629       -1,   151,   104,    -1,   152,   104,    -1,   153,   104,    -1,
00630      150,   104,    -1,   154,   104,    -1,   146,   104,    -1,   133,
00631      104,    -1,   135,   104,    -1,   145,   104,    -1,   143,   104,
00632       -1,   144,   104,    -1,   140,   104,    -1,   141,   104,    -1,
00633      155,   104,    -1,   157,   104,    -1,   156,   104,    -1,   169,
00634      104,    -1,   170,   104,    -1,   164,   104,    -1,   168,   104,
00635       -1,   113,    -1,   114,   113,    -1,     9,    -1,   116,   105,
00636      124,   106,    -1,     3,    -1,     4,    -1,     5,    -1,     6,
00637       -1,     7,    -1,     8,    -1,    66,    -1,   115,    99,   115,
00638       -1,   115,    98,   115,    -1,   115,   100,   115,    -1,   115,
00639      101,   115,    -1,    98,   115,    -1,   105,   115,   106,    -1,
00640      115,    95,   115,    -1,   115,    96,   115,    -1,   115,    97,
00641      115,    -1,   115,    13,   115,    -1,   115,    14,   115,    -1,
00642      115,    15,   115,    -1,   115,    10,   115,    -1,   115,    11,
00643      115,    -1,    12,   115,    -1,     9,   103,    70,    -1,    66,
00644      103,    70,    -1,    71,    -1,    72,    -1,    73,    -1,    74,
00645       -1,    75,    -1,    77,    -1,    78,    -1,    79,    -1,    80,
00646       -1,    83,    -1,    84,    -1,    -1,   107,    -1,   117,   108,
00647      107,    -1,   109,     9,   105,   117,   106,   110,    -1,   120,
00648      105,   124,   106,    -1,    76,    -1,    81,    -1,    82,    -1,
00649        9,   105,   106,    -1,     9,    -1,   122,   108,     9,    -1,
00650       -1,     9,    -1,   123,   108,     9,    -1,    -1,   115,    -1,
00651      124,   108,   115,    -1,   115,    -1,    37,   105,   100,   106,
00652       -1,    37,   105,    38,     9,   106,    -1,    36,   105,   115,
00653      106,    -1,    -1,   125,    -1,   126,   108,   125,    -1,   100,
00654       -1,   126,    49,   123,    -1,   126,    -1,    -1,    40,   115,
00655       -1,    -1,    41,    51,    -1,    -1,    92,    17,    93,    94,
00656       -1,    -1,    46,    -1,    47,    -1,    -1,    44,    45,     9,
00657      131,    -1,    35,   127,    39,   122,   128,   129,   130,   132,
00658       -1,    48,    49,     9,    -1,   134,    50,   105,   124,   106,
00659       -1,   134,   133,    -1,     9,    95,   115,    -1,   136,    -1,
00660      137,   108,   136,    -1,    40,    54,    55,     9,    -1,    51,
00661        9,    52,   137,    -1,   139,   128,    -1,   139,   138,    -1,
00662       53,    39,     9,    -1,   142,   128,    -1,   142,   138,    -1,
00663       85,   133,    -1,     9,    63,   115,    -1,    31,   115,    29,
00664      114,    -1,   147,    -1,   148,   147,    -1,    -1,    30,   114,
00665       -1,   148,    -1,    28,   115,    29,   114,   149,    27,    28,
00666       -1,    33,   115,    32,   114,    27,    32,    -1,    41,     9,
00667       17,   115,    42,   115,    32,   114,    27,    32,    -1,    90,
00668       -1,    34,    -1,    67,     9,    -1,    69,     9,    -1,    68,
00669        9,    49,   123,    -1,    68,     9,    49,   121,    -1,     9,
00670      171,   160,   161,   162,    -1,   158,    -1,   159,   108,   158,
00671       -1,    -1,   105,     3,   106,    -1,    -1,    89,    -1,    -1,
00672       12,     8,    -1,    -1,    61,    -1,    56,    57,     9,   105,
00673      159,   106,   163,    -1,     9,    -1,   165,   108,     9,    -1,
00674       -1,    59,    -1,    -1,    60,    -1,    56,   166,   167,    58,
00675        9,    62,     9,   105,   165,   106,    -1,    86,    88,    -1,
00676       87,    88,    -1,    21,    -1,    22,    -1,    24,    -1,    19,
00677       -1,    20,    -1,     9,    17,   171,    -1,     9,    18,   171,
00678       -1,    -1,   172,    -1,   173,   108,   172,    -1,     9,   171,
00679      104,    -1,    -1,   174,    -1,   175,   174,    -1,    64,    65,
00680        9,    25,   133,   104,    -1,    64,    91,     9,   104,    -1,
00681      176,    -1,   177,    -1,    -1,   178,    -1,   179,   178,    -1,
00682       16,     9,   105,   173,   106,    25,   175,   179,    26,   114,
00683       27,    -1
00684 };
00685 
00686 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
00687 static const yytype_uint16 yyrline[] =
00688 {
00689        0,   153,   153,   156,   157,   158,   159,   160,   161,   162,
00690      163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
00691      173,   174,   175,   176,   177,   181,   182,   187,   188,   190,
00692      191,   192,   193,   194,   195,   196,   197,   198,   199,   200,
00693      201,   202,   203,   204,   205,   206,   207,   208,   209,   210,
00694      211,   212,   214,   219,   220,   221,   222,   224,   225,   226,
00695      227,   228,   229,   230,   233,   235,   236,   240,   245,   250,
00696      251,   252,   256,   260,   261,   266,   267,   268,   273,   274,
00697      275,   279,   280,   285,   291,   298,   299,   300,   305,   307,
00698      309,   313,   314,   318,   319,   324,   325,   330,   331,   332,
00699      336,   337,   342,   352,   357,   359,   364,   368,   369,   374,
00700      380,   387,   392,   397,   403,   408,   413,   418,   423,   429,
00701      430,   435,   436,   438,   442,   449,   455,   463,   467,   471,
00702      477,   483,   485,   490,   495,   496,   501,   502,   507,   508,
00703      514,   515,   521,   522,   528,   534,   535,   540,   541,   545,
00704      546,   550,   558,   563,   568,   569,   570,   571,   572,   576,
00705      579,   585,   586,   587,   592,   596,   598,   599,   603,   609,
00706      614,   615,   618,   620,   621,   625
00707 };
00708 #endif
00709 
00710 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
00711 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
00712    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
00713 static const char *const yytname[] =
00714 {
00715   "$end", "error", "$undefined", "PARS_INT_LIT", "PARS_FLOAT_LIT",
00716   "PARS_STR_LIT", "PARS_FIXBINARY_LIT", "PARS_BLOB_LIT", "PARS_NULL_LIT",
00717   "PARS_ID_TOKEN", "PARS_AND_TOKEN", "PARS_OR_TOKEN", "PARS_NOT_TOKEN",
00718   "PARS_GE_TOKEN", "PARS_LE_TOKEN", "PARS_NE_TOKEN",
00719   "PARS_PROCEDURE_TOKEN", "PARS_IN_TOKEN", "PARS_OUT_TOKEN",
00720   "PARS_BINARY_TOKEN", "PARS_BLOB_TOKEN", "PARS_INT_TOKEN",
00721   "PARS_INTEGER_TOKEN", "PARS_FLOAT_TOKEN", "PARS_CHAR_TOKEN",
00722   "PARS_IS_TOKEN", "PARS_BEGIN_TOKEN", "PARS_END_TOKEN", "PARS_IF_TOKEN",
00723   "PARS_THEN_TOKEN", "PARS_ELSE_TOKEN", "PARS_ELSIF_TOKEN",
00724   "PARS_LOOP_TOKEN", "PARS_WHILE_TOKEN", "PARS_RETURN_TOKEN",
00725   "PARS_SELECT_TOKEN", "PARS_SUM_TOKEN", "PARS_COUNT_TOKEN",
00726   "PARS_DISTINCT_TOKEN", "PARS_FROM_TOKEN", "PARS_WHERE_TOKEN",
00727   "PARS_FOR_TOKEN", "PARS_DDOT_TOKEN", "PARS_READ_TOKEN",
00728   "PARS_ORDER_TOKEN", "PARS_BY_TOKEN", "PARS_ASC_TOKEN", "PARS_DESC_TOKEN",
00729   "PARS_INSERT_TOKEN", "PARS_INTO_TOKEN", "PARS_VALUES_TOKEN",
00730   "PARS_UPDATE_TOKEN", "PARS_SET_TOKEN", "PARS_DELETE_TOKEN",
00731   "PARS_CURRENT_TOKEN", "PARS_OF_TOKEN", "PARS_CREATE_TOKEN",
00732   "PARS_TABLE_TOKEN", "PARS_INDEX_TOKEN", "PARS_UNIQUE_TOKEN",
00733   "PARS_CLUSTERED_TOKEN", "PARS_DOES_NOT_FIT_IN_MEM_TOKEN",
00734   "PARS_ON_TOKEN", "PARS_ASSIGN_TOKEN", "PARS_DECLARE_TOKEN",
00735   "PARS_CURSOR_TOKEN", "PARS_SQL_TOKEN", "PARS_OPEN_TOKEN",
00736   "PARS_FETCH_TOKEN", "PARS_CLOSE_TOKEN", "PARS_NOTFOUND_TOKEN",
00737   "PARS_TO_CHAR_TOKEN", "PARS_TO_NUMBER_TOKEN", "PARS_TO_BINARY_TOKEN",
00738   "PARS_BINARY_TO_NUMBER_TOKEN", "PARS_SUBSTR_TOKEN", "PARS_REPLSTR_TOKEN",
00739   "PARS_CONCAT_TOKEN", "PARS_INSTR_TOKEN", "PARS_LENGTH_TOKEN",
00740   "PARS_SYSDATE_TOKEN", "PARS_PRINTF_TOKEN", "PARS_ASSERT_TOKEN",
00741   "PARS_RND_TOKEN", "PARS_RND_STR_TOKEN", "PARS_ROW_PRINTF_TOKEN",
00742   "PARS_COMMIT_TOKEN", "PARS_ROLLBACK_TOKEN", "PARS_WORK_TOKEN",
00743   "PARS_UNSIGNED_TOKEN", "PARS_EXIT_TOKEN", "PARS_FUNCTION_TOKEN",
00744   "PARS_LOCK_TOKEN", "PARS_SHARE_TOKEN", "PARS_MODE_TOKEN", "'='", "'<'",
00745   "'>'", "'-'", "'+'", "'*'", "'/'", "NEG", "'%'", "';'", "'('", "')'",
00746   "'?'", "','", "'{'", "'}'", "$accept", "top_statement", "statement",
00747   "statement_list", "exp", "function_name", "question_mark_list",
00748   "stored_procedure_call", "predefined_procedure_call",
00749   "predefined_procedure_name", "user_function_call", "table_list",
00750   "variable_list", "exp_list", "select_item", "select_item_list",
00751   "select_list", "search_condition", "for_update_clause",
00752   "lock_shared_clause", "order_direction", "order_by_clause",
00753   "select_statement", "insert_statement_start", "insert_statement",
00754   "column_assignment", "column_assignment_list", "cursor_positioned",
00755   "update_statement_start", "update_statement_searched",
00756   "update_statement_positioned", "delete_statement_start",
00757   "delete_statement_searched", "delete_statement_positioned",
00758   "row_printf_statement", "assignment_statement", "elsif_element",
00759   "elsif_list", "else_part", "if_statement", "while_statement",
00760   "for_statement", "exit_statement", "return_statement",
00761   "open_cursor_statement", "close_cursor_statement", "fetch_statement",
00762   "column_def", "column_def_list", "opt_column_len", "opt_unsigned",
00763   "opt_not_null", "not_fit_in_memory", "create_table", "column_list",
00764   "unique_def", "clustered_def", "create_index", "commit_statement",
00765   "rollback_statement", "type_name", "parameter_declaration",
00766   "parameter_declaration_list", "variable_declaration",
00767   "variable_declaration_list", "cursor_declaration",
00768   "function_declaration", "declaration", "declaration_list",
00769   "procedure_definition", 0
00770 };
00771 #endif
00772 
00773 # ifdef YYPRINT
00774 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
00775    token YYLEX-NUM.  */
00776 static const yytype_uint16 yytoknum[] =
00777 {
00778        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
00779      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
00780      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
00781      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
00782      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
00783      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
00784      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
00785      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
00786      335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
00787      345,   346,   347,   348,   349,    61,    60,    62,    45,    43,
00788       42,    47,   350,    37,    59,    40,    41,    63,    44,   123,
00789      125
00790 };
00791 # endif
00792 
00793 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
00794 static const yytype_uint8 yyr1[] =
00795 {
00796        0,   111,   112,   113,   113,   113,   113,   113,   113,   113,
00797      113,   113,   113,   113,   113,   113,   113,   113,   113,   113,
00798      113,   113,   113,   113,   113,   114,   114,   115,   115,   115,
00799      115,   115,   115,   115,   115,   115,   115,   115,   115,   115,
00800      115,   115,   115,   115,   115,   115,   115,   115,   115,   115,
00801      115,   115,   115,   116,   116,   116,   116,   116,   116,   116,
00802      116,   116,   116,   116,   117,   117,   117,   118,   119,   120,
00803      120,   120,   121,   122,   122,   123,   123,   123,   124,   124,
00804      124,   125,   125,   125,   125,   126,   126,   126,   127,   127,
00805      127,   128,   128,   129,   129,   130,   130,   131,   131,   131,
00806      132,   132,   133,   134,   135,   135,   136,   137,   137,   138,
00807      139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
00808      148,   149,   149,   149,   150,   151,   152,   153,   154,   155,
00809      156,   157,   157,   158,   159,   159,   160,   160,   161,   161,
00810      162,   162,   163,   163,   164,   165,   165,   166,   166,   167,
00811      167,   168,   169,   170,   171,   171,   171,   171,   171,   172,
00812      172,   173,   173,   173,   174,   175,   175,   175,   176,   177,
00813      178,   178,   179,   179,   179,   180
00814 };
00815 
00816 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
00817 static const yytype_uint8 yyr2[] =
00818 {
00819        0,     2,     2,     1,     2,     2,     2,     2,     2,     2,
00820        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00821        2,     2,     2,     2,     2,     1,     2,     1,     4,     1,
00822        1,     1,     1,     1,     1,     1,     3,     3,     3,     3,
00823        2,     3,     3,     3,     3,     3,     3,     3,     3,     3,
00824        2,     3,     3,     1,     1,     1,     1,     1,     1,     1,
00825        1,     1,     1,     1,     0,     1,     3,     6,     4,     1,
00826        1,     1,     3,     1,     3,     0,     1,     3,     0,     1,
00827        3,     1,     4,     5,     4,     0,     1,     3,     1,     3,
00828        1,     0,     2,     0,     2,     0,     4,     0,     1,     1,
00829        0,     4,     8,     3,     5,     2,     3,     1,     3,     4,
00830        4,     2,     2,     3,     2,     2,     2,     3,     4,     1,
00831        2,     0,     2,     1,     7,     6,    10,     1,     1,     2,
00832        2,     4,     4,     5,     1,     3,     0,     3,     0,     1,
00833        0,     2,     0,     1,     7,     1,     3,     0,     1,     0,
00834        1,    10,     2,     2,     1,     1,     1,     1,     1,     3,
00835        3,     0,     1,     3,     3,     0,     1,     2,     6,     4,
00836        1,     1,     0,     1,     2,    11
00837 };
00838 
00839 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
00840    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
00841    means the default is an error.  */
00842 static const yytype_uint8 yydefact[] =
00843 {
00844        0,     0,     0,     0,     0,     1,     2,   161,     0,   162,
00845        0,     0,     0,     0,     0,   157,   158,   154,   155,   156,
00846      159,   160,   165,   163,     0,   166,   172,     0,     0,   167,
00847      170,   171,   173,     0,   164,     0,     0,     0,   174,     0,
00848        0,     0,     0,     0,   128,    85,     0,     0,     0,     0,
00849      147,     0,     0,     0,    69,    70,    71,     0,     0,     0,
00850      127,     0,    25,     0,     3,     0,     0,     0,     0,     0,
00851       91,     0,     0,    91,     0,     0,     0,     0,     0,     0,
00852        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00853        0,   169,     0,    29,    30,    31,    32,    33,    34,    27,
00854        0,    35,    53,    54,    55,    56,    57,    58,    59,    60,
00855       61,    62,    63,     0,     0,     0,     0,     0,     0,     0,
00856       88,    81,    86,    90,     0,     0,     0,     0,     0,     0,
00857      148,   149,   129,     0,   130,   116,   152,   153,     0,   175,
00858       26,     4,    78,    11,     0,   105,    12,     0,   111,   112,
00859       16,    17,   114,   115,    14,    15,    13,    10,     8,     5,
00860        6,     7,     9,    18,    20,    19,    23,    24,    21,    22,
00861        0,   117,     0,    50,     0,    40,     0,     0,     0,     0,
00862        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00863       78,     0,     0,     0,    75,     0,     0,     0,   103,     0,
00864      113,     0,   150,     0,    75,    64,    79,     0,    78,     0,
00865       92,   168,    51,    52,    41,    48,    49,    45,    46,    47,
00866      121,    42,    43,    44,    37,    36,    38,    39,     0,     0,
00867        0,     0,     0,    76,    89,    87,    73,    91,     0,     0,
00868      107,   110,     0,     0,    76,   132,   131,    65,     0,    68,
00869        0,     0,     0,     0,     0,   119,   123,     0,    28,     0,
00870       84,     0,    82,     0,     0,     0,    93,     0,     0,     0,
00871        0,   134,     0,     0,     0,     0,     0,    80,   104,   109,
00872      122,     0,   120,     0,   125,    83,    77,    74,     0,    95,
00873        0,   106,   108,   136,   142,     0,     0,    72,    67,    66,
00874        0,   124,    94,     0,   100,     0,     0,   138,   143,   144,
00875      135,     0,   118,     0,     0,   102,     0,     0,   139,   140,
00876        0,     0,     0,     0,   137,     0,   133,   145,     0,    96,
00877       97,   126,   141,   151,     0,    98,    99,   101,   146
00878 };
00879 
00880 /* YYDEFGOTO[NTERM-NUM].  */
00881 static const yytype_int16 yydefgoto[] =
00882 {
00883       -1,     2,    62,    63,   206,   116,   248,    64,    65,    66,
00884      245,   237,   234,   207,   122,   123,   124,   148,   289,   304,
00885      337,   315,    67,    68,    69,   240,   241,   149,    70,    71,
00886       72,    73,    74,    75,    76,    77,   255,   256,   257,    78,
00887       79,    80,    81,    82,    83,    84,    85,   271,   272,   307,
00888      319,   326,   309,    86,   328,   131,   203,    87,    88,    89,
00889       20,     9,    10,    25,    26,    30,    31,    32,    33,     3
00890 };
00891 
00892 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
00893    STATE-NUM.  */
00894 #define YYPACT_NINF -177
00895 static const yytype_int16 yypact[] =
00896 {
00897       28,    38,    54,   -46,   -29,  -177,  -177,    56,    50,  -177,
00898      -75,     8,     8,    46,    56,  -177,  -177,  -177,  -177,  -177,
00899     -177,  -177,    63,  -177,     8,  -177,     2,   -26,   -51,  -177,
00900     -177,  -177,  -177,   -13,  -177,    71,    72,   587,  -177,    57,
00901      -21,    26,   272,   272,  -177,    13,    91,    55,    96,    67,
00902      -22,    99,   100,   103,  -177,  -177,  -177,    75,    29,    35,
00903     -177,   116,  -177,   396,  -177,    22,    23,    27,    -9,    30,
00904       87,    31,    32,    87,    47,    49,    52,    58,    59,    60,
00905       61,    62,    65,    66,    74,    77,    78,    86,    89,   102,
00906       75,  -177,   272,  -177,  -177,  -177,  -177,  -177,  -177,    39,
00907      272,    51,  -177,  -177,  -177,  -177,  -177,  -177,  -177,  -177,
00908     -177,  -177,  -177,   272,   272,   361,    25,   489,    45,    90,
00909     -177,   651,  -177,   -39,    93,   142,   124,   108,   152,   170,
00910     -177,   131,  -177,   143,  -177,  -177,  -177,  -177,    98,  -177,
00911     -177,  -177,   272,  -177,   110,  -177,  -177,   256,  -177,  -177,
00912     -177,  -177,  -177,  -177,  -177,  -177,  -177,  -177,  -177,  -177,
00913     -177,  -177,  -177,  -177,  -177,  -177,  -177,  -177,  -177,  -177,
00914      112,   651,   137,   101,   147,   204,    88,   272,   272,   272,
00915      272,   272,   587,   272,   272,   272,   272,   272,   272,   272,
00916      272,   587,   272,   -30,   211,   168,   212,   272,  -177,   213,
00917     -177,   118,  -177,   167,   217,   122,   651,   -63,   272,   175,
00918      651,  -177,  -177,  -177,  -177,   101,   101,    21,    21,   651,
00919      332,    21,    21,    21,    -6,    -6,   204,   204,   -60,   460,
00920      198,   222,   126,  -177,   125,  -177,  -177,   -33,   584,   140,
00921     -177,   128,   228,   229,   139,  -177,   125,  -177,   -53,  -177,
00922      272,   -49,   240,   587,   272,  -177,   224,   226,  -177,   225,
00923     -177,   150,  -177,   258,   272,   260,   230,   272,   272,   213,
00924        8,  -177,   -45,   208,   166,   164,   176,   651,  -177,  -177,
00925      587,   631,  -177,   254,  -177,  -177,  -177,  -177,   234,   194,
00926      638,   651,  -177,   182,   227,   228,   280,  -177,  -177,  -177,
00927      587,  -177,  -177,   273,   247,   587,   289,   214,  -177,  -177,
00928     -177,   195,   587,   209,   261,  -177,   524,   199,  -177,   295,
00929      292,   215,   299,   279,  -177,   304,  -177,  -177,   -44,  -177,
00930       -8,  -177,  -177,  -177,   305,  -177,  -177,  -177,  -177
00931 };
00932 
00933 /* YYPGOTO[NTERM-NUM].  */
00934 static const yytype_int16 yypgoto[] =
00935 {
00936     -177,  -177,   -62,  -176,   -40,  -177,  -177,  -177,  -177,  -177,
00937     -177,  -177,   109,  -166,   120,  -177,  -177,   -69,  -177,  -177,
00938     -177,  -177,   -34,  -177,  -177,    48,  -177,   243,  -177,  -177,
00939     -177,  -177,  -177,  -177,  -177,  -177,    64,  -177,  -177,  -177,
00940     -177,  -177,  -177,  -177,  -177,  -177,  -177,    24,  -177,  -177,
00941     -177,  -177,  -177,  -177,  -177,  -177,  -177,  -177,  -177,  -177,
00942      -12,   307,  -177,   297,  -177,  -177,  -177,   285,  -177,  -177
00943 };
00944 
00945 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
00946    positive, shift that token.  If negative, reduce the rule which
00947    number is the opposite.  If zero, do what YYDEFACT says.
00948    If YYTABLE_NINF, syntax error.  */
00949 #define YYTABLE_NINF -1
00950 static const yytype_uint16 yytable[] =
00951 {
00952       21,   140,   115,   117,   152,   121,   220,   264,   231,   181,
00953      194,    24,    27,    37,    35,   229,    93,    94,    95,    96,
00954       97,    98,    99,   135,   228,   100,    45,    15,    16,    17,
00955       18,    13,    19,    14,   145,   129,   181,   130,   335,   336,
00956       36,   144,   251,   249,     1,   250,   258,     4,   250,   118,
00957      119,    28,   171,   275,     5,   276,   170,   278,     6,   250,
00958      173,   294,   333,   295,   334,     8,    28,    11,    12,   195,
00959      232,    22,    24,   175,   176,   265,     7,   280,    34,   101,
00960       39,    40,    90,    91,   102,   103,   104,   105,   106,    92,
00961      107,   108,   109,   110,   188,   189,   111,   112,   177,   178,
00962      125,   179,   180,   181,   126,   127,   128,   210,   132,   133,
00963       45,   113,   134,   120,   179,   180,   181,   136,   114,   186,
00964      187,   188,   189,   137,   312,   138,   141,   147,   142,   316,
00965      190,   143,   196,   198,   146,   150,   151,   215,   216,   217,
00966      218,   219,   172,   221,   222,   223,   224,   225,   226,   227,
00967      192,   154,   230,   155,   174,   121,   156,   238,   140,   197,
00968      199,   200,   157,   158,   159,   160,   161,   140,   266,   162,
00969      163,    93,    94,    95,    96,    97,    98,    99,   164,   201,
00970      100,   165,   166,   183,   184,   185,   186,   187,   188,   189,
00971      167,   202,   204,   168,   214,   193,   183,   184,   185,   186,
00972      187,   188,   189,   205,   118,   119,   169,   212,   177,   178,
00973      277,   179,   180,   181,   281,   208,   211,   213,   140,   181,
00974      233,   236,   239,   242,   210,   243,   244,   290,   291,   247,
00975      252,   261,   262,   263,   101,   268,   269,   270,   273,   102,
00976      103,   104,   105,   106,   274,   107,   108,   109,   110,   279,
00977      140,   111,   112,   283,   140,   254,   285,   284,   293,    93,
00978       94,    95,    96,    97,    98,    99,   113,   286,   100,   287,
00979      296,   288,   297,   114,   298,    93,    94,    95,    96,    97,
00980       98,    99,   301,   299,   100,   302,   303,   306,   308,   311,
00981      313,   314,   317,   183,   184,   185,   186,   187,   188,   189,
00982      320,   327,   321,   318,   260,   324,   322,   325,   330,   329,
00983      209,   331,   332,   246,   338,   235,   153,   292,    38,   310,
00984      282,    23,   101,    29,     0,     0,     0,   102,   103,   104,
00985      105,   106,     0,   107,   108,   109,   110,     0,   101,   111,
00986      112,    41,     0,   102,   103,   104,   105,   106,     0,   107,
00987      108,   109,   110,     0,   113,   111,   112,     0,     0,     0,
00988       42,   114,   253,   254,     0,    43,    44,    45,     0,     0,
00989      113,   177,   178,    46,   179,   180,   181,   114,     0,     0,
00990       47,     0,     0,    48,     0,    49,     0,     0,    50,     0,
00991      182,     0,     0,     0,     0,     0,     0,     0,     0,    51,
00992       52,    53,     0,     0,     0,    41,     0,     0,    54,     0,
00993        0,     0,     0,    55,    56,     0,     0,    57,    58,    59,
00994        0,     0,    60,   139,    42,     0,     0,     0,     0,    43,
00995       44,    45,     0,     0,     0,     0,     0,    46,     0,     0,
00996        0,    61,     0,     0,    47,     0,     0,    48,     0,    49,
00997        0,     0,    50,     0,     0,     0,   183,   184,   185,   186,
00998      187,   188,   189,    51,    52,    53,     0,     0,     0,    41,
00999        0,     0,    54,     0,     0,     0,     0,    55,    56,     0,
01000        0,    57,    58,    59,     0,     0,    60,   259,    42,     0,
01001        0,     0,     0,    43,    44,    45,     0,     0,     0,   177,
01002      178,    46,   179,   180,   181,    61,     0,     0,    47,     0,
01003        0,    48,     0,    49,     0,     0,    50,     0,     0,     0,
01004        0,   191,     0,     0,     0,     0,     0,    51,    52,    53,
01005        0,     0,     0,    41,     0,     0,    54,     0,     0,     0,
01006        0,    55,    56,     0,     0,    57,    58,    59,     0,     0,
01007       60,   323,    42,     0,     0,     0,     0,    43,    44,    45,
01008        0,     0,     0,     0,     0,    46,     0,     0,     0,    61,
01009        0,     0,    47,     0,     0,    48,     0,    49,     0,     0,
01010       50,     0,     0,     0,   183,   184,   185,   186,   187,   188,
01011      189,    51,    52,    53,   177,   178,    41,   179,   180,   181,
01012       54,     0,     0,     0,     0,    55,    56,     0,     0,    57,
01013       58,    59,     0,     0,    60,    42,     0,     0,     0,     0,
01014       43,    44,    45,     0,     0,     0,   267,     0,    46,     0,
01015        0,     0,     0,    61,     0,    47,     0,     0,    48,     0,
01016       49,   177,   178,    50,   179,   180,   181,     0,   177,   178,
01017        0,   179,   180,   181,    51,    52,    53,     0,     0,     0,
01018      300,   177,   178,    54,   179,   180,   181,     0,    55,    56,
01019      305,     0,    57,    58,    59,     0,     0,    60,     0,   183,
01020      184,   185,   186,   187,   188,   189,     0,     0,     0,     0,
01021        0,     0,     0,     0,     0,     0,    61,     0,     0,     0,
01022        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01023        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01024        0,     0,     0,     0,     0,     0,   183,   184,   185,   186,
01025      187,   188,   189,   183,   184,   185,   186,   187,   188,   189,
01026        0,     0,     0,     0,     0,     0,   183,   184,   185,   186,
01027      187,   188,   189
01028 };
01029 
01030 static const yytype_int16 yycheck[] =
01031 {
01032       12,    63,    42,    43,    73,    45,   182,    40,    38,    15,
01033       49,     9,    24,    26,    65,   191,     3,     4,     5,     6,
01034        7,     8,     9,    57,   190,    12,    35,    19,    20,    21,
01035       22,   106,    24,   108,    68,    57,    15,    59,    46,    47,
01036       91,    50,   208,   106,    16,   108,   106,     9,   108,    36,
01037       37,    64,    92,   106,     0,   108,    90,   106,   104,   108,
01038      100,   106,   106,   108,   108,     9,    64,    17,    18,   108,
01039      100,    25,     9,   113,   114,   108,   105,   253,   104,    66,
01040        9,     9,    25,   104,    71,    72,    73,    74,    75,    63,
01041       77,    78,    79,    80,   100,   101,    83,    84,    10,    11,
01042        9,    13,    14,    15,    49,     9,    39,   147,     9,     9,
01043       35,    98,     9,   100,    13,    14,    15,    88,   105,    98,
01044       99,   100,   101,    88,   300,     9,   104,    40,   105,   305,
01045      105,   104,    39,     9,   104,   104,   104,   177,   178,   179,
01046      180,   181,   103,   183,   184,   185,   186,   187,   188,   189,
01047      105,   104,   192,   104,   103,   195,   104,   197,   220,    17,
01048       52,     9,   104,   104,   104,   104,   104,   229,   237,   104,
01049      104,     3,     4,     5,     6,     7,     8,     9,   104,     9,
01050       12,   104,   104,    95,    96,    97,    98,    99,   100,   101,
01051      104,    60,    49,   104,   106,   105,    95,    96,    97,    98,
01052       99,   100,   101,   105,    36,    37,   104,    70,    10,    11,
01053      250,    13,    14,    15,   254,   105,   104,    70,   280,    15,
01054        9,     9,     9,   105,   264,    58,     9,   267,   268,   107,
01055       55,     9,   106,   108,    66,    95,   108,     9,     9,    71,
01056       72,    73,    74,    75,   105,    77,    78,    79,    80,     9,
01057      312,    83,    84,    27,   316,    31,   106,    32,   270,     3,
01058        4,     5,     6,     7,     8,     9,    98,     9,    12,     9,
01059       62,    41,   106,   105,   110,     3,     4,     5,     6,     7,
01060        8,     9,    28,   107,    12,    51,    92,   105,    61,     9,
01061       17,    44,     3,    95,    96,    97,    98,    99,   100,   101,
01062      105,     9,    93,    89,   106,   106,    45,    12,     9,    94,
01063       54,    32,     8,   204,     9,   195,    73,   269,    33,   295,
01064      256,    14,    66,    26,    -1,    -1,    -1,    71,    72,    73,
01065       74,    75,    -1,    77,    78,    79,    80,    -1,    66,    83,
01066       84,     9,    -1,    71,    72,    73,    74,    75,    -1,    77,
01067       78,    79,    80,    -1,    98,    83,    84,    -1,    -1,    -1,
01068       28,   105,    30,    31,    -1,    33,    34,    35,    -1,    -1,
01069       98,    10,    11,    41,    13,    14,    15,   105,    -1,    -1,
01070       48,    -1,    -1,    51,    -1,    53,    -1,    -1,    56,    -1,
01071       29,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    67,
01072       68,    69,    -1,    -1,    -1,     9,    -1,    -1,    76,    -1,
01073       -1,    -1,    -1,    81,    82,    -1,    -1,    85,    86,    87,
01074       -1,    -1,    90,    27,    28,    -1,    -1,    -1,    -1,    33,
01075       34,    35,    -1,    -1,    -1,    -1,    -1,    41,    -1,    -1,
01076       -1,   109,    -1,    -1,    48,    -1,    -1,    51,    -1,    53,
01077       -1,    -1,    56,    -1,    -1,    -1,    95,    96,    97,    98,
01078       99,   100,   101,    67,    68,    69,    -1,    -1,    -1,     9,
01079       -1,    -1,    76,    -1,    -1,    -1,    -1,    81,    82,    -1,
01080       -1,    85,    86,    87,    -1,    -1,    90,    27,    28,    -1,
01081       -1,    -1,    -1,    33,    34,    35,    -1,    -1,    -1,    10,
01082       11,    41,    13,    14,    15,   109,    -1,    -1,    48,    -1,
01083       -1,    51,    -1,    53,    -1,    -1,    56,    -1,    -1,    -1,
01084       -1,    32,    -1,    -1,    -1,    -1,    -1,    67,    68,    69,
01085       -1,    -1,    -1,     9,    -1,    -1,    76,    -1,    -1,    -1,
01086       -1,    81,    82,    -1,    -1,    85,    86,    87,    -1,    -1,
01087       90,    27,    28,    -1,    -1,    -1,    -1,    33,    34,    35,
01088       -1,    -1,    -1,    -1,    -1,    41,    -1,    -1,    -1,   109,
01089       -1,    -1,    48,    -1,    -1,    51,    -1,    53,    -1,    -1,
01090       56,    -1,    -1,    -1,    95,    96,    97,    98,    99,   100,
01091      101,    67,    68,    69,    10,    11,     9,    13,    14,    15,
01092       76,    -1,    -1,    -1,    -1,    81,    82,    -1,    -1,    85,
01093       86,    87,    -1,    -1,    90,    28,    -1,    -1,    -1,    -1,
01094       33,    34,    35,    -1,    -1,    -1,    42,    -1,    41,    -1,
01095       -1,    -1,    -1,   109,    -1,    48,    -1,    -1,    51,    -1,
01096       53,    10,    11,    56,    13,    14,    15,    -1,    10,    11,
01097       -1,    13,    14,    15,    67,    68,    69,    -1,    -1,    -1,
01098       29,    10,    11,    76,    13,    14,    15,    -1,    81,    82,
01099       32,    -1,    85,    86,    87,    -1,    -1,    90,    -1,    95,
01100       96,    97,    98,    99,   100,   101,    -1,    -1,    -1,    -1,
01101       -1,    -1,    -1,    -1,    -1,    -1,   109,    -1,    -1,    -1,
01102       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
01103       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
01104       -1,    -1,    -1,    -1,    -1,    -1,    95,    96,    97,    98,
01105       99,   100,   101,    95,    96,    97,    98,    99,   100,   101,
01106       -1,    -1,    -1,    -1,    -1,    -1,    95,    96,    97,    98,
01107       99,   100,   101
01108 };
01109 
01110 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
01111    symbol of state STATE-NUM.  */
01112 static const yytype_uint8 yystos[] =
01113 {
01114        0,    16,   112,   180,     9,     0,   104,   105,     9,   172,
01115      173,    17,    18,   106,   108,    19,    20,    21,    22,    24,
01116      171,   171,    25,   172,     9,   174,   175,   171,    64,   174,
01117      176,   177,   178,   179,   104,    65,    91,    26,   178,     9,
01118        9,     9,    28,    33,    34,    35,    41,    48,    51,    53,
01119       56,    67,    68,    69,    76,    81,    82,    85,    86,    87,
01120       90,   109,   113,   114,   118,   119,   120,   133,   134,   135,
01121      139,   140,   141,   142,   143,   144,   145,   146,   150,   151,
01122      152,   153,   154,   155,   156,   157,   164,   168,   169,   170,
01123       25,   104,    63,     3,     4,     5,     6,     7,     8,     9,
01124       12,    66,    71,    72,    73,    74,    75,    77,    78,    79,
01125       80,    83,    84,    98,   105,   115,   116,   115,    36,    37,
01126      100,   115,   125,   126,   127,     9,    49,     9,    39,    57,
01127       59,   166,     9,     9,     9,   133,    88,    88,     9,    27,
01128      113,   104,   105,   104,    50,   133,   104,    40,   128,   138,
01129      104,   104,   128,   138,   104,   104,   104,   104,   104,   104,
01130      104,   104,   104,   104,   104,   104,   104,   104,   104,   104,
01131      133,   115,   103,   115,   103,   115,   115,    10,    11,    13,
01132       14,    15,    29,    95,    96,    97,    98,    99,   100,   101,
01133      105,    32,   105,   105,    49,   108,    39,    17,     9,    52,
01134        9,     9,    60,   167,    49,   105,   115,   124,   105,    54,
01135      115,   104,    70,    70,   106,   115,   115,   115,   115,   115,
01136      114,   115,   115,   115,   115,   115,   115,   115,   124,   114,
01137      115,    38,   100,     9,   123,   125,     9,   122,   115,     9,
01138      136,   137,   105,    58,     9,   121,   123,   107,   117,   106,
01139      108,   124,    55,    30,    31,   147,   148,   149,   106,    27,
01140      106,     9,   106,   108,    40,   108,   128,    42,    95,   108,
01141        9,   158,   159,     9,   105,   106,   108,   115,   106,     9,
01142      114,   115,   147,    27,    32,   106,     9,     9,    41,   129,
01143      115,   115,   136,   171,   106,   108,    62,   106,   110,   107,
01144       29,    28,    51,    92,   130,    32,   105,   160,    61,   163,
01145      158,     9,   114,    17,    44,   132,   114,     3,    89,   161,
01146      105,    93,    45,    27,   106,    12,   162,     9,   165,    94,
01147        9,    32,     8,   106,   108,    46,    47,   131,     9
01148 };
01149 
01150 #define yyerrok   (yyerrstatus = 0)
01151 #define yyclearin (yychar = YYEMPTY)
01152 #define YYEMPTY   (-2)
01153 #define YYEOF   0
01154 
01155 #define YYACCEPT  goto yyacceptlab
01156 #define YYABORT   goto yyabortlab
01157 #define YYERROR   goto yyerrorlab
01158 
01159 
01160 /* Like YYERROR except do call yyerror.  This remains here temporarily
01161    to ease the transition to the new meaning of YYERROR, for GCC.
01162    Once GCC version 2 has supplanted version 1, this can go.  */
01163 
01164 #define YYFAIL    goto yyerrlab
01165 
01166 #define YYRECOVERING()  (!!yyerrstatus)
01167 
01168 #define YYBACKUP(Token, Value)          \
01169 do                \
01170   if (yychar == YYEMPTY && yylen == 1)        \
01171     {               \
01172       yychar = (Token);           \
01173       yylval = (Value);           \
01174       yytoken = YYTRANSLATE (yychar);       \
01175       YYPOPSTACK (1);           \
01176       goto yybackup;            \
01177     }               \
01178   else                \
01179     {               \
01180       yyerror (YY_("syntax error: cannot back up")); \
01181       YYERROR;              \
01182     }               \
01183 while (YYID (0))
01184 
01185 
01186 #define YYTERROR  1
01187 #define YYERRCODE 256
01188 
01189 
01190 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
01191    If N is 0, then set CURRENT to the empty location which ends
01192    the previous symbol: RHS[0] (always defined).  */
01193 
01194 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
01195 #ifndef YYLLOC_DEFAULT
01196 # define YYLLOC_DEFAULT(Current, Rhs, N)        \
01197     do                  \
01198       if (YYID (N))                                                    \
01199   {               \
01200     (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;  \
01201     (Current).first_column = YYRHSLOC (Rhs, 1).first_column;  \
01202     (Current).last_line    = YYRHSLOC (Rhs, N).last_line;   \
01203     (Current).last_column  = YYRHSLOC (Rhs, N).last_column; \
01204   }               \
01205       else                \
01206   {               \
01207     (Current).first_line   = (Current).last_line   =    \
01208       YYRHSLOC (Rhs, 0).last_line;        \
01209     (Current).first_column = (Current).last_column =    \
01210       YYRHSLOC (Rhs, 0).last_column;        \
01211   }               \
01212     while (YYID (0))
01213 #endif
01214 
01215 
01216 /* YY_LOCATION_PRINT -- Print the location on the stream.
01217    This macro was not mandated originally: define only if we know
01218    we won't break user code: when these are the locations we know.  */
01219 
01220 #ifndef YY_LOCATION_PRINT
01221 # if YYLTYPE_IS_TRIVIAL
01222 #  define YY_LOCATION_PRINT(File, Loc)      \
01223      fprintf (File, "%d.%d-%d.%d",      \
01224         (Loc).first_line, (Loc).first_column, \
01225         (Loc).last_line,  (Loc).last_column)
01226 # else
01227 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
01228 # endif
01229 #endif
01230 
01231 
01232 /* YYLEX -- calling `yylex' with the right arguments.  */
01233 
01234 #ifdef YYLEX_PARAM
01235 # define YYLEX yylex (YYLEX_PARAM)
01236 #else
01237 # define YYLEX yylex ()
01238 #endif
01239 
01240 /* Enable debugging if requested.  */
01241 #if YYDEBUG
01242 
01243 # ifndef YYFPRINTF
01244 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
01245 #  define YYFPRINTF fprintf
01246 # endif
01247 
01248 # define YYDPRINTF(Args)      \
01249 do {            \
01250   if (yydebug)          \
01251     YYFPRINTF Args;       \
01252 } while (YYID (0))
01253 
01254 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)        \
01255 do {                    \
01256   if (yydebug)                  \
01257     {                   \
01258       YYFPRINTF (stderr, "%s ", Title);           \
01259       yy_symbol_print (stderr,              \
01260       Type, Value); \
01261       YYFPRINTF (stderr, "\n");             \
01262     }                   \
01263 } while (YYID (0))
01264 
01265 
01266 /*--------------------------------.
01267 | Print this symbol on YYOUTPUT.  |
01268 `--------------------------------*/
01269 
01270 /*ARGSUSED*/
01271 #if (defined __STDC__ || defined __C99__FUNC__ \
01272      || defined __cplusplus || defined _MSC_VER)
01273 static void
01274 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
01275 #else
01276 static void
01277 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
01278     FILE *yyoutput;
01279     int yytype;
01280     YYSTYPE const * const yyvaluep;
01281 #endif
01282 {
01283   if (!yyvaluep)
01284     return;
01285 # ifdef YYPRINT
01286   if (yytype < YYNTOKENS)
01287     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
01288 # else
01289   YYUSE (yyoutput);
01290 # endif
01291   switch (yytype)
01292     {
01293       default:
01294   break;
01295     }
01296 }
01297 
01298 
01299 /*--------------------------------.
01300 | Print this symbol on YYOUTPUT.  |
01301 `--------------------------------*/
01302 
01303 #if (defined __STDC__ || defined __C99__FUNC__ \
01304      || defined __cplusplus || defined _MSC_VER)
01305 static void
01306 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
01307 #else
01308 static void
01309 yy_symbol_print (yyoutput, yytype, yyvaluep)
01310     FILE *yyoutput;
01311     int yytype;
01312     YYSTYPE const * const yyvaluep;
01313 #endif
01314 {
01315   if (yytype < YYNTOKENS)
01316     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
01317   else
01318     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
01319 
01320   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
01321   YYFPRINTF (yyoutput, ")");
01322 }
01323 
01324 /*------------------------------------------------------------------.
01325 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
01326 | TOP (included).                                                   |
01327 `------------------------------------------------------------------*/
01328 
01329 #if (defined __STDC__ || defined __C99__FUNC__ \
01330      || defined __cplusplus || defined _MSC_VER)
01331 static void
01332 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
01333 #else
01334 static void
01335 yy_stack_print (yybottom, yytop)
01336     yytype_int16 *yybottom;
01337     yytype_int16 *yytop;
01338 #endif
01339 {
01340   YYFPRINTF (stderr, "Stack now");
01341   for (; yybottom <= yytop; yybottom++)
01342     {
01343       int yybot = *yybottom;
01344       YYFPRINTF (stderr, " %d", yybot);
01345     }
01346   YYFPRINTF (stderr, "\n");
01347 }
01348 
01349 # define YY_STACK_PRINT(Bottom, Top)        \
01350 do {                \
01351   if (yydebug)              \
01352     yy_stack_print ((Bottom), (Top));       \
01353 } while (YYID (0))
01354 
01355 
01356 /*------------------------------------------------.
01357 | Report that the YYRULE is going to be reduced.  |
01358 `------------------------------------------------*/
01359 
01360 #if (defined __STDC__ || defined __C99__FUNC__ \
01361      || defined __cplusplus || defined _MSC_VER)
01362 static void
01363 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
01364 #else
01365 static void
01366 yy_reduce_print (yyvsp, yyrule)
01367     YYSTYPE *yyvsp;
01368     int yyrule;
01369 #endif
01370 {
01371   int yynrhs = yyr2[yyrule];
01372   int yyi;
01373   unsigned long int yylno = yyrline[yyrule];
01374   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
01375        yyrule - 1, yylno);
01376   /* The symbols being reduced.  */
01377   for (yyi = 0; yyi < yynrhs; yyi++)
01378     {
01379       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
01380       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
01381            &(yyvsp[(yyi + 1) - (yynrhs)])
01382                      );
01383       YYFPRINTF (stderr, "\n");
01384     }
01385 }
01386 
01387 # define YY_REDUCE_PRINT(Rule)    \
01388 do {          \
01389   if (yydebug)        \
01390     yy_reduce_print (yyvsp, Rule); \
01391 } while (YYID (0))
01392 
01393 /* Nonzero means print parse trace.  It is left uninitialized so that
01394    multiple parsers can coexist.  */
01395 int yydebug;
01396 #else /* !YYDEBUG */
01397 # define YYDPRINTF(Args)
01398 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
01399 # define YY_STACK_PRINT(Bottom, Top)
01400 # define YY_REDUCE_PRINT(Rule)
01401 #endif /* !YYDEBUG */
01402 
01403 
01404 /* YYINITDEPTH -- initial size of the parser's stacks.  */
01405 #ifndef YYINITDEPTH
01406 # define YYINITDEPTH 200
01407 #endif
01408 
01409 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
01410    if the built-in stack extension method is used).
01411 
01412    Do not make this value too large; the results are undefined if
01413    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
01414    evaluated with infinite-precision integer arithmetic.  */
01415 
01416 #ifndef YYMAXDEPTH
01417 # define YYMAXDEPTH 10000
01418 #endif
01419 
01420 
01421 
01422 #if YYERROR_VERBOSE
01423 
01424 # ifndef yystrlen
01425 #  if defined __GLIBC__ && defined _STRING_H
01426 #   define yystrlen strlen
01427 #  else
01428 /* Return the length of YYSTR.  */
01429 #if (defined __STDC__ || defined __C99__FUNC__ \
01430      || defined __cplusplus || defined _MSC_VER)
01431 static YYSIZE_T
01432 yystrlen (const char *yystr)
01433 #else
01434 static YYSIZE_T
01435 yystrlen (yystr)
01436     const char *yystr;
01437 #endif
01438 {
01439   YYSIZE_T yylen;
01440   for (yylen = 0; yystr[yylen]; yylen++)
01441     continue;
01442   return yylen;
01443 }
01444 #  endif
01445 # endif
01446 
01447 # ifndef yystpcpy
01448 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
01449 #   define yystpcpy stpcpy
01450 #  else
01451 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
01452    YYDEST.  */
01453 #if (defined __STDC__ || defined __C99__FUNC__ \
01454      || defined __cplusplus || defined _MSC_VER)
01455 static char *
01456 yystpcpy (char *yydest, const char *yysrc)
01457 #else
01458 static char *
01459 yystpcpy (yydest, yysrc)
01460     char *yydest;
01461     const char *yysrc;
01462 #endif
01463 {
01464   char *yyd = yydest;
01465   const char *yys = yysrc;
01466 
01467   while ((*yyd++ = *yys++) != '\0')
01468     continue;
01469 
01470   return yyd - 1;
01471 }
01472 #  endif
01473 # endif
01474 
01475 # ifndef yytnamerr
01476 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
01477    quotes and backslashes, so that it's suitable for yyerror.  The
01478    heuristic is that double-quoting is unnecessary unless the string
01479    contains an apostrophe, a comma, or backslash (other than
01480    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
01481    null, do not copy; instead, return the length of what the result
01482    would have been.  */
01483 static YYSIZE_T
01484 yytnamerr (char *yyres, const char *yystr)
01485 {
01486   if (*yystr == '"')
01487     {
01488       YYSIZE_T yyn = 0;
01489       char const *yyp = yystr;
01490 
01491       for (;;)
01492   switch (*++yyp)
01493     {
01494     case '\'':
01495     case ',':
01496       goto do_not_strip_quotes;
01497 
01498     case '\\':
01499       if (*++yyp != '\\')
01500         goto do_not_strip_quotes;
01501       /* Fall through.  */
01502     default:
01503       if (yyres)
01504         yyres[yyn] = *yyp;
01505       yyn++;
01506       break;
01507 
01508     case '"':
01509       if (yyres)
01510         yyres[yyn] = '\0';
01511       return yyn;
01512     }
01513     do_not_strip_quotes: ;
01514     }
01515 
01516   if (! yyres)
01517     return yystrlen (yystr);
01518 
01519   return yystpcpy (yyres, yystr) - yyres;
01520 }
01521 # endif
01522 
01523 /* Copy into YYRESULT an error message about the unexpected token
01524    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
01525    including the terminating null byte.  If YYRESULT is null, do not
01526    copy anything; just return the number of bytes that would be
01527    copied.  As a special case, return 0 if an ordinary "syntax error"
01528    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
01529    size calculation.  */
01530 static YYSIZE_T
01531 yysyntax_error (char *yyresult, int yystate, int yychar)
01532 {
01533   int yyn = yypact[yystate];
01534 
01535   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
01536     return 0;
01537   else
01538     {
01539       int yytype = YYTRANSLATE (yychar);
01540       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
01541       YYSIZE_T yysize = yysize0;
01542       YYSIZE_T yysize1;
01543       int yysize_overflow = 0;
01544       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
01545       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
01546       int yyx;
01547 
01548 # if 0
01549       /* This is so xgettext sees the translatable formats that are
01550    constructed on the fly.  */
01551       YY_("syntax error, unexpected %s");
01552       YY_("syntax error, unexpected %s, expecting %s");
01553       YY_("syntax error, unexpected %s, expecting %s or %s");
01554       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
01555       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
01556 # endif
01557       char *yyfmt;
01558       char const *yyf;
01559       static char const yyunexpected[] = "syntax error, unexpected %s";
01560       static char const yyexpecting[] = ", expecting %s";
01561       static char const yyor[] = " or %s";
01562       char yyformat[sizeof yyunexpected
01563         + sizeof yyexpecting - 1
01564         + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
01565            * (sizeof yyor - 1))];
01566       char const *yyprefix = yyexpecting;
01567 
01568       /* Start YYX at -YYN if negative to avoid negative indexes in
01569    YYCHECK.  */
01570       int yyxbegin = yyn < 0 ? -yyn : 0;
01571 
01572       /* Stay within bounds of both yycheck and yytname.  */
01573       int yychecklim = YYLAST - yyn + 1;
01574       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
01575       int yycount = 1;
01576 
01577       yyarg[0] = yytname[yytype];
01578       yyfmt = yystpcpy (yyformat, yyunexpected);
01579 
01580       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
01581   if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
01582     {
01583       if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
01584         {
01585     yycount = 1;
01586     yysize = yysize0;
01587     yyformat[sizeof yyunexpected - 1] = '\0';
01588     break;
01589         }
01590       yyarg[yycount++] = yytname[yyx];
01591       yysize1 = yysize + yytnamerr (0, yytname[yyx]);
01592       yysize_overflow |= (yysize1 < yysize);
01593       yysize = yysize1;
01594       yyfmt = yystpcpy (yyfmt, yyprefix);
01595       yyprefix = yyor;
01596     }
01597 
01598       yyf = YY_(yyformat);
01599       yysize1 = yysize + yystrlen (yyf);
01600       yysize_overflow |= (yysize1 < yysize);
01601       yysize = yysize1;
01602 
01603       if (yysize_overflow)
01604   return YYSIZE_MAXIMUM;
01605 
01606       if (yyresult)
01607   {
01608     /* Avoid sprintf, as that infringes on the user's name space.
01609        Don't have undefined behavior even if the translation
01610        produced a string with the wrong number of "%s"s.  */
01611     char *yyp = yyresult;
01612     int yyi = 0;
01613     while ((*yyp = *yyf) != '\0')
01614       {
01615         if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
01616     {
01617       yyp += yytnamerr (yyp, yyarg[yyi++]);
01618       yyf += 2;
01619     }
01620         else
01621     {
01622       yyp++;
01623       yyf++;
01624     }
01625       }
01626   }
01627       return yysize;
01628     }
01629 }
01630 #endif /* YYERROR_VERBOSE */
01631 
01632 
01633 /*-----------------------------------------------.
01634 | Release the memory associated to this symbol.  |
01635 `-----------------------------------------------*/
01636 
01637 /*ARGSUSED*/
01638 #if (defined __STDC__ || defined __C99__FUNC__ \
01639      || defined __cplusplus || defined _MSC_VER)
01640 static void
01641 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
01642 #else
01643 static void
01644 yydestruct (yymsg, yytype, yyvaluep)
01645     const char *yymsg;
01646     int yytype;
01647     YYSTYPE *yyvaluep;
01648 #endif
01649 {
01650   YYUSE (yyvaluep);
01651 
01652   if (!yymsg)
01653     yymsg = "Deleting";
01654   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
01655 
01656   switch (yytype)
01657     {
01658 
01659       default:
01660   break;
01661     }
01662 }
01663 
01664 /* Prevent warnings from -Wmissing-prototypes.  */
01665 #ifdef YYPARSE_PARAM
01666 #if defined __STDC__ || defined __cplusplus
01667 UNIV_INTERN int yyparse (void *YYPARSE_PARAM);
01668 #else
01669 UNIV_INTERN int yyparse ();
01670 #endif
01671 #else /* ! YYPARSE_PARAM */
01672 #if defined __STDC__ || defined __cplusplus
01673 UNIV_INTERN int yyparse (void);
01674 #else
01675 UNIV_INTERN int yyparse ();
01676 #endif
01677 #endif /* ! YYPARSE_PARAM */
01678 
01679 
01680 /* The lookahead symbol.  */
01681 static int yychar;
01682 
01683 /* The semantic value of the lookahead symbol.  */
01684 UNIV_INTERN YYSTYPE yylval;
01685 
01686 /* Number of syntax errors so far.  */
01687 static int yynerrs;
01688 
01689 
01690 
01691 /*-------------------------.
01692 | yyparse or yypush_parse.  |
01693 `-------------------------*/
01694 
01695 #ifdef YYPARSE_PARAM
01696 #if (defined __STDC__ || defined __C99__FUNC__ \
01697      || defined __cplusplus || defined _MSC_VER)
01698 int
01699 yyparse (void *YYPARSE_PARAM)
01700 #else
01701 int
01702 yyparse (YYPARSE_PARAM)
01703     void *YYPARSE_PARAM;
01704 #endif
01705 #else /* ! YYPARSE_PARAM */
01706 #if (defined __STDC__ || defined __C99__FUNC__ \
01707      || defined __cplusplus || defined _MSC_VER)
01708 int
01709 yyparse (void)
01710 #else
01711 int
01712 yyparse ()
01713 
01714 #endif
01715 #endif
01716 {
01717 
01718 
01719     int yystate;
01720     /* Number of tokens to shift before error messages enabled.  */
01721     int yyerrstatus;
01722 
01723     /* The stacks and their tools:
01724        `yyss': related to states.
01725        `yyvs': related to semantic values.
01726 
01727        Refer to the stacks thru separate pointers, to allow yyoverflow
01728        to reallocate them elsewhere.  */
01729 
01730     /* The state stack.  */
01731     yytype_int16 yyssa[YYINITDEPTH];
01732     yytype_int16 *yyss;
01733     yytype_int16 *yyssp;
01734 
01735     /* The semantic value stack.  */
01736     YYSTYPE yyvsa[YYINITDEPTH];
01737     YYSTYPE *yyvs;
01738     YYSTYPE *yyvsp;
01739 
01740     YYSIZE_T yystacksize;
01741 
01742   int yyn;
01743   int yyresult;
01744   /* Lookahead token as an internal (translated) token number.  */
01745   int yytoken;
01746   /* The variables used to return semantic value and location from the
01747      action routines.  */
01748   YYSTYPE yyval;
01749 
01750 #if YYERROR_VERBOSE
01751   /* Buffer for error messages, and its allocated size.  */
01752   char yymsgbuf[128];
01753   char *yymsg = yymsgbuf;
01754   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
01755 #endif
01756 
01757 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
01758 
01759   /* The number of symbols on the RHS of the reduced rule.
01760      Keep to zero when no symbol should be popped.  */
01761   int yylen = 0;
01762 
01763   yytoken = 0;
01764   yyss = yyssa;
01765   yyvs = yyvsa;
01766   yystacksize = YYINITDEPTH;
01767 
01768   YYDPRINTF ((stderr, "Starting parse\n"));
01769 
01770   yystate = 0;
01771   yyerrstatus = 0;
01772   yynerrs = 0;
01773   yychar = YYEMPTY; /* Cause a token to be read.  */
01774 
01775   /* Initialize stack pointers.
01776      Waste one element of value and location stack
01777      so that they stay on the same level as the state stack.
01778      The wasted elements are never initialized.  */
01779   yyssp = yyss;
01780   yyvsp = yyvs;
01781 
01782   goto yysetstate;
01783 
01784 /*------------------------------------------------------------.
01785 | yynewstate -- Push a new state, which is found in yystate.  |
01786 `------------------------------------------------------------*/
01787  yynewstate:
01788   /* In all cases, when you get here, the value and location stacks
01789      have just been pushed.  So pushing a state here evens the stacks.  */
01790   yyssp++;
01791 
01792  yysetstate:
01793   *yyssp = yystate;
01794 
01795   if (yyss + yystacksize - 1 <= yyssp)
01796     {
01797       /* Get the current used size of the three stacks, in elements.  */
01798       YYSIZE_T yysize = yyssp - yyss + 1;
01799 
01800 #ifdef yyoverflow
01801       {
01802   /* Give user a chance to reallocate the stack.  Use copies of
01803      these so that the &'s don't force the real ones into
01804      memory.  */
01805   YYSTYPE *yyvs1 = yyvs;
01806   yytype_int16 *yyss1 = yyss;
01807 
01808   /* Each stack pointer address is followed by the size of the
01809      data in use in that stack, in bytes.  This used to be a
01810      conditional around just the two extra args, but that might
01811      be undefined if yyoverflow is a macro.  */
01812   yyoverflow (YY_("memory exhausted"),
01813         &yyss1, yysize * sizeof (*yyssp),
01814         &yyvs1, yysize * sizeof (*yyvsp),
01815         &yystacksize);
01816 
01817   yyss = yyss1;
01818   yyvs = yyvs1;
01819       }
01820 #else /* no yyoverflow */
01821 # ifndef YYSTACK_RELOCATE
01822       goto yyexhaustedlab;
01823 # else
01824       /* Extend the stack our own way.  */
01825       if (YYMAXDEPTH <= yystacksize)
01826   goto yyexhaustedlab;
01827       yystacksize *= 2;
01828       if (YYMAXDEPTH < yystacksize)
01829   yystacksize = YYMAXDEPTH;
01830 
01831       {
01832   yytype_int16 *yyss1 = yyss;
01833   union yyalloc *yyptr =
01834     (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
01835   if (! yyptr)
01836     goto yyexhaustedlab;
01837   YYSTACK_RELOCATE (yyss_alloc, yyss);
01838   YYSTACK_RELOCATE (yyvs_alloc, yyvs);
01839 #  undef YYSTACK_RELOCATE
01840   if (yyss1 != yyssa)
01841     YYSTACK_FREE (yyss1);
01842       }
01843 # endif
01844 #endif /* no yyoverflow */
01845 
01846       yyssp = yyss + yysize - 1;
01847       yyvsp = yyvs + yysize - 1;
01848 
01849       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
01850       (unsigned long int) yystacksize));
01851 
01852       if (yyss + yystacksize - 1 <= yyssp)
01853   YYABORT;
01854     }
01855 
01856   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
01857 
01858   if (yystate == YYFINAL)
01859     YYACCEPT;
01860 
01861   goto yybackup;
01862 
01863 /*-----------.
01864 | yybackup.  |
01865 `-----------*/
01866 yybackup:
01867 
01868   /* Do appropriate processing given the current state.  Read a
01869      lookahead token if we need one and don't already have one.  */
01870 
01871   /* First try to decide what to do without reference to lookahead token.  */
01872   yyn = yypact[yystate];
01873   if (yyn == YYPACT_NINF)
01874     goto yydefault;
01875 
01876   /* Not known => get a lookahead token if don't already have one.  */
01877 
01878   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
01879   if (yychar == YYEMPTY)
01880     {
01881       YYDPRINTF ((stderr, "Reading a token: "));
01882       yychar = YYLEX;
01883     }
01884 
01885   if (yychar <= YYEOF)
01886     {
01887       yychar = yytoken = YYEOF;
01888       YYDPRINTF ((stderr, "Now at end of input.\n"));
01889     }
01890   else
01891     {
01892       yytoken = YYTRANSLATE (yychar);
01893       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
01894     }
01895 
01896   /* If the proper action on seeing token YYTOKEN is to reduce or to
01897      detect an error, take that action.  */
01898   yyn += yytoken;
01899   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
01900     goto yydefault;
01901   yyn = yytable[yyn];
01902   if (yyn <= 0)
01903     {
01904       if (yyn == 0 || yyn == YYTABLE_NINF)
01905   goto yyerrlab;
01906       yyn = -yyn;
01907       goto yyreduce;
01908     }
01909 
01910   /* Count tokens shifted since error; after three, turn off error
01911      status.  */
01912   if (yyerrstatus)
01913     yyerrstatus--;
01914 
01915   /* Shift the lookahead token.  */
01916   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
01917 
01918   /* Discard the shifted token.  */
01919   yychar = YYEMPTY;
01920 
01921   yystate = yyn;
01922   *++yyvsp = yylval;
01923 
01924   goto yynewstate;
01925 
01926 
01927 /*-----------------------------------------------------------.
01928 | yydefault -- do the default action for the current state.  |
01929 `-----------------------------------------------------------*/
01930 yydefault:
01931   yyn = yydefact[yystate];
01932   if (yyn == 0)
01933     goto yyerrlab;
01934   goto yyreduce;
01935 
01936 
01937 /*-----------------------------.
01938 | yyreduce -- Do a reduction.  |
01939 `-----------------------------*/
01940 yyreduce:
01941   /* yyn is the number of a rule to reduce with.  */
01942   yylen = yyr2[yyn];
01943 
01944   /* If YYLEN is nonzero, implement the default value of the action:
01945      `$$ = $1'.
01946 
01947      Otherwise, the following line sets YYVAL to garbage.
01948      This behavior is undocumented and Bison
01949      users should not rely upon it.  Assigning to YYVAL
01950      unconditionally makes the parser a bit smaller, and it avoids a
01951      GCC warning that YYVAL may be used uninitialized.  */
01952   yyval = yyvsp[1-yylen];
01953 
01954 
01955   YY_REDUCE_PRINT (yyn);
01956   switch (yyn)
01957     {
01958         case 25:
01959 
01960 /* Line 1455 of yacc.c  */
01961 #line 181 "plugin/innobase/pars/pars0grm.y"
01962     { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
01963     break;
01964 
01965   case 26:
01966 
01967 /* Line 1455 of yacc.c  */
01968 #line 183 "plugin/innobase/pars/pars0grm.y"
01969     { (yyval) = que_node_list_add_last((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)])); }
01970     break;
01971 
01972   case 27:
01973 
01974 /* Line 1455 of yacc.c  */
01975 #line 187 "plugin/innobase/pars/pars0grm.y"
01976     { (yyval) = (yyvsp[(1) - (1)]);}
01977     break;
01978 
01979   case 28:
01980 
01981 /* Line 1455 of yacc.c  */
01982 #line 189 "plugin/innobase/pars/pars0grm.y"
01983     { (yyval) = pars_func((yyvsp[(1) - (4)]), (yyvsp[(3) - (4)])); }
01984     break;
01985 
01986   case 29:
01987 
01988 /* Line 1455 of yacc.c  */
01989 #line 190 "plugin/innobase/pars/pars0grm.y"
01990     { (yyval) = (yyvsp[(1) - (1)]);}
01991     break;
01992 
01993   case 30:
01994 
01995 /* Line 1455 of yacc.c  */
01996 #line 191 "plugin/innobase/pars/pars0grm.y"
01997     { (yyval) = (yyvsp[(1) - (1)]);}
01998     break;
01999 
02000   case 31:
02001 
02002 /* Line 1455 of yacc.c  */
02003 #line 192 "plugin/innobase/pars/pars0grm.y"
02004     { (yyval) = (yyvsp[(1) - (1)]);}
02005     break;
02006 
02007   case 32:
02008 
02009 /* Line 1455 of yacc.c  */
02010 #line 193 "plugin/innobase/pars/pars0grm.y"
02011     { (yyval) = (yyvsp[(1) - (1)]);}
02012     break;
02013 
02014   case 33:
02015 
02016 /* Line 1455 of yacc.c  */
02017 #line 194 "plugin/innobase/pars/pars0grm.y"
02018     { (yyval) = (yyvsp[(1) - (1)]);}
02019     break;
02020 
02021   case 34:
02022 
02023 /* Line 1455 of yacc.c  */
02024 #line 195 "plugin/innobase/pars/pars0grm.y"
02025     { (yyval) = (yyvsp[(1) - (1)]);}
02026     break;
02027 
02028   case 35:
02029 
02030 /* Line 1455 of yacc.c  */
02031 #line 196 "plugin/innobase/pars/pars0grm.y"
02032     { (yyval) = (yyvsp[(1) - (1)]);}
02033     break;
02034 
02035   case 36:
02036 
02037 /* Line 1455 of yacc.c  */
02038 #line 197 "plugin/innobase/pars/pars0grm.y"
02039     { (yyval) = pars_op('+', (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02040     break;
02041 
02042   case 37:
02043 
02044 /* Line 1455 of yacc.c  */
02045 #line 198 "plugin/innobase/pars/pars0grm.y"
02046     { (yyval) = pars_op('-', (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02047     break;
02048 
02049   case 38:
02050 
02051 /* Line 1455 of yacc.c  */
02052 #line 199 "plugin/innobase/pars/pars0grm.y"
02053     { (yyval) = pars_op('*', (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02054     break;
02055 
02056   case 39:
02057 
02058 /* Line 1455 of yacc.c  */
02059 #line 200 "plugin/innobase/pars/pars0grm.y"
02060     { (yyval) = pars_op('/', (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02061     break;
02062 
02063   case 40:
02064 
02065 /* Line 1455 of yacc.c  */
02066 #line 201 "plugin/innobase/pars/pars0grm.y"
02067     { (yyval) = pars_op('-', (yyvsp[(2) - (2)]), NULL); }
02068     break;
02069 
02070   case 41:
02071 
02072 /* Line 1455 of yacc.c  */
02073 #line 202 "plugin/innobase/pars/pars0grm.y"
02074     { (yyval) = (yyvsp[(2) - (3)]); }
02075     break;
02076 
02077   case 42:
02078 
02079 /* Line 1455 of yacc.c  */
02080 #line 203 "plugin/innobase/pars/pars0grm.y"
02081     { (yyval) = pars_op('=', (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02082     break;
02083 
02084   case 43:
02085 
02086 /* Line 1455 of yacc.c  */
02087 #line 204 "plugin/innobase/pars/pars0grm.y"
02088     { (yyval) = pars_op('<', (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02089     break;
02090 
02091   case 44:
02092 
02093 /* Line 1455 of yacc.c  */
02094 #line 205 "plugin/innobase/pars/pars0grm.y"
02095     { (yyval) = pars_op('>', (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02096     break;
02097 
02098   case 45:
02099 
02100 /* Line 1455 of yacc.c  */
02101 #line 206 "plugin/innobase/pars/pars0grm.y"
02102     { (yyval) = pars_op(PARS_GE_TOKEN, (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02103     break;
02104 
02105   case 46:
02106 
02107 /* Line 1455 of yacc.c  */
02108 #line 207 "plugin/innobase/pars/pars0grm.y"
02109     { (yyval) = pars_op(PARS_LE_TOKEN, (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02110     break;
02111 
02112   case 47:
02113 
02114 /* Line 1455 of yacc.c  */
02115 #line 208 "plugin/innobase/pars/pars0grm.y"
02116     { (yyval) = pars_op(PARS_NE_TOKEN, (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02117     break;
02118 
02119   case 48:
02120 
02121 /* Line 1455 of yacc.c  */
02122 #line 209 "plugin/innobase/pars/pars0grm.y"
02123     { (yyval) = pars_op(PARS_AND_TOKEN, (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02124     break;
02125 
02126   case 49:
02127 
02128 /* Line 1455 of yacc.c  */
02129 #line 210 "plugin/innobase/pars/pars0grm.y"
02130     { (yyval) = pars_op(PARS_OR_TOKEN, (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02131     break;
02132 
02133   case 50:
02134 
02135 /* Line 1455 of yacc.c  */
02136 #line 211 "plugin/innobase/pars/pars0grm.y"
02137     { (yyval) = pars_op(PARS_NOT_TOKEN, (yyvsp[(2) - (2)]), NULL); }
02138     break;
02139 
02140   case 51:
02141 
02142 /* Line 1455 of yacc.c  */
02143 #line 213 "plugin/innobase/pars/pars0grm.y"
02144     { (yyval) = pars_op(PARS_NOTFOUND_TOKEN, (yyvsp[(1) - (3)]), NULL); }
02145     break;
02146 
02147   case 52:
02148 
02149 /* Line 1455 of yacc.c  */
02150 #line 215 "plugin/innobase/pars/pars0grm.y"
02151     { (yyval) = pars_op(PARS_NOTFOUND_TOKEN, (yyvsp[(1) - (3)]), NULL); }
02152     break;
02153 
02154   case 53:
02155 
02156 /* Line 1455 of yacc.c  */
02157 #line 219 "plugin/innobase/pars/pars0grm.y"
02158     { (yyval) = &pars_to_char_token; }
02159     break;
02160 
02161   case 54:
02162 
02163 /* Line 1455 of yacc.c  */
02164 #line 220 "plugin/innobase/pars/pars0grm.y"
02165     { (yyval) = &pars_to_number_token; }
02166     break;
02167 
02168   case 55:
02169 
02170 /* Line 1455 of yacc.c  */
02171 #line 221 "plugin/innobase/pars/pars0grm.y"
02172     { (yyval) = &pars_to_binary_token; }
02173     break;
02174 
02175   case 56:
02176 
02177 /* Line 1455 of yacc.c  */
02178 #line 223 "plugin/innobase/pars/pars0grm.y"
02179     { (yyval) = &pars_binary_to_number_token; }
02180     break;
02181 
02182   case 57:
02183 
02184 /* Line 1455 of yacc.c  */
02185 #line 224 "plugin/innobase/pars/pars0grm.y"
02186     { (yyval) = &pars_substr_token; }
02187     break;
02188 
02189   case 58:
02190 
02191 /* Line 1455 of yacc.c  */
02192 #line 225 "plugin/innobase/pars/pars0grm.y"
02193     { (yyval) = &pars_concat_token; }
02194     break;
02195 
02196   case 59:
02197 
02198 /* Line 1455 of yacc.c  */
02199 #line 226 "plugin/innobase/pars/pars0grm.y"
02200     { (yyval) = &pars_instr_token; }
02201     break;
02202 
02203   case 60:
02204 
02205 /* Line 1455 of yacc.c  */
02206 #line 227 "plugin/innobase/pars/pars0grm.y"
02207     { (yyval) = &pars_length_token; }
02208     break;
02209 
02210   case 61:
02211 
02212 /* Line 1455 of yacc.c  */
02213 #line 228 "plugin/innobase/pars/pars0grm.y"
02214     { (yyval) = &pars_sysdate_token; }
02215     break;
02216 
02217   case 62:
02218 
02219 /* Line 1455 of yacc.c  */
02220 #line 229 "plugin/innobase/pars/pars0grm.y"
02221     { (yyval) = &pars_rnd_token; }
02222     break;
02223 
02224   case 63:
02225 
02226 /* Line 1455 of yacc.c  */
02227 #line 230 "plugin/innobase/pars/pars0grm.y"
02228     { (yyval) = &pars_rnd_str_token; }
02229     break;
02230 
02231   case 67:
02232 
02233 /* Line 1455 of yacc.c  */
02234 #line 241 "plugin/innobase/pars/pars0grm.y"
02235     { (yyval) = pars_stored_procedure_call(static_cast<sym_node_t *>((yyvsp[(2) - (6)]))); }
02236     break;
02237 
02238   case 68:
02239 
02240 /* Line 1455 of yacc.c  */
02241 #line 246 "plugin/innobase/pars/pars0grm.y"
02242     { (yyval) = pars_procedure_call((yyvsp[(1) - (4)]), (yyvsp[(3) - (4)])); }
02243     break;
02244 
02245   case 69:
02246 
02247 /* Line 1455 of yacc.c  */
02248 #line 250 "plugin/innobase/pars/pars0grm.y"
02249     { (yyval) = &pars_replstr_token; }
02250     break;
02251 
02252   case 70:
02253 
02254 /* Line 1455 of yacc.c  */
02255 #line 251 "plugin/innobase/pars/pars0grm.y"
02256     { (yyval) = &pars_printf_token; }
02257     break;
02258 
02259   case 71:
02260 
02261 /* Line 1455 of yacc.c  */
02262 #line 252 "plugin/innobase/pars/pars0grm.y"
02263     { (yyval) = &pars_assert_token; }
02264     break;
02265 
02266   case 72:
02267 
02268 /* Line 1455 of yacc.c  */
02269 #line 256 "plugin/innobase/pars/pars0grm.y"
02270     { (yyval) = (yyvsp[(1) - (3)]); }
02271     break;
02272 
02273   case 73:
02274 
02275 /* Line 1455 of yacc.c  */
02276 #line 260 "plugin/innobase/pars/pars0grm.y"
02277     { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
02278     break;
02279 
02280   case 74:
02281 
02282 /* Line 1455 of yacc.c  */
02283 #line 262 "plugin/innobase/pars/pars0grm.y"
02284     { (yyval) = que_node_list_add_last((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02285     break;
02286 
02287   case 75:
02288 
02289 /* Line 1455 of yacc.c  */
02290 #line 266 "plugin/innobase/pars/pars0grm.y"
02291     { (yyval) = NULL; }
02292     break;
02293 
02294   case 76:
02295 
02296 /* Line 1455 of yacc.c  */
02297 #line 267 "plugin/innobase/pars/pars0grm.y"
02298     { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
02299     break;
02300 
02301   case 77:
02302 
02303 /* Line 1455 of yacc.c  */
02304 #line 269 "plugin/innobase/pars/pars0grm.y"
02305     { (yyval) = que_node_list_add_last((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02306     break;
02307 
02308   case 78:
02309 
02310 /* Line 1455 of yacc.c  */
02311 #line 273 "plugin/innobase/pars/pars0grm.y"
02312     { (yyval) = NULL; }
02313     break;
02314 
02315   case 79:
02316 
02317 /* Line 1455 of yacc.c  */
02318 #line 274 "plugin/innobase/pars/pars0grm.y"
02319     { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)]));}
02320     break;
02321 
02322   case 80:
02323 
02324 /* Line 1455 of yacc.c  */
02325 #line 275 "plugin/innobase/pars/pars0grm.y"
02326     { (yyval) = que_node_list_add_last((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02327     break;
02328 
02329   case 81:
02330 
02331 /* Line 1455 of yacc.c  */
02332 #line 279 "plugin/innobase/pars/pars0grm.y"
02333     { (yyval) = (yyvsp[(1) - (1)]); }
02334     break;
02335 
02336   case 82:
02337 
02338 /* Line 1455 of yacc.c  */
02339 #line 281 "plugin/innobase/pars/pars0grm.y"
02340     { (yyval) = pars_func(&pars_count_token,
02341                   que_node_list_add_last(NULL,
02342               sym_tab_add_int_lit(
02343             pars_sym_tab_global, 1))); }
02344     break;
02345 
02346   case 83:
02347 
02348 /* Line 1455 of yacc.c  */
02349 #line 286 "plugin/innobase/pars/pars0grm.y"
02350     { (yyval) = pars_func(&pars_count_token,
02351               que_node_list_add_last(NULL,
02352             pars_func(&pars_distinct_token,
02353                  que_node_list_add_last(
02354                 NULL, (yyvsp[(4) - (5)]))))); }
02355     break;
02356 
02357   case 84:
02358 
02359 /* Line 1455 of yacc.c  */
02360 #line 292 "plugin/innobase/pars/pars0grm.y"
02361     { (yyval) = pars_func(&pars_sum_token,
02362             que_node_list_add_last(NULL,
02363                   (yyvsp[(3) - (4)]))); }
02364     break;
02365 
02366   case 85:
02367 
02368 /* Line 1455 of yacc.c  */
02369 #line 298 "plugin/innobase/pars/pars0grm.y"
02370     { (yyval) = NULL; }
02371     break;
02372 
02373   case 86:
02374 
02375 /* Line 1455 of yacc.c  */
02376 #line 299 "plugin/innobase/pars/pars0grm.y"
02377     { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
02378     break;
02379 
02380   case 87:
02381 
02382 /* Line 1455 of yacc.c  */
02383 #line 301 "plugin/innobase/pars/pars0grm.y"
02384     { (yyval) = que_node_list_add_last((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02385     break;
02386 
02387   case 88:
02388 
02389 /* Line 1455 of yacc.c  */
02390 #line 305 "plugin/innobase/pars/pars0grm.y"
02391     { (yyval) = pars_select_list(&pars_star_denoter,
02392                 NULL); }
02393     break;
02394 
02395   case 89:
02396 
02397 /* Line 1455 of yacc.c  */
02398 #line 308 "plugin/innobase/pars/pars0grm.y"
02399     { (yyval) = pars_select_list(static_cast<sym_node_t *>((yyvsp[(1) - (3)])), static_cast<sym_node_t *>((yyvsp[(3) - (3)]))); }
02400     break;
02401 
02402   case 90:
02403 
02404 /* Line 1455 of yacc.c  */
02405 #line 309 "plugin/innobase/pars/pars0grm.y"
02406     { (yyval) = pars_select_list((yyvsp[(1) - (1)]), NULL); }
02407     break;
02408 
02409   case 91:
02410 
02411 /* Line 1455 of yacc.c  */
02412 #line 313 "plugin/innobase/pars/pars0grm.y"
02413     { (yyval) = NULL; }
02414     break;
02415 
02416   case 92:
02417 
02418 /* Line 1455 of yacc.c  */
02419 #line 314 "plugin/innobase/pars/pars0grm.y"
02420     { (yyval) = (yyvsp[(2) - (2)]); }
02421     break;
02422 
02423   case 93:
02424 
02425 /* Line 1455 of yacc.c  */
02426 #line 318 "plugin/innobase/pars/pars0grm.y"
02427     { (yyval) = NULL; }
02428     break;
02429 
02430   case 94:
02431 
02432 /* Line 1455 of yacc.c  */
02433 #line 320 "plugin/innobase/pars/pars0grm.y"
02434     { (yyval) = &pars_update_token; }
02435     break;
02436 
02437   case 95:
02438 
02439 /* Line 1455 of yacc.c  */
02440 #line 324 "plugin/innobase/pars/pars0grm.y"
02441     { (yyval) = NULL; }
02442     break;
02443 
02444   case 96:
02445 
02446 /* Line 1455 of yacc.c  */
02447 #line 326 "plugin/innobase/pars/pars0grm.y"
02448     { (yyval) = &pars_share_token; }
02449     break;
02450 
02451   case 97:
02452 
02453 /* Line 1455 of yacc.c  */
02454 #line 330 "plugin/innobase/pars/pars0grm.y"
02455     { (yyval) = &pars_asc_token; }
02456     break;
02457 
02458   case 98:
02459 
02460 /* Line 1455 of yacc.c  */
02461 #line 331 "plugin/innobase/pars/pars0grm.y"
02462     { (yyval) = &pars_asc_token; }
02463     break;
02464 
02465   case 99:
02466 
02467 /* Line 1455 of yacc.c  */
02468 #line 332 "plugin/innobase/pars/pars0grm.y"
02469     { (yyval) = &pars_desc_token; }
02470     break;
02471 
02472   case 100:
02473 
02474 /* Line 1455 of yacc.c  */
02475 #line 336 "plugin/innobase/pars/pars0grm.y"
02476     { (yyval) = NULL; }
02477     break;
02478 
02479   case 101:
02480 
02481 /* Line 1455 of yacc.c  */
02482 #line 338 "plugin/innobase/pars/pars0grm.y"
02483     { (yyval) = pars_order_by(static_cast<sym_node_t *>((yyvsp[(3) - (4)])), static_cast<pars_res_word_t *>((yyvsp[(4) - (4)]))); }
02484     break;
02485 
02486   case 102:
02487 
02488 /* Line 1455 of yacc.c  */
02489 #line 347 "plugin/innobase/pars/pars0grm.y"
02490     { (yyval) = pars_select_statement(static_cast<sel_node_t *>((yyvsp[(2) - (8)])), static_cast<sym_node_t *>((yyvsp[(4) - (8)])), (yyvsp[(5) - (8)]),
02491                                                              static_cast<pars_res_word_t *>((yyvsp[(6) - (8)])), static_cast<pars_res_word_t *>((yyvsp[(7) - (8)])), static_cast<order_node_t *>((yyvsp[(8) - (8)]))); }
02492     break;
02493 
02494   case 103:
02495 
02496 /* Line 1455 of yacc.c  */
02497 #line 353 "plugin/innobase/pars/pars0grm.y"
02498     { (yyval) = (yyvsp[(3) - (3)]); }
02499     break;
02500 
02501   case 104:
02502 
02503 /* Line 1455 of yacc.c  */
02504 #line 358 "plugin/innobase/pars/pars0grm.y"
02505     { (yyval) = pars_insert_statement(static_cast<sym_node_t *>((yyvsp[(1) - (5)])), (yyvsp[(4) - (5)]), NULL); }
02506     break;
02507 
02508   case 105:
02509 
02510 /* Line 1455 of yacc.c  */
02511 #line 360 "plugin/innobase/pars/pars0grm.y"
02512     { (yyval) = pars_insert_statement(static_cast<sym_node_t *>((yyvsp[(1) - (2)])), NULL, static_cast<sel_node_t *>((yyvsp[(2) - (2)]))); }
02513     break;
02514 
02515   case 106:
02516 
02517 /* Line 1455 of yacc.c  */
02518 #line 364 "plugin/innobase/pars/pars0grm.y"
02519     { (yyval) = pars_column_assignment(static_cast<sym_node_t *>((yyvsp[(1) - (3)])), (yyvsp[(3) - (3)])); }
02520     break;
02521 
02522   case 107:
02523 
02524 /* Line 1455 of yacc.c  */
02525 #line 368 "plugin/innobase/pars/pars0grm.y"
02526     { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
02527     break;
02528 
02529   case 108:
02530 
02531 /* Line 1455 of yacc.c  */
02532 #line 370 "plugin/innobase/pars/pars0grm.y"
02533     { (yyval) = que_node_list_add_last((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02534     break;
02535 
02536   case 109:
02537 
02538 /* Line 1455 of yacc.c  */
02539 #line 376 "plugin/innobase/pars/pars0grm.y"
02540     { (yyval) = (yyvsp[(4) - (4)]); }
02541     break;
02542 
02543   case 110:
02544 
02545 /* Line 1455 of yacc.c  */
02546 #line 382 "plugin/innobase/pars/pars0grm.y"
02547     { (yyval) = pars_update_statement_start(FALSE,
02548                                                                    static_cast<sym_node_t *>((yyvsp[(2) - (4)])), static_cast<col_assign_node_t *>((yyvsp[(4) - (4)]))); }
02549     break;
02550 
02551   case 111:
02552 
02553 /* Line 1455 of yacc.c  */
02554 #line 388 "plugin/innobase/pars/pars0grm.y"
02555     { (yyval) = pars_update_statement(static_cast<upd_node_t *>((yyvsp[(1) - (2)])), NULL, (yyvsp[(2) - (2)])); }
02556     break;
02557 
02558   case 112:
02559 
02560 /* Line 1455 of yacc.c  */
02561 #line 393 "plugin/innobase/pars/pars0grm.y"
02562     { (yyval) = pars_update_statement(static_cast<upd_node_t *>((yyvsp[(1) - (2)])), static_cast<sym_node_t *>((yyvsp[(2) - (2)])), NULL); }
02563     break;
02564 
02565   case 113:
02566 
02567 /* Line 1455 of yacc.c  */
02568 #line 398 "plugin/innobase/pars/pars0grm.y"
02569     { (yyval) = pars_update_statement_start(TRUE,
02570                                                                    static_cast<sym_node_t *>((yyvsp[(3) - (3)])), NULL); }
02571     break;
02572 
02573   case 114:
02574 
02575 /* Line 1455 of yacc.c  */
02576 #line 404 "plugin/innobase/pars/pars0grm.y"
02577     { (yyval) = pars_update_statement(static_cast<upd_node_t *>((yyvsp[(1) - (2)])), NULL, (yyvsp[(2) - (2)])); }
02578     break;
02579 
02580   case 115:
02581 
02582 /* Line 1455 of yacc.c  */
02583 #line 409 "plugin/innobase/pars/pars0grm.y"
02584     { (yyval) = pars_update_statement(static_cast<upd_node_t *>((yyvsp[(1) - (2)])), static_cast<sym_node_t *>((yyvsp[(2) - (2)])), NULL); }
02585     break;
02586 
02587   case 116:
02588 
02589 /* Line 1455 of yacc.c  */
02590 #line 414 "plugin/innobase/pars/pars0grm.y"
02591     { (yyval) = pars_row_printf_statement(static_cast<sel_node_t *>((yyvsp[(2) - (2)]))); }
02592     break;
02593 
02594   case 117:
02595 
02596 /* Line 1455 of yacc.c  */
02597 #line 419 "plugin/innobase/pars/pars0grm.y"
02598     { (yyval) = pars_assignment_statement(static_cast<sym_node_t *>((yyvsp[(1) - (3)])), (yyvsp[(3) - (3)])); }
02599     break;
02600 
02601   case 118:
02602 
02603 /* Line 1455 of yacc.c  */
02604 #line 425 "plugin/innobase/pars/pars0grm.y"
02605     { (yyval) = pars_elsif_element((yyvsp[(2) - (4)]), (yyvsp[(4) - (4)])); }
02606     break;
02607 
02608   case 119:
02609 
02610 /* Line 1455 of yacc.c  */
02611 #line 429 "plugin/innobase/pars/pars0grm.y"
02612     { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
02613     break;
02614 
02615   case 120:
02616 
02617 /* Line 1455 of yacc.c  */
02618 #line 431 "plugin/innobase/pars/pars0grm.y"
02619     { (yyval) = que_node_list_add_last((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)])); }
02620     break;
02621 
02622   case 121:
02623 
02624 /* Line 1455 of yacc.c  */
02625 #line 435 "plugin/innobase/pars/pars0grm.y"
02626     { (yyval) = NULL; }
02627     break;
02628 
02629   case 122:
02630 
02631 /* Line 1455 of yacc.c  */
02632 #line 437 "plugin/innobase/pars/pars0grm.y"
02633     { (yyval) = (yyvsp[(2) - (2)]); }
02634     break;
02635 
02636   case 123:
02637 
02638 /* Line 1455 of yacc.c  */
02639 #line 438 "plugin/innobase/pars/pars0grm.y"
02640     { (yyval) = (yyvsp[(1) - (1)]); }
02641     break;
02642 
02643   case 124:
02644 
02645 /* Line 1455 of yacc.c  */
02646 #line 445 "plugin/innobase/pars/pars0grm.y"
02647     { (yyval) = pars_if_statement((yyvsp[(2) - (7)]), (yyvsp[(4) - (7)]), (yyvsp[(5) - (7)])); }
02648     break;
02649 
02650   case 125:
02651 
02652 /* Line 1455 of yacc.c  */
02653 #line 451 "plugin/innobase/pars/pars0grm.y"
02654     { (yyval) = pars_while_statement((yyvsp[(2) - (6)]), (yyvsp[(4) - (6)])); }
02655     break;
02656 
02657   case 126:
02658 
02659 /* Line 1455 of yacc.c  */
02660 #line 459 "plugin/innobase/pars/pars0grm.y"
02661     { (yyval) = pars_for_statement(static_cast<sym_node_t *>((yyvsp[(2) - (10)])), (yyvsp[(4) - (10)]), (yyvsp[(6) - (10)]), (yyvsp[(8) - (10)])); }
02662     break;
02663 
02664   case 127:
02665 
02666 /* Line 1455 of yacc.c  */
02667 #line 463 "plugin/innobase/pars/pars0grm.y"
02668     { (yyval) = pars_exit_statement(); }
02669     break;
02670 
02671   case 128:
02672 
02673 /* Line 1455 of yacc.c  */
02674 #line 467 "plugin/innobase/pars/pars0grm.y"
02675     { (yyval) = pars_return_statement(); }
02676     break;
02677 
02678   case 129:
02679 
02680 /* Line 1455 of yacc.c  */
02681 #line 472 "plugin/innobase/pars/pars0grm.y"
02682     { (yyval) = pars_open_statement(ROW_SEL_OPEN_CURSOR,
02683                                    static_cast<sym_node_t *>((yyvsp[(2) - (2)]))); }
02684     break;
02685 
02686   case 130:
02687 
02688 /* Line 1455 of yacc.c  */
02689 #line 478 "plugin/innobase/pars/pars0grm.y"
02690     { (yyval) = pars_open_statement(ROW_SEL_CLOSE_CURSOR,
02691                                    static_cast<sym_node_t *>((yyvsp[(2) - (2)]))); }
02692     break;
02693 
02694   case 131:
02695 
02696 /* Line 1455 of yacc.c  */
02697 #line 484 "plugin/innobase/pars/pars0grm.y"
02698     { (yyval) = pars_fetch_statement(static_cast<sym_node_t *>((yyvsp[(2) - (4)])), static_cast<sym_node_t *>((yyvsp[(4) - (4)])), NULL); }
02699     break;
02700 
02701   case 132:
02702 
02703 /* Line 1455 of yacc.c  */
02704 #line 486 "plugin/innobase/pars/pars0grm.y"
02705     { (yyval) = pars_fetch_statement(static_cast<sym_node_t *>((yyvsp[(2) - (4)])), NULL, static_cast<sym_node_t *>((yyvsp[(4) - (4)]))); }
02706     break;
02707 
02708   case 133:
02709 
02710 /* Line 1455 of yacc.c  */
02711 #line 491 "plugin/innobase/pars/pars0grm.y"
02712     { (yyval) = pars_column_def(static_cast<sym_node_t *>((yyvsp[(1) - (5)])), static_cast<pars_res_word_t *>((yyvsp[(2) - (5)])), static_cast<sym_node_t *>((yyvsp[(3) - (5)])), (yyvsp[(4) - (5)]), (yyvsp[(5) - (5)])); }
02713     break;
02714 
02715   case 134:
02716 
02717 /* Line 1455 of yacc.c  */
02718 #line 495 "plugin/innobase/pars/pars0grm.y"
02719     { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
02720     break;
02721 
02722   case 135:
02723 
02724 /* Line 1455 of yacc.c  */
02725 #line 497 "plugin/innobase/pars/pars0grm.y"
02726     { (yyval) = que_node_list_add_last((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02727     break;
02728 
02729   case 136:
02730 
02731 /* Line 1455 of yacc.c  */
02732 #line 501 "plugin/innobase/pars/pars0grm.y"
02733     { (yyval) = NULL; }
02734     break;
02735 
02736   case 137:
02737 
02738 /* Line 1455 of yacc.c  */
02739 #line 503 "plugin/innobase/pars/pars0grm.y"
02740     { (yyval) = (yyvsp[(2) - (3)]); }
02741     break;
02742 
02743   case 138:
02744 
02745 /* Line 1455 of yacc.c  */
02746 #line 507 "plugin/innobase/pars/pars0grm.y"
02747     { (yyval) = NULL; }
02748     break;
02749 
02750   case 139:
02751 
02752 /* Line 1455 of yacc.c  */
02753 #line 509 "plugin/innobase/pars/pars0grm.y"
02754     { (yyval) = &pars_int_token;
02755           /* pass any non-NULL pointer */ }
02756     break;
02757 
02758   case 140:
02759 
02760 /* Line 1455 of yacc.c  */
02761 #line 514 "plugin/innobase/pars/pars0grm.y"
02762     { (yyval) = NULL; }
02763     break;
02764 
02765   case 141:
02766 
02767 /* Line 1455 of yacc.c  */
02768 #line 516 "plugin/innobase/pars/pars0grm.y"
02769     { (yyval) = &pars_int_token;
02770           /* pass any non-NULL pointer */ }
02771     break;
02772 
02773   case 142:
02774 
02775 /* Line 1455 of yacc.c  */
02776 #line 521 "plugin/innobase/pars/pars0grm.y"
02777     { (yyval) = NULL; }
02778     break;
02779 
02780   case 143:
02781 
02782 /* Line 1455 of yacc.c  */
02783 #line 523 "plugin/innobase/pars/pars0grm.y"
02784     { (yyval) = &pars_int_token;
02785           /* pass any non-NULL pointer */ }
02786     break;
02787 
02788   case 144:
02789 
02790 /* Line 1455 of yacc.c  */
02791 #line 530 "plugin/innobase/pars/pars0grm.y"
02792     { (yyval) = pars_create_table(static_cast<sym_node_t *>((yyvsp[(3) - (7)])), static_cast<sym_node_t *>((yyvsp[(5) - (7)])), (yyvsp[(7) - (7)])); }
02793     break;
02794 
02795   case 145:
02796 
02797 /* Line 1455 of yacc.c  */
02798 #line 534 "plugin/innobase/pars/pars0grm.y"
02799     { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
02800     break;
02801 
02802   case 146:
02803 
02804 /* Line 1455 of yacc.c  */
02805 #line 536 "plugin/innobase/pars/pars0grm.y"
02806     { (yyval) = que_node_list_add_last((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02807     break;
02808 
02809   case 147:
02810 
02811 /* Line 1455 of yacc.c  */
02812 #line 540 "plugin/innobase/pars/pars0grm.y"
02813     { (yyval) = NULL; }
02814     break;
02815 
02816   case 148:
02817 
02818 /* Line 1455 of yacc.c  */
02819 #line 541 "plugin/innobase/pars/pars0grm.y"
02820     { (yyval) = &pars_unique_token; }
02821     break;
02822 
02823   case 149:
02824 
02825 /* Line 1455 of yacc.c  */
02826 #line 545 "plugin/innobase/pars/pars0grm.y"
02827     { (yyval) = NULL; }
02828     break;
02829 
02830   case 150:
02831 
02832 /* Line 1455 of yacc.c  */
02833 #line 546 "plugin/innobase/pars/pars0grm.y"
02834     { (yyval) = &pars_clustered_token; }
02835     break;
02836 
02837   case 151:
02838 
02839 /* Line 1455 of yacc.c  */
02840 #line 554 "plugin/innobase/pars/pars0grm.y"
02841     { (yyval) = pars_create_index(static_cast<pars_res_word_t *>((yyvsp[(2) - (10)])), static_cast<pars_res_word_t *>((yyvsp[(3) - (10)])), static_cast<sym_node_t *>((yyvsp[(5) - (10)])), static_cast<sym_node_t *>((yyvsp[(7) - (10)])), static_cast<sym_node_t *>((yyvsp[(9) - (10)]))); }
02842     break;
02843 
02844   case 152:
02845 
02846 /* Line 1455 of yacc.c  */
02847 #line 559 "plugin/innobase/pars/pars0grm.y"
02848     { (yyval) = pars_commit_statement(); }
02849     break;
02850 
02851   case 153:
02852 
02853 /* Line 1455 of yacc.c  */
02854 #line 564 "plugin/innobase/pars/pars0grm.y"
02855     { (yyval) = pars_rollback_statement(); }
02856     break;
02857 
02858   case 154:
02859 
02860 /* Line 1455 of yacc.c  */
02861 #line 568 "plugin/innobase/pars/pars0grm.y"
02862     { (yyval) = &pars_int_token; }
02863     break;
02864 
02865   case 155:
02866 
02867 /* Line 1455 of yacc.c  */
02868 #line 569 "plugin/innobase/pars/pars0grm.y"
02869     { (yyval) = &pars_int_token; }
02870     break;
02871 
02872   case 156:
02873 
02874 /* Line 1455 of yacc.c  */
02875 #line 570 "plugin/innobase/pars/pars0grm.y"
02876     { (yyval) = &pars_char_token; }
02877     break;
02878 
02879   case 157:
02880 
02881 /* Line 1455 of yacc.c  */
02882 #line 571 "plugin/innobase/pars/pars0grm.y"
02883     { (yyval) = &pars_binary_token; }
02884     break;
02885 
02886   case 158:
02887 
02888 /* Line 1455 of yacc.c  */
02889 #line 572 "plugin/innobase/pars/pars0grm.y"
02890     { (yyval) = &pars_blob_token; }
02891     break;
02892 
02893   case 159:
02894 
02895 /* Line 1455 of yacc.c  */
02896 #line 577 "plugin/innobase/pars/pars0grm.y"
02897     { (yyval) = pars_parameter_declaration(static_cast<sym_node_t *>((yyvsp[(1) - (3)])),
02898                                                                   PARS_INPUT, static_cast<pars_res_word_t *>((yyvsp[(3) - (3)]))); }
02899     break;
02900 
02901   case 160:
02902 
02903 /* Line 1455 of yacc.c  */
02904 #line 580 "plugin/innobase/pars/pars0grm.y"
02905     { (yyval) = pars_parameter_declaration(static_cast<sym_node_t *>((yyvsp[(1) - (3)])),
02906                                                                   PARS_OUTPUT, static_cast<pars_res_word_t *>((yyvsp[(3) - (3)]))); }
02907     break;
02908 
02909   case 161:
02910 
02911 /* Line 1455 of yacc.c  */
02912 #line 585 "plugin/innobase/pars/pars0grm.y"
02913     { (yyval) = NULL; }
02914     break;
02915 
02916   case 162:
02917 
02918 /* Line 1455 of yacc.c  */
02919 #line 586 "plugin/innobase/pars/pars0grm.y"
02920     { (yyval) = que_node_list_add_last(NULL, (yyvsp[(1) - (1)])); }
02921     break;
02922 
02923   case 163:
02924 
02925 /* Line 1455 of yacc.c  */
02926 #line 588 "plugin/innobase/pars/pars0grm.y"
02927     { (yyval) = que_node_list_add_last((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
02928     break;
02929 
02930   case 164:
02931 
02932 /* Line 1455 of yacc.c  */
02933 #line 593 "plugin/innobase/pars/pars0grm.y"
02934     { (yyval) = pars_variable_declaration(static_cast<sym_node_t *>((yyvsp[(1) - (3)])), static_cast<pars_res_word_t *>((yyvsp[(2) - (3)]))); }
02935     break;
02936 
02937   case 168:
02938 
02939 /* Line 1455 of yacc.c  */
02940 #line 605 "plugin/innobase/pars/pars0grm.y"
02941     { (yyval) = pars_cursor_declaration(static_cast<sym_node_t *>((yyvsp[(3) - (6)])), static_cast<sel_node_t *>((yyvsp[(5) - (6)]))); }
02942     break;
02943 
02944   case 169:
02945 
02946 /* Line 1455 of yacc.c  */
02947 #line 610 "plugin/innobase/pars/pars0grm.y"
02948     { (yyval) = pars_function_declaration(static_cast<sym_node_t *>((yyvsp[(3) - (4)]))); }
02949     break;
02950 
02951   case 175:
02952 
02953 /* Line 1455 of yacc.c  */
02954 #line 631 "plugin/innobase/pars/pars0grm.y"
02955     { (yyval) = pars_procedure_definition(static_cast<sym_node_t *>((yyvsp[(2) - (11)])), static_cast<sym_node_t *>((yyvsp[(4) - (11)])),
02956                 (yyvsp[(10) - (11)])); }
02957     break;
02958 
02959 
02960 
02961 /* Line 1455 of yacc.c  */
02962 #line 2963 "plugin/innobase/pars/pars0grm.cc"
02963       default: break;
02964     }
02965   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
02966 
02967   YYPOPSTACK (yylen);
02968   yylen = 0;
02969   YY_STACK_PRINT (yyss, yyssp);
02970 
02971   *++yyvsp = yyval;
02972 
02973   /* Now `shift' the result of the reduction.  Determine what state
02974      that goes to, based on the state we popped back to and the rule
02975      number reduced by.  */
02976 
02977   yyn = yyr1[yyn];
02978 
02979   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
02980   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
02981     yystate = yytable[yystate];
02982   else
02983     yystate = yydefgoto[yyn - YYNTOKENS];
02984 
02985   goto yynewstate;
02986 
02987 
02988 /*------------------------------------.
02989 | yyerrlab -- here on detecting error |
02990 `------------------------------------*/
02991 yyerrlab:
02992   /* If not already recovering from an error, report this error.  */
02993   if (!yyerrstatus)
02994     {
02995       ++yynerrs;
02996 #if ! YYERROR_VERBOSE
02997       yyerror (YY_("syntax error"));
02998 #else
02999       {
03000   YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
03001   if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
03002     {
03003       YYSIZE_T yyalloc = 2 * yysize;
03004       if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
03005         yyalloc = YYSTACK_ALLOC_MAXIMUM;
03006       if (yymsg != yymsgbuf)
03007         YYSTACK_FREE (yymsg);
03008       yymsg = (char *) YYSTACK_ALLOC (yyalloc);
03009       if (yymsg)
03010         yymsg_alloc = yyalloc;
03011       else
03012         {
03013     yymsg = yymsgbuf;
03014     yymsg_alloc = sizeof yymsgbuf;
03015         }
03016     }
03017 
03018   if (0 < yysize && yysize <= yymsg_alloc)
03019     {
03020       (void) yysyntax_error (yymsg, yystate, yychar);
03021       yyerror (yymsg);
03022     }
03023   else
03024     {
03025       yyerror (YY_("syntax error"));
03026       if (yysize != 0)
03027         goto yyexhaustedlab;
03028     }
03029       }
03030 #endif
03031     }
03032 
03033 
03034 
03035   if (yyerrstatus == 3)
03036     {
03037       /* If just tried and failed to reuse lookahead token after an
03038    error, discard it.  */
03039 
03040       if (yychar <= YYEOF)
03041   {
03042     /* Return failure if at end of input.  */
03043     if (yychar == YYEOF)
03044       YYABORT;
03045   }
03046       else
03047   {
03048     yydestruct ("Error: discarding",
03049           yytoken, &yylval);
03050     yychar = YYEMPTY;
03051   }
03052     }
03053 
03054   /* Else will try to reuse lookahead token after shifting the error
03055      token.  */
03056   goto yyerrlab1;
03057 
03058 
03059 /*---------------------------------------------------.
03060 | yyerrorlab -- error raised explicitly by YYERROR.  |
03061 `---------------------------------------------------*/
03062 yyerrorlab:
03063 
03064   /* Pacify compilers like GCC when the user code never invokes
03065      YYERROR and the label yyerrorlab therefore never appears in user
03066      code.  */
03067   if (/*CONSTCOND*/ 0)
03068      goto yyerrorlab;
03069 
03070   /* Do not reclaim the symbols of the rule which action triggered
03071      this YYERROR.  */
03072   YYPOPSTACK (yylen);
03073   yylen = 0;
03074   YY_STACK_PRINT (yyss, yyssp);
03075   yystate = *yyssp;
03076   goto yyerrlab1;
03077 
03078 
03079 /*-------------------------------------------------------------.
03080 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
03081 `-------------------------------------------------------------*/
03082 yyerrlab1:
03083   yyerrstatus = 3;  /* Each real token shifted decrements this.  */
03084 
03085   for (;;)
03086     {
03087       yyn = yypact[yystate];
03088       if (yyn != YYPACT_NINF)
03089   {
03090     yyn += YYTERROR;
03091     if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
03092       {
03093         yyn = yytable[yyn];
03094         if (0 < yyn)
03095     break;
03096       }
03097   }
03098 
03099       /* Pop the current state because it cannot handle the error token.  */
03100       if (yyssp == yyss)
03101   YYABORT;
03102 
03103 
03104       yydestruct ("Error: popping",
03105       yystos[yystate], yyvsp);
03106       YYPOPSTACK (1);
03107       yystate = *yyssp;
03108       YY_STACK_PRINT (yyss, yyssp);
03109     }
03110 
03111   *++yyvsp = yylval;
03112 
03113 
03114   /* Shift the error token.  */
03115   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
03116 
03117   yystate = yyn;
03118   goto yynewstate;
03119 
03120 
03121 /*-------------------------------------.
03122 | yyacceptlab -- YYACCEPT comes here.  |
03123 `-------------------------------------*/
03124 yyacceptlab:
03125   yyresult = 0;
03126   goto yyreturn;
03127 
03128 /*-----------------------------------.
03129 | yyabortlab -- YYABORT comes here.  |
03130 `-----------------------------------*/
03131 yyabortlab:
03132   yyresult = 1;
03133   goto yyreturn;
03134 
03135 #if !defined(yyoverflow) || YYERROR_VERBOSE
03136 /*-------------------------------------------------.
03137 | yyexhaustedlab -- memory exhaustion comes here.  |
03138 `-------------------------------------------------*/
03139 yyexhaustedlab:
03140   yyerror (YY_("memory exhausted"));
03141   yyresult = 2;
03142   /* Fall through.  */
03143 #endif
03144 
03145 yyreturn:
03146   if (yychar != YYEMPTY)
03147      yydestruct ("Cleanup: discarding lookahead",
03148      yytoken, &yylval);
03149   /* Do not reclaim the symbols of the rule which action triggered
03150      this YYABORT or YYACCEPT.  */
03151   YYPOPSTACK (yylen);
03152   YY_STACK_PRINT (yyss, yyssp);
03153   while (yyssp != yyss)
03154     {
03155       yydestruct ("Cleanup: popping",
03156       yystos[*yyssp], yyvsp);
03157       YYPOPSTACK (1);
03158     }
03159 #ifndef yyoverflow
03160   if (yyss != yyssa)
03161     YYSTACK_FREE (yyss);
03162 #endif
03163 #if YYERROR_VERBOSE
03164   if (yymsg != yymsgbuf)
03165     YYSTACK_FREE (yymsg);
03166 #endif
03167   /* Make sure YYID is used.  */
03168   return YYID (yyresult);
03169 }
03170 
03171 
03172 
03173 /* Line 1675 of yacc.c  */
03174 #line 635 "plugin/innobase/pars/pars0grm.y"
03175 
03176