From 7b22ee8ecbe7985f4feca7ee8263ad751bd5f772 Mon Sep 17 00:00:00 2001 From: Mike Siomkin Date: Tue, 16 Jun 2020 21:16:58 +0300 Subject: [PATCH] Add support of CAST(expression AS datatype(length)) CAST(expression AS datatype(length)) construction is a part of ANSI SQL-92 standard. So we have to support it. --- src/parser/bison_parser.cpp | 4087 +++++++++++++++++++---------------- src/parser/bison_parser.h | 316 +-- src/parser/bison_parser.y | 12 +- src/parser/flex_lexer.cpp | 2115 +++++++++--------- src/parser/flex_lexer.h | 2 +- src/parser/flex_lexer.l | 2 + src/sql/ColumnType.h | 33 + src/sql/CreateStatement.h | 24 +- src/sql/Expr.cpp | 9 + src/sql/Expr.h | 4 + src/sql/statements.cpp | 3 + test/sql_tests.cpp | 16 + 12 files changed, 3587 insertions(+), 3036 deletions(-) create mode 100755 src/sql/ColumnType.h diff --git a/src/parser/bison_parser.cpp b/src/parser/bison_parser.cpp index d9fee6b..4e710f5 100644 --- a/src/parser/bison_parser.cpp +++ b/src/parser/bison_parser.cpp @@ -1,8 +1,8 @@ -/* A Bison parser, made by GNU Bison 3.4.2. */ +/* A Bison parser, made by GNU Bison 3.6.4. */ /* Bison implementation for Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation, + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify @@ -34,6 +34,10 @@ /* C LALR(1) parser skeleton written by Richard Stallman, by simplifying the original so-called "semantic" parser. */ +/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, + especially those whose name start with YY_ or yy_. They are + private implementation details that can be changed or removed. */ + /* All symbols defined below should begin with yy or YY, to avoid infringing on user name space. This should be done even for local variables, as they might otherwise be expanded by user macros. @@ -41,14 +45,11 @@ define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below. */ -/* Undocumented macros, especially those whose name start with YY_, - are private implementation details. Do not rely on them. */ - /* Identify Bison output. */ #define YYBISON 1 /* Bison version. */ -#define YYBISON_VERSION "3.4.2" +#define YYBISON_VERSION "3.6.4" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" @@ -72,7 +73,6 @@ #define yydebug hsql_debug #define yynerrs hsql_nerrs - /* First part of user prologue. */ #line 1 "bison_parser.y" @@ -105,6 +105,15 @@ int yyerror(YYLTYPE* llocp, SQLParserResult* result, yyscan_t scanner, const cha #line 107 "bison_parser.cpp" +# ifndef YY_CAST +# ifdef __cplusplus +# define YY_CAST(Type, Val) static_cast (Val) +# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val) +# else +# define YY_CAST(Type, Val) ((Type) (Val)) +# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) +# endif +# endif # ifndef YY_NULLPTR # if defined __cplusplus # if 201103L <= __cplusplus @@ -117,14 +126,6 @@ int yyerror(YYLTYPE* llocp, SQLParserResult* result, yyscan_t scanner, const cha # endif # endif -/* Enabling verbose error messages. */ -#ifdef YYERROR_VERBOSE -# undef YYERROR_VERBOSE -# define YYERROR_VERBOSE 1 -#else -# define YYERROR_VERBOSE 1 -#endif - /* Use api.header.include to #include this header instead of duplicating it here. */ #ifndef YY_HSQL_BISON_PARSER_H_INCLUDED @@ -169,161 +170,168 @@ extern int hsql_debug; } \ } -#line 173 "bison_parser.cpp" +#line 174 "bison_parser.cpp" -/* Token type. */ +/* Token kinds. */ #ifndef HSQL_TOKENTYPE # define HSQL_TOKENTYPE enum hsql_tokentype { - SQL_IDENTIFIER = 258, - SQL_STRING = 259, - SQL_FLOATVAL = 260, - SQL_INTVAL = 261, - SQL_DEALLOCATE = 262, - SQL_PARAMETERS = 263, - SQL_INTERSECT = 264, - SQL_TEMPORARY = 265, - SQL_TIMESTAMP = 266, - SQL_DISTINCT = 267, - SQL_NVARCHAR = 268, - SQL_RESTRICT = 269, - SQL_TRUNCATE = 270, - SQL_ANALYZE = 271, - SQL_BETWEEN = 272, - SQL_CASCADE = 273, - SQL_COLUMNS = 274, - SQL_CONTROL = 275, - SQL_DEFAULT = 276, - SQL_EXECUTE = 277, - SQL_EXPLAIN = 278, - SQL_INTEGER = 279, - SQL_NATURAL = 280, - SQL_PREPARE = 281, - SQL_PRIMARY = 282, - SQL_SCHEMAS = 283, - SQL_SPATIAL = 284, - SQL_VARCHAR = 285, - SQL_VIRTUAL = 286, - SQL_DESCRIBE = 287, - SQL_BEFORE = 288, - SQL_COLUMN = 289, - SQL_CREATE = 290, - SQL_DELETE = 291, - SQL_DIRECT = 292, - SQL_DOUBLE = 293, - SQL_ESCAPE = 294, - SQL_EXCEPT = 295, - SQL_EXISTS = 296, - SQL_EXTRACT = 297, - SQL_FORMAT = 298, - SQL_GLOBAL = 299, - SQL_HAVING = 300, - SQL_IMPORT = 301, - SQL_INSERT = 302, - SQL_ISNULL = 303, - SQL_OFFSET = 304, - SQL_RENAME = 305, - SQL_SCHEMA = 306, - SQL_SELECT = 307, - SQL_SORTED = 308, - SQL_TABLES = 309, - SQL_UNIQUE = 310, - SQL_UNLOAD = 311, - SQL_UPDATE = 312, - SQL_VALUES = 313, - SQL_AFTER = 314, - SQL_ALTER = 315, - SQL_CROSS = 316, - SQL_DELTA = 317, - SQL_FLOAT = 318, - SQL_GROUP = 319, - SQL_INDEX = 320, - SQL_INNER = 321, - SQL_LIMIT = 322, - SQL_LOCAL = 323, - SQL_MERGE = 324, - SQL_MINUS = 325, - SQL_ORDER = 326, - SQL_OUTER = 327, - SQL_RIGHT = 328, - SQL_TABLE = 329, - SQL_UNION = 330, - SQL_USING = 331, - SQL_WHERE = 332, - SQL_CALL = 333, - SQL_CASE = 334, - SQL_CHAR = 335, - SQL_COPY = 336, - SQL_DATE = 337, - SQL_DESC = 338, - SQL_DROP = 339, - SQL_ELSE = 340, - SQL_FILE = 341, - SQL_FROM = 342, - SQL_FULL = 343, - SQL_HASH = 344, - SQL_HINT = 345, - SQL_INTO = 346, - SQL_JOIN = 347, - SQL_LEFT = 348, - SQL_LIKE = 349, - SQL_LOAD = 350, - SQL_LONG = 351, - SQL_NULL = 352, - SQL_PLAN = 353, - SQL_SHOW = 354, - SQL_TEXT = 355, - SQL_THEN = 356, - SQL_TIME = 357, - SQL_VIEW = 358, - SQL_WHEN = 359, - SQL_WITH = 360, - SQL_ADD = 361, - SQL_ALL = 362, - SQL_AND = 363, - SQL_ASC = 364, - SQL_END = 365, - SQL_FOR = 366, - SQL_INT = 367, - SQL_KEY = 368, - SQL_NOT = 369, - SQL_OFF = 370, - SQL_SET = 371, - SQL_TOP = 372, - SQL_AS = 373, - SQL_BY = 374, - SQL_IF = 375, - SQL_IN = 376, - SQL_IS = 377, - SQL_OF = 378, - SQL_ON = 379, - SQL_OR = 380, - SQL_TO = 381, - SQL_ARRAY = 382, - SQL_CONCAT = 383, - SQL_ILIKE = 384, - SQL_SECOND = 385, - SQL_MINUTE = 386, - SQL_HOUR = 387, - SQL_DAY = 388, - SQL_MONTH = 389, - SQL_YEAR = 390, - SQL_TRUE = 391, - SQL_FALSE = 392, - SQL_TRANSACTION = 393, - SQL_BEGIN = 394, - SQL_COMMIT = 395, - SQL_ROLLBACK = 396, - SQL_EQUALS = 397, - SQL_NOTEQUALS = 398, - SQL_LESS = 399, - SQL_GREATER = 400, - SQL_LESSEQ = 401, - SQL_GREATEREQ = 402, - SQL_NOTNULL = 403, - SQL_UMINUS = 404 + SQL_HSQL_EMPTY = -2, + SQL_YYEOF = 0, /* "end of file" */ + SQL_HSQL_error = 256, /* error */ + SQL_HSQL_UNDEF = 257, /* "invalid token" */ + SQL_IDENTIFIER = 258, /* IDENTIFIER */ + SQL_STRING = 259, /* STRING */ + SQL_FLOATVAL = 260, /* FLOATVAL */ + SQL_INTVAL = 261, /* INTVAL */ + SQL_DEALLOCATE = 262, /* DEALLOCATE */ + SQL_PARAMETERS = 263, /* PARAMETERS */ + SQL_INTERSECT = 264, /* INTERSECT */ + SQL_TEMPORARY = 265, /* TEMPORARY */ + SQL_TIMESTAMP = 266, /* TIMESTAMP */ + SQL_DISTINCT = 267, /* DISTINCT */ + SQL_NVARCHAR = 268, /* NVARCHAR */ + SQL_RESTRICT = 269, /* RESTRICT */ + SQL_TRUNCATE = 270, /* TRUNCATE */ + SQL_ANALYZE = 271, /* ANALYZE */ + SQL_BETWEEN = 272, /* BETWEEN */ + SQL_CASCADE = 273, /* CASCADE */ + SQL_COLUMNS = 274, /* COLUMNS */ + SQL_CONTROL = 275, /* CONTROL */ + SQL_DEFAULT = 276, /* DEFAULT */ + SQL_EXECUTE = 277, /* EXECUTE */ + SQL_EXPLAIN = 278, /* EXPLAIN */ + SQL_INTEGER = 279, /* INTEGER */ + SQL_NATURAL = 280, /* NATURAL */ + SQL_PREPARE = 281, /* PREPARE */ + SQL_PRIMARY = 282, /* PRIMARY */ + SQL_SCHEMAS = 283, /* SCHEMAS */ + SQL_SPATIAL = 284, /* SPATIAL */ + SQL_VARCHAR = 285, /* VARCHAR */ + SQL_VIRTUAL = 286, /* VIRTUAL */ + SQL_DESCRIBE = 287, /* DESCRIBE */ + SQL_BEFORE = 288, /* BEFORE */ + SQL_COLUMN = 289, /* COLUMN */ + SQL_CREATE = 290, /* CREATE */ + SQL_DELETE = 291, /* DELETE */ + SQL_DIRECT = 292, /* DIRECT */ + SQL_DOUBLE = 293, /* DOUBLE */ + SQL_ESCAPE = 294, /* ESCAPE */ + SQL_EXCEPT = 295, /* EXCEPT */ + SQL_EXISTS = 296, /* EXISTS */ + SQL_EXTRACT = 297, /* EXTRACT */ + SQL_CAST = 298, /* CAST */ + SQL_FORMAT = 299, /* FORMAT */ + SQL_GLOBAL = 300, /* GLOBAL */ + SQL_HAVING = 301, /* HAVING */ + SQL_IMPORT = 302, /* IMPORT */ + SQL_INSERT = 303, /* INSERT */ + SQL_ISNULL = 304, /* ISNULL */ + SQL_OFFSET = 305, /* OFFSET */ + SQL_RENAME = 306, /* RENAME */ + SQL_SCHEMA = 307, /* SCHEMA */ + SQL_SELECT = 308, /* SELECT */ + SQL_SORTED = 309, /* SORTED */ + SQL_TABLES = 310, /* TABLES */ + SQL_UNIQUE = 311, /* UNIQUE */ + SQL_UNLOAD = 312, /* UNLOAD */ + SQL_UPDATE = 313, /* UPDATE */ + SQL_VALUES = 314, /* VALUES */ + SQL_AFTER = 315, /* AFTER */ + SQL_ALTER = 316, /* ALTER */ + SQL_CROSS = 317, /* CROSS */ + SQL_DELTA = 318, /* DELTA */ + SQL_FLOAT = 319, /* FLOAT */ + SQL_GROUP = 320, /* GROUP */ + SQL_INDEX = 321, /* INDEX */ + SQL_INNER = 322, /* INNER */ + SQL_LIMIT = 323, /* LIMIT */ + SQL_LOCAL = 324, /* LOCAL */ + SQL_MERGE = 325, /* MERGE */ + SQL_MINUS = 326, /* MINUS */ + SQL_ORDER = 327, /* ORDER */ + SQL_OUTER = 328, /* OUTER */ + SQL_RIGHT = 329, /* RIGHT */ + SQL_TABLE = 330, /* TABLE */ + SQL_UNION = 331, /* UNION */ + SQL_USING = 332, /* USING */ + SQL_WHERE = 333, /* WHERE */ + SQL_CALL = 334, /* CALL */ + SQL_CASE = 335, /* CASE */ + SQL_CHAR = 336, /* CHAR */ + SQL_COPY = 337, /* COPY */ + SQL_DATE = 338, /* DATE */ + SQL_DATETIME = 339, /* DATETIME */ + SQL_DESC = 340, /* DESC */ + SQL_DROP = 341, /* DROP */ + SQL_ELSE = 342, /* ELSE */ + SQL_FILE = 343, /* FILE */ + SQL_FROM = 344, /* FROM */ + SQL_FULL = 345, /* FULL */ + SQL_HASH = 346, /* HASH */ + SQL_HINT = 347, /* HINT */ + SQL_INTO = 348, /* INTO */ + SQL_JOIN = 349, /* JOIN */ + SQL_LEFT = 350, /* LEFT */ + SQL_LIKE = 351, /* LIKE */ + SQL_LOAD = 352, /* LOAD */ + SQL_LONG = 353, /* LONG */ + SQL_NULL = 354, /* NULL */ + SQL_PLAN = 355, /* PLAN */ + SQL_SHOW = 356, /* SHOW */ + SQL_TEXT = 357, /* TEXT */ + SQL_THEN = 358, /* THEN */ + SQL_TIME = 359, /* TIME */ + SQL_VIEW = 360, /* VIEW */ + SQL_WHEN = 361, /* WHEN */ + SQL_WITH = 362, /* WITH */ + SQL_ADD = 363, /* ADD */ + SQL_ALL = 364, /* ALL */ + SQL_AND = 365, /* AND */ + SQL_ASC = 366, /* ASC */ + SQL_END = 367, /* END */ + SQL_FOR = 368, /* FOR */ + SQL_INT = 369, /* INT */ + SQL_KEY = 370, /* KEY */ + SQL_NOT = 371, /* NOT */ + SQL_OFF = 372, /* OFF */ + SQL_SET = 373, /* SET */ + SQL_TOP = 374, /* TOP */ + SQL_AS = 375, /* AS */ + SQL_BY = 376, /* BY */ + SQL_IF = 377, /* IF */ + SQL_IN = 378, /* IN */ + SQL_IS = 379, /* IS */ + SQL_OF = 380, /* OF */ + SQL_ON = 381, /* ON */ + SQL_OR = 382, /* OR */ + SQL_TO = 383, /* TO */ + SQL_ARRAY = 384, /* ARRAY */ + SQL_CONCAT = 385, /* CONCAT */ + SQL_ILIKE = 386, /* ILIKE */ + SQL_SECOND = 387, /* SECOND */ + SQL_MINUTE = 388, /* MINUTE */ + SQL_HOUR = 389, /* HOUR */ + SQL_DAY = 390, /* DAY */ + SQL_MONTH = 391, /* MONTH */ + SQL_YEAR = 392, /* YEAR */ + SQL_TRUE = 393, /* TRUE */ + SQL_FALSE = 394, /* FALSE */ + SQL_TRANSACTION = 395, /* TRANSACTION */ + SQL_BEGIN = 396, /* BEGIN */ + SQL_COMMIT = 397, /* COMMIT */ + SQL_ROLLBACK = 398, /* ROLLBACK */ + SQL_EQUALS = 399, /* EQUALS */ + SQL_NOTEQUALS = 400, /* NOTEQUALS */ + SQL_LESS = 401, /* LESS */ + SQL_GREATER = 402, /* GREATER */ + SQL_LESSEQ = 403, /* LESSEQ */ + SQL_GREATEREQ = 404, /* GREATEREQ */ + SQL_NOTNULL = 405, /* NOTNULL */ + SQL_UMINUS = 406 /* UMINUS */ }; + typedef enum hsql_tokentype hsql_token_kind_t; #endif /* Value type. */ @@ -378,7 +386,7 @@ union HSQL_STYPE std::vector* order_vec; std::vector* with_description_vec; -#line 382 "bison_parser.cpp" +#line 390 "bison_parser.cpp" }; typedef union HSQL_STYPE HSQL_STYPE; @@ -405,6 +413,288 @@ struct HSQL_LTYPE int hsql_parse (hsql::SQLParserResult* result, yyscan_t scanner); #endif /* !YY_HSQL_BISON_PARSER_H_INCLUDED */ +/* Symbol kind. */ +enum yysymbol_kind_t +{ + YYSYMBOL_YYEMPTY = -2, + YYSYMBOL_YYEOF = 0, /* "end of file" */ + YYSYMBOL_YYerror = 1, /* error */ + YYSYMBOL_YYUNDEF = 2, /* "invalid token" */ + YYSYMBOL_IDENTIFIER = 3, /* IDENTIFIER */ + YYSYMBOL_STRING = 4, /* STRING */ + YYSYMBOL_FLOATVAL = 5, /* FLOATVAL */ + YYSYMBOL_INTVAL = 6, /* INTVAL */ + YYSYMBOL_DEALLOCATE = 7, /* DEALLOCATE */ + YYSYMBOL_PARAMETERS = 8, /* PARAMETERS */ + YYSYMBOL_INTERSECT = 9, /* INTERSECT */ + YYSYMBOL_TEMPORARY = 10, /* TEMPORARY */ + YYSYMBOL_TIMESTAMP = 11, /* TIMESTAMP */ + YYSYMBOL_DISTINCT = 12, /* DISTINCT */ + YYSYMBOL_NVARCHAR = 13, /* NVARCHAR */ + YYSYMBOL_RESTRICT = 14, /* RESTRICT */ + YYSYMBOL_TRUNCATE = 15, /* TRUNCATE */ + YYSYMBOL_ANALYZE = 16, /* ANALYZE */ + YYSYMBOL_BETWEEN = 17, /* BETWEEN */ + YYSYMBOL_CASCADE = 18, /* CASCADE */ + YYSYMBOL_COLUMNS = 19, /* COLUMNS */ + YYSYMBOL_CONTROL = 20, /* CONTROL */ + YYSYMBOL_DEFAULT = 21, /* DEFAULT */ + YYSYMBOL_EXECUTE = 22, /* EXECUTE */ + YYSYMBOL_EXPLAIN = 23, /* EXPLAIN */ + YYSYMBOL_INTEGER = 24, /* INTEGER */ + YYSYMBOL_NATURAL = 25, /* NATURAL */ + YYSYMBOL_PREPARE = 26, /* PREPARE */ + YYSYMBOL_PRIMARY = 27, /* PRIMARY */ + YYSYMBOL_SCHEMAS = 28, /* SCHEMAS */ + YYSYMBOL_SPATIAL = 29, /* SPATIAL */ + YYSYMBOL_VARCHAR = 30, /* VARCHAR */ + YYSYMBOL_VIRTUAL = 31, /* VIRTUAL */ + YYSYMBOL_DESCRIBE = 32, /* DESCRIBE */ + YYSYMBOL_BEFORE = 33, /* BEFORE */ + YYSYMBOL_COLUMN = 34, /* COLUMN */ + YYSYMBOL_CREATE = 35, /* CREATE */ + YYSYMBOL_DELETE = 36, /* DELETE */ + YYSYMBOL_DIRECT = 37, /* DIRECT */ + YYSYMBOL_DOUBLE = 38, /* DOUBLE */ + YYSYMBOL_ESCAPE = 39, /* ESCAPE */ + YYSYMBOL_EXCEPT = 40, /* EXCEPT */ + YYSYMBOL_EXISTS = 41, /* EXISTS */ + YYSYMBOL_EXTRACT = 42, /* EXTRACT */ + YYSYMBOL_CAST = 43, /* CAST */ + YYSYMBOL_FORMAT = 44, /* FORMAT */ + YYSYMBOL_GLOBAL = 45, /* GLOBAL */ + YYSYMBOL_HAVING = 46, /* HAVING */ + YYSYMBOL_IMPORT = 47, /* IMPORT */ + YYSYMBOL_INSERT = 48, /* INSERT */ + YYSYMBOL_ISNULL = 49, /* ISNULL */ + YYSYMBOL_OFFSET = 50, /* OFFSET */ + YYSYMBOL_RENAME = 51, /* RENAME */ + YYSYMBOL_SCHEMA = 52, /* SCHEMA */ + YYSYMBOL_SELECT = 53, /* SELECT */ + YYSYMBOL_SORTED = 54, /* SORTED */ + YYSYMBOL_TABLES = 55, /* TABLES */ + YYSYMBOL_UNIQUE = 56, /* UNIQUE */ + YYSYMBOL_UNLOAD = 57, /* UNLOAD */ + YYSYMBOL_UPDATE = 58, /* UPDATE */ + YYSYMBOL_VALUES = 59, /* VALUES */ + YYSYMBOL_AFTER = 60, /* AFTER */ + YYSYMBOL_ALTER = 61, /* ALTER */ + YYSYMBOL_CROSS = 62, /* CROSS */ + YYSYMBOL_DELTA = 63, /* DELTA */ + YYSYMBOL_FLOAT = 64, /* FLOAT */ + YYSYMBOL_GROUP = 65, /* GROUP */ + YYSYMBOL_INDEX = 66, /* INDEX */ + YYSYMBOL_INNER = 67, /* INNER */ + YYSYMBOL_LIMIT = 68, /* LIMIT */ + YYSYMBOL_LOCAL = 69, /* LOCAL */ + YYSYMBOL_MERGE = 70, /* MERGE */ + YYSYMBOL_MINUS = 71, /* MINUS */ + YYSYMBOL_ORDER = 72, /* ORDER */ + YYSYMBOL_OUTER = 73, /* OUTER */ + YYSYMBOL_RIGHT = 74, /* RIGHT */ + YYSYMBOL_TABLE = 75, /* TABLE */ + YYSYMBOL_UNION = 76, /* UNION */ + YYSYMBOL_USING = 77, /* USING */ + YYSYMBOL_WHERE = 78, /* WHERE */ + YYSYMBOL_CALL = 79, /* CALL */ + YYSYMBOL_CASE = 80, /* CASE */ + YYSYMBOL_CHAR = 81, /* CHAR */ + YYSYMBOL_COPY = 82, /* COPY */ + YYSYMBOL_DATE = 83, /* DATE */ + YYSYMBOL_DATETIME = 84, /* DATETIME */ + YYSYMBOL_DESC = 85, /* DESC */ + YYSYMBOL_DROP = 86, /* DROP */ + YYSYMBOL_ELSE = 87, /* ELSE */ + YYSYMBOL_FILE = 88, /* FILE */ + YYSYMBOL_FROM = 89, /* FROM */ + YYSYMBOL_FULL = 90, /* FULL */ + YYSYMBOL_HASH = 91, /* HASH */ + YYSYMBOL_HINT = 92, /* HINT */ + YYSYMBOL_INTO = 93, /* INTO */ + YYSYMBOL_JOIN = 94, /* JOIN */ + YYSYMBOL_LEFT = 95, /* LEFT */ + YYSYMBOL_LIKE = 96, /* LIKE */ + YYSYMBOL_LOAD = 97, /* LOAD */ + YYSYMBOL_LONG = 98, /* LONG */ + YYSYMBOL_NULL = 99, /* NULL */ + YYSYMBOL_PLAN = 100, /* PLAN */ + YYSYMBOL_SHOW = 101, /* SHOW */ + YYSYMBOL_TEXT = 102, /* TEXT */ + YYSYMBOL_THEN = 103, /* THEN */ + YYSYMBOL_TIME = 104, /* TIME */ + YYSYMBOL_VIEW = 105, /* VIEW */ + YYSYMBOL_WHEN = 106, /* WHEN */ + YYSYMBOL_WITH = 107, /* WITH */ + YYSYMBOL_ADD = 108, /* ADD */ + YYSYMBOL_ALL = 109, /* ALL */ + YYSYMBOL_AND = 110, /* AND */ + YYSYMBOL_ASC = 111, /* ASC */ + YYSYMBOL_END = 112, /* END */ + YYSYMBOL_FOR = 113, /* FOR */ + YYSYMBOL_INT = 114, /* INT */ + YYSYMBOL_KEY = 115, /* KEY */ + YYSYMBOL_NOT = 116, /* NOT */ + YYSYMBOL_OFF = 117, /* OFF */ + YYSYMBOL_SET = 118, /* SET */ + YYSYMBOL_TOP = 119, /* TOP */ + YYSYMBOL_AS = 120, /* AS */ + YYSYMBOL_BY = 121, /* BY */ + YYSYMBOL_IF = 122, /* IF */ + YYSYMBOL_IN = 123, /* IN */ + YYSYMBOL_IS = 124, /* IS */ + YYSYMBOL_OF = 125, /* OF */ + YYSYMBOL_ON = 126, /* ON */ + YYSYMBOL_OR = 127, /* OR */ + YYSYMBOL_TO = 128, /* TO */ + YYSYMBOL_ARRAY = 129, /* ARRAY */ + YYSYMBOL_CONCAT = 130, /* CONCAT */ + YYSYMBOL_ILIKE = 131, /* ILIKE */ + YYSYMBOL_SECOND = 132, /* SECOND */ + YYSYMBOL_MINUTE = 133, /* MINUTE */ + YYSYMBOL_HOUR = 134, /* HOUR */ + YYSYMBOL_DAY = 135, /* DAY */ + YYSYMBOL_MONTH = 136, /* MONTH */ + YYSYMBOL_YEAR = 137, /* YEAR */ + YYSYMBOL_TRUE = 138, /* TRUE */ + YYSYMBOL_FALSE = 139, /* FALSE */ + YYSYMBOL_TRANSACTION = 140, /* TRANSACTION */ + YYSYMBOL_BEGIN = 141, /* BEGIN */ + YYSYMBOL_COMMIT = 142, /* COMMIT */ + YYSYMBOL_ROLLBACK = 143, /* ROLLBACK */ + YYSYMBOL_144_ = 144, /* '=' */ + YYSYMBOL_EQUALS = 145, /* EQUALS */ + YYSYMBOL_NOTEQUALS = 146, /* NOTEQUALS */ + YYSYMBOL_147_ = 147, /* '<' */ + YYSYMBOL_148_ = 148, /* '>' */ + YYSYMBOL_LESS = 149, /* LESS */ + YYSYMBOL_GREATER = 150, /* GREATER */ + YYSYMBOL_LESSEQ = 151, /* LESSEQ */ + YYSYMBOL_GREATEREQ = 152, /* GREATEREQ */ + YYSYMBOL_NOTNULL = 153, /* NOTNULL */ + YYSYMBOL_154_ = 154, /* '+' */ + YYSYMBOL_155_ = 155, /* '-' */ + YYSYMBOL_156_ = 156, /* '*' */ + YYSYMBOL_157_ = 157, /* '/' */ + YYSYMBOL_158_ = 158, /* '%' */ + YYSYMBOL_159_ = 159, /* '^' */ + YYSYMBOL_UMINUS = 160, /* UMINUS */ + YYSYMBOL_161_ = 161, /* '[' */ + YYSYMBOL_162_ = 162, /* ']' */ + YYSYMBOL_163_ = 163, /* '(' */ + YYSYMBOL_164_ = 164, /* ')' */ + YYSYMBOL_165_ = 165, /* '.' */ + YYSYMBOL_166_ = 166, /* ';' */ + YYSYMBOL_167_ = 167, /* ',' */ + YYSYMBOL_168_ = 168, /* '?' */ + YYSYMBOL_YYACCEPT = 169, /* $accept */ + YYSYMBOL_input = 170, /* input */ + YYSYMBOL_statement_list = 171, /* statement_list */ + YYSYMBOL_statement = 172, /* statement */ + YYSYMBOL_preparable_statement = 173, /* preparable_statement */ + YYSYMBOL_opt_hints = 174, /* opt_hints */ + YYSYMBOL_hint_list = 175, /* hint_list */ + YYSYMBOL_hint = 176, /* hint */ + YYSYMBOL_transaction_statement = 177, /* transaction_statement */ + YYSYMBOL_opt_transaction_keyword = 178, /* opt_transaction_keyword */ + YYSYMBOL_prepare_statement = 179, /* prepare_statement */ + YYSYMBOL_prepare_target_query = 180, /* prepare_target_query */ + YYSYMBOL_execute_statement = 181, /* execute_statement */ + YYSYMBOL_import_statement = 182, /* import_statement */ + YYSYMBOL_file_type = 183, /* file_type */ + YYSYMBOL_file_path = 184, /* file_path */ + YYSYMBOL_opt_file_type = 185, /* opt_file_type */ + YYSYMBOL_export_statement = 186, /* export_statement */ + YYSYMBOL_show_statement = 187, /* show_statement */ + YYSYMBOL_create_statement = 188, /* create_statement */ + YYSYMBOL_opt_not_exists = 189, /* opt_not_exists */ + YYSYMBOL_column_def_commalist = 190, /* column_def_commalist */ + YYSYMBOL_column_def = 191, /* column_def */ + YYSYMBOL_column_type = 192, /* column_type */ + YYSYMBOL_opt_column_nullable = 193, /* opt_column_nullable */ + YYSYMBOL_drop_statement = 194, /* drop_statement */ + YYSYMBOL_opt_exists = 195, /* opt_exists */ + YYSYMBOL_delete_statement = 196, /* delete_statement */ + YYSYMBOL_truncate_statement = 197, /* truncate_statement */ + YYSYMBOL_insert_statement = 198, /* insert_statement */ + YYSYMBOL_opt_column_list = 199, /* opt_column_list */ + YYSYMBOL_update_statement = 200, /* update_statement */ + YYSYMBOL_update_clause_commalist = 201, /* update_clause_commalist */ + YYSYMBOL_update_clause = 202, /* update_clause */ + YYSYMBOL_select_statement = 203, /* select_statement */ + YYSYMBOL_select_within_set_operation = 204, /* select_within_set_operation */ + YYSYMBOL_select_within_set_operation_no_parentheses = 205, /* select_within_set_operation_no_parentheses */ + YYSYMBOL_select_with_paren = 206, /* select_with_paren */ + YYSYMBOL_select_no_paren = 207, /* select_no_paren */ + YYSYMBOL_set_operator = 208, /* set_operator */ + YYSYMBOL_set_type = 209, /* set_type */ + YYSYMBOL_opt_all = 210, /* opt_all */ + YYSYMBOL_select_clause = 211, /* select_clause */ + YYSYMBOL_opt_distinct = 212, /* opt_distinct */ + YYSYMBOL_select_list = 213, /* select_list */ + YYSYMBOL_opt_from_clause = 214, /* opt_from_clause */ + YYSYMBOL_from_clause = 215, /* from_clause */ + YYSYMBOL_opt_where = 216, /* opt_where */ + YYSYMBOL_opt_group = 217, /* opt_group */ + YYSYMBOL_opt_having = 218, /* opt_having */ + YYSYMBOL_opt_order = 219, /* opt_order */ + YYSYMBOL_order_list = 220, /* order_list */ + YYSYMBOL_order_desc = 221, /* order_desc */ + YYSYMBOL_opt_order_type = 222, /* opt_order_type */ + YYSYMBOL_opt_top = 223, /* opt_top */ + YYSYMBOL_opt_limit = 224, /* opt_limit */ + YYSYMBOL_expr_list = 225, /* expr_list */ + YYSYMBOL_opt_literal_list = 226, /* opt_literal_list */ + YYSYMBOL_literal_list = 227, /* literal_list */ + YYSYMBOL_expr_alias = 228, /* expr_alias */ + YYSYMBOL_expr = 229, /* expr */ + YYSYMBOL_operand = 230, /* operand */ + YYSYMBOL_scalar_expr = 231, /* scalar_expr */ + YYSYMBOL_unary_expr = 232, /* unary_expr */ + YYSYMBOL_binary_expr = 233, /* binary_expr */ + YYSYMBOL_logic_expr = 234, /* logic_expr */ + YYSYMBOL_in_expr = 235, /* in_expr */ + YYSYMBOL_case_expr = 236, /* case_expr */ + YYSYMBOL_case_list = 237, /* case_list */ + YYSYMBOL_exists_expr = 238, /* exists_expr */ + YYSYMBOL_comp_expr = 239, /* comp_expr */ + YYSYMBOL_function_expr = 240, /* function_expr */ + YYSYMBOL_extract_expr = 241, /* extract_expr */ + YYSYMBOL_cast_expr = 242, /* cast_expr */ + YYSYMBOL_datetime_field = 243, /* datetime_field */ + YYSYMBOL_array_expr = 244, /* array_expr */ + YYSYMBOL_array_index = 245, /* array_index */ + YYSYMBOL_between_expr = 246, /* between_expr */ + YYSYMBOL_column_name = 247, /* column_name */ + YYSYMBOL_literal = 248, /* literal */ + YYSYMBOL_string_literal = 249, /* string_literal */ + YYSYMBOL_bool_literal = 250, /* bool_literal */ + YYSYMBOL_num_literal = 251, /* num_literal */ + YYSYMBOL_int_literal = 252, /* int_literal */ + YYSYMBOL_null_literal = 253, /* null_literal */ + YYSYMBOL_param_expr = 254, /* param_expr */ + YYSYMBOL_table_ref = 255, /* table_ref */ + YYSYMBOL_table_ref_atomic = 256, /* table_ref_atomic */ + YYSYMBOL_nonjoin_table_ref_atomic = 257, /* nonjoin_table_ref_atomic */ + YYSYMBOL_table_ref_commalist = 258, /* table_ref_commalist */ + YYSYMBOL_table_ref_name = 259, /* table_ref_name */ + YYSYMBOL_table_ref_name_no_alias = 260, /* table_ref_name_no_alias */ + YYSYMBOL_table_name = 261, /* table_name */ + YYSYMBOL_table_alias = 262, /* table_alias */ + YYSYMBOL_opt_table_alias = 263, /* opt_table_alias */ + YYSYMBOL_alias = 264, /* alias */ + YYSYMBOL_opt_alias = 265, /* opt_alias */ + YYSYMBOL_opt_with_clause = 266, /* opt_with_clause */ + YYSYMBOL_with_clause = 267, /* with_clause */ + YYSYMBOL_with_description_list = 268, /* with_description_list */ + YYSYMBOL_with_description = 269, /* with_description */ + YYSYMBOL_join_clause = 270, /* join_clause */ + YYSYMBOL_opt_join_type = 271, /* opt_join_type */ + YYSYMBOL_join_condition = 272, /* join_condition */ + YYSYMBOL_opt_semicolon = 273, /* opt_semicolon */ + YYSYMBOL_ident_commalist = 274 /* ident_commalist */ +}; +typedef enum yysymbol_kind_t yysymbol_kind_t; + @@ -412,36 +702,83 @@ int hsql_parse (hsql::SQLParserResult* result, yyscan_t scanner); # undef short #endif -#ifdef YYTYPE_UINT8 -typedef YYTYPE_UINT8 yytype_uint8; -#else -typedef unsigned char yytype_uint8; +/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure + and (if available) are included + so that the code can choose integer types of a good width. */ + +#ifndef __PTRDIFF_MAX__ +# include /* INFRINGES ON USER NAME SPACE */ +# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_STDINT_H +# endif #endif -#ifdef YYTYPE_INT8 -typedef YYTYPE_INT8 yytype_int8; +/* Narrow types that promote to a signed type and that can represent a + signed or unsigned integer of at least N bits. In tables they can + save space and decrease cache pressure. Promoting to a signed type + helps avoid bugs in integer arithmetic. */ + +#ifdef __INT_LEAST8_MAX__ +typedef __INT_LEAST8_TYPE__ yytype_int8; +#elif defined YY_STDINT_H +typedef int_least8_t yytype_int8; #else typedef signed char yytype_int8; #endif -#ifdef YYTYPE_UINT16 -typedef YYTYPE_UINT16 yytype_uint16; -#else -typedef unsigned short yytype_uint16; -#endif - -#ifdef YYTYPE_INT16 -typedef YYTYPE_INT16 yytype_int16; +#ifdef __INT_LEAST16_MAX__ +typedef __INT_LEAST16_TYPE__ yytype_int16; +#elif defined YY_STDINT_H +typedef int_least16_t yytype_int16; #else typedef short yytype_int16; #endif +#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST8_TYPE__ yytype_uint8; +#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST8_MAX <= INT_MAX) +typedef uint_least8_t yytype_uint8; +#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX +typedef unsigned char yytype_uint8; +#else +typedef short yytype_uint8; +#endif + +#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST16_TYPE__ yytype_uint16; +#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST16_MAX <= INT_MAX) +typedef uint_least16_t yytype_uint16; +#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX +typedef unsigned short yytype_uint16; +#else +typedef int yytype_uint16; +#endif + +#ifndef YYPTRDIFF_T +# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__ +# define YYPTRDIFF_T __PTRDIFF_TYPE__ +# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__ +# elif defined PTRDIFF_MAX +# ifndef ptrdiff_t +# include /* INFRINGES ON USER NAME SPACE */ +# endif +# define YYPTRDIFF_T ptrdiff_t +# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX +# else +# define YYPTRDIFF_T long +# define YYPTRDIFF_MAXIMUM LONG_MAX +# endif +#endif + #ifndef YYSIZE_T # ifdef __SIZE_TYPE__ # define YYSIZE_T __SIZE_TYPE__ # elif defined size_t # define YYSIZE_T size_t -# elif ! defined YYSIZE_T +# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # else @@ -449,7 +786,20 @@ typedef short yytype_int16; # endif #endif -#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) +#define YYSIZE_MAXIMUM \ + YY_CAST (YYPTRDIFF_T, \ + (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ + ? YYPTRDIFF_MAXIMUM \ + : YY_CAST (YYSIZE_T, -1))) + +#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) + + +/* Stored state numbers (used for stacks). */ +typedef yytype_int16 yy_state_t; + +/* State numbers in computations. */ +typedef int yy_state_fast_t; #ifndef YY_ # if defined YYENABLE_NLS && YYENABLE_NLS @@ -463,22 +813,21 @@ typedef short yytype_int16; # endif #endif -#ifndef YY_ATTRIBUTE -# if (defined __GNUC__ \ - && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ - || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C -# define YY_ATTRIBUTE(Spec) __attribute__(Spec) + +#ifndef YY_ATTRIBUTE_PURE +# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) # else -# define YY_ATTRIBUTE(Spec) /* empty */ +# define YY_ATTRIBUTE_PURE # endif #endif -#ifndef YY_ATTRIBUTE_PURE -# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) -#endif - #ifndef YY_ATTRIBUTE_UNUSED -# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) +# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) +# else +# define YY_ATTRIBUTE_UNUSED +# endif #endif /* Suppress unused-variable warnings by "using" E. */ @@ -490,11 +839,11 @@ typedef short yytype_int16; #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ /* Suppress an incorrect diagnostic about yylval being uninitialized. */ -# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ - _Pragma ("GCC diagnostic push") \ - _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") -# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ +# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ _Pragma ("GCC diagnostic pop") #else # define YY_INITIAL_VALUE(Value) Value @@ -507,10 +856,22 @@ typedef short yytype_int16; # define YY_INITIAL_VALUE(Value) /* Nothing. */ #endif +#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ +# define YY_IGNORE_USELESS_CAST_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") +# define YY_IGNORE_USELESS_CAST_END \ + _Pragma ("GCC diagnostic pop") +#endif +#ifndef YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_END +#endif + #define YY_ASSERT(E) ((void) (0 && (E))) -#if ! defined yyoverflow || YYERROR_VERBOSE +#if 1 /* The parser invokes alloca or malloc; define the necessary symbols. */ @@ -575,8 +936,7 @@ void free (void *); /* INFRINGES ON USER NAME SPACE */ # endif # endif # endif -#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ - +#endif /* 1 */ #if (! defined yyoverflow \ && (! defined __cplusplus \ @@ -586,18 +946,19 @@ void free (void *); /* INFRINGES ON USER NAME SPACE */ /* A type that is properly aligned for any stack member. */ union yyalloc { - yytype_int16 yyss_alloc; + yy_state_t yyss_alloc; YYSTYPE yyvs_alloc; YYLTYPE yyls_alloc; }; /* The size of the maximum gap between one aligned stack and the next. */ -# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) +# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) /* The size of an array large to enough to hold all stacks, each with N elements. */ # define YYSTACK_BYTES(N) \ - ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ + ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \ + + YYSIZEOF (YYLTYPE)) \ + 2 * YYSTACK_GAP_MAXIMUM) # define YYCOPY_NEEDED 1 @@ -610,11 +971,11 @@ union yyalloc # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ do \ { \ - YYSIZE_T yynewbytes; \ + YYPTRDIFF_T yynewbytes; \ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ Stack = &yyptr->Stack_alloc; \ - yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ - yyptr += yynewbytes / sizeof (*yyptr); \ + yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / YYSIZEOF (*yyptr); \ } \ while (0) @@ -626,12 +987,12 @@ union yyalloc # ifndef YYCOPY # if defined __GNUC__ && 1 < __GNUC__ # define YYCOPY(Dst, Src, Count) \ - __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) + __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) # else # define YYCOPY(Dst, Src, Count) \ do \ { \ - YYSIZE_T yyi; \ + YYPTRDIFF_T yyi; \ for (yyi = 0; yyi < (Count); yyi++) \ (Dst)[yyi] = (Src)[yyi]; \ } \ @@ -643,24 +1004,26 @@ union yyalloc /* YYFINAL -- State number of the termination state. */ #define YYFINAL 62 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 725 +#define YYLAST 783 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 167 +#define YYNTOKENS 169 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 105 +#define YYNNTS 106 /* YYNRULES -- Number of rules. */ -#define YYNRULES 258 +#define YYNRULES 261 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 465 +#define YYNSTATES 473 + +#define YYMAXUTOK 406 -#define YYUNDEFTOK 2 -#define YYMAXUTOK 404 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM as returned by yylex, with out-of-bounds checking. */ -#define YYTRANSLATE(YYX) \ - ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) +#define YYTRANSLATE(YYX) \ + (0 <= (YYX) && (YYX) <= YYMAXUTOK \ + ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ + : YYSYMBOL_YYUNDEF) /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM as returned by yylex. */ @@ -669,13 +1032,13 @@ static const yytype_uint8 yytranslate[] = 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 156, 2, 2, - 161, 162, 154, 152, 165, 153, 163, 155, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 164, - 145, 142, 146, 166, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 158, 2, 2, + 163, 164, 156, 154, 167, 155, 165, 157, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 166, + 147, 144, 148, 168, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 159, 2, 160, 157, 2, 2, 2, 2, 2, + 2, 161, 2, 162, 159, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -705,13 +1068,13 @@ static const yytype_uint8 yytranslate[] = 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 143, 144, 147, - 148, 149, 150, 151, 158 + 135, 136, 137, 138, 139, 140, 141, 142, 143, 145, + 146, 149, 150, 151, 152, 153, 160 }; #if HSQL_DEBUG /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ -static const yytype_uint16 yyrline[] = +static const yytype_int16 yyrline[] = { 0, 269, 269, 290, 296, 305, 309, 313, 316, 319, 326, 327, 328, 329, 330, 331, 332, 333, 334, 343, @@ -719,57 +1082,65 @@ static const yytype_uint16 yyrline[] = 390, 397, 400, 404, 418, 424, 433, 450, 454, 457, 466, 480, 483, 488, 502, 515, 522, 529, 540, 541, 545, 546, 550, 556, 557, 558, 559, 560, 561, 562, - 563, 567, 568, 569, 579, 585, 591, 599, 600, 609, - 618, 631, 638, 649, 650, 660, 669, 670, 674, 686, - 690, 694, 708, 709, 712, 713, 724, 725, 729, 739, - 752, 759, 763, 767, 774, 777, 783, 795, 796, 800, - 804, 805, 809, 814, 815, 819, 824, 828, 829, 833, - 834, 838, 839, 843, 847, 848, 849, 855, 856, 860, - 861, 862, 863, 864, 865, 872, 873, 877, 878, 882, - 883, 887, 897, 898, 899, 900, 901, 905, 906, 907, - 908, 909, 910, 911, 912, 913, 914, 918, 919, 923, - 924, 925, 926, 927, 931, 932, 933, 934, 935, 936, - 937, 938, 939, 940, 941, 945, 946, 950, 951, 952, - 953, 959, 960, 961, 962, 966, 967, 971, 972, 976, - 977, 978, 979, 980, 981, 982, 986, 987, 991, 995, - 996, 997, 998, 999, 1000, 1004, 1008, 1012, 1016, 1017, - 1018, 1019, 1023, 1024, 1025, 1026, 1027, 1031, 1035, 1036, - 1040, 1041, 1045, 1049, 1053, 1065, 1066, 1076, 1077, 1081, - 1082, 1091, 1092, 1097, 1108, 1117, 1118, 1123, 1124, 1129, - 1130, 1135, 1136, 1141, 1142, 1151, 1152, 1156, 1160, 1164, - 1171, 1184, 1192, 1202, 1221, 1222, 1223, 1224, 1225, 1226, - 1227, 1228, 1229, 1230, 1235, 1244, 1245, 1250, 1251 + 563, 564, 568, 569, 570, 580, 586, 592, 600, 601, + 610, 619, 632, 639, 650, 651, 661, 670, 671, 675, + 687, 691, 695, 709, 710, 713, 714, 725, 726, 730, + 740, 753, 760, 764, 768, 775, 778, 784, 796, 797, + 801, 805, 806, 810, 815, 816, 820, 825, 829, 830, + 834, 835, 839, 840, 844, 848, 849, 850, 856, 857, + 861, 862, 863, 864, 865, 866, 873, 874, 878, 879, + 883, 884, 888, 898, 899, 900, 901, 902, 906, 907, + 908, 909, 910, 911, 912, 913, 914, 915, 916, 920, + 921, 925, 926, 927, 928, 929, 933, 934, 935, 936, + 937, 938, 939, 940, 941, 942, 943, 947, 948, 952, + 953, 954, 955, 961, 962, 963, 964, 968, 969, 973, + 974, 978, 979, 980, 981, 982, 983, 984, 988, 989, + 993, 997, 1001, 1002, 1003, 1004, 1005, 1006, 1010, 1014, + 1018, 1022, 1023, 1024, 1025, 1029, 1030, 1031, 1032, 1033, + 1037, 1041, 1042, 1046, 1047, 1051, 1055, 1059, 1071, 1072, + 1082, 1083, 1087, 1088, 1097, 1098, 1103, 1114, 1123, 1124, + 1129, 1130, 1135, 1136, 1141, 1142, 1147, 1148, 1157, 1158, + 1162, 1166, 1170, 1177, 1190, 1198, 1208, 1227, 1228, 1229, + 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1241, 1250, 1251, + 1256, 1257 }; #endif -#if HSQL_DEBUG || YYERROR_VERBOSE || 1 +/** Accessing symbol of state STATE. */ +#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) + +#if 1 +/* The user-facing name of the symbol whose (internal) number is + YYSYMBOL. No bounds checking. */ +static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; + /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. First, the terminals, then, starting at YYNTOKENS, nonterminals. */ static const char *const yytname[] = { - "$end", "error", "$undefined", "IDENTIFIER", "STRING", "FLOATVAL", - "INTVAL", "DEALLOCATE", "PARAMETERS", "INTERSECT", "TEMPORARY", - "TIMESTAMP", "DISTINCT", "NVARCHAR", "RESTRICT", "TRUNCATE", "ANALYZE", - "BETWEEN", "CASCADE", "COLUMNS", "CONTROL", "DEFAULT", "EXECUTE", - "EXPLAIN", "INTEGER", "NATURAL", "PREPARE", "PRIMARY", "SCHEMAS", - "SPATIAL", "VARCHAR", "VIRTUAL", "DESCRIBE", "BEFORE", "COLUMN", - "CREATE", "DELETE", "DIRECT", "DOUBLE", "ESCAPE", "EXCEPT", "EXISTS", - "EXTRACT", "FORMAT", "GLOBAL", "HAVING", "IMPORT", "INSERT", "ISNULL", - "OFFSET", "RENAME", "SCHEMA", "SELECT", "SORTED", "TABLES", "UNIQUE", - "UNLOAD", "UPDATE", "VALUES", "AFTER", "ALTER", "CROSS", "DELTA", - "FLOAT", "GROUP", "INDEX", "INNER", "LIMIT", "LOCAL", "MERGE", "MINUS", - "ORDER", "OUTER", "RIGHT", "TABLE", "UNION", "USING", "WHERE", "CALL", - "CASE", "CHAR", "COPY", "DATE", "DESC", "DROP", "ELSE", "FILE", "FROM", - "FULL", "HASH", "HINT", "INTO", "JOIN", "LEFT", "LIKE", "LOAD", "LONG", - "NULL", "PLAN", "SHOW", "TEXT", "THEN", "TIME", "VIEW", "WHEN", "WITH", - "ADD", "ALL", "AND", "ASC", "END", "FOR", "INT", "KEY", "NOT", "OFF", - "SET", "TOP", "AS", "BY", "IF", "IN", "IS", "OF", "ON", "OR", "TO", - "ARRAY", "CONCAT", "ILIKE", "SECOND", "MINUTE", "HOUR", "DAY", "MONTH", - "YEAR", "TRUE", "FALSE", "TRANSACTION", "BEGIN", "COMMIT", "ROLLBACK", - "'='", "EQUALS", "NOTEQUALS", "'<'", "'>'", "LESS", "GREATER", "LESSEQ", - "GREATEREQ", "NOTNULL", "'+'", "'-'", "'*'", "'/'", "'%'", "'^'", - "UMINUS", "'['", "']'", "'('", "')'", "'.'", "';'", "','", "'?'", - "$accept", "input", "statement_list", "statement", + "\"end of file\"", "error", "\"invalid token\"", "IDENTIFIER", "STRING", + "FLOATVAL", "INTVAL", "DEALLOCATE", "PARAMETERS", "INTERSECT", + "TEMPORARY", "TIMESTAMP", "DISTINCT", "NVARCHAR", "RESTRICT", "TRUNCATE", + "ANALYZE", "BETWEEN", "CASCADE", "COLUMNS", "CONTROL", "DEFAULT", + "EXECUTE", "EXPLAIN", "INTEGER", "NATURAL", "PREPARE", "PRIMARY", + "SCHEMAS", "SPATIAL", "VARCHAR", "VIRTUAL", "DESCRIBE", "BEFORE", + "COLUMN", "CREATE", "DELETE", "DIRECT", "DOUBLE", "ESCAPE", "EXCEPT", + "EXISTS", "EXTRACT", "CAST", "FORMAT", "GLOBAL", "HAVING", "IMPORT", + "INSERT", "ISNULL", "OFFSET", "RENAME", "SCHEMA", "SELECT", "SORTED", + "TABLES", "UNIQUE", "UNLOAD", "UPDATE", "VALUES", "AFTER", "ALTER", + "CROSS", "DELTA", "FLOAT", "GROUP", "INDEX", "INNER", "LIMIT", "LOCAL", + "MERGE", "MINUS", "ORDER", "OUTER", "RIGHT", "TABLE", "UNION", "USING", + "WHERE", "CALL", "CASE", "CHAR", "COPY", "DATE", "DATETIME", "DESC", + "DROP", "ELSE", "FILE", "FROM", "FULL", "HASH", "HINT", "INTO", "JOIN", + "LEFT", "LIKE", "LOAD", "LONG", "NULL", "PLAN", "SHOW", "TEXT", "THEN", + "TIME", "VIEW", "WHEN", "WITH", "ADD", "ALL", "AND", "ASC", "END", "FOR", + "INT", "KEY", "NOT", "OFF", "SET", "TOP", "AS", "BY", "IF", "IN", "IS", + "OF", "ON", "OR", "TO", "ARRAY", "CONCAT", "ILIKE", "SECOND", "MINUTE", + "HOUR", "DAY", "MONTH", "YEAR", "TRUE", "FALSE", "TRANSACTION", "BEGIN", + "COMMIT", "ROLLBACK", "'='", "EQUALS", "NOTEQUALS", "'<'", "'>'", "LESS", + "GREATER", "LESSEQ", "GREATEREQ", "NOTNULL", "'+'", "'-'", "'*'", "'/'", + "'%'", "'^'", "UMINUS", "'['", "']'", "'('", "')'", "'.'", "';'", "','", + "'?'", "$accept", "input", "statement_list", "statement", "preparable_statement", "opt_hints", "hint_list", "hint", "transaction_statement", "opt_transaction_keyword", "prepare_statement", "prepare_target_query", "execute_statement", "import_statement", @@ -788,8 +1159,8 @@ static const char *const yytname[] = "expr_list", "opt_literal_list", "literal_list", "expr_alias", "expr", "operand", "scalar_expr", "unary_expr", "binary_expr", "logic_expr", "in_expr", "case_expr", "case_list", "exists_expr", "comp_expr", - "function_expr", "extract_expr", "datetime_field", "array_expr", - "array_index", "between_expr", "column_name", "literal", + "function_expr", "extract_expr", "cast_expr", "datetime_field", + "array_expr", "array_index", "between_expr", "column_name", "literal", "string_literal", "bool_literal", "num_literal", "int_literal", "null_literal", "param_expr", "table_ref", "table_ref_atomic", "nonjoin_table_ref_atomic", "table_ref_commalist", "table_ref_name", @@ -799,12 +1170,18 @@ static const char *const yytname[] = "join_clause", "opt_join_type", "join_condition", "opt_semicolon", "ident_commalist", YY_NULLPTR }; + +static const char * +yysymbol_name (yysymbol_kind_t yysymbol) +{ + return yytname[yysymbol]; +} #endif -# ifdef YYPRINT +#ifdef YYPRINT /* YYTOKNUM[NUM] -- (External) token number corresponding to the (internal) symbol number NUM (which must be that of a token). */ -static const yytype_uint16 yytoknum[] = +static const yytype_int16 yytoknum[] = { 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, @@ -820,159 +1197,161 @@ static const yytype_uint16 yytoknum[] = 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 61, 397, 398, 60, 62, 399, 400, 401, - 402, 403, 43, 45, 42, 47, 37, 94, 404, 91, - 93, 40, 41, 46, 59, 44, 63 + 395, 396, 397, 398, 61, 399, 400, 60, 62, 401, + 402, 403, 404, 405, 43, 45, 42, 47, 37, 94, + 406, 91, 93, 40, 41, 46, 59, 44, 63 }; -# endif +#endif -#define YYPACT_NINF -369 +#define YYPACT_NINF (-287) -#define yypact_value_is_default(Yystate) \ - (!!((Yystate) == (-369))) +#define yypact_value_is_default(Yyn) \ + ((Yyn) == YYPACT_NINF) -#define YYTABLE_NINF -256 +#define YYTABLE_NINF (-259) -#define yytable_value_is_error(Yytable_value) \ - (!!((Yytable_value) == (-256))) +#define yytable_value_is_error(Yyn) \ + ((Yyn) == YYTABLE_NINF) /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ static const yytype_int16 yypact[] = { - 482, 23, 79, 159, 178, 79, -39, 69, 95, 112, - 79, 79, -17, 26, 180, 81, 81, 81, 231, 73, - -369, 147, -369, 147, -369, -369, -369, -369, -369, -369, - -369, -369, -369, -369, -369, -23, -369, 247, 94, -369, - 100, 191, -369, 164, 164, 79, 286, 79, 184, -369, - -21, 176, 176, 79, -369, 189, 144, -369, -369, -369, - -369, -369, -369, 477, -369, 220, -369, -369, 203, -23, - 44, -369, 113, -369, 319, 10, 321, 209, 79, 79, - 251, -369, 243, 171, 330, 331, 331, 293, 79, 79, - -369, 177, 180, -369, 181, 333, 325, 182, 183, -369, - -369, -369, -23, 239, 232, -23, -9, -369, -369, -369, - -369, -369, -369, -369, -369, 199, 188, -369, -369, -369, - -369, -369, -369, -369, -369, -369, 315, -48, 171, 271, - -369, 331, 359, 2, 223, -44, -369, 261, -369, 261, - -369, -369, -369, -369, -369, 366, -369, -369, 271, -369, - -369, 300, -369, -369, 44, -369, -369, 271, 300, 271, - 126, -369, -369, 10, -369, 367, 267, 370, 259, -89, - 219, 221, 145, 299, 227, 222, -369, 194, 96, 326, - -369, -369, -369, -369, -369, -369, -369, -369, -369, -369, - -369, -369, -369, -369, -369, 290, -369, 76, 226, -369, - 271, 330, -369, 346, -369, -369, 230, 105, -369, 305, - 228, -369, 17, -9, -23, 229, -369, -46, -9, 96, - 348, 1, -369, 313, -369, 492, 106, -369, 267, 11, - 16, 351, 468, 271, 140, -49, 244, 222, 530, 271, - 52, 238, -52, 271, 271, 222, -369, 222, -56, 245, - -55, 222, 222, 222, 222, 222, 222, 222, 222, 222, - 222, 222, 222, 222, 222, 222, 333, 79, -369, 401, - 10, 96, -369, 286, 10, -369, 366, 14, 251, -369, - 271, -369, 406, -369, -369, -369, -369, 271, -369, -369, - -369, -369, 271, 271, 331, -369, 249, -369, -369, 250, - -369, -369, -369, 137, -369, 370, -369, -369, 271, -369, - -369, 252, -369, -369, -369, -369, -369, -369, 332, 53, - 92, 271, 271, -369, 351, 318, -5, -369, -369, -369, - 308, 483, 566, 222, 257, 194, -369, 334, 264, 566, - 566, 566, 566, 397, 397, 397, 397, 52, 52, 61, - 61, 61, 0, 268, -369, -369, 121, -369, 123, -369, - 267, -369, 51, -369, 262, -369, 19, -369, 365, -369, - -369, -369, 96, 96, -369, 424, 427, -369, 337, -369, - -369, 128, -369, 271, 271, 271, -369, 122, 114, 276, - -369, 222, 566, 194, 277, 132, -369, -369, -369, -369, - 279, 350, -369, -369, -369, 371, 372, 374, 357, 14, - 447, -369, -369, -369, 338, -369, 289, 294, -369, -369, - 32, 96, 135, -369, 271, -369, 530, 296, 152, -369, - -369, 19, 14, -369, -369, -369, 14, 329, 298, 271, - -369, -369, -369, -369, 96, -369, -369, -369, -369, 291, - 359, -20, 301, 271, 153, 271, -369, 18, 96, -369, - -369, 96, 303, 302, -369 + 510, -2, 32, 56, 120, 32, -14, 36, 71, 130, + 32, 32, 3, 45, 200, 95, 95, 95, 257, 92, + -287, 163, -287, 163, -287, -287, -287, -287, -287, -287, + -287, -287, -287, -287, -287, 2, -287, 277, 134, -287, + 151, 228, -287, 196, 196, 32, 316, 32, 205, -287, + -66, 202, 202, 32, -287, 206, 166, -287, -287, -287, + -287, -287, -287, 505, -287, 244, -287, -287, 218, 2, + 20, -287, 23, -287, 336, 10, 337, 224, 32, 32, + 266, -287, 259, 182, 345, 347, 347, 311, 32, 32, + -287, 190, 200, -287, 191, 350, 346, 193, 197, -287, + -287, -287, 2, 251, 241, 2, 113, -287, -287, -287, + -287, -287, -287, -287, -287, 208, 207, -287, -287, -287, + -287, -287, -287, -287, -287, -287, 332, -62, 182, 247, + -287, 347, 372, -16, 233, -57, -287, 272, -287, 272, + -287, -287, -287, -287, -287, 377, -287, -287, 247, -287, + -287, 312, -287, -287, 20, -287, -287, 247, 312, 247, + 78, -287, -287, 10, -287, 380, 280, 387, 271, 150, + 229, 230, 234, 148, 279, 235, 325, -287, 226, -12, + 352, -287, -287, -287, -287, -287, -287, -287, -287, -287, + -287, -287, -287, -287, -287, -287, -287, 305, -287, 51, + 236, -287, 247, 345, -287, 356, -287, -287, 243, 60, + -287, 315, 240, -287, 35, 113, 2, 242, -287, 110, + 113, -12, 361, -24, -287, 324, -287, 158, 81, -287, + 280, 8, 14, 360, 159, 247, 247, -34, 87, 253, + 325, 540, 247, -91, 250, -76, 247, 247, 325, -287, + 325, 77, 256, 12, 325, 325, 325, 325, 325, 325, + 325, 325, 325, 325, 325, 325, 325, 325, 325, 350, + 32, -287, 417, 10, -12, -287, 316, 10, -287, 377, + 16, 266, -287, 247, -287, 418, -287, -287, -287, -287, + 247, -287, -287, -287, -287, 247, 247, 347, -287, 260, + -287, -287, 263, -287, -287, -287, -287, 109, -287, 387, + -287, -287, 247, -287, -287, 258, -287, -287, -287, -287, + -287, -287, 338, 116, 65, 98, 247, 247, -287, 360, + 333, -40, -287, -287, -287, 318, 474, 559, 325, 268, + 226, -287, 334, 278, 559, 559, 559, 559, 424, 424, + 424, 424, -91, -91, -74, -74, -74, -59, 270, -287, + -287, 99, -287, 111, -287, 280, -287, 276, -287, 273, + -287, 30, -287, 373, -287, -287, -287, -12, -12, -287, + 438, 439, -287, 351, -287, -287, 133, -287, 247, 158, + 247, 247, -287, 74, 171, 282, -287, 325, 559, 226, + 285, 141, -287, -287, -287, -287, 287, 358, -287, -287, + -287, 382, 383, 386, 366, 16, 458, -287, -287, -287, + 341, -287, 301, 302, -287, -287, -70, 303, -12, 128, + -287, 247, -287, 540, 306, 143, -287, -287, 30, 16, + -287, -287, -287, 16, 363, 308, 247, -287, -287, -287, + -287, -287, -12, -287, -287, -287, -287, 657, 372, -21, + 309, 247, 145, 247, -287, 15, -12, -287, -287, -12, + 304, 310, -287 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. Performed when YYTABLE does not specify something else to do. Zero means the default is an error. */ -static const yytype_uint16 yydefact[] = +static const yytype_int16 yydefact[] = { - 236, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 29, 29, 29, 0, 256, + 239, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 29, 29, 29, 0, 259, 3, 20, 18, 20, 17, 8, 9, 7, 11, 16, - 13, 14, 12, 15, 10, 0, 235, 0, 225, 70, - 32, 0, 43, 49, 49, 0, 0, 0, 0, 224, - 0, 68, 68, 0, 41, 0, 237, 238, 28, 25, - 27, 26, 1, 236, 2, 0, 6, 5, 118, 0, - 79, 80, 110, 66, 0, 128, 0, 0, 0, 0, - 104, 36, 0, 74, 0, 0, 0, 0, 0, 0, - 42, 0, 0, 4, 0, 0, 98, 0, 0, 92, - 93, 91, 0, 95, 0, 0, 124, 226, 207, 210, - 212, 213, 208, 209, 214, 0, 127, 129, 202, 203, - 204, 211, 205, 206, 31, 30, 0, 0, 74, 0, - 69, 0, 0, 0, 0, 104, 76, 39, 37, 39, - 67, 64, 65, 240, 239, 0, 117, 97, 0, 87, - 86, 110, 83, 82, 84, 94, 90, 0, 110, 0, - 0, 88, 33, 0, 48, 0, 236, 0, 0, 198, - 0, 0, 0, 0, 0, 0, 200, 0, 103, 132, - 139, 140, 141, 134, 136, 142, 135, 154, 143, 144, - 145, 138, 133, 147, 148, 0, 257, 0, 0, 72, - 0, 0, 75, 0, 35, 40, 23, 0, 21, 101, - 99, 125, 234, 124, 0, 109, 111, 116, 124, 120, - 122, 119, 130, 0, 46, 0, 0, 50, 236, 98, - 0, 0, 0, 0, 0, 0, 0, 0, 150, 0, - 149, 0, 0, 0, 0, 0, 151, 0, 0, 0, + 13, 14, 12, 15, 10, 0, 238, 0, 228, 71, + 32, 0, 43, 49, 49, 0, 0, 0, 0, 227, + 0, 69, 69, 0, 41, 0, 240, 241, 28, 25, + 27, 26, 1, 239, 2, 0, 6, 5, 119, 0, + 80, 81, 111, 67, 0, 129, 0, 0, 0, 0, + 105, 36, 0, 75, 0, 0, 0, 0, 0, 0, + 42, 0, 0, 4, 0, 0, 99, 0, 0, 93, + 94, 92, 0, 96, 0, 0, 125, 229, 210, 213, + 215, 216, 211, 212, 217, 0, 128, 130, 205, 206, + 207, 214, 208, 209, 31, 30, 0, 0, 75, 0, + 70, 0, 0, 0, 0, 105, 77, 39, 37, 39, + 68, 65, 66, 243, 242, 0, 118, 98, 0, 88, + 87, 111, 84, 83, 85, 95, 91, 0, 111, 0, + 0, 89, 33, 0, 48, 0, 239, 0, 0, 201, + 0, 0, 0, 0, 0, 0, 0, 203, 0, 104, + 133, 140, 141, 142, 135, 137, 143, 136, 156, 144, + 145, 146, 147, 139, 134, 149, 150, 0, 260, 0, + 0, 73, 0, 0, 76, 0, 35, 40, 23, 0, + 21, 102, 100, 126, 237, 125, 0, 110, 112, 117, + 125, 121, 123, 120, 131, 0, 46, 0, 0, 50, + 239, 99, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 152, 0, 151, 0, 0, 0, 0, 0, 153, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 73, 0, - 0, 78, 77, 0, 0, 19, 0, 0, 104, 100, - 0, 232, 0, 233, 131, 81, 85, 0, 115, 114, - 113, 89, 0, 0, 0, 54, 0, 57, 56, 0, - 55, 60, 53, 63, 45, 0, 47, 186, 0, 199, - 201, 0, 189, 190, 191, 192, 193, 194, 0, 0, - 0, 0, 0, 173, 0, 0, 0, 146, 137, 165, - 166, 0, 161, 0, 0, 0, 152, 0, 164, 163, - 179, 180, 181, 182, 183, 184, 185, 156, 155, 158, - 157, 159, 160, 0, 34, 258, 0, 38, 0, 22, - 236, 102, 215, 217, 0, 219, 230, 218, 106, 126, - 231, 112, 123, 121, 44, 0, 0, 61, 0, 52, - 51, 0, 177, 0, 0, 0, 171, 0, 0, 0, - 195, 0, 162, 0, 0, 0, 153, 196, 71, 24, - 0, 0, 252, 244, 250, 248, 251, 246, 0, 0, - 0, 229, 223, 227, 0, 96, 0, 0, 62, 187, - 0, 175, 0, 174, 0, 178, 197, 0, 0, 169, - 167, 230, 0, 247, 249, 245, 0, 216, 231, 0, - 58, 59, 188, 172, 176, 170, 168, 220, 241, 253, - 0, 108, 0, 0, 0, 0, 105, 0, 254, 242, - 228, 107, 198, 0, 243 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 74, 0, 0, 79, 78, 0, 0, 19, 0, + 0, 105, 101, 0, 235, 0, 236, 132, 82, 86, + 0, 116, 115, 114, 90, 0, 0, 0, 54, 0, + 57, 56, 0, 61, 55, 60, 53, 64, 45, 0, + 47, 188, 0, 202, 204, 0, 192, 193, 194, 195, + 196, 197, 0, 0, 0, 0, 0, 0, 175, 0, + 0, 0, 148, 138, 167, 168, 0, 163, 0, 0, + 0, 154, 0, 166, 165, 181, 182, 183, 184, 185, + 186, 187, 158, 157, 160, 159, 161, 162, 0, 34, + 261, 0, 38, 0, 22, 239, 103, 218, 220, 0, + 222, 233, 221, 107, 127, 234, 113, 124, 122, 44, + 0, 0, 62, 0, 52, 51, 0, 179, 0, 0, + 0, 0, 173, 0, 0, 0, 198, 0, 164, 0, + 0, 0, 155, 199, 72, 24, 0, 0, 255, 247, + 253, 251, 254, 249, 0, 0, 0, 232, 226, 230, + 0, 97, 0, 0, 63, 189, 0, 0, 177, 0, + 176, 0, 180, 200, 0, 0, 171, 169, 233, 0, + 250, 252, 248, 0, 219, 234, 0, 58, 59, 190, + 191, 174, 178, 172, 170, 223, 244, 256, 0, 109, + 0, 0, 0, 0, 106, 0, 257, 245, 231, 108, + 201, 0, 246 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -369, -369, -369, 398, -369, 440, -369, 197, -369, 117, - -369, -369, -369, -369, 201, -84, 328, -369, -369, -369, - 442, -369, 185, -369, -369, -369, 435, -369, -369, -369, - 360, -369, -369, 292, -159, -73, -369, 83, -66, -38, - -369, -369, -78, 266, -369, -369, -369, -109, -369, -369, - -31, -369, 204, -369, -369, -28, -227, -369, -79, 216, - -129, -162, -369, -369, -369, -369, -369, -369, 272, -369, - -369, -369, -369, -369, -369, -369, -369, 41, -57, -80, - -369, -369, -87, -369, -369, -369, -368, 68, -369, -369, - -369, -1, -369, 70, 295, -369, -369, -369, -369, 410, - -369, -369, -369, -369, 55 + -287, -287, -287, 414, -287, 455, -287, 210, -287, 96, + -287, -287, -287, -287, 203, -78, 348, -287, -287, -287, + 440, -287, 176, 97, -287, -287, 442, -287, -287, -287, + 362, -287, -287, 288, -156, -69, -287, 6, -64, -50, + -287, -287, -60, 261, -287, -287, -287, -122, -287, -287, + 54, -287, 211, -287, -287, 29, -235, -287, -97, 212, + -129, -124, -287, -287, -287, -287, -287, -287, 265, -287, + -287, -287, -287, -287, -287, -287, -287, -287, 49, -71, + -84, -287, -287, -86, -287, -287, -287, -286, 76, -287, + -287, -287, 1, -287, 80, 307, -287, -287, -287, -287, + 427, -287, -287, -287, -287, 58 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - -1, 18, 19, 20, 21, 66, 207, 208, 22, 59, - 23, 125, 24, 25, 82, 137, 204, 26, 27, 28, - 78, 226, 227, 303, 379, 29, 88, 30, 31, 32, + -1, 18, 19, 20, 21, 66, 209, 210, 22, 59, + 23, 125, 24, 25, 82, 137, 206, 26, 27, 28, + 78, 228, 229, 307, 384, 29, 88, 30, 31, 32, 133, 33, 135, 136, 34, 151, 152, 153, 71, 102, - 103, 156, 72, 148, 209, 278, 279, 130, 415, 456, - 106, 215, 216, 290, 96, 161, 210, 115, 116, 211, - 212, 179, 180, 181, 182, 183, 184, 185, 235, 186, - 187, 188, 189, 318, 190, 191, 192, 193, 194, 118, - 119, 120, 121, 122, 123, 361, 362, 363, 364, 365, - 48, 366, 411, 412, 413, 284, 35, 36, 56, 57, - 367, 408, 459, 64, 197 + 103, 156, 72, 148, 211, 281, 282, 130, 421, 464, + 106, 217, 218, 293, 96, 161, 212, 115, 116, 213, + 214, 180, 181, 182, 183, 184, 185, 186, 238, 187, + 188, 189, 190, 191, 322, 192, 193, 194, 195, 196, + 118, 119, 120, 121, 122, 123, 366, 367, 368, 369, + 370, 48, 371, 417, 418, 419, 287, 35, 36, 56, + 57, 372, 414, 467, 64, 199 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If @@ -980,244 +1359,258 @@ static const yytype_int16 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = { - 178, 39, 139, 98, 42, 138, 138, 224, 146, 49, - 50, 238, 326, 240, 108, 109, 110, 38, 117, 309, - 281, 462, 281, 147, 154, 455, 202, 154, 217, 68, - 219, 221, 158, 129, 105, 43, 321, 288, 333, 165, - 159, 437, 336, 234, 80, 53, 83, 195, 242, 37, - 293, 138, 90, 99, 68, 322, 243, 51, 160, 337, - 198, 323, 243, 289, 44, 334, 85, 199, 449, 306, - 166, 271, 229, 244, 230, 238, 401, 127, 128, 244, - 54, 381, 38, 331, 100, 332, 52, 141, 142, 338, - 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 350, 351, 352, 319, 86, 222, 111, 395, 243, - 328, 241, 402, 167, 329, 330, 214, 403, 70, 101, - 213, 201, 99, 404, 405, 243, 244, 218, 251, 169, - 108, 109, 110, 60, 61, 282, 154, 410, 69, 406, - 243, 286, 244, -253, 407, 280, 112, 113, 169, 108, - 109, 110, 97, 100, 384, 390, 45, 244, 217, 266, - 280, 243, 40, 372, 373, 311, 428, 170, 171, 368, - 310, 392, 176, 307, 143, 360, 114, 385, 244, 353, - 251, 41, 46, 55, 104, 285, 170, 171, 101, 251, - 291, 356, 387, 388, 442, 358, 322, 169, 108, 109, - 110, 400, 386, 47, 243, 172, 262, 263, 264, 265, - 374, 266, 451, 117, 138, 424, -221, 117, 265, 58, - 266, 244, 243, 111, 172, 169, 108, 109, 110, 426, - 243, 62, 423, 220, 377, 170, 171, 63, 268, 244, - 173, 269, 111, 243, 233, 443, 68, 244, 243, 233, - 73, 378, 65, 174, 420, 421, 422, 74, 389, 173, - 244, 75, 112, 113, 171, 244, 354, 275, 304, 394, - 276, 305, 174, 172, 169, 108, 109, 110, 76, 175, - 176, 112, 113, 398, 77, 399, 163, 177, 163, 81, - 419, 111, 114, 280, 430, 444, 87, 280, 175, 176, - 84, 172, 169, 108, 109, 110, 177, 91, 173, 92, - 94, 114, 170, 171, 446, 460, 401, 280, 269, 111, - 95, 174, 107, 126, 458, 124, 461, 427, 129, 131, - 112, 113, 132, 134, 140, 108, 237, 147, 69, 110, - 236, 171, 145, 245, 149, 150, 155, 175, 176, 174, - 172, 157, 402, 163, 401, 177, 164, 403, 112, 113, - 114, 162, 196, 404, 405, 200, 203, 452, 111, 206, - 223, 104, 14, 225, 246, 175, 176, 228, 172, 406, - 231, 267, 232, 177, 407, 173, 239, 270, 114, 273, - 402, 274, 277, 280, 287, 403, 111, 292, 174, 294, - 327, 404, 405, 68, 355, 324, 335, 112, 113, 370, - 375, 376, 333, 237, 382, 453, 243, 406, 393, 383, - 247, -253, 407, 266, 175, 176, 174, 409, 397, 414, - 416, 396, 177, 417, 418, 112, 113, 114, 425, 429, - 248, 431, 432, 433, 434, 246, 435, 249, 250, 436, - 438, 440, 175, 176, 251, 252, 441, 439, 445, 450, - 177, 93, 457, 67, 464, 114, 230, 205, 253, 254, - 255, 256, 257, 359, 357, 258, 259, -255, 260, 261, - 262, 263, 264, 265, 1, 266, 79, 89, 168, 1, - 380, 371, 2, 272, -222, 308, 369, 2, 463, 3, - 448, 447, 144, 4, 3, 454, 320, 283, 4, 5, - 0, 0, 6, 7, 5, 0, 295, 6, 7, 250, - 0, 0, 296, 8, 9, 251, 0, 0, 8, 9, - 297, 246, 0, 0, 10, 0, 0, 0, 0, 10, - 0, 0, -256, -256, 0, 0, -256, -256, 0, 260, - 261, 262, 263, 264, 265, 298, 266, 0, 11, 0, - 0, 12, 0, 11, 0, 0, 12, 0, 0, 0, - 0, 0, 299, 0, 0, 0, 13, 247, 246, 0, - 0, 13, 14, 0, 0, 0, 0, 14, 300, 0, - 0, 391, 301, 0, 0, 0, 0, 325, 312, 313, - 314, 315, 316, 317, 302, 250, 0, 0, 0, 0, - 0, 251, 252, 0, 246, 0, 15, 16, 17, 0, - 0, 15, 16, 17, 247, 253, 254, 255, 256, 257, - 0, 0, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 0, 266, 0, 325, 0, 0, 0, 0, 0, - 0, 0, 250, 0, 0, 0, 0, 0, 251, 252, - -256, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 253, 254, 255, 256, 257, 0, 0, 258, - 259, 0, 260, 261, 262, 263, 264, 265, 250, 266, - 0, 0, 0, 0, 251, -256, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, -256, -256, - -256, 256, 257, 0, 0, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 0, 266 + 179, 138, 138, 39, 117, 98, 42, 331, 139, 146, + 226, 49, 50, 204, 108, 109, 110, 313, 470, 38, + 147, 129, 105, 85, 37, 463, 296, 165, 219, 99, + 221, 223, 99, 284, 246, 38, 158, 68, 284, 254, + 246, 70, 154, 200, 237, 154, 80, 138, 83, 245, + 241, 247, 243, 197, 90, 68, 254, 247, 166, 40, + 100, 43, 86, 100, 53, 265, 266, 267, 268, 201, + 269, 254, 236, 274, 310, 97, 246, 386, 51, 127, + 128, 169, 108, 109, 110, 268, 246, 269, 333, 141, + 142, 44, 224, 247, 449, 104, 101, 143, 246, 101, + 54, 167, 269, 247, 216, 401, 323, 324, 52, 111, + 203, 341, 60, 61, 244, 247, 241, 334, 335, 170, + 171, 172, 396, 41, 336, 45, 337, 283, 342, 444, + 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 246, 283, 289, 112, 113, + 416, 169, 108, 109, 110, 285, 154, 457, 173, 373, + 46, 219, 247, 159, 435, 69, 377, 378, 390, 315, + 314, 177, 311, 338, 326, 246, 361, 111, 114, 365, + 363, 160, 298, 358, 246, 391, 430, 222, 299, 170, + 171, 172, 247, 327, 174, 291, 300, 393, 394, 328, + 339, 247, 117, 55, 327, 215, 117, 175, 382, 406, + 392, 459, 220, 138, 398, 271, 112, 113, 272, 379, + 246, 292, 301, 47, 278, 383, 246, 279, 173, 169, + 108, 109, 110, 176, 177, 58, 389, 247, 246, 302, + 451, 178, 303, 247, 288, 308, 114, 111, 309, 294, + 169, 108, 109, 110, 236, 247, 304, 62, 63, 426, + 305, 428, 429, 404, 174, 395, 163, 170, 171, 172, + 65, 359, 306, 433, 431, 405, 400, 175, 163, 68, + 73, 246, 169, 108, 109, 110, 112, 113, 170, 171, + 172, 316, 317, 318, 319, 320, 321, 425, 247, 74, + 283, 407, 452, 176, 177, 437, 173, 454, 283, 468, + 283, 178, 272, 231, 75, 232, 114, 76, 77, 81, + 239, 171, 172, 84, 87, 111, 91, 173, 169, 108, + 109, 110, 466, 92, 469, 434, 94, 95, 408, 107, + 126, 124, 174, 409, 129, 132, 111, 131, 134, 410, + 411, 108, 140, 69, 145, 175, 110, 149, 147, 173, + 155, 150, 157, 174, 112, 113, 412, 171, 172, 248, + -256, 413, 162, 164, 163, 198, 175, 202, 111, 205, + 208, 176, 177, 225, 104, 112, 113, 14, 407, 178, + 227, 230, 233, 234, 114, 240, 242, 235, 270, 273, + 276, 249, 176, 177, 280, 173, 277, 283, 175, 290, + 178, 295, 297, 68, 332, 114, 329, 112, 113, 340, + 360, 375, 387, 380, 111, 408, 381, 388, 246, 338, + 409, 399, 403, 402, 176, 177, 410, 411, 420, 269, + 415, 240, 178, -224, 422, 423, 432, 114, 250, 436, + 424, 438, 439, 412, 175, 440, 441, -256, 413, 442, + 443, 445, 446, 112, 113, 447, 448, 450, 251, 232, + 453, 458, 465, 249, 472, 252, 253, 93, 67, 362, + 176, 177, 254, 255, 79, 385, 427, 207, 178, 364, + 168, 275, 312, 114, 89, 374, 256, 257, 258, 259, + 260, 376, 325, 261, 262, -258, 263, 264, 265, 266, + 267, 268, 1, 269, 471, 456, 462, 1, 455, 144, + 2, 286, 0, 249, 0, 2, 0, 3, 0, 0, + -225, 4, 3, 0, 0, 0, 4, 5, 0, 0, + 6, 7, 5, 0, 0, 6, 7, 0, 253, 0, + 0, 0, 8, 9, 254, 0, 0, 8, 9, 0, + 0, 0, 0, 10, 0, 0, 0, 0, 10, 0, + 250, -259, -259, 0, 0, -259, -259, 0, 263, 264, + 265, 266, 267, 268, 397, 269, 0, 11, 0, 249, + 330, 12, 11, 0, 0, 0, 12, 0, 253, 0, + 0, 0, 0, 0, 254, 255, 13, 0, 249, 0, + 0, 13, 14, 0, 0, 0, 0, 14, 256, 257, + 258, 259, 260, 0, 0, 261, 262, 0, 263, 264, + 265, 266, 267, 268, 0, 269, 250, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 15, 16, 17, 0, + 0, 15, 16, 17, 0, -259, 330, 0, 0, 0, + 0, 0, 0, 0, 253, 0, 0, 0, 0, 0, + 254, 255, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 407, 253, 256, 257, 258, 259, 260, 254, + -259, 261, 262, 0, 263, 264, 265, 266, 267, 268, + 0, 269, 0, -259, -259, -259, 259, 260, 0, 0, + 261, 262, 0, 263, 264, 265, 266, 267, 268, 408, + 269, 0, 0, 0, 409, 0, 0, 0, 0, 0, + 410, 411, 0, 0, 460, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 412, 0, 0, + 0, 0, 413, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 461 }; static const yytype_int16 yycheck[] = { - 129, 2, 86, 69, 5, 85, 86, 166, 95, 10, - 11, 173, 239, 175, 4, 5, 6, 3, 75, 3, - 3, 3, 3, 12, 102, 45, 135, 105, 157, 52, - 159, 160, 105, 77, 72, 74, 85, 83, 94, 87, - 49, 409, 97, 172, 45, 19, 47, 131, 177, 26, - 49, 131, 53, 9, 52, 104, 108, 74, 67, 114, - 58, 110, 108, 109, 103, 121, 87, 133, 436, 228, - 118, 200, 161, 125, 163, 237, 25, 78, 79, 125, - 54, 308, 3, 245, 40, 247, 103, 88, 89, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 233, 126, 163, 97, 335, 108, - 162, 177, 61, 161, 243, 244, 154, 66, 35, 75, - 151, 165, 9, 72, 73, 108, 125, 158, 128, 3, - 4, 5, 6, 16, 17, 118, 214, 118, 161, 88, - 108, 214, 125, 92, 93, 165, 136, 137, 3, 4, - 5, 6, 69, 40, 101, 160, 87, 125, 287, 159, - 165, 108, 3, 292, 293, 231, 393, 41, 42, 278, - 154, 333, 154, 162, 91, 161, 166, 85, 125, 266, - 128, 3, 87, 3, 71, 213, 41, 42, 75, 128, - 218, 270, 321, 322, 162, 274, 104, 3, 4, 5, - 6, 360, 110, 91, 108, 79, 154, 155, 156, 157, - 294, 159, 439, 270, 294, 101, 165, 274, 157, 138, - 159, 125, 108, 97, 79, 3, 4, 5, 6, 391, - 108, 0, 110, 107, 97, 41, 42, 164, 162, 125, - 114, 165, 97, 108, 104, 110, 52, 125, 108, 104, - 3, 114, 105, 127, 383, 384, 385, 163, 324, 114, - 125, 161, 136, 137, 42, 125, 267, 162, 162, 335, - 165, 165, 127, 79, 3, 4, 5, 6, 87, 153, - 154, 136, 137, 162, 120, 162, 165, 161, 165, 3, - 162, 97, 166, 165, 162, 424, 120, 165, 153, 154, - 116, 79, 3, 4, 5, 6, 161, 118, 114, 165, - 90, 166, 41, 42, 162, 162, 25, 165, 165, 97, - 117, 127, 3, 114, 453, 4, 455, 393, 77, 86, - 136, 137, 161, 3, 41, 4, 114, 12, 161, 6, - 41, 42, 161, 17, 162, 162, 107, 153, 154, 127, - 79, 119, 61, 165, 25, 161, 41, 66, 136, 137, - 166, 162, 3, 72, 73, 142, 105, 76, 97, 3, - 3, 71, 105, 3, 48, 153, 154, 118, 79, 88, - 161, 91, 161, 161, 93, 114, 159, 161, 166, 43, - 61, 161, 87, 165, 165, 66, 97, 49, 127, 86, - 162, 72, 73, 52, 3, 161, 161, 136, 137, 3, - 161, 161, 94, 114, 162, 124, 108, 88, 161, 87, - 94, 92, 93, 159, 153, 154, 127, 165, 160, 64, - 6, 97, 161, 6, 97, 136, 137, 166, 162, 162, - 114, 162, 92, 72, 72, 48, 72, 121, 122, 92, - 3, 162, 153, 154, 128, 129, 162, 119, 162, 161, - 161, 63, 161, 23, 162, 166, 163, 139, 142, 143, - 144, 145, 146, 276, 273, 149, 150, 0, 152, 153, - 154, 155, 156, 157, 7, 159, 44, 52, 128, 7, - 305, 287, 15, 201, 165, 229, 280, 15, 457, 22, - 432, 431, 92, 26, 22, 450, 234, 212, 26, 32, - -1, -1, 35, 36, 32, -1, 24, 35, 36, 122, - -1, -1, 30, 46, 47, 128, -1, -1, 46, 47, - 38, 48, -1, -1, 57, -1, -1, -1, -1, 57, - -1, -1, 145, 146, -1, -1, 149, 150, -1, 152, - 153, 154, 155, 156, 157, 63, 159, -1, 81, -1, - -1, 84, -1, 81, -1, -1, 84, -1, -1, -1, - -1, -1, 80, -1, -1, -1, 99, 94, 48, -1, - -1, 99, 105, -1, -1, -1, -1, 105, 96, -1, - -1, 108, 100, -1, -1, -1, -1, 114, 130, 131, - 132, 133, 134, 135, 112, 122, -1, -1, -1, -1, - -1, 128, 129, -1, 48, -1, 139, 140, 141, -1, - -1, 139, 140, 141, 94, 142, 143, 144, 145, 146, - -1, -1, 149, 150, -1, 152, 153, 154, 155, 156, - 157, -1, 159, -1, 114, -1, -1, -1, -1, -1, - -1, -1, 122, -1, -1, -1, -1, -1, 128, 129, - 94, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 142, 143, 144, 145, 146, -1, -1, 149, - 150, -1, 152, 153, 154, 155, 156, 157, 122, 159, - -1, -1, -1, -1, 128, 129, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 142, 143, - 144, 145, 146, -1, -1, 149, 150, -1, 152, 153, - 154, 155, 156, 157, -1, 159 + 129, 85, 86, 2, 75, 69, 5, 242, 86, 95, + 166, 10, 11, 135, 4, 5, 6, 3, 3, 3, + 12, 78, 72, 89, 26, 46, 50, 89, 157, 9, + 159, 160, 9, 3, 110, 3, 105, 53, 3, 130, + 110, 35, 102, 59, 173, 105, 45, 131, 47, 178, + 174, 127, 176, 131, 53, 53, 130, 127, 120, 3, + 40, 75, 128, 40, 19, 156, 157, 158, 159, 133, + 161, 130, 106, 202, 230, 69, 110, 312, 75, 78, + 79, 3, 4, 5, 6, 159, 110, 161, 164, 88, + 89, 105, 163, 127, 164, 72, 76, 91, 110, 76, + 55, 163, 161, 127, 154, 340, 235, 236, 105, 99, + 167, 99, 16, 17, 178, 127, 240, 246, 247, 41, + 42, 43, 162, 3, 248, 89, 250, 167, 116, 415, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 110, 167, 216, 138, 139, + 120, 3, 4, 5, 6, 120, 216, 443, 80, 281, + 89, 290, 127, 50, 399, 163, 295, 296, 103, 233, + 156, 156, 164, 96, 87, 110, 273, 99, 168, 163, + 277, 68, 24, 269, 110, 87, 112, 109, 30, 41, + 42, 43, 127, 106, 116, 85, 38, 326, 327, 112, + 123, 127, 273, 3, 106, 151, 277, 129, 99, 365, + 112, 446, 158, 297, 338, 164, 138, 139, 167, 297, + 110, 111, 64, 93, 164, 116, 110, 167, 80, 3, + 4, 5, 6, 155, 156, 140, 120, 127, 110, 81, + 112, 163, 84, 127, 215, 164, 168, 99, 167, 220, + 3, 4, 5, 6, 106, 127, 98, 0, 166, 388, + 102, 390, 391, 164, 116, 329, 167, 41, 42, 43, + 107, 270, 114, 397, 103, 164, 340, 129, 167, 53, + 3, 110, 3, 4, 5, 6, 138, 139, 41, 42, + 43, 132, 133, 134, 135, 136, 137, 164, 127, 165, + 167, 25, 431, 155, 156, 164, 80, 164, 167, 164, + 167, 163, 167, 163, 163, 165, 168, 89, 122, 3, + 41, 42, 43, 118, 122, 99, 120, 80, 3, 4, + 5, 6, 461, 167, 463, 399, 92, 119, 62, 3, + 116, 4, 116, 67, 78, 163, 99, 88, 3, 73, + 74, 4, 41, 163, 163, 129, 6, 164, 12, 80, + 109, 164, 121, 116, 138, 139, 90, 42, 43, 17, + 94, 95, 164, 41, 167, 3, 129, 144, 99, 107, + 3, 155, 156, 3, 72, 138, 139, 107, 25, 163, + 3, 120, 163, 163, 168, 116, 161, 163, 93, 163, + 44, 49, 155, 156, 89, 80, 163, 167, 129, 167, + 163, 50, 88, 53, 164, 168, 163, 138, 139, 163, + 3, 3, 164, 163, 99, 62, 163, 89, 110, 96, + 67, 163, 162, 99, 155, 156, 73, 74, 65, 161, + 167, 116, 163, 167, 6, 6, 164, 168, 96, 164, + 99, 164, 94, 90, 129, 73, 73, 94, 95, 73, + 94, 3, 121, 138, 139, 164, 164, 164, 116, 165, + 164, 163, 163, 49, 164, 123, 124, 63, 23, 276, + 155, 156, 130, 131, 44, 309, 389, 139, 163, 279, + 128, 203, 231, 168, 52, 283, 144, 145, 146, 147, + 148, 290, 237, 151, 152, 0, 154, 155, 156, 157, + 158, 159, 7, 161, 465, 439, 458, 7, 438, 92, + 15, 214, -1, 49, -1, 15, -1, 22, -1, -1, + 167, 26, 22, -1, -1, -1, 26, 32, -1, -1, + 35, 36, 32, -1, -1, 35, 36, -1, 124, -1, + -1, -1, 47, 48, 130, -1, -1, 47, 48, -1, + -1, -1, -1, 58, -1, -1, -1, -1, 58, -1, + 96, 147, 148, -1, -1, 151, 152, -1, 154, 155, + 156, 157, 158, 159, 110, 161, -1, 82, -1, 49, + 116, 86, 82, -1, -1, -1, 86, -1, 124, -1, + -1, -1, -1, -1, 130, 131, 101, -1, 49, -1, + -1, 101, 107, -1, -1, -1, -1, 107, 144, 145, + 146, 147, 148, -1, -1, 151, 152, -1, 154, 155, + 156, 157, 158, 159, -1, 161, 96, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 141, 142, 143, -1, + -1, 141, 142, 143, -1, 96, 116, -1, -1, -1, + -1, -1, -1, -1, 124, -1, -1, -1, -1, -1, + 130, 131, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 25, 124, 144, 145, 146, 147, 148, 130, + 131, 151, 152, -1, 154, 155, 156, 157, 158, 159, + -1, 161, -1, 144, 145, 146, 147, 148, -1, -1, + 151, 152, -1, 154, 155, 156, 157, 158, 159, 62, + 161, -1, -1, -1, 67, -1, -1, -1, -1, -1, + 73, 74, -1, -1, 77, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 90, -1, -1, + -1, -1, 95, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 126 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ -static const yytype_uint16 yystos[] = +static const yytype_int16 yystos[] = { - 0, 7, 15, 22, 26, 32, 35, 36, 46, 47, - 57, 81, 84, 99, 105, 139, 140, 141, 168, 169, - 170, 171, 175, 177, 179, 180, 184, 185, 186, 192, - 194, 195, 196, 198, 201, 263, 264, 26, 3, 258, - 3, 3, 258, 74, 103, 87, 87, 91, 257, 258, - 258, 74, 103, 19, 54, 3, 265, 266, 138, 176, - 176, 176, 0, 164, 270, 105, 172, 172, 52, 161, - 204, 205, 209, 3, 163, 161, 87, 120, 187, 187, - 258, 3, 181, 258, 116, 87, 126, 120, 193, 193, - 258, 118, 165, 170, 90, 117, 221, 204, 205, 9, - 40, 75, 206, 207, 71, 206, 217, 3, 4, 5, - 6, 97, 136, 137, 166, 224, 225, 245, 246, 247, - 248, 249, 250, 251, 4, 178, 114, 258, 258, 77, - 214, 86, 161, 197, 3, 199, 200, 182, 246, 182, - 41, 258, 258, 204, 266, 161, 249, 12, 210, 162, - 162, 202, 203, 204, 209, 107, 208, 119, 202, 49, - 67, 222, 162, 165, 41, 87, 118, 161, 197, 3, - 41, 42, 79, 114, 127, 153, 154, 161, 227, 228, - 229, 230, 231, 232, 233, 234, 236, 237, 238, 239, - 241, 242, 243, 244, 245, 182, 3, 271, 58, 205, - 142, 165, 214, 105, 183, 183, 3, 173, 174, 211, - 223, 226, 227, 217, 206, 218, 219, 227, 217, 227, - 107, 227, 245, 3, 201, 3, 188, 189, 118, 161, - 163, 161, 161, 104, 227, 235, 41, 114, 228, 159, - 228, 205, 227, 108, 125, 17, 48, 94, 114, 121, - 122, 128, 129, 142, 143, 144, 145, 146, 149, 150, - 152, 153, 154, 155, 156, 157, 159, 91, 162, 165, - 161, 227, 200, 43, 161, 162, 165, 87, 212, 213, - 165, 3, 118, 261, 262, 222, 202, 165, 83, 109, - 220, 222, 49, 49, 86, 24, 30, 38, 63, 80, - 96, 100, 112, 190, 162, 165, 201, 162, 210, 3, - 154, 205, 130, 131, 132, 133, 134, 135, 240, 227, - 235, 85, 104, 110, 161, 114, 223, 162, 162, 227, - 227, 228, 228, 94, 121, 161, 97, 114, 228, 228, - 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, - 228, 228, 228, 249, 258, 3, 225, 181, 225, 174, - 161, 252, 253, 254, 255, 256, 258, 267, 214, 226, - 3, 219, 227, 227, 182, 161, 161, 97, 114, 191, - 189, 223, 162, 87, 101, 85, 110, 227, 227, 205, - 160, 108, 228, 161, 205, 223, 97, 160, 162, 162, - 201, 25, 61, 66, 72, 73, 88, 93, 268, 165, - 118, 259, 260, 261, 64, 215, 6, 6, 97, 162, - 227, 227, 227, 110, 101, 162, 228, 205, 223, 162, - 162, 162, 92, 72, 72, 72, 92, 253, 3, 119, - 162, 162, 162, 110, 227, 162, 162, 260, 254, 253, - 161, 223, 76, 124, 271, 45, 216, 161, 227, 269, - 162, 227, 3, 244, 162 + 0, 7, 15, 22, 26, 32, 35, 36, 47, 48, + 58, 82, 86, 101, 107, 141, 142, 143, 170, 171, + 172, 173, 177, 179, 181, 182, 186, 187, 188, 194, + 196, 197, 198, 200, 203, 266, 267, 26, 3, 261, + 3, 3, 261, 75, 105, 89, 89, 93, 260, 261, + 261, 75, 105, 19, 55, 3, 268, 269, 140, 178, + 178, 178, 0, 166, 273, 107, 174, 174, 53, 163, + 206, 207, 211, 3, 165, 163, 89, 122, 189, 189, + 261, 3, 183, 261, 118, 89, 128, 122, 195, 195, + 261, 120, 167, 172, 92, 119, 223, 206, 207, 9, + 40, 76, 208, 209, 72, 208, 219, 3, 4, 5, + 6, 99, 138, 139, 168, 226, 227, 248, 249, 250, + 251, 252, 253, 254, 4, 180, 116, 261, 261, 78, + 216, 88, 163, 199, 3, 201, 202, 184, 249, 184, + 41, 261, 261, 206, 269, 163, 252, 12, 212, 164, + 164, 204, 205, 206, 211, 109, 210, 121, 204, 50, + 68, 224, 164, 167, 41, 89, 120, 163, 199, 3, + 41, 42, 43, 80, 116, 129, 155, 156, 163, 229, + 230, 231, 232, 233, 234, 235, 236, 238, 239, 240, + 241, 242, 244, 245, 246, 247, 248, 184, 3, 274, + 59, 207, 144, 167, 216, 107, 185, 185, 3, 175, + 176, 213, 225, 228, 229, 219, 208, 220, 221, 229, + 219, 229, 109, 229, 248, 3, 203, 3, 190, 191, + 120, 163, 165, 163, 163, 163, 106, 229, 237, 41, + 116, 230, 161, 230, 207, 229, 110, 127, 17, 49, + 96, 116, 123, 124, 130, 131, 144, 145, 146, 147, + 148, 151, 152, 154, 155, 156, 157, 158, 159, 161, + 93, 164, 167, 163, 229, 202, 44, 163, 164, 167, + 89, 214, 215, 167, 3, 120, 264, 265, 224, 204, + 167, 85, 111, 222, 224, 50, 50, 88, 24, 30, + 38, 64, 81, 84, 98, 102, 114, 192, 164, 167, + 203, 164, 212, 3, 156, 207, 132, 133, 134, 135, + 136, 137, 243, 229, 229, 237, 87, 106, 112, 163, + 116, 225, 164, 164, 229, 229, 230, 230, 96, 123, + 163, 99, 116, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, 252, 261, + 3, 227, 183, 227, 176, 163, 255, 256, 257, 258, + 259, 261, 270, 216, 228, 3, 221, 229, 229, 184, + 163, 163, 99, 116, 193, 191, 225, 164, 89, 120, + 103, 87, 112, 229, 229, 207, 162, 110, 230, 163, + 207, 225, 99, 162, 164, 164, 203, 25, 62, 67, + 73, 74, 90, 95, 271, 167, 120, 262, 263, 264, + 65, 217, 6, 6, 99, 164, 229, 192, 229, 229, + 112, 103, 164, 230, 207, 225, 164, 164, 164, 94, + 73, 73, 73, 94, 256, 3, 121, 164, 164, 164, + 164, 112, 229, 164, 164, 263, 257, 256, 163, 225, + 77, 126, 274, 46, 218, 163, 229, 272, 164, 229, + 3, 247, 164 }; /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const yytype_uint16 yyr1[] = +static const yytype_int16 yyr1[] = { - 0, 167, 168, 169, 169, 170, 170, 170, 170, 170, - 171, 171, 171, 171, 171, 171, 171, 171, 171, 172, - 172, 173, 173, 174, 174, 175, 175, 175, 176, 176, - 177, 178, 179, 179, 180, 180, 181, 182, 183, 183, - 184, 185, 185, 185, 186, 186, 186, 186, 187, 187, - 188, 188, 189, 190, 190, 190, 190, 190, 190, 190, - 190, 191, 191, 191, 192, 192, 192, 193, 193, 194, - 195, 196, 196, 197, 197, 198, 199, 199, 200, 201, - 201, 201, 202, 202, 203, 203, 204, 204, 205, 205, - 206, 207, 207, 207, 208, 208, 209, 210, 210, 211, - 212, 212, 213, 214, 214, 215, 215, 216, 216, 217, - 217, 218, 218, 219, 220, 220, 220, 221, 221, 222, - 222, 222, 222, 222, 222, 223, 223, 224, 224, 225, - 225, 226, 227, 227, 227, 227, 227, 228, 228, 228, - 228, 228, 228, 228, 228, 228, 228, 229, 229, 230, - 230, 230, 230, 230, 231, 231, 231, 231, 231, 231, - 231, 231, 231, 231, 231, 232, 232, 233, 233, 233, - 233, 234, 234, 234, 234, 235, 235, 236, 236, 237, - 237, 237, 237, 237, 237, 237, 238, 238, 239, 240, - 240, 240, 240, 240, 240, 241, 242, 243, 244, 244, - 244, 244, 245, 245, 245, 245, 245, 246, 247, 247, - 248, 248, 249, 250, 251, 252, 252, 253, 253, 254, - 254, 255, 255, 256, 257, 258, 258, 259, 259, 260, - 260, 261, 261, 262, 262, 263, 263, 264, 265, 265, - 266, 267, 267, 267, 268, 268, 268, 268, 268, 268, - 268, 268, 268, 268, 269, 270, 270, 271, 271 + 0, 169, 170, 171, 171, 172, 172, 172, 172, 172, + 173, 173, 173, 173, 173, 173, 173, 173, 173, 174, + 174, 175, 175, 176, 176, 177, 177, 177, 178, 178, + 179, 180, 181, 181, 182, 182, 183, 184, 185, 185, + 186, 187, 187, 187, 188, 188, 188, 188, 189, 189, + 190, 190, 191, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 193, 193, 193, 194, 194, 194, 195, 195, + 196, 197, 198, 198, 199, 199, 200, 201, 201, 202, + 203, 203, 203, 204, 204, 205, 205, 206, 206, 207, + 207, 208, 209, 209, 209, 210, 210, 211, 212, 212, + 213, 214, 214, 215, 216, 216, 217, 217, 218, 218, + 219, 219, 220, 220, 221, 222, 222, 222, 223, 223, + 224, 224, 224, 224, 224, 224, 225, 225, 226, 226, + 227, 227, 228, 229, 229, 229, 229, 229, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, 230, 231, + 231, 232, 232, 232, 232, 232, 233, 233, 233, 233, + 233, 233, 233, 233, 233, 233, 233, 234, 234, 235, + 235, 235, 235, 236, 236, 236, 236, 237, 237, 238, + 238, 239, 239, 239, 239, 239, 239, 239, 240, 240, + 241, 242, 243, 243, 243, 243, 243, 243, 244, 245, + 246, 247, 247, 247, 247, 248, 248, 248, 248, 248, + 249, 250, 250, 251, 251, 252, 253, 254, 255, 255, + 256, 256, 257, 257, 258, 258, 259, 260, 261, 261, + 262, 262, 263, 263, 264, 264, 265, 265, 266, 266, + 267, 268, 268, 269, 270, 270, 270, 271, 271, 271, + 271, 271, 271, 271, 271, 271, 271, 272, 273, 273, + 274, 274 }; /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ -static const yytype_uint8 yyr2[] = +static const yytype_int8 yyr2[] = { 0, 2, 2, 1, 3, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, @@ -1225,33 +1618,34 @@ static const yytype_uint8 yyr2[] = 4, 1, 2, 5, 7, 5, 1, 1, 3, 0, 5, 2, 3, 2, 8, 7, 6, 7, 3, 0, 1, 3, 3, 1, 1, 1, 1, 1, 4, 4, - 1, 1, 2, 0, 4, 4, 3, 2, 0, 4, - 2, 8, 5, 3, 0, 5, 1, 3, 3, 2, - 2, 6, 1, 1, 1, 3, 3, 3, 3, 5, - 2, 1, 1, 1, 1, 0, 7, 1, 0, 1, - 1, 0, 2, 2, 0, 4, 0, 2, 0, 3, - 0, 1, 3, 2, 1, 1, 0, 2, 0, 2, - 2, 4, 2, 4, 0, 1, 3, 1, 0, 1, - 3, 2, 1, 1, 1, 1, 1, 3, 1, 1, - 1, 1, 1, 1, 1, 1, 3, 1, 1, 2, - 2, 2, 3, 4, 1, 3, 3, 3, 3, 3, - 3, 3, 4, 3, 3, 3, 3, 5, 6, 5, - 6, 4, 6, 3, 5, 4, 5, 4, 5, 3, - 3, 3, 3, 3, 3, 3, 3, 5, 6, 1, - 1, 1, 1, 1, 1, 4, 4, 5, 1, 3, - 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, - 4, 1, 3, 2, 1, 1, 3, 1, 5, 1, - 0, 2, 1, 1, 0, 1, 0, 2, 1, 3, - 3, 4, 6, 8, 1, 2, 1, 2, 1, 2, - 1, 1, 1, 0, 1, 1, 0, 1, 3 + 1, 1, 1, 2, 0, 4, 4, 3, 2, 0, + 4, 2, 8, 5, 3, 0, 5, 1, 3, 3, + 2, 2, 6, 1, 1, 1, 3, 3, 3, 3, + 5, 2, 1, 1, 1, 1, 0, 7, 1, 0, + 1, 1, 0, 2, 2, 0, 4, 0, 2, 0, + 3, 0, 1, 3, 2, 1, 1, 0, 2, 0, + 2, 2, 4, 2, 4, 0, 1, 3, 1, 0, + 1, 3, 2, 1, 1, 1, 1, 1, 3, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, + 1, 2, 2, 2, 3, 4, 1, 3, 3, 3, + 3, 3, 3, 3, 4, 3, 3, 3, 3, 5, + 6, 5, 6, 4, 6, 3, 5, 4, 5, 4, + 5, 3, 3, 3, 3, 3, 3, 3, 3, 5, + 6, 6, 1, 1, 1, 1, 1, 1, 4, 4, + 5, 1, 3, 1, 3, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, + 1, 1, 1, 4, 1, 3, 2, 1, 1, 3, + 1, 5, 1, 0, 2, 1, 1, 0, 1, 0, + 2, 1, 3, 3, 4, 6, 8, 1, 2, 1, + 2, 1, 2, 1, 1, 1, 0, 1, 1, 0, + 1, 3 }; +enum { YYENOMEM = -2 }; + #define yyerrok (yyerrstatus = 0) -#define yyclearin (yychar = YYEMPTY) -#define YYEMPTY (-2) -#define YYEOF 0 +#define yyclearin (yychar = SQL_HSQL_EMPTY) #define YYACCEPT goto yyacceptlab #define YYABORT goto yyabortlab @@ -1262,7 +1656,7 @@ static const yytype_uint8 yyr2[] = #define YYBACKUP(Token, Value) \ do \ - if (yychar == YYEMPTY) \ + if (yychar == SQL_HSQL_EMPTY) \ { \ yychar = (Token); \ yylval = (Value); \ @@ -1277,10 +1671,9 @@ static const yytype_uint8 yyr2[] = } \ while (0) -/* Error token number */ -#define YYTERROR 1 -#define YYERRCODE 256 - +/* Backward compatibility with an undocumented macro. + Use SQL_HSQL_error or SQL_HSQL_UNDEF. */ +#define YYERRCODE SQL_HSQL_UNDEF /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. If N is 0, then set CURRENT to the empty location which ends @@ -1328,8 +1721,8 @@ do { \ This macro was not mandated originally: define only if we know we won't break user code: when these are the locations we know. */ -#ifndef YY_LOCATION_PRINT -# if defined HSQL_LTYPE_IS_TRIVIAL && HSQL_LTYPE_IS_TRIVIAL +# ifndef YY_LOCATION_PRINT +# if defined HSQL_LTYPE_IS_TRIVIAL && HSQL_LTYPE_IS_TRIVIAL /* Print *YYLOCP on YYO. Private, do not rely on its existence. */ @@ -1359,22 +1752,22 @@ yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp) return res; } -# define YY_LOCATION_PRINT(File, Loc) \ +# define YY_LOCATION_PRINT(File, Loc) \ yy_location_print_ (File, &(Loc)) -# else -# define YY_LOCATION_PRINT(File, Loc) ((void) 0) -# endif -#endif +# else +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +# endif +# endif /* !defined YY_LOCATION_PRINT */ -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ do { \ if (yydebug) \ { \ YYFPRINTF (stderr, "%s ", Title); \ yy_symbol_print (stderr, \ - Type, Value, Location, result, scanner); \ + Kind, Value, Location, result, scanner); \ YYFPRINTF (stderr, "\n"); \ } \ } while (0) @@ -1385,7 +1778,8 @@ do { \ `-----------------------------------*/ static void -yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, hsql::SQLParserResult* result, yyscan_t scanner) +yy_symbol_value_print (FILE *yyo, + yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, hsql::SQLParserResult* result, yyscan_t scanner) { FILE *yyoutput = yyo; YYUSE (yyoutput); @@ -1395,11 +1789,11 @@ yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YY if (!yyvaluep) return; # ifdef YYPRINT - if (yytype < YYNTOKENS) - YYPRINT (yyo, yytoknum[yytype], *yyvaluep); + if (yykind < YYNTOKENS) + YYPRINT (yyo, yytoknum[yykind], *yyvaluep); # endif YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN - YYUSE (yytype); + YYUSE (yykind); YY_IGNORE_MAYBE_UNINITIALIZED_END } @@ -1409,14 +1803,15 @@ yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YY `---------------------------*/ static void -yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, hsql::SQLParserResult* result, yyscan_t scanner) +yy_symbol_print (FILE *yyo, + yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, hsql::SQLParserResult* result, yyscan_t scanner) { YYFPRINTF (yyo, "%s %s (", - yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); + yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind)); YY_LOCATION_PRINT (yyo, *yylocationp); YYFPRINTF (yyo, ": "); - yy_symbol_value_print (yyo, yytype, yyvaluep, yylocationp, result, scanner); + yy_symbol_value_print (yyo, yykind, yyvaluep, yylocationp, result, scanner); YYFPRINTF (yyo, ")"); } @@ -1426,7 +1821,7 @@ yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE `------------------------------------------------------------------*/ static void -yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) +yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) { YYFPRINTF (stderr, "Stack now"); for (; yybottom <= yytop; yybottom++) @@ -1449,21 +1844,22 @@ do { \ `------------------------------------------------*/ static void -yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, hsql::SQLParserResult* result, yyscan_t scanner) +yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, + int yyrule, hsql::SQLParserResult* result, yyscan_t scanner) { - unsigned long yylno = yyrline[yyrule]; + int yylno = yyrline[yyrule]; int yynrhs = yyr2[yyrule]; int yyi; - YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", + YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n", yyrule - 1, yylno); /* The symbols being reduced. */ for (yyi = 0; yyi < yynrhs; yyi++) { YYFPRINTF (stderr, " $%d = ", yyi + 1); yy_symbol_print (stderr, - yystos[yyssp[yyi + 1 - yynrhs]], - &yyvsp[(yyi + 1) - (yynrhs)] - , &(yylsp[(yyi + 1) - (yynrhs)]) , result, scanner); + YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]), + &yyvsp[(yyi + 1) - (yynrhs)], + &(yylsp[(yyi + 1) - (yynrhs)]), result, scanner); YYFPRINTF (stderr, "\n"); } } @@ -1478,8 +1874,8 @@ do { \ multiple parsers can coexist. */ int yydebug; #else /* !HSQL_DEBUG */ -# define YYDPRINTF(Args) -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YYDPRINTF(Args) ((void) 0) +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) # define YY_STACK_PRINT(Bottom, Top) # define YY_REDUCE_PRINT(Rule) #endif /* !HSQL_DEBUG */ @@ -1502,28 +1898,77 @@ int yydebug; #endif -#if YYERROR_VERBOSE +/* Context of a parse error. */ +typedef struct +{ + yy_state_t *yyssp; + yysymbol_kind_t yytoken; + YYLTYPE *yylloc; +} yypcontext_t; -# ifndef yystrlen -# if defined __GLIBC__ && defined _STRING_H -# define yystrlen strlen -# else +/* Put in YYARG at most YYARGN of the expected tokens given the + current YYCTX, and return the number of tokens stored in YYARG. If + YYARG is null, return the number of expected tokens (guaranteed to + be less than YYNTOKENS). Return YYENOMEM on memory exhaustion. + Return 0 if there are more than YYARGN expected tokens, yet fill + YYARG up to YYARGN. */ +static int +yypcontext_expected_tokens (const yypcontext_t *yyctx, + yysymbol_kind_t yyarg[], int yyargn) +{ + /* Actual size of YYARG. */ + int yycount = 0; + int yyn = yypact[+*yyctx->yyssp]; + if (!yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yyx; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYSYMBOL_YYerror + && !yytable_value_is_error (yytable[yyx + yyn])) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx); + } + } + if (yyarg && yycount == 0 && 0 < yyargn) + yyarg[0] = YYSYMBOL_YYEMPTY; + return yycount; +} + + + + +#ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) +# else /* Return the length of YYSTR. */ -static YYSIZE_T +static YYPTRDIFF_T yystrlen (const char *yystr) { - YYSIZE_T yylen; + YYPTRDIFF_T yylen; for (yylen = 0; yystr[yylen]; yylen++) continue; return yylen; } -# endif # endif +#endif -# ifndef yystpcpy -# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE -# define yystpcpy stpcpy -# else +#ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in YYDEST. */ static char * @@ -1537,10 +1982,10 @@ yystpcpy (char *yydest, const char *yysrc) return yyd - 1; } -# endif # endif +#endif -# ifndef yytnamerr +#ifndef yytnamerr /* Copy to YYRES the contents of YYSTR after stripping away unnecessary quotes and backslashes, so that it's suitable for yyerror. The heuristic is that double-quoting is unnecessary unless the string @@ -1548,14 +1993,13 @@ yystpcpy (char *yydest, const char *yysrc) backslash-backslash). YYSTR is taken from yytname. If YYRES is null, do not copy; instead, return the length of what the result would have been. */ -static YYSIZE_T +static YYPTRDIFF_T yytnamerr (char *yyres, const char *yystr) { if (*yystr == '"') { - YYSIZE_T yyn = 0; + YYPTRDIFF_T yyn = 0; char const *yyp = yystr; - for (;;) switch (*++yyp) { @@ -1584,36 +2028,20 @@ yytnamerr (char *yyres, const char *yystr) do_not_strip_quotes: ; } - if (! yyres) + if (yyres) + return yystpcpy (yyres, yystr) - yyres; + else return yystrlen (yystr); - - return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres); } -# endif +#endif -/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message - about the unexpected token YYTOKEN for the state stack whose top is - YYSSP. - Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is - not large enough to hold the message. In that case, also set - *YYMSG_ALLOC to the required number of bytes. Return 2 if the - required number of bytes is too large to store. */ static int -yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, - yytype_int16 *yyssp, int yytoken) +yy_syntax_error_arguments (const yypcontext_t *yyctx, + yysymbol_kind_t yyarg[], int yyargn) { - YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); - YYSIZE_T yysize = yysize0; - enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; - /* Internationalized format string. */ - const char *yyformat = YY_NULLPTR; - /* Arguments of yyformat. */ - char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; - /* Number of reported tokens (one for the "unexpected", one per - "expected"). */ + /* Actual size of YYARG. */ int yycount = 0; - /* There are many possibilities here to consider: - If this state is a consistent state with a default action, then the only way this function was invoked is if the default action @@ -1637,49 +2065,54 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, one exception: it will still contain any token that will not be accepted due to an error action in a later state. */ - if (yytoken != YYEMPTY) + if (yyctx->yytoken != YYSYMBOL_YYEMPTY) { - int yyn = yypact[*yyssp]; - yyarg[yycount++] = yytname[yytoken]; - if (!yypact_value_is_default (yyn)) - { - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. In other words, skip the first -YYN actions for - this state because they are default actions. */ - int yyxbegin = yyn < 0 ? -yyn : 0; - /* Stay within bounds of both yycheck and yytname. */ - int yychecklim = YYLAST - yyn + 1; - int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; - int yyx; - - for (yyx = yyxbegin; yyx < yyxend; ++yyx) - if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR - && !yytable_value_is_error (yytable[yyx + yyn])) - { - if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) - { - yycount = 1; - yysize = yysize0; - break; - } - yyarg[yycount++] = yytname[yyx]; - { - YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); - if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) - yysize = yysize1; - else - return 2; - } - } - } + int yyn; + if (yyarg) + yyarg[yycount] = yyctx->yytoken; + ++yycount; + yyn = yypcontext_expected_tokens (yyctx, + yyarg ? yyarg + 1 : yyarg, yyargn - 1); + if (yyn == YYENOMEM) + return YYENOMEM; + else + yycount += yyn; } + return yycount; +} + +/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message + about the unexpected token YYTOKEN for the state stack whose top is + YYSSP. + + Return 0 if *YYMSG was successfully written. Return -1 if *YYMSG is + not large enough to hold the message. In that case, also set + *YYMSG_ALLOC to the required number of bytes. Return YYENOMEM if the + required number of bytes is too large to store. */ +static int +yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg, + const yypcontext_t *yyctx) +{ + enum { YYARGS_MAX = 5 }; + /* Internationalized format string. */ + const char *yyformat = YY_NULLPTR; + /* Arguments of yyformat: reported tokens (one for the "unexpected", + one per "expected"). */ + yysymbol_kind_t yyarg[YYARGS_MAX]; + /* Cumulated lengths of YYARG. */ + YYPTRDIFF_T yysize = 0; + + /* Actual size of YYARG. */ + int yycount = yy_syntax_error_arguments (yyctx, yyarg, YYARGS_MAX); + if (yycount == YYENOMEM) + return YYENOMEM; switch (yycount) { -# define YYCASE_(N, S) \ +#define YYCASE_(N, S) \ case N: \ yyformat = S; \ - break + break default: /* Avoid compiler warnings. */ YYCASE_(0, YY_("syntax error")); YYCASE_(1, YY_("syntax error, unexpected %s")); @@ -1687,15 +2120,23 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); -# undef YYCASE_ +#undef YYCASE_ } + /* Compute error message size. Don't count the "%s"s, but reserve + room for the terminator. */ + yysize = yystrlen (yyformat) - 2 * yycount + 1; { - YYSIZE_T yysize1 = yysize + yystrlen (yyformat); - if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) - yysize = yysize1; - else - return 2; + int yyi; + for (yyi = 0; yyi < yycount; ++yyi) + { + YYPTRDIFF_T yysize1 + = yysize + yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]]); + if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) + yysize = yysize1; + else + return YYENOMEM; + } } if (*yymsg_alloc < yysize) @@ -1704,7 +2145,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, if (! (yysize <= *yymsg_alloc && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; - return 1; + return -1; } /* Avoid sprintf, as that infringes on the user's name space. @@ -1716,25 +2157,26 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, while ((*yyp = *yyformat) != '\0') if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) { - yyp += yytnamerr (yyp, yyarg[yyi++]); + yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]); yyformat += 2; } else { - yyp++; - yyformat++; + ++yyp; + ++yyformat; } } return 0; } -#endif /* YYERROR_VERBOSE */ + /*-----------------------------------------------. | Release the memory associated to this symbol. | `-----------------------------------------------*/ static void -yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, hsql::SQLParserResult* result, yyscan_t scanner) +yydestruct (const char *yymsg, + yysymbol_kind_t yykind, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, hsql::SQLParserResult* result, yyscan_t scanner) { YYUSE (yyvaluep); YYUSE (yylocationp); @@ -1742,38 +2184,38 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio YYUSE (scanner); if (!yymsg) yymsg = "Deleting"; - YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN - switch (yytype) + switch (yykind) { case 3: /* IDENTIFIER */ #line 149 "bison_parser.y" - { free( (((*yyvaluep).sval)) ); } -#line 1754 "bison_parser.cpp" + { free( (((*yyvaluep).sval)) ); } +#line 2196 "bison_parser.cpp" break; case 4: /* STRING */ #line 149 "bison_parser.y" - { free( (((*yyvaluep).sval)) ); } -#line 1760 "bison_parser.cpp" + { free( (((*yyvaluep).sval)) ); } +#line 2202 "bison_parser.cpp" break; case 5: /* FLOATVAL */ #line 147 "bison_parser.y" - { } -#line 1766 "bison_parser.cpp" + { } +#line 2208 "bison_parser.cpp" break; case 6: /* INTVAL */ #line 147 "bison_parser.y" - { } -#line 1772 "bison_parser.cpp" + { } +#line 2214 "bison_parser.cpp" break; - case 169: /* statement_list */ + case 171: /* statement_list */ #line 150 "bison_parser.y" - { + { if ((((*yyvaluep).stmt_vec)) != nullptr) { for (auto ptr : *(((*yyvaluep).stmt_vec))) { delete ptr; @@ -1781,24 +2223,24 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio } delete (((*yyvaluep).stmt_vec)); } -#line 1785 "bison_parser.cpp" +#line 2227 "bison_parser.cpp" break; - case 170: /* statement */ + case 172: /* statement */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).statement)); } -#line 1791 "bison_parser.cpp" + { delete (((*yyvaluep).statement)); } +#line 2233 "bison_parser.cpp" break; - case 171: /* preparable_statement */ + case 173: /* preparable_statement */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).statement)); } -#line 1797 "bison_parser.cpp" + { delete (((*yyvaluep).statement)); } +#line 2239 "bison_parser.cpp" break; - case 172: /* opt_hints */ + case 174: /* opt_hints */ #line 150 "bison_parser.y" - { + { if ((((*yyvaluep).expr_vec)) != nullptr) { for (auto ptr : *(((*yyvaluep).expr_vec))) { delete ptr; @@ -1806,12 +2248,12 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio } delete (((*yyvaluep).expr_vec)); } -#line 1810 "bison_parser.cpp" +#line 2252 "bison_parser.cpp" break; - case 173: /* hint_list */ + case 175: /* hint_list */ #line 150 "bison_parser.y" - { + { if ((((*yyvaluep).expr_vec)) != nullptr) { for (auto ptr : *(((*yyvaluep).expr_vec))) { delete ptr; @@ -1819,90 +2261,90 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio } delete (((*yyvaluep).expr_vec)); } -#line 1823 "bison_parser.cpp" +#line 2265 "bison_parser.cpp" break; - case 174: /* hint */ + case 176: /* hint */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 1829 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2271 "bison_parser.cpp" break; - case 175: /* transaction_statement */ + case 177: /* transaction_statement */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).transaction_stmt)); } -#line 1835 "bison_parser.cpp" + { delete (((*yyvaluep).transaction_stmt)); } +#line 2277 "bison_parser.cpp" break; - case 177: /* prepare_statement */ + case 179: /* prepare_statement */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).prep_stmt)); } -#line 1841 "bison_parser.cpp" + { delete (((*yyvaluep).prep_stmt)); } +#line 2283 "bison_parser.cpp" break; - case 178: /* prepare_target_query */ + case 180: /* prepare_target_query */ #line 149 "bison_parser.y" - { free( (((*yyvaluep).sval)) ); } -#line 1847 "bison_parser.cpp" + { free( (((*yyvaluep).sval)) ); } +#line 2289 "bison_parser.cpp" break; - case 179: /* execute_statement */ + case 181: /* execute_statement */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).exec_stmt)); } -#line 1853 "bison_parser.cpp" + { delete (((*yyvaluep).exec_stmt)); } +#line 2295 "bison_parser.cpp" break; - case 180: /* import_statement */ + case 182: /* import_statement */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).import_stmt)); } -#line 1859 "bison_parser.cpp" + { delete (((*yyvaluep).import_stmt)); } +#line 2301 "bison_parser.cpp" break; - case 181: /* file_type */ + case 183: /* file_type */ #line 147 "bison_parser.y" - { } -#line 1865 "bison_parser.cpp" + { } +#line 2307 "bison_parser.cpp" break; - case 182: /* file_path */ + case 184: /* file_path */ #line 149 "bison_parser.y" - { free( (((*yyvaluep).sval)) ); } -#line 1871 "bison_parser.cpp" + { free( (((*yyvaluep).sval)) ); } +#line 2313 "bison_parser.cpp" break; - case 183: /* opt_file_type */ + case 185: /* opt_file_type */ #line 147 "bison_parser.y" - { } -#line 1877 "bison_parser.cpp" + { } +#line 2319 "bison_parser.cpp" break; - case 184: /* export_statement */ + case 186: /* export_statement */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).export_stmt)); } -#line 1883 "bison_parser.cpp" + { delete (((*yyvaluep).export_stmt)); } +#line 2325 "bison_parser.cpp" break; - case 185: /* show_statement */ + case 187: /* show_statement */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).show_stmt)); } -#line 1889 "bison_parser.cpp" + { delete (((*yyvaluep).show_stmt)); } +#line 2331 "bison_parser.cpp" break; - case 186: /* create_statement */ + case 188: /* create_statement */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).create_stmt)); } -#line 1895 "bison_parser.cpp" + { delete (((*yyvaluep).create_stmt)); } +#line 2337 "bison_parser.cpp" break; - case 187: /* opt_not_exists */ + case 189: /* opt_not_exists */ #line 147 "bison_parser.y" - { } -#line 1901 "bison_parser.cpp" + { } +#line 2343 "bison_parser.cpp" break; - case 188: /* column_def_commalist */ + case 190: /* column_def_commalist */ #line 150 "bison_parser.y" - { + { if ((((*yyvaluep).column_vec)) != nullptr) { for (auto ptr : *(((*yyvaluep).column_vec))) { delete ptr; @@ -1910,60 +2352,60 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio } delete (((*yyvaluep).column_vec)); } -#line 1914 "bison_parser.cpp" +#line 2356 "bison_parser.cpp" break; - case 189: /* column_def */ + case 191: /* column_def */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).column_t)); } -#line 1920 "bison_parser.cpp" + { delete (((*yyvaluep).column_t)); } +#line 2362 "bison_parser.cpp" break; - case 190: /* column_type */ + case 192: /* column_type */ #line 147 "bison_parser.y" - { } -#line 1926 "bison_parser.cpp" + { } +#line 2368 "bison_parser.cpp" break; - case 191: /* opt_column_nullable */ + case 193: /* opt_column_nullable */ #line 147 "bison_parser.y" - { } -#line 1932 "bison_parser.cpp" + { } +#line 2374 "bison_parser.cpp" break; - case 192: /* drop_statement */ + case 194: /* drop_statement */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).drop_stmt)); } -#line 1938 "bison_parser.cpp" + { delete (((*yyvaluep).drop_stmt)); } +#line 2380 "bison_parser.cpp" break; - case 193: /* opt_exists */ + case 195: /* opt_exists */ #line 147 "bison_parser.y" - { } -#line 1944 "bison_parser.cpp" + { } +#line 2386 "bison_parser.cpp" break; - case 194: /* delete_statement */ + case 196: /* delete_statement */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).delete_stmt)); } -#line 1950 "bison_parser.cpp" + { delete (((*yyvaluep).delete_stmt)); } +#line 2392 "bison_parser.cpp" break; - case 195: /* truncate_statement */ + case 197: /* truncate_statement */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).delete_stmt)); } -#line 1956 "bison_parser.cpp" + { delete (((*yyvaluep).delete_stmt)); } +#line 2398 "bison_parser.cpp" break; - case 196: /* insert_statement */ + case 198: /* insert_statement */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).insert_stmt)); } -#line 1962 "bison_parser.cpp" + { delete (((*yyvaluep).insert_stmt)); } +#line 2404 "bison_parser.cpp" break; - case 197: /* opt_column_list */ + case 199: /* opt_column_list */ #line 150 "bison_parser.y" - { + { if ((((*yyvaluep).str_vec)) != nullptr) { for (auto ptr : *(((*yyvaluep).str_vec))) { delete ptr; @@ -1971,18 +2413,18 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio } delete (((*yyvaluep).str_vec)); } -#line 1975 "bison_parser.cpp" +#line 2417 "bison_parser.cpp" break; - case 198: /* update_statement */ + case 200: /* update_statement */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).update_stmt)); } -#line 1981 "bison_parser.cpp" + { delete (((*yyvaluep).update_stmt)); } +#line 2423 "bison_parser.cpp" break; - case 199: /* update_clause_commalist */ + case 201: /* update_clause_commalist */ #line 150 "bison_parser.y" - { + { if ((((*yyvaluep).update_vec)) != nullptr) { for (auto ptr : *(((*yyvaluep).update_vec))) { delete ptr; @@ -1990,78 +2432,78 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio } delete (((*yyvaluep).update_vec)); } -#line 1994 "bison_parser.cpp" +#line 2436 "bison_parser.cpp" break; - case 200: /* update_clause */ + case 202: /* update_clause */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).update_t)); } -#line 2000 "bison_parser.cpp" + { delete (((*yyvaluep).update_t)); } +#line 2442 "bison_parser.cpp" break; - case 201: /* select_statement */ + case 203: /* select_statement */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).select_stmt)); } -#line 2006 "bison_parser.cpp" + { delete (((*yyvaluep).select_stmt)); } +#line 2448 "bison_parser.cpp" break; - case 202: /* select_within_set_operation */ + case 204: /* select_within_set_operation */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).select_stmt)); } -#line 2012 "bison_parser.cpp" + { delete (((*yyvaluep).select_stmt)); } +#line 2454 "bison_parser.cpp" break; - case 203: /* select_within_set_operation_no_parentheses */ + case 205: /* select_within_set_operation_no_parentheses */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).select_stmt)); } -#line 2018 "bison_parser.cpp" + { delete (((*yyvaluep).select_stmt)); } +#line 2460 "bison_parser.cpp" break; - case 204: /* select_with_paren */ + case 206: /* select_with_paren */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).select_stmt)); } -#line 2024 "bison_parser.cpp" + { delete (((*yyvaluep).select_stmt)); } +#line 2466 "bison_parser.cpp" break; - case 205: /* select_no_paren */ + case 207: /* select_no_paren */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).select_stmt)); } -#line 2030 "bison_parser.cpp" + { delete (((*yyvaluep).select_stmt)); } +#line 2472 "bison_parser.cpp" break; - case 206: /* set_operator */ + case 208: /* set_operator */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).set_operator_t)); } -#line 2036 "bison_parser.cpp" + { delete (((*yyvaluep).set_operator_t)); } +#line 2478 "bison_parser.cpp" break; - case 207: /* set_type */ + case 209: /* set_type */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).set_operator_t)); } -#line 2042 "bison_parser.cpp" + { delete (((*yyvaluep).set_operator_t)); } +#line 2484 "bison_parser.cpp" break; - case 208: /* opt_all */ + case 210: /* opt_all */ #line 147 "bison_parser.y" - { } -#line 2048 "bison_parser.cpp" + { } +#line 2490 "bison_parser.cpp" break; - case 209: /* select_clause */ + case 211: /* select_clause */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).select_stmt)); } -#line 2054 "bison_parser.cpp" + { delete (((*yyvaluep).select_stmt)); } +#line 2496 "bison_parser.cpp" break; - case 210: /* opt_distinct */ + case 212: /* opt_distinct */ #line 147 "bison_parser.y" - { } -#line 2060 "bison_parser.cpp" + { } +#line 2502 "bison_parser.cpp" break; - case 211: /* select_list */ + case 213: /* select_list */ #line 150 "bison_parser.y" - { + { if ((((*yyvaluep).expr_vec)) != nullptr) { for (auto ptr : *(((*yyvaluep).expr_vec))) { delete ptr; @@ -2069,42 +2511,42 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio } delete (((*yyvaluep).expr_vec)); } -#line 2073 "bison_parser.cpp" +#line 2515 "bison_parser.cpp" break; - case 212: /* opt_from_clause */ + case 214: /* opt_from_clause */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).table)); } -#line 2079 "bison_parser.cpp" + { delete (((*yyvaluep).table)); } +#line 2521 "bison_parser.cpp" break; - case 213: /* from_clause */ + case 215: /* from_clause */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).table)); } -#line 2085 "bison_parser.cpp" + { delete (((*yyvaluep).table)); } +#line 2527 "bison_parser.cpp" break; - case 214: /* opt_where */ + case 216: /* opt_where */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2091 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2533 "bison_parser.cpp" break; - case 215: /* opt_group */ + case 217: /* opt_group */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).group_t)); } -#line 2097 "bison_parser.cpp" + { delete (((*yyvaluep).group_t)); } +#line 2539 "bison_parser.cpp" break; - case 216: /* opt_having */ + case 218: /* opt_having */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2103 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2545 "bison_parser.cpp" break; - case 217: /* opt_order */ + case 219: /* opt_order */ #line 150 "bison_parser.y" - { + { if ((((*yyvaluep).order_vec)) != nullptr) { for (auto ptr : *(((*yyvaluep).order_vec))) { delete ptr; @@ -2112,12 +2554,12 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio } delete (((*yyvaluep).order_vec)); } -#line 2116 "bison_parser.cpp" +#line 2558 "bison_parser.cpp" break; - case 218: /* order_list */ + case 220: /* order_list */ #line 150 "bison_parser.y" - { + { if ((((*yyvaluep).order_vec)) != nullptr) { for (auto ptr : *(((*yyvaluep).order_vec))) { delete ptr; @@ -2125,36 +2567,36 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio } delete (((*yyvaluep).order_vec)); } -#line 2129 "bison_parser.cpp" +#line 2571 "bison_parser.cpp" break; - case 219: /* order_desc */ + case 221: /* order_desc */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).order)); } -#line 2135 "bison_parser.cpp" + { delete (((*yyvaluep).order)); } +#line 2577 "bison_parser.cpp" break; - case 220: /* opt_order_type */ + case 222: /* opt_order_type */ #line 147 "bison_parser.y" - { } -#line 2141 "bison_parser.cpp" + { } +#line 2583 "bison_parser.cpp" break; - case 221: /* opt_top */ + case 223: /* opt_top */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).limit)); } -#line 2147 "bison_parser.cpp" + { delete (((*yyvaluep).limit)); } +#line 2589 "bison_parser.cpp" break; - case 222: /* opt_limit */ + case 224: /* opt_limit */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).limit)); } -#line 2153 "bison_parser.cpp" + { delete (((*yyvaluep).limit)); } +#line 2595 "bison_parser.cpp" break; - case 223: /* expr_list */ + case 225: /* expr_list */ #line 150 "bison_parser.y" - { + { if ((((*yyvaluep).expr_vec)) != nullptr) { for (auto ptr : *(((*yyvaluep).expr_vec))) { delete ptr; @@ -2162,12 +2604,12 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio } delete (((*yyvaluep).expr_vec)); } -#line 2166 "bison_parser.cpp" +#line 2608 "bison_parser.cpp" break; - case 224: /* opt_literal_list */ + case 226: /* opt_literal_list */ #line 150 "bison_parser.y" - { + { if ((((*yyvaluep).expr_vec)) != nullptr) { for (auto ptr : *(((*yyvaluep).expr_vec))) { delete ptr; @@ -2175,12 +2617,12 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio } delete (((*yyvaluep).expr_vec)); } -#line 2179 "bison_parser.cpp" +#line 2621 "bison_parser.cpp" break; - case 225: /* literal_list */ + case 227: /* literal_list */ #line 150 "bison_parser.y" - { + { if ((((*yyvaluep).expr_vec)) != nullptr) { for (auto ptr : *(((*yyvaluep).expr_vec))) { delete ptr; @@ -2188,186 +2630,192 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio } delete (((*yyvaluep).expr_vec)); } -#line 2192 "bison_parser.cpp" +#line 2634 "bison_parser.cpp" break; - case 226: /* expr_alias */ + case 228: /* expr_alias */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2198 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2640 "bison_parser.cpp" break; - case 227: /* expr */ + case 229: /* expr */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2204 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2646 "bison_parser.cpp" break; - case 228: /* operand */ + case 230: /* operand */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2210 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2652 "bison_parser.cpp" break; - case 229: /* scalar_expr */ + case 231: /* scalar_expr */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2216 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2658 "bison_parser.cpp" break; - case 230: /* unary_expr */ + case 232: /* unary_expr */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2222 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2664 "bison_parser.cpp" break; - case 231: /* binary_expr */ + case 233: /* binary_expr */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2228 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2670 "bison_parser.cpp" break; - case 232: /* logic_expr */ + case 234: /* logic_expr */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2234 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2676 "bison_parser.cpp" break; - case 233: /* in_expr */ + case 235: /* in_expr */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2240 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2682 "bison_parser.cpp" break; - case 234: /* case_expr */ + case 236: /* case_expr */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2246 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2688 "bison_parser.cpp" break; - case 235: /* case_list */ + case 237: /* case_list */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2252 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2694 "bison_parser.cpp" break; - case 236: /* exists_expr */ + case 238: /* exists_expr */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2258 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2700 "bison_parser.cpp" break; - case 237: /* comp_expr */ + case 239: /* comp_expr */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2264 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2706 "bison_parser.cpp" break; - case 238: /* function_expr */ + case 240: /* function_expr */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2270 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2712 "bison_parser.cpp" break; - case 239: /* extract_expr */ + case 241: /* extract_expr */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2276 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2718 "bison_parser.cpp" break; - case 240: /* datetime_field */ + case 242: /* cast_expr */ +#line 158 "bison_parser.y" + { delete (((*yyvaluep).expr)); } +#line 2724 "bison_parser.cpp" + break; + + case 243: /* datetime_field */ #line 147 "bison_parser.y" - { } -#line 2282 "bison_parser.cpp" + { } +#line 2730 "bison_parser.cpp" break; - case 241: /* array_expr */ + case 244: /* array_expr */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2288 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2736 "bison_parser.cpp" break; - case 242: /* array_index */ + case 245: /* array_index */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2294 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2742 "bison_parser.cpp" break; - case 243: /* between_expr */ + case 246: /* between_expr */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2300 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2748 "bison_parser.cpp" break; - case 244: /* column_name */ + case 247: /* column_name */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2306 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2754 "bison_parser.cpp" break; - case 245: /* literal */ + case 248: /* literal */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2312 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2760 "bison_parser.cpp" break; - case 246: /* string_literal */ + case 249: /* string_literal */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2318 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2766 "bison_parser.cpp" break; - case 247: /* bool_literal */ + case 250: /* bool_literal */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2324 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2772 "bison_parser.cpp" break; - case 248: /* num_literal */ + case 251: /* num_literal */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2330 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2778 "bison_parser.cpp" break; - case 249: /* int_literal */ + case 252: /* int_literal */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2336 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2784 "bison_parser.cpp" break; - case 250: /* null_literal */ + case 253: /* null_literal */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2342 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2790 "bison_parser.cpp" break; - case 251: /* param_expr */ + case 254: /* param_expr */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2348 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2796 "bison_parser.cpp" break; - case 252: /* table_ref */ + case 255: /* table_ref */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).table)); } -#line 2354 "bison_parser.cpp" + { delete (((*yyvaluep).table)); } +#line 2802 "bison_parser.cpp" break; - case 253: /* table_ref_atomic */ + case 256: /* table_ref_atomic */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).table)); } -#line 2360 "bison_parser.cpp" + { delete (((*yyvaluep).table)); } +#line 2808 "bison_parser.cpp" break; - case 254: /* nonjoin_table_ref_atomic */ + case 257: /* nonjoin_table_ref_atomic */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).table)); } -#line 2366 "bison_parser.cpp" + { delete (((*yyvaluep).table)); } +#line 2814 "bison_parser.cpp" break; - case 255: /* table_ref_commalist */ + case 258: /* table_ref_commalist */ #line 150 "bison_parser.y" - { + { if ((((*yyvaluep).table_vec)) != nullptr) { for (auto ptr : *(((*yyvaluep).table_vec))) { delete ptr; @@ -2375,96 +2823,96 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio } delete (((*yyvaluep).table_vec)); } -#line 2379 "bison_parser.cpp" +#line 2827 "bison_parser.cpp" break; - case 256: /* table_ref_name */ + case 259: /* table_ref_name */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).table)); } -#line 2385 "bison_parser.cpp" + { delete (((*yyvaluep).table)); } +#line 2833 "bison_parser.cpp" break; - case 257: /* table_ref_name_no_alias */ + case 260: /* table_ref_name_no_alias */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).table)); } -#line 2391 "bison_parser.cpp" + { delete (((*yyvaluep).table)); } +#line 2839 "bison_parser.cpp" break; - case 258: /* table_name */ + case 261: /* table_name */ #line 148 "bison_parser.y" - { free( (((*yyvaluep).table_name).name) ); free( (((*yyvaluep).table_name).schema) ); } -#line 2397 "bison_parser.cpp" + { free( (((*yyvaluep).table_name).name) ); free( (((*yyvaluep).table_name).schema) ); } +#line 2845 "bison_parser.cpp" break; - case 259: /* table_alias */ + case 262: /* table_alias */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).alias_t)); } -#line 2403 "bison_parser.cpp" + { delete (((*yyvaluep).alias_t)); } +#line 2851 "bison_parser.cpp" break; - case 260: /* opt_table_alias */ + case 263: /* opt_table_alias */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).alias_t)); } -#line 2409 "bison_parser.cpp" + { delete (((*yyvaluep).alias_t)); } +#line 2857 "bison_parser.cpp" break; - case 261: /* alias */ + case 264: /* alias */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).alias_t)); } -#line 2415 "bison_parser.cpp" + { delete (((*yyvaluep).alias_t)); } +#line 2863 "bison_parser.cpp" break; - case 262: /* opt_alias */ + case 265: /* opt_alias */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).alias_t)); } -#line 2421 "bison_parser.cpp" + { delete (((*yyvaluep).alias_t)); } +#line 2869 "bison_parser.cpp" break; - case 263: /* opt_with_clause */ + case 266: /* opt_with_clause */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).with_description_vec)); } -#line 2427 "bison_parser.cpp" + { delete (((*yyvaluep).with_description_vec)); } +#line 2875 "bison_parser.cpp" break; - case 264: /* with_clause */ + case 267: /* with_clause */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).with_description_vec)); } -#line 2433 "bison_parser.cpp" + { delete (((*yyvaluep).with_description_vec)); } +#line 2881 "bison_parser.cpp" break; - case 265: /* with_description_list */ + case 268: /* with_description_list */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).with_description_vec)); } -#line 2439 "bison_parser.cpp" + { delete (((*yyvaluep).with_description_vec)); } +#line 2887 "bison_parser.cpp" break; - case 266: /* with_description */ + case 269: /* with_description */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).with_description_t)); } -#line 2445 "bison_parser.cpp" + { delete (((*yyvaluep).with_description_t)); } +#line 2893 "bison_parser.cpp" break; - case 267: /* join_clause */ + case 270: /* join_clause */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).table)); } -#line 2451 "bison_parser.cpp" + { delete (((*yyvaluep).table)); } +#line 2899 "bison_parser.cpp" break; - case 268: /* opt_join_type */ + case 271: /* opt_join_type */ #line 147 "bison_parser.y" - { } -#line 2457 "bison_parser.cpp" + { } +#line 2905 "bison_parser.cpp" break; - case 269: /* join_condition */ + case 272: /* join_condition */ #line 158 "bison_parser.y" - { delete (((*yyvaluep).expr)); } -#line 2463 "bison_parser.cpp" + { delete (((*yyvaluep).expr)); } +#line 2911 "bison_parser.cpp" break; - case 271: /* ident_commalist */ + case 274: /* ident_commalist */ #line 150 "bison_parser.y" - { + { if ((((*yyvaluep).str_vec)) != nullptr) { for (auto ptr : *(((*yyvaluep).str_vec))) { delete ptr; @@ -2472,7 +2920,7 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio } delete (((*yyvaluep).str_vec)); } -#line 2476 "bison_parser.cpp" +#line 2924 "bison_parser.cpp" break; default: @@ -2484,6 +2932,8 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio + + /*----------. | yyparse. | `----------*/ @@ -2512,7 +2962,7 @@ YYLTYPE yylloc = yyloc_default; /* Number of syntax errors so far. */ int yynerrs; - int yystate; + yy_state_fast_t yystate; /* Number of tokens to shift before error messages enabled. */ int yyerrstatus; @@ -2524,10 +2974,13 @@ YYLTYPE yylloc = yyloc_default; Refer to the stacks through separate pointers, to allow yyoverflow to reallocate them elsewhere. */ + /* Their size. */ + YYPTRDIFF_T yystacksize; + /* The state stack. */ - yytype_int16 yyssa[YYINITDEPTH]; - yytype_int16 *yyss; - yytype_int16 *yyssp; + yy_state_t yyssa[YYINITDEPTH]; + yy_state_t *yyss; + yy_state_t *yyssp; /* The semantic value stack. */ YYSTYPE yyvsa[YYINITDEPTH]; @@ -2539,26 +2992,23 @@ YYLTYPE yylloc = yyloc_default; YYLTYPE *yyls; YYLTYPE *yylsp; - /* The locations where the error started and ended. */ - YYLTYPE yyerror_range[3]; - - YYSIZE_T yystacksize; - int yyn; + /* The return value of yyparse. */ int yyresult; /* Lookahead token as an internal (translated) token number. */ - int yytoken = 0; + yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; /* The variables used to return semantic value and location from the action routines. */ YYSTYPE yyval; YYLTYPE yyloc; -#if YYERROR_VERBOSE + /* The locations where the error started and ended. */ + YYLTYPE yyerror_range[3]; + /* Buffer for error messages, and its allocated size. */ char yymsgbuf[128]; char *yymsg = yymsgbuf; - YYSIZE_T yymsg_alloc = sizeof yymsgbuf; -#endif + YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) @@ -2566,17 +3016,19 @@ YYLTYPE yylloc = yyloc_default; Keep to zero when no symbol should be popped. */ int yylen = 0; + yynerrs = 0; + yystate = 0; + yyerrstatus = 0; + + yystacksize = YYINITDEPTH; yyssp = yyss = yyssa; yyvsp = yyvs = yyvsa; yylsp = yyls = yylsa; - yystacksize = YYINITDEPTH; + YYDPRINTF ((stderr, "Starting parse\n")); - yystate = 0; - yyerrstatus = 0; - yynerrs = 0; - yychar = YYEMPTY; /* Cause a token to be read. */ + yychar = SQL_HSQL_EMPTY; /* Cause a token to be read. */ /* User initialization code. */ #line 73 "bison_parser.y" @@ -2590,7 +3042,7 @@ YYLTYPE yylloc = yyloc_default; yylloc.string_length = 0; } -#line 2594 "bison_parser.cpp" +#line 3046 "bison_parser.cpp" yylsp[0] = yylloc; goto yysetstate; @@ -2606,12 +3058,15 @@ yynewstate: /*--------------------------------------------------------------------. -| yynewstate -- set current state (the top of the stack) to yystate. | +| yysetstate -- set current state (the top of the stack) to yystate. | `--------------------------------------------------------------------*/ yysetstate: YYDPRINTF ((stderr, "Entering state %d\n", yystate)); YY_ASSERT (0 <= yystate && yystate < YYNSTATES); - *yyssp = (yytype_int16) yystate; + YY_IGNORE_USELESS_CAST_BEGIN + *yyssp = YY_CAST (yy_state_t, yystate); + YY_IGNORE_USELESS_CAST_END + YY_STACK_PRINT (yyss, yyssp); if (yyss + yystacksize - 1 <= yyssp) #if !defined yyoverflow && !defined YYSTACK_RELOCATE @@ -2619,15 +3074,15 @@ yysetstate: #else { /* Get the current used size of the three stacks, in elements. */ - YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1); + YYPTRDIFF_T yysize = yyssp - yyss + 1; # if defined yyoverflow { /* Give user a chance to reallocate the stack. Use copies of these so that the &'s don't force the real ones into memory. */ + yy_state_t *yyss1 = yyss; YYSTYPE *yyvs1 = yyvs; - yytype_int16 *yyss1 = yyss; YYLTYPE *yyls1 = yyls; /* Each stack pointer address is followed by the size of the @@ -2635,9 +3090,9 @@ yysetstate: conditional around just the two extra args, but that might be undefined if yyoverflow is a macro. */ yyoverflow (YY_("memory exhausted"), - &yyss1, yysize * sizeof (*yyssp), - &yyvs1, yysize * sizeof (*yyvsp), - &yyls1, yysize * sizeof (*yylsp), + &yyss1, yysize * YYSIZEOF (*yyssp), + &yyvs1, yysize * YYSIZEOF (*yyvsp), + &yyls1, yysize * YYSIZEOF (*yylsp), &yystacksize); yyss = yyss1; yyvs = yyvs1; @@ -2652,15 +3107,16 @@ yysetstate: yystacksize = YYMAXDEPTH; { - yytype_int16 *yyss1 = yyss; + yy_state_t *yyss1 = yyss; union yyalloc *yyptr = - (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + YY_CAST (union yyalloc *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); if (! yyptr) goto yyexhaustedlab; YYSTACK_RELOCATE (yyss_alloc, yyss); YYSTACK_RELOCATE (yyvs_alloc, yyvs); YYSTACK_RELOCATE (yyls_alloc, yyls); -# undef YYSTACK_RELOCATE +# undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } @@ -2670,8 +3126,10 @@ yysetstate: yyvsp = yyvs + yysize - 1; yylsp = yyls + yysize - 1; - YYDPRINTF ((stderr, "Stack size increased to %lu\n", - (unsigned long) yystacksize)); + YY_IGNORE_USELESS_CAST_BEGIN + YYDPRINTF ((stderr, "Stack size increased to %ld\n", + YY_CAST (long, yystacksize))); + YY_IGNORE_USELESS_CAST_END if (yyss + yystacksize - 1 <= yyssp) YYABORT; @@ -2698,18 +3156,30 @@ yybackup: /* Not known => get a lookahead token if don't already have one. */ - /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ - if (yychar == YYEMPTY) + /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ + if (yychar == SQL_HSQL_EMPTY) { - YYDPRINTF ((stderr, "Reading a token: ")); + YYDPRINTF ((stderr, "Reading a token\n")); yychar = yylex (&yylval, &yylloc, scanner); } - if (yychar <= YYEOF) + if (yychar <= SQL_YYEOF) { - yychar = yytoken = YYEOF; + yychar = SQL_YYEOF; + yytoken = YYSYMBOL_YYEOF; YYDPRINTF ((stderr, "Now at end of input.\n")); } + else if (yychar == SQL_HSQL_error) + { + /* The scanner already issued an error message, process directly + to error recovery. But do not keep the error token as + lookahead, it is too special and may lead us to an endless + loop in error recovery. */ + yychar = SQL_HSQL_UNDEF; + yytoken = YYSYMBOL_YYerror; + yyerror_range[1] = yylloc; + goto yyerrlab1; + } else { yytoken = YYTRANSLATE (yychar); @@ -2737,15 +3207,14 @@ yybackup: /* Shift the lookahead token. */ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); - - /* Discard the shifted token. */ - yychar = YYEMPTY; - yystate = yyn; YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN *++yyvsp = yylval; YY_IGNORE_MAYBE_UNINITIALIZED_END *++yylsp = yylloc; + + /* Discard the shifted token. */ + yychar = SQL_HSQL_EMPTY; goto yynewstate; @@ -2784,7 +3253,7 @@ yyreduce: { case 2: #line 269 "bison_parser.y" - { + { for (SQLStatement* stmt : *(yyvsp[-1].stmt_vec)) { // Transfers ownership of the statement. result->addStatement(stmt); @@ -2801,248 +3270,248 @@ yyreduce: } delete (yyvsp[-1].stmt_vec); } -#line 2805 "bison_parser.cpp" +#line 3274 "bison_parser.cpp" break; case 3: #line 290 "bison_parser.y" - { + { (yyvsp[0].statement)->stringLength = yylloc.string_length; yylloc.string_length = 0; (yyval.stmt_vec) = new std::vector(); (yyval.stmt_vec)->push_back((yyvsp[0].statement)); } -#line 2816 "bison_parser.cpp" +#line 3285 "bison_parser.cpp" break; case 4: #line 296 "bison_parser.y" - { + { (yyvsp[0].statement)->stringLength = yylloc.string_length; yylloc.string_length = 0; (yyvsp[-2].stmt_vec)->push_back((yyvsp[0].statement)); (yyval.stmt_vec) = (yyvsp[-2].stmt_vec); } -#line 2827 "bison_parser.cpp" +#line 3296 "bison_parser.cpp" break; case 5: #line 305 "bison_parser.y" - { + { (yyval.statement) = (yyvsp[-1].prep_stmt); (yyval.statement)->hints = (yyvsp[0].expr_vec); } -#line 2836 "bison_parser.cpp" +#line 3305 "bison_parser.cpp" break; case 6: #line 309 "bison_parser.y" - { + { (yyval.statement) = (yyvsp[-1].statement); (yyval.statement)->hints = (yyvsp[0].expr_vec); } -#line 2845 "bison_parser.cpp" +#line 3314 "bison_parser.cpp" break; case 7: #line 313 "bison_parser.y" - { + { (yyval.statement) = (yyvsp[0].show_stmt); } -#line 2853 "bison_parser.cpp" +#line 3322 "bison_parser.cpp" break; case 8: #line 316 "bison_parser.y" - { + { (yyval.statement) = (yyvsp[0].import_stmt); } -#line 2861 "bison_parser.cpp" +#line 3330 "bison_parser.cpp" break; case 9: #line 319 "bison_parser.y" - { + { (yyval.statement) = (yyvsp[0].export_stmt); } -#line 2869 "bison_parser.cpp" +#line 3338 "bison_parser.cpp" break; case 10: #line 326 "bison_parser.y" - { (yyval.statement) = (yyvsp[0].select_stmt); } -#line 2875 "bison_parser.cpp" + { (yyval.statement) = (yyvsp[0].select_stmt); } +#line 3344 "bison_parser.cpp" break; case 11: #line 327 "bison_parser.y" - { (yyval.statement) = (yyvsp[0].create_stmt); } -#line 2881 "bison_parser.cpp" + { (yyval.statement) = (yyvsp[0].create_stmt); } +#line 3350 "bison_parser.cpp" break; case 12: #line 328 "bison_parser.y" - { (yyval.statement) = (yyvsp[0].insert_stmt); } -#line 2887 "bison_parser.cpp" + { (yyval.statement) = (yyvsp[0].insert_stmt); } +#line 3356 "bison_parser.cpp" break; case 13: #line 329 "bison_parser.y" - { (yyval.statement) = (yyvsp[0].delete_stmt); } -#line 2893 "bison_parser.cpp" + { (yyval.statement) = (yyvsp[0].delete_stmt); } +#line 3362 "bison_parser.cpp" break; case 14: #line 330 "bison_parser.y" - { (yyval.statement) = (yyvsp[0].delete_stmt); } -#line 2899 "bison_parser.cpp" + { (yyval.statement) = (yyvsp[0].delete_stmt); } +#line 3368 "bison_parser.cpp" break; case 15: #line 331 "bison_parser.y" - { (yyval.statement) = (yyvsp[0].update_stmt); } -#line 2905 "bison_parser.cpp" + { (yyval.statement) = (yyvsp[0].update_stmt); } +#line 3374 "bison_parser.cpp" break; case 16: #line 332 "bison_parser.y" - { (yyval.statement) = (yyvsp[0].drop_stmt); } -#line 2911 "bison_parser.cpp" + { (yyval.statement) = (yyvsp[0].drop_stmt); } +#line 3380 "bison_parser.cpp" break; case 17: #line 333 "bison_parser.y" - { (yyval.statement) = (yyvsp[0].exec_stmt); } -#line 2917 "bison_parser.cpp" + { (yyval.statement) = (yyvsp[0].exec_stmt); } +#line 3386 "bison_parser.cpp" break; case 18: #line 334 "bison_parser.y" - { (yyval.statement) = (yyvsp[0].transaction_stmt); } -#line 2923 "bison_parser.cpp" + { (yyval.statement) = (yyvsp[0].transaction_stmt); } +#line 3392 "bison_parser.cpp" break; case 19: #line 343 "bison_parser.y" - { (yyval.expr_vec) = (yyvsp[-1].expr_vec); } -#line 2929 "bison_parser.cpp" + { (yyval.expr_vec) = (yyvsp[-1].expr_vec); } +#line 3398 "bison_parser.cpp" break; case 20: #line 344 "bison_parser.y" - { (yyval.expr_vec) = nullptr; } -#line 2935 "bison_parser.cpp" + { (yyval.expr_vec) = nullptr; } +#line 3404 "bison_parser.cpp" break; case 21: #line 349 "bison_parser.y" - { (yyval.expr_vec) = new std::vector(); (yyval.expr_vec)->push_back((yyvsp[0].expr)); } -#line 2941 "bison_parser.cpp" + { (yyval.expr_vec) = new std::vector(); (yyval.expr_vec)->push_back((yyvsp[0].expr)); } +#line 3410 "bison_parser.cpp" break; case 22: #line 350 "bison_parser.y" - { (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); (yyval.expr_vec) = (yyvsp[-2].expr_vec); } -#line 2947 "bison_parser.cpp" + { (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); (yyval.expr_vec) = (yyvsp[-2].expr_vec); } +#line 3416 "bison_parser.cpp" break; case 23: #line 354 "bison_parser.y" - { + { (yyval.expr) = Expr::make(kExprHint); (yyval.expr)->name = (yyvsp[0].sval); } -#line 2956 "bison_parser.cpp" +#line 3425 "bison_parser.cpp" break; case 24: #line 358 "bison_parser.y" - { + { (yyval.expr) = Expr::make(kExprHint); (yyval.expr)->name = (yyvsp[-3].sval); (yyval.expr)->exprList = (yyvsp[-1].expr_vec); } -#line 2966 "bison_parser.cpp" +#line 3435 "bison_parser.cpp" break; case 25: #line 370 "bison_parser.y" - { + { (yyval.transaction_stmt) = new TransactionStatement(kBeginTransaction); } -#line 2974 "bison_parser.cpp" +#line 3443 "bison_parser.cpp" break; case 26: #line 373 "bison_parser.y" - { + { (yyval.transaction_stmt) = new TransactionStatement(kRollbackTransaction); } -#line 2982 "bison_parser.cpp" +#line 3451 "bison_parser.cpp" break; case 27: #line 376 "bison_parser.y" - { + { (yyval.transaction_stmt) = new TransactionStatement(kCommitTransaction); } -#line 2990 "bison_parser.cpp" +#line 3459 "bison_parser.cpp" break; case 30: #line 390 "bison_parser.y" - { + { (yyval.prep_stmt) = new PrepareStatement(); (yyval.prep_stmt)->name = (yyvsp[-2].sval); (yyval.prep_stmt)->query = (yyvsp[0].sval); } -#line 3000 "bison_parser.cpp" +#line 3469 "bison_parser.cpp" break; case 32: #line 400 "bison_parser.y" - { + { (yyval.exec_stmt) = new ExecuteStatement(); (yyval.exec_stmt)->name = (yyvsp[0].sval); } -#line 3009 "bison_parser.cpp" +#line 3478 "bison_parser.cpp" break; case 33: #line 404 "bison_parser.y" - { + { (yyval.exec_stmt) = new ExecuteStatement(); (yyval.exec_stmt)->name = (yyvsp[-3].sval); (yyval.exec_stmt)->parameters = (yyvsp[-1].expr_vec); } -#line 3019 "bison_parser.cpp" +#line 3488 "bison_parser.cpp" break; case 34: #line 418 "bison_parser.y" - { + { (yyval.import_stmt) = new ImportStatement((yyvsp[-4].import_type_t)); (yyval.import_stmt)->filePath = (yyvsp[-2].sval); (yyval.import_stmt)->schema = (yyvsp[0].table_name).schema; (yyval.import_stmt)->tableName = (yyvsp[0].table_name).name; } -#line 3030 "bison_parser.cpp" +#line 3499 "bison_parser.cpp" break; case 35: #line 424 "bison_parser.y" - { + { (yyval.import_stmt) = new ImportStatement((yyvsp[0].import_type_t)); (yyval.import_stmt)->filePath = (yyvsp[-1].sval); (yyval.import_stmt)->schema = (yyvsp[-3].table_name).schema; (yyval.import_stmt)->tableName = (yyvsp[-3].table_name).name; } -#line 3041 "bison_parser.cpp" +#line 3510 "bison_parser.cpp" break; case 36: #line 433 "bison_parser.y" - { + { if (strcasecmp((yyvsp[0].sval), "csv") == 0) { (yyval.import_type_t) = kImportCSV; } else if (strcasecmp((yyvsp[0].sval), "tbl") == 0) { @@ -3056,71 +3525,71 @@ yyreduce: } free((yyvsp[0].sval)); } -#line 3060 "bison_parser.cpp" +#line 3529 "bison_parser.cpp" break; case 37: #line 450 "bison_parser.y" - { (yyval.sval) = strdup((yyvsp[0].expr)->name); delete (yyvsp[0].expr); } -#line 3066 "bison_parser.cpp" + { (yyval.sval) = strdup((yyvsp[0].expr)->name); delete (yyvsp[0].expr); } +#line 3535 "bison_parser.cpp" break; case 38: #line 454 "bison_parser.y" - { + { (yyval.import_type_t) = (yyvsp[0].import_type_t); } -#line 3074 "bison_parser.cpp" +#line 3543 "bison_parser.cpp" break; case 39: #line 457 "bison_parser.y" - { (yyval.import_type_t) = kImportAuto; } -#line 3080 "bison_parser.cpp" + { (yyval.import_type_t) = kImportAuto; } +#line 3549 "bison_parser.cpp" break; case 40: #line 466 "bison_parser.y" - { + { (yyval.export_stmt) = new ExportStatement((yyvsp[0].import_type_t)); (yyval.export_stmt)->filePath = (yyvsp[-1].sval); (yyval.export_stmt)->schema = (yyvsp[-3].table_name).schema; (yyval.export_stmt)->tableName = (yyvsp[-3].table_name).name; } -#line 3091 "bison_parser.cpp" +#line 3560 "bison_parser.cpp" break; case 41: #line 480 "bison_parser.y" - { + { (yyval.show_stmt) = new ShowStatement(kShowTables); } -#line 3099 "bison_parser.cpp" +#line 3568 "bison_parser.cpp" break; case 42: #line 483 "bison_parser.y" - { + { (yyval.show_stmt) = new ShowStatement(kShowColumns); (yyval.show_stmt)->schema = (yyvsp[0].table_name).schema; (yyval.show_stmt)->name = (yyvsp[0].table_name).name; } -#line 3109 "bison_parser.cpp" +#line 3578 "bison_parser.cpp" break; case 43: #line 488 "bison_parser.y" - { + { (yyval.show_stmt) = new ShowStatement(kShowColumns); (yyval.show_stmt)->schema = (yyvsp[0].table_name).schema; (yyval.show_stmt)->name = (yyvsp[0].table_name).name; } -#line 3119 "bison_parser.cpp" +#line 3588 "bison_parser.cpp" break; case 44: #line 502 "bison_parser.y" - { + { (yyval.create_stmt) = new CreateStatement(kCreateTableFromTbl); (yyval.create_stmt)->ifNotExists = (yyvsp[-5].bval); (yyval.create_stmt)->schema = (yyvsp[-4].table_name).schema; @@ -3133,36 +3602,36 @@ yyreduce: free((yyvsp[-2].sval)); (yyval.create_stmt)->filePath = (yyvsp[0].sval); } -#line 3137 "bison_parser.cpp" +#line 3606 "bison_parser.cpp" break; case 45: #line 515 "bison_parser.y" - { + { (yyval.create_stmt) = new CreateStatement(kCreateTable); (yyval.create_stmt)->ifNotExists = (yyvsp[-4].bval); (yyval.create_stmt)->schema = (yyvsp[-3].table_name).schema; (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; (yyval.create_stmt)->columns = (yyvsp[-1].column_vec); } -#line 3149 "bison_parser.cpp" +#line 3618 "bison_parser.cpp" break; case 46: #line 522 "bison_parser.y" - { + { (yyval.create_stmt) = new CreateStatement(kCreateTable); (yyval.create_stmt)->ifNotExists = (yyvsp[-3].bval); (yyval.create_stmt)->schema = (yyvsp[-2].table_name).schema; (yyval.create_stmt)->tableName = (yyvsp[-2].table_name).name; (yyval.create_stmt)->select = (yyvsp[0].select_stmt); } -#line 3161 "bison_parser.cpp" +#line 3630 "bison_parser.cpp" break; case 47: #line 529 "bison_parser.y" - { + { (yyval.create_stmt) = new CreateStatement(kCreateView); (yyval.create_stmt)->ifNotExists = (yyvsp[-4].bval); (yyval.create_stmt)->schema = (yyvsp[-3].table_name).schema; @@ -3170,262 +3639,268 @@ yyreduce: (yyval.create_stmt)->viewColumns = (yyvsp[-2].str_vec); (yyval.create_stmt)->select = (yyvsp[0].select_stmt); } -#line 3174 "bison_parser.cpp" +#line 3643 "bison_parser.cpp" break; case 48: #line 540 "bison_parser.y" - { (yyval.bval) = true; } -#line 3180 "bison_parser.cpp" + { (yyval.bval) = true; } +#line 3649 "bison_parser.cpp" break; case 49: #line 541 "bison_parser.y" - { (yyval.bval) = false; } -#line 3186 "bison_parser.cpp" + { (yyval.bval) = false; } +#line 3655 "bison_parser.cpp" break; case 50: #line 545 "bison_parser.y" - { (yyval.column_vec) = new std::vector(); (yyval.column_vec)->push_back((yyvsp[0].column_t)); } -#line 3192 "bison_parser.cpp" + { (yyval.column_vec) = new std::vector(); (yyval.column_vec)->push_back((yyvsp[0].column_t)); } +#line 3661 "bison_parser.cpp" break; case 51: #line 546 "bison_parser.y" - { (yyvsp[-2].column_vec)->push_back((yyvsp[0].column_t)); (yyval.column_vec) = (yyvsp[-2].column_vec); } -#line 3198 "bison_parser.cpp" + { (yyvsp[-2].column_vec)->push_back((yyvsp[0].column_t)); (yyval.column_vec) = (yyvsp[-2].column_vec); } +#line 3667 "bison_parser.cpp" break; case 52: #line 550 "bison_parser.y" - { + { (yyval.column_t) = new ColumnDefinition((yyvsp[-2].sval), (yyvsp[-1].column_type_t), (yyvsp[0].bval)); } -#line 3206 "bison_parser.cpp" +#line 3675 "bison_parser.cpp" break; case 53: #line 556 "bison_parser.y" - { (yyval.column_type_t) = ColumnType{DataType::INT}; } -#line 3212 "bison_parser.cpp" + { (yyval.column_type_t) = ColumnType{DataType::INT}; } +#line 3681 "bison_parser.cpp" break; case 54: #line 557 "bison_parser.y" - { (yyval.column_type_t) = ColumnType{DataType::INT}; } -#line 3218 "bison_parser.cpp" + { (yyval.column_type_t) = ColumnType{DataType::INT}; } +#line 3687 "bison_parser.cpp" break; case 55: #line 558 "bison_parser.y" - { (yyval.column_type_t) = ColumnType{DataType::LONG}; } -#line 3224 "bison_parser.cpp" + { (yyval.column_type_t) = ColumnType{DataType::LONG}; } +#line 3693 "bison_parser.cpp" break; case 56: #line 559 "bison_parser.y" - { (yyval.column_type_t) = ColumnType{DataType::FLOAT}; } -#line 3230 "bison_parser.cpp" + { (yyval.column_type_t) = ColumnType{DataType::FLOAT}; } +#line 3699 "bison_parser.cpp" break; case 57: #line 560 "bison_parser.y" - { (yyval.column_type_t) = ColumnType{DataType::DOUBLE}; } -#line 3236 "bison_parser.cpp" + { (yyval.column_type_t) = ColumnType{DataType::DOUBLE}; } +#line 3705 "bison_parser.cpp" break; case 58: #line 561 "bison_parser.y" - { (yyval.column_type_t) = ColumnType{DataType::VARCHAR, (yyvsp[-1].ival)}; } -#line 3242 "bison_parser.cpp" + { (yyval.column_type_t) = ColumnType{DataType::VARCHAR, (yyvsp[-1].ival)}; } +#line 3711 "bison_parser.cpp" break; case 59: #line 562 "bison_parser.y" - { (yyval.column_type_t) = ColumnType{DataType::CHAR, (yyvsp[-1].ival)}; } -#line 3248 "bison_parser.cpp" + { (yyval.column_type_t) = ColumnType{DataType::CHAR, (yyvsp[-1].ival)}; } +#line 3717 "bison_parser.cpp" break; case 60: #line 563 "bison_parser.y" - { (yyval.column_type_t) = ColumnType{DataType::TEXT}; } -#line 3254 "bison_parser.cpp" + { (yyval.column_type_t) = ColumnType{DataType::TEXT}; } +#line 3723 "bison_parser.cpp" break; case 61: -#line 567 "bison_parser.y" - { (yyval.bval) = true; } -#line 3260 "bison_parser.cpp" +#line 564 "bison_parser.y" + { (yyval.column_type_t) = ColumnType{DataType::DATETIME}; } +#line 3729 "bison_parser.cpp" break; case 62: #line 568 "bison_parser.y" - { (yyval.bval) = false; } -#line 3266 "bison_parser.cpp" + { (yyval.bval) = true; } +#line 3735 "bison_parser.cpp" break; case 63: #line 569 "bison_parser.y" - { (yyval.bval) = false; } -#line 3272 "bison_parser.cpp" + { (yyval.bval) = false; } +#line 3741 "bison_parser.cpp" break; case 64: -#line 579 "bison_parser.y" - { +#line 570 "bison_parser.y" + { (yyval.bval) = false; } +#line 3747 "bison_parser.cpp" + break; + + case 65: +#line 580 "bison_parser.y" + { (yyval.drop_stmt) = new DropStatement(kDropTable); (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); (yyval.drop_stmt)->schema = (yyvsp[0].table_name).schema; (yyval.drop_stmt)->name = (yyvsp[0].table_name).name; } -#line 3283 "bison_parser.cpp" +#line 3758 "bison_parser.cpp" break; - case 65: -#line 585 "bison_parser.y" - { + case 66: +#line 586 "bison_parser.y" + { (yyval.drop_stmt) = new DropStatement(kDropView); (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); (yyval.drop_stmt)->schema = (yyvsp[0].table_name).schema; (yyval.drop_stmt)->name = (yyvsp[0].table_name).name; } -#line 3294 "bison_parser.cpp" +#line 3769 "bison_parser.cpp" break; - case 66: -#line 591 "bison_parser.y" - { + case 67: +#line 592 "bison_parser.y" + { (yyval.drop_stmt) = new DropStatement(kDropPreparedStatement); (yyval.drop_stmt)->ifExists = false; (yyval.drop_stmt)->name = (yyvsp[0].sval); } -#line 3304 "bison_parser.cpp" - break; - - case 67: -#line 599 "bison_parser.y" - { (yyval.bval) = true; } -#line 3310 "bison_parser.cpp" +#line 3779 "bison_parser.cpp" break; case 68: #line 600 "bison_parser.y" - { (yyval.bval) = false; } -#line 3316 "bison_parser.cpp" + { (yyval.bval) = true; } +#line 3785 "bison_parser.cpp" break; case 69: -#line 609 "bison_parser.y" - { +#line 601 "bison_parser.y" + { (yyval.bval) = false; } +#line 3791 "bison_parser.cpp" + break; + + case 70: +#line 610 "bison_parser.y" + { (yyval.delete_stmt) = new DeleteStatement(); (yyval.delete_stmt)->schema = (yyvsp[-1].table_name).schema; (yyval.delete_stmt)->tableName = (yyvsp[-1].table_name).name; (yyval.delete_stmt)->expr = (yyvsp[0].expr); } -#line 3327 "bison_parser.cpp" +#line 3802 "bison_parser.cpp" break; - case 70: -#line 618 "bison_parser.y" - { + case 71: +#line 619 "bison_parser.y" + { (yyval.delete_stmt) = new DeleteStatement(); (yyval.delete_stmt)->schema = (yyvsp[0].table_name).schema; (yyval.delete_stmt)->tableName = (yyvsp[0].table_name).name; } -#line 3337 "bison_parser.cpp" +#line 3812 "bison_parser.cpp" break; - case 71: -#line 631 "bison_parser.y" - { + case 72: +#line 632 "bison_parser.y" + { (yyval.insert_stmt) = new InsertStatement(kInsertValues); (yyval.insert_stmt)->schema = (yyvsp[-5].table_name).schema; (yyval.insert_stmt)->tableName = (yyvsp[-5].table_name).name; (yyval.insert_stmt)->columns = (yyvsp[-4].str_vec); (yyval.insert_stmt)->values = (yyvsp[-1].expr_vec); } -#line 3349 "bison_parser.cpp" +#line 3824 "bison_parser.cpp" break; - case 72: -#line 638 "bison_parser.y" - { + case 73: +#line 639 "bison_parser.y" + { (yyval.insert_stmt) = new InsertStatement(kInsertSelect); (yyval.insert_stmt)->schema = (yyvsp[-2].table_name).schema; (yyval.insert_stmt)->tableName = (yyvsp[-2].table_name).name; (yyval.insert_stmt)->columns = (yyvsp[-1].str_vec); (yyval.insert_stmt)->select = (yyvsp[0].select_stmt); } -#line 3361 "bison_parser.cpp" - break; - - case 73: -#line 649 "bison_parser.y" - { (yyval.str_vec) = (yyvsp[-1].str_vec); } -#line 3367 "bison_parser.cpp" +#line 3836 "bison_parser.cpp" break; case 74: #line 650 "bison_parser.y" - { (yyval.str_vec) = nullptr; } -#line 3373 "bison_parser.cpp" + { (yyval.str_vec) = (yyvsp[-1].str_vec); } +#line 3842 "bison_parser.cpp" break; case 75: -#line 660 "bison_parser.y" - { +#line 651 "bison_parser.y" + { (yyval.str_vec) = nullptr; } +#line 3848 "bison_parser.cpp" + break; + + case 76: +#line 661 "bison_parser.y" + { (yyval.update_stmt) = new UpdateStatement(); (yyval.update_stmt)->table = (yyvsp[-3].table); (yyval.update_stmt)->updates = (yyvsp[-1].update_vec); (yyval.update_stmt)->where = (yyvsp[0].expr); } -#line 3384 "bison_parser.cpp" - break; - - case 76: -#line 669 "bison_parser.y" - { (yyval.update_vec) = new std::vector(); (yyval.update_vec)->push_back((yyvsp[0].update_t)); } -#line 3390 "bison_parser.cpp" +#line 3859 "bison_parser.cpp" break; case 77: #line 670 "bison_parser.y" - { (yyvsp[-2].update_vec)->push_back((yyvsp[0].update_t)); (yyval.update_vec) = (yyvsp[-2].update_vec); } -#line 3396 "bison_parser.cpp" + { (yyval.update_vec) = new std::vector(); (yyval.update_vec)->push_back((yyvsp[0].update_t)); } +#line 3865 "bison_parser.cpp" break; case 78: -#line 674 "bison_parser.y" - { +#line 671 "bison_parser.y" + { (yyvsp[-2].update_vec)->push_back((yyvsp[0].update_t)); (yyval.update_vec) = (yyvsp[-2].update_vec); } +#line 3871 "bison_parser.cpp" + break; + + case 79: +#line 675 "bison_parser.y" + { (yyval.update_t) = new UpdateClause(); (yyval.update_t)->column = (yyvsp[-2].sval); (yyval.update_t)->value = (yyvsp[0].expr); } -#line 3406 "bison_parser.cpp" - break; - - case 79: -#line 686 "bison_parser.y" - { - (yyval.select_stmt) = (yyvsp[0].select_stmt); - (yyval.select_stmt)->withDescriptions = (yyvsp[-1].with_description_vec); - } -#line 3415 "bison_parser.cpp" +#line 3881 "bison_parser.cpp" break; case 80: -#line 690 "bison_parser.y" - { +#line 687 "bison_parser.y" + { (yyval.select_stmt) = (yyvsp[0].select_stmt); (yyval.select_stmt)->withDescriptions = (yyvsp[-1].with_description_vec); } -#line 3424 "bison_parser.cpp" +#line 3890 "bison_parser.cpp" break; case 81: -#line 694 "bison_parser.y" - { +#line 691 "bison_parser.y" + { + (yyval.select_stmt) = (yyvsp[0].select_stmt); + (yyval.select_stmt)->withDescriptions = (yyvsp[-1].with_description_vec); + } +#line 3899 "bison_parser.cpp" + break; + + case 82: +#line 695 "bison_parser.y" + { (yyval.select_stmt) = (yyvsp[-4].select_stmt); if ((yyval.select_stmt)->setOperations == nullptr) { (yyval.select_stmt)->setOperations = new std::vector(); @@ -3436,18 +3911,18 @@ yyreduce: (yyval.select_stmt)->setOperations->back()->resultLimit = (yyvsp[0].limit); (yyval.select_stmt)->withDescriptions = (yyvsp[-5].with_description_vec); } -#line 3440 "bison_parser.cpp" - break; - - case 84: -#line 712 "bison_parser.y" - { (yyval.select_stmt) = (yyvsp[0].select_stmt); } -#line 3446 "bison_parser.cpp" +#line 3915 "bison_parser.cpp" break; case 85: #line 713 "bison_parser.y" - { + { (yyval.select_stmt) = (yyvsp[0].select_stmt); } +#line 3921 "bison_parser.cpp" + break; + + case 86: +#line 714 "bison_parser.y" + { (yyval.select_stmt) = (yyvsp[-2].select_stmt); if ((yyval.select_stmt)->setOperations == nullptr) { (yyval.select_stmt)->setOperations = new std::vector(); @@ -3455,24 +3930,24 @@ yyreduce: (yyval.select_stmt)->setOperations->push_back((yyvsp[-1].set_operator_t)); (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[0].select_stmt); } -#line 3459 "bison_parser.cpp" - break; - - case 86: -#line 724 "bison_parser.y" - { (yyval.select_stmt) = (yyvsp[-1].select_stmt); } -#line 3465 "bison_parser.cpp" +#line 3934 "bison_parser.cpp" break; case 87: #line 725 "bison_parser.y" - { (yyval.select_stmt) = (yyvsp[-1].select_stmt); } -#line 3471 "bison_parser.cpp" + { (yyval.select_stmt) = (yyvsp[-1].select_stmt); } +#line 3940 "bison_parser.cpp" break; case 88: -#line 729 "bison_parser.y" - { +#line 726 "bison_parser.y" + { (yyval.select_stmt) = (yyvsp[-1].select_stmt); } +#line 3946 "bison_parser.cpp" + break; + + case 89: +#line 730 "bison_parser.y" + { (yyval.select_stmt) = (yyvsp[-2].select_stmt); (yyval.select_stmt)->order = (yyvsp[-1].order_vec); @@ -3482,12 +3957,12 @@ yyreduce: (yyval.select_stmt)->limit = (yyvsp[0].limit); } } -#line 3486 "bison_parser.cpp" +#line 3961 "bison_parser.cpp" break; - case 89: -#line 739 "bison_parser.y" - { + case 90: +#line 740 "bison_parser.y" + { (yyval.select_stmt) = (yyvsp[-4].select_stmt); if ((yyval.select_stmt)->setOperations == nullptr) { (yyval.select_stmt)->setOperations = new std::vector(); @@ -3497,64 +3972,64 @@ yyreduce: (yyval.select_stmt)->setOperations->back()->resultOrder = (yyvsp[-1].order_vec); (yyval.select_stmt)->setOperations->back()->resultLimit = (yyvsp[0].limit); } -#line 3501 "bison_parser.cpp" - break; - - case 90: -#line 752 "bison_parser.y" - { - (yyval.set_operator_t) = (yyvsp[-1].set_operator_t); - (yyval.set_operator_t)->isAll = (yyvsp[0].bval); - } -#line 3510 "bison_parser.cpp" +#line 3976 "bison_parser.cpp" break; case 91: -#line 759 "bison_parser.y" - { - (yyval.set_operator_t) = new SetOperation(); - (yyval.set_operator_t)->setType = SetType::kSetUnion; +#line 753 "bison_parser.y" + { + (yyval.set_operator_t) = (yyvsp[-1].set_operator_t); + (yyval.set_operator_t)->isAll = (yyvsp[0].bval); } -#line 3519 "bison_parser.cpp" +#line 3985 "bison_parser.cpp" break; case 92: -#line 763 "bison_parser.y" - { +#line 760 "bison_parser.y" + { (yyval.set_operator_t) = new SetOperation(); - (yyval.set_operator_t)->setType = SetType::kSetIntersect; - } -#line 3528 "bison_parser.cpp" + (yyval.set_operator_t)->setType = SetType::kSetUnion; + } +#line 3994 "bison_parser.cpp" break; case 93: -#line 767 "bison_parser.y" - { +#line 764 "bison_parser.y" + { (yyval.set_operator_t) = new SetOperation(); - (yyval.set_operator_t)->setType = SetType::kSetExcept; + (yyval.set_operator_t)->setType = SetType::kSetIntersect; } -#line 3537 "bison_parser.cpp" +#line 4003 "bison_parser.cpp" break; case 94: -#line 774 "bison_parser.y" - { - (yyval.bval) = true; - } -#line 3545 "bison_parser.cpp" +#line 768 "bison_parser.y" + { + (yyval.set_operator_t) = new SetOperation(); + (yyval.set_operator_t)->setType = SetType::kSetExcept; + } +#line 4012 "bison_parser.cpp" break; case 95: -#line 777 "bison_parser.y" - { - (yyval.bval) = false; - } -#line 3553 "bison_parser.cpp" +#line 775 "bison_parser.y" + { + (yyval.bval) = true; + } +#line 4020 "bison_parser.cpp" break; case 96: -#line 783 "bison_parser.y" - { +#line 778 "bison_parser.y" + { + (yyval.bval) = false; + } +#line 4028 "bison_parser.cpp" + break; + + case 97: +#line 784 "bison_parser.y" + { (yyval.select_stmt) = new SelectStatement(); (yyval.select_stmt)->limit = (yyvsp[-5].limit); (yyval.select_stmt)->selectDistinct = (yyvsp[-4].bval); @@ -3563,746 +4038,752 @@ yyreduce: (yyval.select_stmt)->whereClause = (yyvsp[-1].expr); (yyval.select_stmt)->groupBy = (yyvsp[0].group_t); } -#line 3567 "bison_parser.cpp" - break; - - case 97: -#line 795 "bison_parser.y" - { (yyval.bval) = true; } -#line 3573 "bison_parser.cpp" +#line 4042 "bison_parser.cpp" break; case 98: #line 796 "bison_parser.y" - { (yyval.bval) = false; } -#line 3579 "bison_parser.cpp" + { (yyval.bval) = true; } +#line 4048 "bison_parser.cpp" break; - case 100: -#line 804 "bison_parser.y" - { (yyval.table) = (yyvsp[0].table); } -#line 3585 "bison_parser.cpp" + case 99: +#line 797 "bison_parser.y" + { (yyval.bval) = false; } +#line 4054 "bison_parser.cpp" break; case 101: #line 805 "bison_parser.y" - { (yyval.table) = nullptr; } -#line 3591 "bison_parser.cpp" + { (yyval.table) = (yyvsp[0].table); } +#line 4060 "bison_parser.cpp" break; case 102: -#line 809 "bison_parser.y" - { (yyval.table) = (yyvsp[0].table); } -#line 3597 "bison_parser.cpp" +#line 806 "bison_parser.y" + { (yyval.table) = nullptr; } +#line 4066 "bison_parser.cpp" break; case 103: -#line 814 "bison_parser.y" - { (yyval.expr) = (yyvsp[0].expr); } -#line 3603 "bison_parser.cpp" +#line 810 "bison_parser.y" + { (yyval.table) = (yyvsp[0].table); } +#line 4072 "bison_parser.cpp" break; case 104: #line 815 "bison_parser.y" - { (yyval.expr) = nullptr; } -#line 3609 "bison_parser.cpp" + { (yyval.expr) = (yyvsp[0].expr); } +#line 4078 "bison_parser.cpp" break; case 105: -#line 819 "bison_parser.y" - { +#line 816 "bison_parser.y" + { (yyval.expr) = nullptr; } +#line 4084 "bison_parser.cpp" + break; + + case 106: +#line 820 "bison_parser.y" + { (yyval.group_t) = new GroupByDescription(); (yyval.group_t)->columns = (yyvsp[-1].expr_vec); (yyval.group_t)->having = (yyvsp[0].expr); } -#line 3619 "bison_parser.cpp" - break; - - case 106: -#line 824 "bison_parser.y" - { (yyval.group_t) = nullptr; } -#line 3625 "bison_parser.cpp" +#line 4094 "bison_parser.cpp" break; case 107: -#line 828 "bison_parser.y" - { (yyval.expr) = (yyvsp[0].expr); } -#line 3631 "bison_parser.cpp" +#line 825 "bison_parser.y" + { (yyval.group_t) = nullptr; } +#line 4100 "bison_parser.cpp" break; case 108: #line 829 "bison_parser.y" - { (yyval.expr) = nullptr; } -#line 3637 "bison_parser.cpp" + { (yyval.expr) = (yyvsp[0].expr); } +#line 4106 "bison_parser.cpp" break; case 109: -#line 833 "bison_parser.y" - { (yyval.order_vec) = (yyvsp[0].order_vec); } -#line 3643 "bison_parser.cpp" +#line 830 "bison_parser.y" + { (yyval.expr) = nullptr; } +#line 4112 "bison_parser.cpp" break; case 110: #line 834 "bison_parser.y" - { (yyval.order_vec) = nullptr; } -#line 3649 "bison_parser.cpp" + { (yyval.order_vec) = (yyvsp[0].order_vec); } +#line 4118 "bison_parser.cpp" break; case 111: -#line 838 "bison_parser.y" - { (yyval.order_vec) = new std::vector(); (yyval.order_vec)->push_back((yyvsp[0].order)); } -#line 3655 "bison_parser.cpp" +#line 835 "bison_parser.y" + { (yyval.order_vec) = nullptr; } +#line 4124 "bison_parser.cpp" break; case 112: #line 839 "bison_parser.y" - { (yyvsp[-2].order_vec)->push_back((yyvsp[0].order)); (yyval.order_vec) = (yyvsp[-2].order_vec); } -#line 3661 "bison_parser.cpp" + { (yyval.order_vec) = new std::vector(); (yyval.order_vec)->push_back((yyvsp[0].order)); } +#line 4130 "bison_parser.cpp" break; case 113: -#line 843 "bison_parser.y" - { (yyval.order) = new OrderDescription((yyvsp[0].order_type), (yyvsp[-1].expr)); } -#line 3667 "bison_parser.cpp" +#line 840 "bison_parser.y" + { (yyvsp[-2].order_vec)->push_back((yyvsp[0].order)); (yyval.order_vec) = (yyvsp[-2].order_vec); } +#line 4136 "bison_parser.cpp" break; case 114: -#line 847 "bison_parser.y" - { (yyval.order_type) = kOrderAsc; } -#line 3673 "bison_parser.cpp" +#line 844 "bison_parser.y" + { (yyval.order) = new OrderDescription((yyvsp[0].order_type), (yyvsp[-1].expr)); } +#line 4142 "bison_parser.cpp" break; case 115: #line 848 "bison_parser.y" - { (yyval.order_type) = kOrderDesc; } -#line 3679 "bison_parser.cpp" + { (yyval.order_type) = kOrderAsc; } +#line 4148 "bison_parser.cpp" break; case 116: #line 849 "bison_parser.y" - { (yyval.order_type) = kOrderAsc; } -#line 3685 "bison_parser.cpp" + { (yyval.order_type) = kOrderDesc; } +#line 4154 "bison_parser.cpp" break; case 117: -#line 855 "bison_parser.y" - { (yyval.limit) = new LimitDescription((yyvsp[0].expr), nullptr); } -#line 3691 "bison_parser.cpp" +#line 850 "bison_parser.y" + { (yyval.order_type) = kOrderAsc; } +#line 4160 "bison_parser.cpp" break; case 118: #line 856 "bison_parser.y" - { (yyval.limit) = nullptr; } -#line 3697 "bison_parser.cpp" + { (yyval.limit) = new LimitDescription((yyvsp[0].expr), nullptr); } +#line 4166 "bison_parser.cpp" break; case 119: -#line 860 "bison_parser.y" - { (yyval.limit) = new LimitDescription((yyvsp[0].expr), nullptr); } -#line 3703 "bison_parser.cpp" +#line 857 "bison_parser.y" + { (yyval.limit) = nullptr; } +#line 4172 "bison_parser.cpp" break; case 120: #line 861 "bison_parser.y" - { (yyval.limit) = new LimitDescription(nullptr, (yyvsp[0].expr)); } -#line 3709 "bison_parser.cpp" + { (yyval.limit) = new LimitDescription((yyvsp[0].expr), nullptr); } +#line 4178 "bison_parser.cpp" break; case 121: #line 862 "bison_parser.y" - { (yyval.limit) = new LimitDescription((yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 3715 "bison_parser.cpp" + { (yyval.limit) = new LimitDescription(nullptr, (yyvsp[0].expr)); } +#line 4184 "bison_parser.cpp" break; case 122: #line 863 "bison_parser.y" - { (yyval.limit) = new LimitDescription(nullptr, nullptr); } -#line 3721 "bison_parser.cpp" + { (yyval.limit) = new LimitDescription((yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 4190 "bison_parser.cpp" break; case 123: #line 864 "bison_parser.y" - { (yyval.limit) = new LimitDescription(nullptr, (yyvsp[0].expr)); } -#line 3727 "bison_parser.cpp" + { (yyval.limit) = new LimitDescription(nullptr, nullptr); } +#line 4196 "bison_parser.cpp" break; case 124: #line 865 "bison_parser.y" - { (yyval.limit) = nullptr; } -#line 3733 "bison_parser.cpp" + { (yyval.limit) = new LimitDescription(nullptr, (yyvsp[0].expr)); } +#line 4202 "bison_parser.cpp" break; case 125: -#line 872 "bison_parser.y" - { (yyval.expr_vec) = new std::vector(); (yyval.expr_vec)->push_back((yyvsp[0].expr)); } -#line 3739 "bison_parser.cpp" +#line 866 "bison_parser.y" + { (yyval.limit) = nullptr; } +#line 4208 "bison_parser.cpp" break; case 126: #line 873 "bison_parser.y" - { (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); (yyval.expr_vec) = (yyvsp[-2].expr_vec); } -#line 3745 "bison_parser.cpp" + { (yyval.expr_vec) = new std::vector(); (yyval.expr_vec)->push_back((yyvsp[0].expr)); } +#line 4214 "bison_parser.cpp" break; case 127: -#line 877 "bison_parser.y" - { (yyval.expr_vec) = (yyvsp[0].expr_vec); } -#line 3751 "bison_parser.cpp" +#line 874 "bison_parser.y" + { (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); (yyval.expr_vec) = (yyvsp[-2].expr_vec); } +#line 4220 "bison_parser.cpp" break; case 128: #line 878 "bison_parser.y" - { (yyval.expr_vec) = nullptr; } -#line 3757 "bison_parser.cpp" + { (yyval.expr_vec) = (yyvsp[0].expr_vec); } +#line 4226 "bison_parser.cpp" break; case 129: -#line 882 "bison_parser.y" - { (yyval.expr_vec) = new std::vector(); (yyval.expr_vec)->push_back((yyvsp[0].expr)); } -#line 3763 "bison_parser.cpp" +#line 879 "bison_parser.y" + { (yyval.expr_vec) = nullptr; } +#line 4232 "bison_parser.cpp" break; case 130: #line 883 "bison_parser.y" - { (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); (yyval.expr_vec) = (yyvsp[-2].expr_vec); } -#line 3769 "bison_parser.cpp" + { (yyval.expr_vec) = new std::vector(); (yyval.expr_vec)->push_back((yyvsp[0].expr)); } +#line 4238 "bison_parser.cpp" break; case 131: -#line 887 "bison_parser.y" - { +#line 884 "bison_parser.y" + { (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); (yyval.expr_vec) = (yyvsp[-2].expr_vec); } +#line 4244 "bison_parser.cpp" + break; + + case 132: +#line 888 "bison_parser.y" + { (yyval.expr) = (yyvsp[-1].expr); if ((yyvsp[0].alias_t)) { (yyval.expr)->alias = strdup((yyvsp[0].alias_t)->name); delete (yyvsp[0].alias_t); } } -#line 3781 "bison_parser.cpp" +#line 4256 "bison_parser.cpp" break; - case 137: -#line 905 "bison_parser.y" - { (yyval.expr) = (yyvsp[-1].expr); } -#line 3787 "bison_parser.cpp" + case 138: +#line 906 "bison_parser.y" + { (yyval.expr) = (yyvsp[-1].expr); } +#line 4262 "bison_parser.cpp" break; - case 146: -#line 914 "bison_parser.y" - { (yyval.expr) = Expr::makeSelect((yyvsp[-1].select_stmt)); } -#line 3793 "bison_parser.cpp" - break; - - case 149: -#line 923 "bison_parser.y" - { (yyval.expr) = Expr::makeOpUnary(kOpUnaryMinus, (yyvsp[0].expr)); } -#line 3799 "bison_parser.cpp" - break; - - case 150: -#line 924 "bison_parser.y" - { (yyval.expr) = Expr::makeOpUnary(kOpNot, (yyvsp[0].expr)); } -#line 3805 "bison_parser.cpp" + case 148: +#line 916 "bison_parser.y" + { (yyval.expr) = Expr::makeSelect((yyvsp[-1].select_stmt)); } +#line 4268 "bison_parser.cpp" break; case 151: #line 925 "bison_parser.y" - { (yyval.expr) = Expr::makeOpUnary(kOpIsNull, (yyvsp[-1].expr)); } -#line 3811 "bison_parser.cpp" + { (yyval.expr) = Expr::makeOpUnary(kOpUnaryMinus, (yyvsp[0].expr)); } +#line 4274 "bison_parser.cpp" break; case 152: #line 926 "bison_parser.y" - { (yyval.expr) = Expr::makeOpUnary(kOpIsNull, (yyvsp[-2].expr)); } -#line 3817 "bison_parser.cpp" + { (yyval.expr) = Expr::makeOpUnary(kOpNot, (yyvsp[0].expr)); } +#line 4280 "bison_parser.cpp" break; case 153: #line 927 "bison_parser.y" - { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeOpUnary(kOpIsNull, (yyvsp[-3].expr))); } -#line 3823 "bison_parser.cpp" + { (yyval.expr) = Expr::makeOpUnary(kOpIsNull, (yyvsp[-1].expr)); } +#line 4286 "bison_parser.cpp" + break; + + case 154: +#line 928 "bison_parser.y" + { (yyval.expr) = Expr::makeOpUnary(kOpIsNull, (yyvsp[-2].expr)); } +#line 4292 "bison_parser.cpp" break; case 155: -#line 932 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpMinus, (yyvsp[0].expr)); } -#line 3829 "bison_parser.cpp" - break; - - case 156: -#line 933 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpPlus, (yyvsp[0].expr)); } -#line 3835 "bison_parser.cpp" +#line 929 "bison_parser.y" + { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeOpUnary(kOpIsNull, (yyvsp[-3].expr))); } +#line 4298 "bison_parser.cpp" break; case 157: #line 934 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpSlash, (yyvsp[0].expr)); } -#line 3841 "bison_parser.cpp" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpMinus, (yyvsp[0].expr)); } +#line 4304 "bison_parser.cpp" break; case 158: #line 935 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpAsterisk, (yyvsp[0].expr)); } -#line 3847 "bison_parser.cpp" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpPlus, (yyvsp[0].expr)); } +#line 4310 "bison_parser.cpp" break; case 159: #line 936 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpPercentage, (yyvsp[0].expr)); } -#line 3853 "bison_parser.cpp" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpSlash, (yyvsp[0].expr)); } +#line 4316 "bison_parser.cpp" break; case 160: #line 937 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpCaret, (yyvsp[0].expr)); } -#line 3859 "bison_parser.cpp" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpAsterisk, (yyvsp[0].expr)); } +#line 4322 "bison_parser.cpp" break; case 161: #line 938 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLike, (yyvsp[0].expr)); } -#line 3865 "bison_parser.cpp" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpPercentage, (yyvsp[0].expr)); } +#line 4328 "bison_parser.cpp" break; case 162: #line 939 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-3].expr), kOpNotLike, (yyvsp[0].expr)); } -#line 3871 "bison_parser.cpp" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpCaret, (yyvsp[0].expr)); } +#line 4334 "bison_parser.cpp" break; case 163: #line 940 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpILike, (yyvsp[0].expr)); } -#line 3877 "bison_parser.cpp" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLike, (yyvsp[0].expr)); } +#line 4340 "bison_parser.cpp" break; case 164: #line 941 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpConcat, (yyvsp[0].expr)); } -#line 3883 "bison_parser.cpp" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-3].expr), kOpNotLike, (yyvsp[0].expr)); } +#line 4346 "bison_parser.cpp" break; case 165: -#line 945 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpAnd, (yyvsp[0].expr)); } -#line 3889 "bison_parser.cpp" +#line 942 "bison_parser.y" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpILike, (yyvsp[0].expr)); } +#line 4352 "bison_parser.cpp" break; case 166: -#line 946 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpOr, (yyvsp[0].expr)); } -#line 3895 "bison_parser.cpp" +#line 943 "bison_parser.y" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpConcat, (yyvsp[0].expr)); } +#line 4358 "bison_parser.cpp" break; case 167: -#line 950 "bison_parser.y" - { (yyval.expr) = Expr::makeInOperator((yyvsp[-4].expr), (yyvsp[-1].expr_vec)); } -#line 3901 "bison_parser.cpp" +#line 947 "bison_parser.y" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpAnd, (yyvsp[0].expr)); } +#line 4364 "bison_parser.cpp" break; case 168: -#line 951 "bison_parser.y" - { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeInOperator((yyvsp[-5].expr), (yyvsp[-1].expr_vec))); } -#line 3907 "bison_parser.cpp" +#line 948 "bison_parser.y" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpOr, (yyvsp[0].expr)); } +#line 4370 "bison_parser.cpp" break; case 169: #line 952 "bison_parser.y" - { (yyval.expr) = Expr::makeInOperator((yyvsp[-4].expr), (yyvsp[-1].select_stmt)); } -#line 3913 "bison_parser.cpp" + { (yyval.expr) = Expr::makeInOperator((yyvsp[-4].expr), (yyvsp[-1].expr_vec)); } +#line 4376 "bison_parser.cpp" break; case 170: #line 953 "bison_parser.y" - { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeInOperator((yyvsp[-5].expr), (yyvsp[-1].select_stmt))); } -#line 3919 "bison_parser.cpp" + { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeInOperator((yyvsp[-5].expr), (yyvsp[-1].expr_vec))); } +#line 4382 "bison_parser.cpp" break; case 171: -#line 959 "bison_parser.y" - { (yyval.expr) = Expr::makeCase((yyvsp[-2].expr), (yyvsp[-1].expr), nullptr); } -#line 3925 "bison_parser.cpp" +#line 954 "bison_parser.y" + { (yyval.expr) = Expr::makeInOperator((yyvsp[-4].expr), (yyvsp[-1].select_stmt)); } +#line 4388 "bison_parser.cpp" break; case 172: -#line 960 "bison_parser.y" - { (yyval.expr) = Expr::makeCase((yyvsp[-4].expr), (yyvsp[-3].expr), (yyvsp[-1].expr)); } -#line 3931 "bison_parser.cpp" +#line 955 "bison_parser.y" + { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeInOperator((yyvsp[-5].expr), (yyvsp[-1].select_stmt))); } +#line 4394 "bison_parser.cpp" break; case 173: #line 961 "bison_parser.y" - { (yyval.expr) = Expr::makeCase(nullptr, (yyvsp[-1].expr), nullptr); } -#line 3937 "bison_parser.cpp" + { (yyval.expr) = Expr::makeCase((yyvsp[-2].expr), (yyvsp[-1].expr), nullptr); } +#line 4400 "bison_parser.cpp" break; case 174: #line 962 "bison_parser.y" - { (yyval.expr) = Expr::makeCase(nullptr, (yyvsp[-3].expr), (yyvsp[-1].expr)); } -#line 3943 "bison_parser.cpp" + { (yyval.expr) = Expr::makeCase((yyvsp[-4].expr), (yyvsp[-3].expr), (yyvsp[-1].expr)); } +#line 4406 "bison_parser.cpp" break; case 175: -#line 966 "bison_parser.y" - { (yyval.expr) = Expr::makeCaseList(Expr::makeCaseListElement((yyvsp[-2].expr), (yyvsp[0].expr))); } -#line 3949 "bison_parser.cpp" +#line 963 "bison_parser.y" + { (yyval.expr) = Expr::makeCase(nullptr, (yyvsp[-1].expr), nullptr); } +#line 4412 "bison_parser.cpp" break; case 176: -#line 967 "bison_parser.y" - { (yyval.expr) = Expr::caseListAppend((yyvsp[-4].expr), Expr::makeCaseListElement((yyvsp[-2].expr), (yyvsp[0].expr))); } -#line 3955 "bison_parser.cpp" +#line 964 "bison_parser.y" + { (yyval.expr) = Expr::makeCase(nullptr, (yyvsp[-3].expr), (yyvsp[-1].expr)); } +#line 4418 "bison_parser.cpp" break; case 177: -#line 971 "bison_parser.y" - { (yyval.expr) = Expr::makeExists((yyvsp[-1].select_stmt)); } -#line 3961 "bison_parser.cpp" +#line 968 "bison_parser.y" + { (yyval.expr) = Expr::makeCaseList(Expr::makeCaseListElement((yyvsp[-2].expr), (yyvsp[0].expr))); } +#line 4424 "bison_parser.cpp" break; case 178: -#line 972 "bison_parser.y" - { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeExists((yyvsp[-1].select_stmt))); } -#line 3967 "bison_parser.cpp" +#line 969 "bison_parser.y" + { (yyval.expr) = Expr::caseListAppend((yyvsp[-4].expr), Expr::makeCaseListElement((yyvsp[-2].expr), (yyvsp[0].expr))); } +#line 4430 "bison_parser.cpp" break; case 179: -#line 976 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpEquals, (yyvsp[0].expr)); } -#line 3973 "bison_parser.cpp" +#line 973 "bison_parser.y" + { (yyval.expr) = Expr::makeExists((yyvsp[-1].select_stmt)); } +#line 4436 "bison_parser.cpp" break; case 180: -#line 977 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpEquals, (yyvsp[0].expr)); } -#line 3979 "bison_parser.cpp" +#line 974 "bison_parser.y" + { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeExists((yyvsp[-1].select_stmt))); } +#line 4442 "bison_parser.cpp" break; case 181: #line 978 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpNotEquals, (yyvsp[0].expr)); } -#line 3985 "bison_parser.cpp" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpEquals, (yyvsp[0].expr)); } +#line 4448 "bison_parser.cpp" break; case 182: #line 979 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLess, (yyvsp[0].expr)); } -#line 3991 "bison_parser.cpp" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpEquals, (yyvsp[0].expr)); } +#line 4454 "bison_parser.cpp" break; case 183: #line 980 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpGreater, (yyvsp[0].expr)); } -#line 3997 "bison_parser.cpp" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpNotEquals, (yyvsp[0].expr)); } +#line 4460 "bison_parser.cpp" break; case 184: #line 981 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLessEq, (yyvsp[0].expr)); } -#line 4003 "bison_parser.cpp" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLess, (yyvsp[0].expr)); } +#line 4466 "bison_parser.cpp" break; case 185: #line 982 "bison_parser.y" - { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpGreaterEq, (yyvsp[0].expr)); } -#line 4009 "bison_parser.cpp" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpGreater, (yyvsp[0].expr)); } +#line 4472 "bison_parser.cpp" break; case 186: -#line 986 "bison_parser.y" - { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-2].sval), new std::vector(), false); } -#line 4015 "bison_parser.cpp" +#line 983 "bison_parser.y" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLessEq, (yyvsp[0].expr)); } +#line 4478 "bison_parser.cpp" break; case 187: -#line 987 "bison_parser.y" - { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-4].sval), (yyvsp[-1].expr_vec), (yyvsp[-2].bval)); } -#line 4021 "bison_parser.cpp" +#line 984 "bison_parser.y" + { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpGreaterEq, (yyvsp[0].expr)); } +#line 4484 "bison_parser.cpp" break; case 188: -#line 991 "bison_parser.y" - { (yyval.expr) = Expr::makeExtract((yyvsp[-3].datetime_field), (yyvsp[-1].expr)); } -#line 4027 "bison_parser.cpp" +#line 988 "bison_parser.y" + { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-2].sval), new std::vector(), false); } +#line 4490 "bison_parser.cpp" break; case 189: -#line 995 "bison_parser.y" - { (yyval.datetime_field) = kDatetimeSecond; } -#line 4033 "bison_parser.cpp" +#line 989 "bison_parser.y" + { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-4].sval), (yyvsp[-1].expr_vec), (yyvsp[-2].bval)); } +#line 4496 "bison_parser.cpp" break; case 190: -#line 996 "bison_parser.y" - { (yyval.datetime_field) = kDatetimeMinute; } -#line 4039 "bison_parser.cpp" +#line 993 "bison_parser.y" + { (yyval.expr) = Expr::makeExtract((yyvsp[-3].datetime_field), (yyvsp[-1].expr)); } +#line 4502 "bison_parser.cpp" break; case 191: #line 997 "bison_parser.y" - { (yyval.datetime_field) = kDatetimeHour; } -#line 4045 "bison_parser.cpp" + { (yyval.expr) = Expr::makeCast((yyvsp[-3].expr), (yyvsp[-1].column_type_t)); } +#line 4508 "bison_parser.cpp" break; case 192: -#line 998 "bison_parser.y" - { (yyval.datetime_field) = kDatetimeDay; } -#line 4051 "bison_parser.cpp" +#line 1001 "bison_parser.y" + { (yyval.datetime_field) = kDatetimeSecond; } +#line 4514 "bison_parser.cpp" break; case 193: -#line 999 "bison_parser.y" - { (yyval.datetime_field) = kDatetimeMonth; } -#line 4057 "bison_parser.cpp" +#line 1002 "bison_parser.y" + { (yyval.datetime_field) = kDatetimeMinute; } +#line 4520 "bison_parser.cpp" break; case 194: -#line 1000 "bison_parser.y" - { (yyval.datetime_field) = kDatetimeYear; } -#line 4063 "bison_parser.cpp" +#line 1003 "bison_parser.y" + { (yyval.datetime_field) = kDatetimeHour; } +#line 4526 "bison_parser.cpp" break; case 195: #line 1004 "bison_parser.y" - { (yyval.expr) = Expr::makeArray((yyvsp[-1].expr_vec)); } -#line 4069 "bison_parser.cpp" + { (yyval.datetime_field) = kDatetimeDay; } +#line 4532 "bison_parser.cpp" break; case 196: -#line 1008 "bison_parser.y" - { (yyval.expr) = Expr::makeArrayIndex((yyvsp[-3].expr), (yyvsp[-1].expr)->ival); } -#line 4075 "bison_parser.cpp" +#line 1005 "bison_parser.y" + { (yyval.datetime_field) = kDatetimeMonth; } +#line 4538 "bison_parser.cpp" break; case 197: -#line 1012 "bison_parser.y" - { (yyval.expr) = Expr::makeBetween((yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); } -#line 4081 "bison_parser.cpp" +#line 1006 "bison_parser.y" + { (yyval.datetime_field) = kDatetimeYear; } +#line 4544 "bison_parser.cpp" break; case 198: -#line 1016 "bison_parser.y" - { (yyval.expr) = Expr::makeColumnRef((yyvsp[0].sval)); } -#line 4087 "bison_parser.cpp" +#line 1010 "bison_parser.y" + { (yyval.expr) = Expr::makeArray((yyvsp[-1].expr_vec)); } +#line 4550 "bison_parser.cpp" break; case 199: -#line 1017 "bison_parser.y" - { (yyval.expr) = Expr::makeColumnRef((yyvsp[-2].sval), (yyvsp[0].sval)); } -#line 4093 "bison_parser.cpp" +#line 1014 "bison_parser.y" + { (yyval.expr) = Expr::makeArrayIndex((yyvsp[-3].expr), (yyvsp[-1].expr)->ival); } +#line 4556 "bison_parser.cpp" break; case 200: #line 1018 "bison_parser.y" - { (yyval.expr) = Expr::makeStar(); } -#line 4099 "bison_parser.cpp" + { (yyval.expr) = Expr::makeBetween((yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); } +#line 4562 "bison_parser.cpp" break; case 201: -#line 1019 "bison_parser.y" - { (yyval.expr) = Expr::makeStar((yyvsp[-2].sval)); } -#line 4105 "bison_parser.cpp" +#line 1022 "bison_parser.y" + { (yyval.expr) = Expr::makeColumnRef((yyvsp[0].sval)); } +#line 4568 "bison_parser.cpp" break; - case 207: -#line 1031 "bison_parser.y" - { (yyval.expr) = Expr::makeLiteral((yyvsp[0].sval)); } -#line 4111 "bison_parser.cpp" + case 202: +#line 1023 "bison_parser.y" + { (yyval.expr) = Expr::makeColumnRef((yyvsp[-2].sval), (yyvsp[0].sval)); } +#line 4574 "bison_parser.cpp" break; - case 208: -#line 1035 "bison_parser.y" - { (yyval.expr) = Expr::makeLiteral(true); } -#line 4117 "bison_parser.cpp" + case 203: +#line 1024 "bison_parser.y" + { (yyval.expr) = Expr::makeStar(); } +#line 4580 "bison_parser.cpp" break; - case 209: -#line 1036 "bison_parser.y" - { (yyval.expr) = Expr::makeLiteral(false); } -#line 4123 "bison_parser.cpp" + case 204: +#line 1025 "bison_parser.y" + { (yyval.expr) = Expr::makeStar((yyvsp[-2].sval)); } +#line 4586 "bison_parser.cpp" break; case 210: -#line 1040 "bison_parser.y" - { (yyval.expr) = Expr::makeLiteral((yyvsp[0].fval)); } -#line 4129 "bison_parser.cpp" +#line 1037 "bison_parser.y" + { (yyval.expr) = Expr::makeLiteral((yyvsp[0].sval)); } +#line 4592 "bison_parser.cpp" + break; + + case 211: +#line 1041 "bison_parser.y" + { (yyval.expr) = Expr::makeLiteral(true); } +#line 4598 "bison_parser.cpp" break; case 212: -#line 1045 "bison_parser.y" - { (yyval.expr) = Expr::makeLiteral((yyvsp[0].ival)); } -#line 4135 "bison_parser.cpp" +#line 1042 "bison_parser.y" + { (yyval.expr) = Expr::makeLiteral(false); } +#line 4604 "bison_parser.cpp" break; case 213: -#line 1049 "bison_parser.y" - { (yyval.expr) = Expr::makeNullLiteral(); } -#line 4141 "bison_parser.cpp" +#line 1046 "bison_parser.y" + { (yyval.expr) = Expr::makeLiteral((yyvsp[0].fval)); } +#line 4610 "bison_parser.cpp" break; - case 214: -#line 1053 "bison_parser.y" - { + case 215: +#line 1051 "bison_parser.y" + { (yyval.expr) = Expr::makeLiteral((yyvsp[0].ival)); } +#line 4616 "bison_parser.cpp" + break; + + case 216: +#line 1055 "bison_parser.y" + { (yyval.expr) = Expr::makeNullLiteral(); } +#line 4622 "bison_parser.cpp" + break; + + case 217: +#line 1059 "bison_parser.y" + { (yyval.expr) = Expr::makeParameter(yylloc.total_column); (yyval.expr)->ival2 = yyloc.param_list.size(); yyloc.param_list.push_back((yyval.expr)); } -#line 4151 "bison_parser.cpp" +#line 4632 "bison_parser.cpp" break; - case 216: -#line 1066 "bison_parser.y" - { + case 219: +#line 1072 "bison_parser.y" + { (yyvsp[-2].table_vec)->push_back((yyvsp[0].table)); auto tbl = new TableRef(kTableCrossProduct); tbl->list = (yyvsp[-2].table_vec); (yyval.table) = tbl; } -#line 4162 "bison_parser.cpp" +#line 4643 "bison_parser.cpp" break; - case 220: -#line 1082 "bison_parser.y" - { + case 223: +#line 1088 "bison_parser.y" + { auto tbl = new TableRef(kTableSelect); tbl->select = (yyvsp[-2].select_stmt); tbl->alias = (yyvsp[0].alias_t); (yyval.table) = tbl; } -#line 4173 "bison_parser.cpp" +#line 4654 "bison_parser.cpp" break; - case 221: -#line 1091 "bison_parser.y" - { (yyval.table_vec) = new std::vector(); (yyval.table_vec)->push_back((yyvsp[0].table)); } -#line 4179 "bison_parser.cpp" - break; - - case 222: -#line 1092 "bison_parser.y" - { (yyvsp[-2].table_vec)->push_back((yyvsp[0].table)); (yyval.table_vec) = (yyvsp[-2].table_vec); } -#line 4185 "bison_parser.cpp" - break; - - case 223: + case 224: #line 1097 "bison_parser.y" - { + { (yyval.table_vec) = new std::vector(); (yyval.table_vec)->push_back((yyvsp[0].table)); } +#line 4660 "bison_parser.cpp" + break; + + case 225: +#line 1098 "bison_parser.y" + { (yyvsp[-2].table_vec)->push_back((yyvsp[0].table)); (yyval.table_vec) = (yyvsp[-2].table_vec); } +#line 4666 "bison_parser.cpp" + break; + + case 226: +#line 1103 "bison_parser.y" + { auto tbl = new TableRef(kTableName); tbl->schema = (yyvsp[-1].table_name).schema; tbl->name = (yyvsp[-1].table_name).name; tbl->alias = (yyvsp[0].alias_t); (yyval.table) = tbl; } -#line 4197 "bison_parser.cpp" +#line 4678 "bison_parser.cpp" break; - case 224: -#line 1108 "bison_parser.y" - { + case 227: +#line 1114 "bison_parser.y" + { (yyval.table) = new TableRef(kTableName); (yyval.table)->schema = (yyvsp[0].table_name).schema; (yyval.table)->name = (yyvsp[0].table_name).name; } -#line 4207 "bison_parser.cpp" - break; - - case 225: -#line 1117 "bison_parser.y" - { (yyval.table_name).schema = nullptr; (yyval.table_name).name = (yyvsp[0].sval);} -#line 4213 "bison_parser.cpp" - break; - - case 226: -#line 1118 "bison_parser.y" - { (yyval.table_name).schema = (yyvsp[-2].sval); (yyval.table_name).name = (yyvsp[0].sval); } -#line 4219 "bison_parser.cpp" +#line 4688 "bison_parser.cpp" break; case 228: -#line 1124 "bison_parser.y" - { (yyval.alias_t) = new Alias((yyvsp[-3].sval), (yyvsp[-1].str_vec)); } -#line 4225 "bison_parser.cpp" +#line 1123 "bison_parser.y" + { (yyval.table_name).schema = nullptr; (yyval.table_name).name = (yyvsp[0].sval);} +#line 4694 "bison_parser.cpp" break; - case 230: -#line 1130 "bison_parser.y" - { (yyval.alias_t) = nullptr; } -#line 4231 "bison_parser.cpp" + case 229: +#line 1124 "bison_parser.y" + { (yyval.table_name).schema = (yyvsp[-2].sval); (yyval.table_name).name = (yyvsp[0].sval); } +#line 4700 "bison_parser.cpp" break; case 231: -#line 1135 "bison_parser.y" - { (yyval.alias_t) = new Alias((yyvsp[0].sval)); } -#line 4237 "bison_parser.cpp" +#line 1130 "bison_parser.y" + { (yyval.alias_t) = new Alias((yyvsp[-3].sval), (yyvsp[-1].str_vec)); } +#line 4706 "bison_parser.cpp" break; - case 232: + case 233: #line 1136 "bison_parser.y" - { (yyval.alias_t) = new Alias((yyvsp[0].sval)); } -#line 4243 "bison_parser.cpp" + { (yyval.alias_t) = nullptr; } +#line 4712 "bison_parser.cpp" break; case 234: -#line 1142 "bison_parser.y" - { (yyval.alias_t) = nullptr; } -#line 4249 "bison_parser.cpp" +#line 1141 "bison_parser.y" + { (yyval.alias_t) = new Alias((yyvsp[0].sval)); } +#line 4718 "bison_parser.cpp" break; - case 236: -#line 1152 "bison_parser.y" - { (yyval.with_description_vec) = nullptr; } -#line 4255 "bison_parser.cpp" + case 235: +#line 1142 "bison_parser.y" + { (yyval.alias_t) = new Alias((yyvsp[0].sval)); } +#line 4724 "bison_parser.cpp" break; case 237: -#line 1156 "bison_parser.y" - { (yyval.with_description_vec) = (yyvsp[0].with_description_vec); } -#line 4261 "bison_parser.cpp" - break; - - case 238: -#line 1160 "bison_parser.y" - { - (yyval.with_description_vec) = new std::vector(); - (yyval.with_description_vec)->push_back((yyvsp[0].with_description_t)); - } -#line 4270 "bison_parser.cpp" +#line 1148 "bison_parser.y" + { (yyval.alias_t) = nullptr; } +#line 4730 "bison_parser.cpp" break; case 239: -#line 1164 "bison_parser.y" - { - (yyvsp[-2].with_description_vec)->push_back((yyvsp[0].with_description_t)); - (yyval.with_description_vec) = (yyvsp[-2].with_description_vec); - } -#line 4279 "bison_parser.cpp" +#line 1158 "bison_parser.y" + { (yyval.with_description_vec) = nullptr; } +#line 4736 "bison_parser.cpp" break; case 240: -#line 1171 "bison_parser.y" - { +#line 1162 "bison_parser.y" + { (yyval.with_description_vec) = (yyvsp[0].with_description_vec); } +#line 4742 "bison_parser.cpp" + break; + + case 241: +#line 1166 "bison_parser.y" + { + (yyval.with_description_vec) = new std::vector(); + (yyval.with_description_vec)->push_back((yyvsp[0].with_description_t)); + } +#line 4751 "bison_parser.cpp" + break; + + case 242: +#line 1170 "bison_parser.y" + { + (yyvsp[-2].with_description_vec)->push_back((yyvsp[0].with_description_t)); + (yyval.with_description_vec) = (yyvsp[-2].with_description_vec); + } +#line 4760 "bison_parser.cpp" + break; + + case 243: +#line 1177 "bison_parser.y" + { (yyval.with_description_t) = new WithDescription(); (yyval.with_description_t)->alias = (yyvsp[-2].sval); (yyval.with_description_t)->select = (yyvsp[0].select_stmt); } -#line 4289 "bison_parser.cpp" +#line 4770 "bison_parser.cpp" break; - case 241: -#line 1185 "bison_parser.y" - { + case 244: +#line 1191 "bison_parser.y" + { (yyval.table) = new TableRef(kTableJoin); (yyval.table)->join = new JoinDefinition(); (yyval.table)->join->type = kJoinNatural; (yyval.table)->join->left = (yyvsp[-3].table); (yyval.table)->join->right = (yyvsp[0].table); } -#line 4301 "bison_parser.cpp" +#line 4782 "bison_parser.cpp" break; - case 242: -#line 1193 "bison_parser.y" - { + case 245: +#line 1199 "bison_parser.y" + { (yyval.table) = new TableRef(kTableJoin); (yyval.table)->join = new JoinDefinition(); (yyval.table)->join->type = (JoinType) (yyvsp[-4].uval); @@ -4310,12 +4791,12 @@ yyreduce: (yyval.table)->join->right = (yyvsp[-2].table); (yyval.table)->join->condition = (yyvsp[0].expr); } -#line 4314 "bison_parser.cpp" +#line 4795 "bison_parser.cpp" break; - case 243: -#line 1203 "bison_parser.y" - { + case 246: +#line 1209 "bison_parser.y" + { (yyval.table) = new TableRef(kTableJoin); (yyval.table)->join = new JoinDefinition(); (yyval.table)->join->type = (JoinType) (yyvsp[-6].uval); @@ -4330,83 +4811,83 @@ yyreduce: (yyval.table)->join->condition = Expr::makeOpBinary(left_col, kOpEquals, right_col); delete (yyvsp[-1].expr); } -#line 4334 "bison_parser.cpp" - break; - - case 244: -#line 1221 "bison_parser.y" - { (yyval.uval) = kJoinInner; } -#line 4340 "bison_parser.cpp" - break; - - case 245: -#line 1222 "bison_parser.y" - { (yyval.uval) = kJoinLeft; } -#line 4346 "bison_parser.cpp" - break; - - case 246: -#line 1223 "bison_parser.y" - { (yyval.uval) = kJoinLeft; } -#line 4352 "bison_parser.cpp" +#line 4815 "bison_parser.cpp" break; case 247: -#line 1224 "bison_parser.y" - { (yyval.uval) = kJoinRight; } -#line 4358 "bison_parser.cpp" +#line 1227 "bison_parser.y" + { (yyval.uval) = kJoinInner; } +#line 4821 "bison_parser.cpp" break; case 248: -#line 1225 "bison_parser.y" - { (yyval.uval) = kJoinRight; } -#line 4364 "bison_parser.cpp" +#line 1228 "bison_parser.y" + { (yyval.uval) = kJoinLeft; } +#line 4827 "bison_parser.cpp" break; case 249: -#line 1226 "bison_parser.y" - { (yyval.uval) = kJoinFull; } -#line 4370 "bison_parser.cpp" +#line 1229 "bison_parser.y" + { (yyval.uval) = kJoinLeft; } +#line 4833 "bison_parser.cpp" break; case 250: -#line 1227 "bison_parser.y" - { (yyval.uval) = kJoinFull; } -#line 4376 "bison_parser.cpp" +#line 1230 "bison_parser.y" + { (yyval.uval) = kJoinRight; } +#line 4839 "bison_parser.cpp" break; case 251: -#line 1228 "bison_parser.y" - { (yyval.uval) = kJoinFull; } -#line 4382 "bison_parser.cpp" +#line 1231 "bison_parser.y" + { (yyval.uval) = kJoinRight; } +#line 4845 "bison_parser.cpp" break; case 252: -#line 1229 "bison_parser.y" - { (yyval.uval) = kJoinCross; } -#line 4388 "bison_parser.cpp" +#line 1232 "bison_parser.y" + { (yyval.uval) = kJoinFull; } +#line 4851 "bison_parser.cpp" break; case 253: -#line 1230 "bison_parser.y" - { (yyval.uval) = kJoinInner; } -#line 4394 "bison_parser.cpp" +#line 1233 "bison_parser.y" + { (yyval.uval) = kJoinFull; } +#line 4857 "bison_parser.cpp" break; - case 257: -#line 1250 "bison_parser.y" - { (yyval.str_vec) = new std::vector(); (yyval.str_vec)->push_back((yyvsp[0].sval)); } -#line 4400 "bison_parser.cpp" + case 254: +#line 1234 "bison_parser.y" + { (yyval.uval) = kJoinFull; } +#line 4863 "bison_parser.cpp" break; - case 258: -#line 1251 "bison_parser.y" - { (yyvsp[-2].str_vec)->push_back((yyvsp[0].sval)); (yyval.str_vec) = (yyvsp[-2].str_vec); } -#line 4406 "bison_parser.cpp" + case 255: +#line 1235 "bison_parser.y" + { (yyval.uval) = kJoinCross; } +#line 4869 "bison_parser.cpp" + break; + + case 256: +#line 1236 "bison_parser.y" + { (yyval.uval) = kJoinInner; } +#line 4875 "bison_parser.cpp" + break; + + case 260: +#line 1256 "bison_parser.y" + { (yyval.str_vec) = new std::vector(); (yyval.str_vec)->push_back((yyvsp[0].sval)); } +#line 4881 "bison_parser.cpp" + break; + + case 261: +#line 1257 "bison_parser.y" + { (yyvsp[-2].str_vec)->push_back((yyvsp[0].sval)); (yyval.str_vec) = (yyvsp[-2].str_vec); } +#line 4887 "bison_parser.cpp" break; -#line 4410 "bison_parser.cpp" +#line 4891 "bison_parser.cpp" default: break; } @@ -4421,11 +4902,10 @@ yyreduce: case of YYERROR or YYBACKUP, subsequent parser actions might lead to an incorrect destructor call or verbose syntax error message before the lookahead is translated. */ - YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); + YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); YYPOPSTACK (yylen); yylen = 0; - YY_STACK_PRINT (yyss, yyssp); *++yyvsp = yyval; *++yylsp = yyloc; @@ -4450,66 +4930,61 @@ yyreduce: yyerrlab: /* Make sure we have latest lookahead translation. See comments at user semantic actions for why this is necessary. */ - yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); - + yytoken = yychar == SQL_HSQL_EMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); /* If not already recovering from an error, report this error. */ if (!yyerrstatus) { ++yynerrs; -#if ! YYERROR_VERBOSE - yyerror (&yylloc, result, scanner, YY_("syntax error")); -#else -# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ - yyssp, yytoken) { + yypcontext_t yyctx + = {yyssp, yytoken, &yylloc}; char const *yymsgp = YY_("syntax error"); int yysyntax_error_status; - yysyntax_error_status = YYSYNTAX_ERROR; + yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); if (yysyntax_error_status == 0) yymsgp = yymsg; - else if (yysyntax_error_status == 1) + else if (yysyntax_error_status == -1) { if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); - yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); - if (!yymsg) + yymsg = YY_CAST (char *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); + if (yymsg) { - yymsg = yymsgbuf; - yymsg_alloc = sizeof yymsgbuf; - yysyntax_error_status = 2; + yysyntax_error_status + = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); + yymsgp = yymsg; } else { - yysyntax_error_status = YYSYNTAX_ERROR; - yymsgp = yymsg; + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + yysyntax_error_status = YYENOMEM; } } yyerror (&yylloc, result, scanner, yymsgp); - if (yysyntax_error_status == 2) + if (yysyntax_error_status == YYENOMEM) goto yyexhaustedlab; } -# undef YYSYNTAX_ERROR -#endif } yyerror_range[1] = yylloc; - if (yyerrstatus == 3) { /* If just tried and failed to reuse lookahead token after an error, discard it. */ - if (yychar <= YYEOF) + if (yychar <= SQL_YYEOF) { /* Return failure if at end of input. */ - if (yychar == YYEOF) + if (yychar == SQL_YYEOF) YYABORT; } else { yydestruct ("Error: discarding", yytoken, &yylval, &yylloc, result, scanner); - yychar = YYEMPTY; + yychar = SQL_HSQL_EMPTY; } } @@ -4542,13 +5017,14 @@ yyerrorlab: yyerrlab1: yyerrstatus = 3; /* Each real token shifted decrements this. */ + /* Pop stack until we find a state that shifts the error token. */ for (;;) { yyn = yypact[yystate]; if (!yypact_value_is_default (yyn)) { - yyn += YYTERROR; - if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + yyn += YYSYMBOL_YYerror; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) { yyn = yytable[yyn]; if (0 < yyn) @@ -4562,7 +5038,7 @@ yyerrlab1: yyerror_range[1] = *yylsp; yydestruct ("Error: popping", - yystos[yystate], yyvsp, yylsp, result, scanner); + YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp, result, scanner); YYPOPSTACK (1); yystate = *yyssp; YY_STACK_PRINT (yyss, yyssp); @@ -4573,13 +5049,11 @@ yyerrlab1: YY_IGNORE_MAYBE_UNINITIALIZED_END yyerror_range[2] = yylloc; - /* Using YYLLOC is tempting, but would change the location of - the lookahead. YYLOC is available though. */ - YYLLOC_DEFAULT (yyloc, yyerror_range, 2); - *++yylsp = yyloc; + ++yylsp; + YYLLOC_DEFAULT (*yylsp, yyerror_range, 2); /* Shift the error token. */ - YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); yystate = yyn; goto yynewstate; @@ -4601,7 +5075,7 @@ yyabortlab: goto yyreturn; -#if !defined yyoverflow || YYERROR_VERBOSE +#if 1 /*-------------------------------------------------. | yyexhaustedlab -- memory exhaustion comes here. | `-------------------------------------------------*/ @@ -4616,7 +5090,7 @@ yyexhaustedlab: | yyreturn -- parsing is finished, return the result. | `-----------------------------------------------------*/ yyreturn: - if (yychar != YYEMPTY) + if (yychar != SQL_HSQL_EMPTY) { /* Make sure we have latest lookahead translation. See comments at user semantic actions for why this is necessary. */ @@ -4631,20 +5105,19 @@ yyreturn: while (yyssp != yyss) { yydestruct ("Cleanup: popping", - yystos[*yyssp], yyvsp, yylsp, result, scanner); + YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp, result, scanner); YYPOPSTACK (1); } #ifndef yyoverflow if (yyss != yyssa) YYSTACK_FREE (yyss); #endif -#if YYERROR_VERBOSE if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); -#endif return yyresult; } -#line 1254 "bison_parser.y" + +#line 1260 "bison_parser.y" /********************************* ** Section 4: Additional C code diff --git a/src/parser/bison_parser.h b/src/parser/bison_parser.h index 7a380e8..7e87207 100644 --- a/src/parser/bison_parser.h +++ b/src/parser/bison_parser.h @@ -1,8 +1,8 @@ -/* A Bison parser, made by GNU Bison 3.4.2. */ +/* A Bison parser, made by GNU Bison 3.6.4. */ /* Bison interface for Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation, + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify @@ -31,8 +31,9 @@ This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ -/* Undocumented macros, especially those whose name start with YY_, - are private implementation details. Do not rely on them. */ +/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, + especially those whose name start with YY_ or yy_. They are + private implementation details that can be changed or removed. */ #ifndef YY_HSQL_BISON_PARSER_H_INCLUDED # define YY_HSQL_BISON_PARSER_H_INCLUDED @@ -76,161 +77,168 @@ extern int hsql_debug; } \ } -#line 80 "bison_parser.h" +#line 81 "bison_parser.h" -/* Token type. */ +/* Token kinds. */ #ifndef HSQL_TOKENTYPE # define HSQL_TOKENTYPE enum hsql_tokentype { - SQL_IDENTIFIER = 258, - SQL_STRING = 259, - SQL_FLOATVAL = 260, - SQL_INTVAL = 261, - SQL_DEALLOCATE = 262, - SQL_PARAMETERS = 263, - SQL_INTERSECT = 264, - SQL_TEMPORARY = 265, - SQL_TIMESTAMP = 266, - SQL_DISTINCT = 267, - SQL_NVARCHAR = 268, - SQL_RESTRICT = 269, - SQL_TRUNCATE = 270, - SQL_ANALYZE = 271, - SQL_BETWEEN = 272, - SQL_CASCADE = 273, - SQL_COLUMNS = 274, - SQL_CONTROL = 275, - SQL_DEFAULT = 276, - SQL_EXECUTE = 277, - SQL_EXPLAIN = 278, - SQL_INTEGER = 279, - SQL_NATURAL = 280, - SQL_PREPARE = 281, - SQL_PRIMARY = 282, - SQL_SCHEMAS = 283, - SQL_SPATIAL = 284, - SQL_VARCHAR = 285, - SQL_VIRTUAL = 286, - SQL_DESCRIBE = 287, - SQL_BEFORE = 288, - SQL_COLUMN = 289, - SQL_CREATE = 290, - SQL_DELETE = 291, - SQL_DIRECT = 292, - SQL_DOUBLE = 293, - SQL_ESCAPE = 294, - SQL_EXCEPT = 295, - SQL_EXISTS = 296, - SQL_EXTRACT = 297, - SQL_FORMAT = 298, - SQL_GLOBAL = 299, - SQL_HAVING = 300, - SQL_IMPORT = 301, - SQL_INSERT = 302, - SQL_ISNULL = 303, - SQL_OFFSET = 304, - SQL_RENAME = 305, - SQL_SCHEMA = 306, - SQL_SELECT = 307, - SQL_SORTED = 308, - SQL_TABLES = 309, - SQL_UNIQUE = 310, - SQL_UNLOAD = 311, - SQL_UPDATE = 312, - SQL_VALUES = 313, - SQL_AFTER = 314, - SQL_ALTER = 315, - SQL_CROSS = 316, - SQL_DELTA = 317, - SQL_FLOAT = 318, - SQL_GROUP = 319, - SQL_INDEX = 320, - SQL_INNER = 321, - SQL_LIMIT = 322, - SQL_LOCAL = 323, - SQL_MERGE = 324, - SQL_MINUS = 325, - SQL_ORDER = 326, - SQL_OUTER = 327, - SQL_RIGHT = 328, - SQL_TABLE = 329, - SQL_UNION = 330, - SQL_USING = 331, - SQL_WHERE = 332, - SQL_CALL = 333, - SQL_CASE = 334, - SQL_CHAR = 335, - SQL_COPY = 336, - SQL_DATE = 337, - SQL_DESC = 338, - SQL_DROP = 339, - SQL_ELSE = 340, - SQL_FILE = 341, - SQL_FROM = 342, - SQL_FULL = 343, - SQL_HASH = 344, - SQL_HINT = 345, - SQL_INTO = 346, - SQL_JOIN = 347, - SQL_LEFT = 348, - SQL_LIKE = 349, - SQL_LOAD = 350, - SQL_LONG = 351, - SQL_NULL = 352, - SQL_PLAN = 353, - SQL_SHOW = 354, - SQL_TEXT = 355, - SQL_THEN = 356, - SQL_TIME = 357, - SQL_VIEW = 358, - SQL_WHEN = 359, - SQL_WITH = 360, - SQL_ADD = 361, - SQL_ALL = 362, - SQL_AND = 363, - SQL_ASC = 364, - SQL_END = 365, - SQL_FOR = 366, - SQL_INT = 367, - SQL_KEY = 368, - SQL_NOT = 369, - SQL_OFF = 370, - SQL_SET = 371, - SQL_TOP = 372, - SQL_AS = 373, - SQL_BY = 374, - SQL_IF = 375, - SQL_IN = 376, - SQL_IS = 377, - SQL_OF = 378, - SQL_ON = 379, - SQL_OR = 380, - SQL_TO = 381, - SQL_ARRAY = 382, - SQL_CONCAT = 383, - SQL_ILIKE = 384, - SQL_SECOND = 385, - SQL_MINUTE = 386, - SQL_HOUR = 387, - SQL_DAY = 388, - SQL_MONTH = 389, - SQL_YEAR = 390, - SQL_TRUE = 391, - SQL_FALSE = 392, - SQL_TRANSACTION = 393, - SQL_BEGIN = 394, - SQL_COMMIT = 395, - SQL_ROLLBACK = 396, - SQL_EQUALS = 397, - SQL_NOTEQUALS = 398, - SQL_LESS = 399, - SQL_GREATER = 400, - SQL_LESSEQ = 401, - SQL_GREATEREQ = 402, - SQL_NOTNULL = 403, - SQL_UMINUS = 404 + SQL_HSQL_EMPTY = -2, + SQL_YYEOF = 0, /* "end of file" */ + SQL_HSQL_error = 256, /* error */ + SQL_HSQL_UNDEF = 257, /* "invalid token" */ + SQL_IDENTIFIER = 258, /* IDENTIFIER */ + SQL_STRING = 259, /* STRING */ + SQL_FLOATVAL = 260, /* FLOATVAL */ + SQL_INTVAL = 261, /* INTVAL */ + SQL_DEALLOCATE = 262, /* DEALLOCATE */ + SQL_PARAMETERS = 263, /* PARAMETERS */ + SQL_INTERSECT = 264, /* INTERSECT */ + SQL_TEMPORARY = 265, /* TEMPORARY */ + SQL_TIMESTAMP = 266, /* TIMESTAMP */ + SQL_DISTINCT = 267, /* DISTINCT */ + SQL_NVARCHAR = 268, /* NVARCHAR */ + SQL_RESTRICT = 269, /* RESTRICT */ + SQL_TRUNCATE = 270, /* TRUNCATE */ + SQL_ANALYZE = 271, /* ANALYZE */ + SQL_BETWEEN = 272, /* BETWEEN */ + SQL_CASCADE = 273, /* CASCADE */ + SQL_COLUMNS = 274, /* COLUMNS */ + SQL_CONTROL = 275, /* CONTROL */ + SQL_DEFAULT = 276, /* DEFAULT */ + SQL_EXECUTE = 277, /* EXECUTE */ + SQL_EXPLAIN = 278, /* EXPLAIN */ + SQL_INTEGER = 279, /* INTEGER */ + SQL_NATURAL = 280, /* NATURAL */ + SQL_PREPARE = 281, /* PREPARE */ + SQL_PRIMARY = 282, /* PRIMARY */ + SQL_SCHEMAS = 283, /* SCHEMAS */ + SQL_SPATIAL = 284, /* SPATIAL */ + SQL_VARCHAR = 285, /* VARCHAR */ + SQL_VIRTUAL = 286, /* VIRTUAL */ + SQL_DESCRIBE = 287, /* DESCRIBE */ + SQL_BEFORE = 288, /* BEFORE */ + SQL_COLUMN = 289, /* COLUMN */ + SQL_CREATE = 290, /* CREATE */ + SQL_DELETE = 291, /* DELETE */ + SQL_DIRECT = 292, /* DIRECT */ + SQL_DOUBLE = 293, /* DOUBLE */ + SQL_ESCAPE = 294, /* ESCAPE */ + SQL_EXCEPT = 295, /* EXCEPT */ + SQL_EXISTS = 296, /* EXISTS */ + SQL_EXTRACT = 297, /* EXTRACT */ + SQL_CAST = 298, /* CAST */ + SQL_FORMAT = 299, /* FORMAT */ + SQL_GLOBAL = 300, /* GLOBAL */ + SQL_HAVING = 301, /* HAVING */ + SQL_IMPORT = 302, /* IMPORT */ + SQL_INSERT = 303, /* INSERT */ + SQL_ISNULL = 304, /* ISNULL */ + SQL_OFFSET = 305, /* OFFSET */ + SQL_RENAME = 306, /* RENAME */ + SQL_SCHEMA = 307, /* SCHEMA */ + SQL_SELECT = 308, /* SELECT */ + SQL_SORTED = 309, /* SORTED */ + SQL_TABLES = 310, /* TABLES */ + SQL_UNIQUE = 311, /* UNIQUE */ + SQL_UNLOAD = 312, /* UNLOAD */ + SQL_UPDATE = 313, /* UPDATE */ + SQL_VALUES = 314, /* VALUES */ + SQL_AFTER = 315, /* AFTER */ + SQL_ALTER = 316, /* ALTER */ + SQL_CROSS = 317, /* CROSS */ + SQL_DELTA = 318, /* DELTA */ + SQL_FLOAT = 319, /* FLOAT */ + SQL_GROUP = 320, /* GROUP */ + SQL_INDEX = 321, /* INDEX */ + SQL_INNER = 322, /* INNER */ + SQL_LIMIT = 323, /* LIMIT */ + SQL_LOCAL = 324, /* LOCAL */ + SQL_MERGE = 325, /* MERGE */ + SQL_MINUS = 326, /* MINUS */ + SQL_ORDER = 327, /* ORDER */ + SQL_OUTER = 328, /* OUTER */ + SQL_RIGHT = 329, /* RIGHT */ + SQL_TABLE = 330, /* TABLE */ + SQL_UNION = 331, /* UNION */ + SQL_USING = 332, /* USING */ + SQL_WHERE = 333, /* WHERE */ + SQL_CALL = 334, /* CALL */ + SQL_CASE = 335, /* CASE */ + SQL_CHAR = 336, /* CHAR */ + SQL_COPY = 337, /* COPY */ + SQL_DATE = 338, /* DATE */ + SQL_DATETIME = 339, /* DATETIME */ + SQL_DESC = 340, /* DESC */ + SQL_DROP = 341, /* DROP */ + SQL_ELSE = 342, /* ELSE */ + SQL_FILE = 343, /* FILE */ + SQL_FROM = 344, /* FROM */ + SQL_FULL = 345, /* FULL */ + SQL_HASH = 346, /* HASH */ + SQL_HINT = 347, /* HINT */ + SQL_INTO = 348, /* INTO */ + SQL_JOIN = 349, /* JOIN */ + SQL_LEFT = 350, /* LEFT */ + SQL_LIKE = 351, /* LIKE */ + SQL_LOAD = 352, /* LOAD */ + SQL_LONG = 353, /* LONG */ + SQL_NULL = 354, /* NULL */ + SQL_PLAN = 355, /* PLAN */ + SQL_SHOW = 356, /* SHOW */ + SQL_TEXT = 357, /* TEXT */ + SQL_THEN = 358, /* THEN */ + SQL_TIME = 359, /* TIME */ + SQL_VIEW = 360, /* VIEW */ + SQL_WHEN = 361, /* WHEN */ + SQL_WITH = 362, /* WITH */ + SQL_ADD = 363, /* ADD */ + SQL_ALL = 364, /* ALL */ + SQL_AND = 365, /* AND */ + SQL_ASC = 366, /* ASC */ + SQL_END = 367, /* END */ + SQL_FOR = 368, /* FOR */ + SQL_INT = 369, /* INT */ + SQL_KEY = 370, /* KEY */ + SQL_NOT = 371, /* NOT */ + SQL_OFF = 372, /* OFF */ + SQL_SET = 373, /* SET */ + SQL_TOP = 374, /* TOP */ + SQL_AS = 375, /* AS */ + SQL_BY = 376, /* BY */ + SQL_IF = 377, /* IF */ + SQL_IN = 378, /* IN */ + SQL_IS = 379, /* IS */ + SQL_OF = 380, /* OF */ + SQL_ON = 381, /* ON */ + SQL_OR = 382, /* OR */ + SQL_TO = 383, /* TO */ + SQL_ARRAY = 384, /* ARRAY */ + SQL_CONCAT = 385, /* CONCAT */ + SQL_ILIKE = 386, /* ILIKE */ + SQL_SECOND = 387, /* SECOND */ + SQL_MINUTE = 388, /* MINUTE */ + SQL_HOUR = 389, /* HOUR */ + SQL_DAY = 390, /* DAY */ + SQL_MONTH = 391, /* MONTH */ + SQL_YEAR = 392, /* YEAR */ + SQL_TRUE = 393, /* TRUE */ + SQL_FALSE = 394, /* FALSE */ + SQL_TRANSACTION = 395, /* TRANSACTION */ + SQL_BEGIN = 396, /* BEGIN */ + SQL_COMMIT = 397, /* COMMIT */ + SQL_ROLLBACK = 398, /* ROLLBACK */ + SQL_EQUALS = 399, /* EQUALS */ + SQL_NOTEQUALS = 400, /* NOTEQUALS */ + SQL_LESS = 401, /* LESS */ + SQL_GREATER = 402, /* GREATER */ + SQL_LESSEQ = 403, /* LESSEQ */ + SQL_GREATEREQ = 404, /* GREATEREQ */ + SQL_NOTNULL = 405, /* NOTNULL */ + SQL_UMINUS = 406 /* UMINUS */ }; + typedef enum hsql_tokentype hsql_token_kind_t; #endif /* Value type. */ @@ -285,7 +293,7 @@ union HSQL_STYPE std::vector* order_vec; std::vector* with_description_vec; -#line 289 "bison_parser.h" +#line 297 "bison_parser.h" }; typedef union HSQL_STYPE HSQL_STYPE; diff --git a/src/parser/bison_parser.y b/src/parser/bison_parser.y index b502c8a..8a097e8 100755 --- a/src/parser/bison_parser.y +++ b/src/parser/bison_parser.y @@ -171,11 +171,11 @@ int yyerror(YYLTYPE* llocp, SQLParserResult* result, yyscan_t scanner, const cha %token CASCADE COLUMNS CONTROL DEFAULT EXECUTE EXPLAIN %token INTEGER NATURAL PREPARE PRIMARY SCHEMAS %token SPATIAL VARCHAR VIRTUAL DESCRIBE BEFORE COLUMN CREATE DELETE DIRECT -%token DOUBLE ESCAPE EXCEPT EXISTS EXTRACT FORMAT GLOBAL HAVING IMPORT +%token DOUBLE ESCAPE EXCEPT EXISTS EXTRACT CAST FORMAT GLOBAL HAVING IMPORT %token INSERT ISNULL OFFSET RENAME SCHEMA SELECT SORTED %token TABLES UNIQUE UNLOAD UPDATE VALUES AFTER ALTER CROSS %token DELTA FLOAT GROUP INDEX INNER LIMIT LOCAL MERGE MINUS ORDER -%token OUTER RIGHT TABLE UNION USING WHERE CALL CASE CHAR COPY DATE +%token OUTER RIGHT TABLE UNION USING WHERE CALL CASE CHAR COPY DATE DATETIME %token DESC DROP ELSE FILE FROM FULL HASH HINT INTO JOIN %token LEFT LIKE LOAD LONG NULL PLAN SHOW TEXT THEN TIME %token VIEW WHEN WITH ADD ALL AND ASC END FOR INT KEY @@ -207,7 +207,7 @@ int yyerror(YYLTYPE* llocp, SQLParserResult* result, yyscan_t scanner, const cha %type opt_join_type %type opt_from_clause from_clause table_ref table_ref_atomic table_ref_name nonjoin_table_ref_atomic %type
join_clause table_ref_name_no_alias -%type expr operand scalar_expr unary_expr binary_expr logic_expr exists_expr extract_expr +%type expr operand scalar_expr unary_expr binary_expr logic_expr exists_expr extract_expr cast_expr %type function_expr between_expr expr_alias param_expr %type column_name literal int_literal num_literal string_literal bool_literal %type comp_expr opt_where join_condition opt_having case_expr case_list in_expr hint @@ -561,6 +561,7 @@ column_type: | VARCHAR '(' INTVAL ')' { $$ = ColumnType{DataType::VARCHAR, $3}; } | CHAR '(' INTVAL ')' { $$ = ColumnType{DataType::CHAR, $3}; } | TEXT { $$ = ColumnType{DataType::TEXT}; } + | DATETIME { $$ = ColumnType{DataType::DATETIME}; } ; opt_column_nullable: @@ -910,6 +911,7 @@ operand: | case_expr | function_expr | extract_expr + | cast_expr | array_expr | '(' select_no_paren ')' { $$ = Expr::makeSelect($2); } ; @@ -991,6 +993,10 @@ extract_expr: EXTRACT '(' datetime_field FROM expr ')' { $$ = Expr::makeExtract($3, $5); } ; +cast_expr: + CAST '(' expr AS column_type ')' { $$ = Expr::makeCast($3, $5); } + ; + datetime_field: SECOND { $$ = kDatetimeSecond; } | MINUTE { $$ = kDatetimeMinute; } diff --git a/src/parser/flex_lexer.cpp b/src/parser/flex_lexer.cpp index fc8200c..a97400e 100644 --- a/src/parser/flex_lexer.cpp +++ b/src/parser/flex_lexer.cpp @@ -573,8 +573,8 @@ static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner ); yyg->yy_hold_char = *yy_cp; \ *yy_cp = '\0'; \ yyg->yy_c_buf_p = yy_cp; -#define YY_NUM_RULES 158 -#define YY_END_OF_BUFFER 159 +#define YY_NUM_RULES 160 +#define YY_END_OF_BUFFER 161 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info @@ -582,27 +582,27 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static const flex_int16_t yy_accept[1072] = +static const flex_int16_t yy_accept[1082] = { 0, - 0, 0, 155, 155, 2, 2, 159, 157, 4, 4, - 157, 157, 147, 153, 147, 147, 150, 147, 147, 147, - 152, 152, 152, 152, 152, 152, 152, 152, 152, 152, - 152, 152, 152, 152, 152, 152, 152, 152, 152, 152, - 152, 152, 152, 152, 147, 155, 156, 2, 2, 3, + 0, 0, 157, 157, 2, 2, 161, 159, 4, 4, + 159, 159, 149, 155, 149, 149, 152, 149, 149, 149, + 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 149, 157, 158, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 4, 142, 0, 1, 150, - 149, 148, 144, 143, 141, 145, 152, 152, 152, 152, + 2, 2, 2, 2, 2, 4, 144, 0, 1, 152, + 151, 150, 146, 145, 143, 147, 154, 154, 154, 154, - 152, 152, 120, 152, 121, 152, 152, 152, 152, 152, - 152, 152, 152, 152, 152, 152, 152, 152, 152, 152, - 152, 152, 152, 152, 152, 152, 152, 152, 152, 122, - 152, 152, 123, 124, 152, 152, 152, 152, 152, 152, - 152, 152, 152, 152, 152, 152, 125, 126, 127, 152, - 152, 152, 152, 152, 152, 152, 152, 152, 152, 152, - 152, 152, 152, 152, 152, 128, 152, 152, 152, 152, - 152, 152, 152, 152, 152, 146, 155, 154, 2, 2, + 154, 154, 122, 154, 123, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 154, 124, + 154, 154, 125, 126, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 127, 128, 129, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 130, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 148, 157, 156, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -613,19 +613,19 @@ static const flex_int16_t yy_accept[1072] = 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 151, 148, 108, 152, 109, 152, 152, 110, 152, 111, - 152, 152, 152, 152, 152, 152, 152, 152, 152, 152, - 152, 152, 152, 132, 152, 152, 152, 152, 152, 152, + 153, 150, 110, 154, 111, 154, 154, 112, 154, 113, + 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 134, 154, 154, 154, 154, 154, 154, - 152, 152, 152, 112, 152, 152, 152, 152, 152, 152, - 152, 152, 152, 113, 152, 152, 152, 152, 152, 152, - 152, 152, 152, 152, 152, 152, 152, 114, 152, 152, - 115, 152, 152, 152, 152, 152, 152, 152, 152, 152, - 152, 116, 152, 152, 117, 152, 152, 152, 152, 152, - 152, 152, 152, 152, 152, 152, 152, 152, 118, 152, - 152, 152, 152, 152, 152, 152, 152, 119, 152, 152, - 152, 152, 152, 152, 152, 152, 152, 152, 152, 152, - 152, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 154, 154, 154, 114, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 115, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 116, 154, 154, + 117, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 118, 154, 154, 119, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 120, 154, + 154, 154, 154, 154, 154, 154, 154, 121, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -637,18 +637,18 @@ static const flex_int16_t yy_accept[1072] = 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 152, 152, 152, 152, 152, 152, 152, 79, + 2, 2, 154, 154, 154, 154, 154, 154, 154, 80, - 152, 80, 81, 152, 152, 152, 82, 152, 152, 83, - 152, 152, 152, 152, 84, 152, 152, 152, 85, 86, - 152, 152, 152, 152, 152, 152, 152, 87, 152, 152, - 88, 89, 152, 152, 90, 152, 91, 131, 152, 152, - 152, 152, 152, 152, 92, 152, 93, 94, 95, 152, - 97, 152, 98, 152, 152, 152, 152, 99, 152, 152, - 152, 152, 152, 100, 152, 152, 152, 152, 152, 152, - 152, 152, 152, 101, 152, 152, 152, 152, 102, 103, - 104, 152, 135, 152, 152, 152, 152, 152, 152, 152, - 152, 105, 152, 106, 152, 107, 134, 2, 2, 2, + 154, 81, 41, 82, 154, 154, 154, 83, 154, 154, + 84, 154, 154, 154, 154, 86, 154, 154, 154, 87, + 88, 154, 154, 154, 154, 154, 154, 154, 89, 154, + 154, 90, 91, 154, 154, 92, 154, 93, 133, 154, + 154, 154, 154, 154, 154, 94, 154, 95, 96, 97, + 154, 99, 154, 100, 154, 154, 154, 154, 101, 154, + 154, 154, 154, 154, 102, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 103, 154, 154, 154, 154, 104, + 105, 106, 154, 137, 154, 154, 154, 154, 154, 154, + 154, 154, 107, 154, 108, 154, 109, 136, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -661,15 +661,15 @@ static const flex_int16_t yy_accept[1072] = 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 57, 58, 152, 59, 152, 138, 152, 152, - 152, 152, 152, 152, 60, 152, 152, 152, 61, 152, - 152, 152, 152, 152, 152, 152, 152, 152, 152, 136, - 62, 152, 152, 63, 152, 96, 152, 64, 65, 152, - 152, 152, 152, 66, 67, 68, 69, 152, 133, 152, - 152, 152, 70, 71, 152, 152, 152, 152, 152, 72, - 152, 152, 152, 152, 152, 152, 73, 152, 152, 152, - 152, 74, 152, 152, 152, 77, 152, 152, 152, 78, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 58, 59, 154, 60, 154, 140, + 154, 154, 154, 154, 154, 154, 61, 154, 154, 154, + 154, 62, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 138, 63, 154, 154, 64, 154, 98, 154, + 65, 66, 154, 154, 154, 154, 67, 68, 69, 70, + 154, 135, 154, 154, 154, 71, 72, 154, 154, 154, + 154, 154, 73, 154, 154, 154, 154, 154, 154, 74, + 154, 154, 154, 154, 75, 154, 154, 154, 78, 154, + 154, 154, 79, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -677,30 +677,31 @@ static const flex_int16_t yy_accept[1072] = 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 152, 31, - 152, 152, 32, 140, 152, 33, 152, 152, 34, 152, - 35, 152, 36, 37, 38, 152, 39, 152, 152, 41, - 42, 43, 44, 45, 152, 152, 46, 130, 152, 152, - 47, 152, 152, 152, 48, 152, 152, 49, 129, 50, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 154, 31, 154, 154, 32, 142, 154, 33, + 154, 154, 154, 34, 154, 35, 154, 36, 37, 38, + 154, 39, 154, 154, 42, 43, 44, 45, 46, 154, + 154, 47, 132, 154, 154, 48, 154, 154, 154, 49, - 51, 152, 52, 152, 152, 152, 152, 53, 54, 55, - 56, 152, 152, 2, 2, 2, 2, 2, 2, 2, + 154, 154, 50, 131, 51, 52, 154, 53, 154, 154, + 154, 154, 54, 55, 56, 57, 154, 154, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 15, 16, - 17, 18, 19, 152, 20, 152, 152, 21, 22, 40, - 23, 152, 24, 152, 152, 25, 26, 152, 152, 27, - 28, 152, 152, 152, 152, 29, 30, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 15, 16, 17, 18, 19, 154, + 154, 20, 154, 154, 21, 22, 40, 23, 154, 24, + 154, 154, 25, 26, 154, 154, 27, 28, 154, 154, + 154, 154, 29, 30, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 152, 10, 11, 152, - 12, 152, 13, 139, 152, 152, 152, 14, 2, 2, + 2, 2, 2, 2, 85, 154, 10, 11, 154, 12, + 154, 13, 141, 154, 154, 154, 14, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 152, 7, 152, 8, 9, 152, 2, 2, 2, 2, - 2, 2, 5, 6, 152, 2, 2, 2, 137, 2, + 154, 7, 154, 8, 9, 154, 2, 2, 2, 2, + 2, 2, 5, 6, 154, 2, 2, 2, 139, 2, 0 } ; @@ -747,18 +748,18 @@ static const YY_CHAR yy_meta[68] = 5, 5, 5, 5, 5, 5, 1 } ; -static const flex_int16_t yy_base[1079] = +static const flex_int16_t yy_base[1089] = { 0, - 0, 0, 422, 414, 67, 0, 410, 4278, 133, 135, - 368, 0, 4278, 4278, 131, 345, 133, 132, 312, 300, + 0, 0, 422, 414, 67, 0, 410, 4309, 133, 135, + 368, 0, 4309, 4309, 131, 345, 133, 132, 312, 300, 129, 129, 137, 135, 145, 196, 171, 184, 188, 124, 141, 183, 228, 230, 236, 235, 0, 250, 280, 323, 257, 194, 231, 144, 243, 0, 297, 0, 259, 272, 276, 276, 0, 0, 161, 259, 293, 294, 247, 224, 381, 448, 502, 554, 602, 654, 301, 377, 702, 302, 304, 379, 440, 754, 802, 449, 358, 453, 852, 904, - 499, 524, 553, 366, 164, 312, 4278, 221, 4278, 308, - 212, 209, 4278, 4278, 4278, 4278, 0, 147, 267, 296, + 499, 524, 553, 366, 164, 312, 4309, 221, 4309, 308, + 212, 209, 4309, 4309, 4309, 4309, 0, 147, 267, 296, 317, 302, 322, 450, 0, 318, 338, 552, 391, 439, 596, 406, 341, 386, 384, 403, 457, 641, 451, 454, @@ -767,7 +768,7 @@ static const flex_int16_t yy_base[1079] = 563, 569, 583, 592, 601, 617, 614, 0, 621, 611, 615, 636, 665, 637, 655, 653, 659, 700, 676, 680, 703, 707, 700, 712, 706, 707, 732, 749, 725, 736, - 745, 759, 757, 745, 765, 4278, 0, 4278, 0, 360, + 745, 759, 757, 745, 765, 4309, 0, 4309, 0, 360, 0, 212, 0, 364, 193, 190, 0, 0, 0, 0, 762, 793, 790, 824, 847, 794, 856, 891, 806, 895, @@ -778,119 +779,120 @@ static const flex_int16_t yy_base[1079] = 1172, 1151, 1255, 1249, 1277, 1283, 1288, 1298, 1293, 1309, 1311, 1344, 1347, 1333, 1352, 1365, 1368, 1350, 1382, 1393, 1405, 1419, 1407, 1418, 1444, 1442, 1416, 1441, 1474, 0, - 4278, 145, 0, 768, 0, 769, 766, 0, 812, 0, - 838, 853, 841, 853, 965, 848, 869, 913, 932, 938, - 974, 957, 1018, 0, 1017, 1051, 1161, 1063, 1077, 1152, + 4309, 145, 0, 768, 0, 769, 766, 0, 812, 0, + 838, 853, 841, 853, 1460, 848, 869, 913, 932, 938, + 967, 951, 970, 0, 964, 1022, 1161, 1026, 1047, 1046, - 1189, 1194, 1229, 0, 1239, 1278, 1301, 1286, 1294, 1341, - 1369, 1408, 1462, 1451, 1452, 1465, 1476, 1459, 1473, 1473, - 1464, 1467, 1475, 1480, 1492, 1493, 1495, 1505, 1480, 1489, - 0, 1494, 1510, 1507, 1513, 1517, 1512, 1514, 1502, 1509, - 1510, 0, 1520, 1515, 1515, 1530, 1531, 1537, 1525, 1524, - 1536, 1550, 1532, 1545, 1542, 1550, 1542, 1559, 0, 1545, - 1549, 1550, 1559, 1556, 1553, 1560, 1570, 0, 1563, 1578, - 1570, 1571, 1587, 1575, 1569, 1590, 1571, 1583, 1591, 1598, - 1589, 0, 140, 1603, 1606, 1617, 1618, 1632, 1620, 1655, - 1621, 1636, 1654, 1642, 1670, 1686, 1680, 1672, 1708, 1676, + 1080, 1156, 1186, 0, 1209, 1229, 1237, 1264, 1292, 1287, + 1287, 1354, 1387, 1400, 1451, 1465, 1476, 1460, 1474, 1475, + 1465, 1468, 1484, 1482, 1493, 1495, 1496, 1505, 1482, 1500, + 0, 1495, 1511, 1508, 1514, 1518, 1514, 1516, 1508, 1511, + 1511, 0, 1521, 1516, 1516, 1531, 1533, 1538, 1526, 1533, + 1538, 1551, 1533, 1546, 1543, 1552, 1549, 1563, 0, 1546, + 1550, 1551, 1560, 1557, 1554, 1561, 1572, 0, 1569, 1580, + 1571, 1572, 1588, 1576, 1571, 1590, 1580, 1585, 1593, 1598, + 1590, 0, 140, 1604, 1617, 1618, 1619, 1634, 1620, 1636, + 1622, 1650, 1653, 1658, 1655, 1692, 1686, 1688, 1701, 1696, - 1694, 1709, 1710, 1722, 1725, 1739, 1738, 1747, 1750, 1744, - 1763, 1779, 1781, 1760, 1768, 1800, 1782, 1813, 1798, 1814, - 1804, 1816, 1822, 1850, 1854, 1856, 1852, 1858, 1868, 1887, - 1892, 1893, 1909, 1898, 1906, 1910, 1921, 1924, 1932, 1938, - 1946, 1947, 1960, 1950, 1972, 1963, 1988, 1996, 2004, 2001, - 2012, 2014, 2009, 2038, 2040, 2049, 2046, 2050, 2068, 2062, - 2081, 2086, 2103, 2102, 2104, 2105, 2100, 2135, 2116, 2137, - 2138, 2146, 2154, 2160, 2148, 2177, 2189, 2179, 2190, 2191, - 2203, 2221, 2222, 2244, 2234, 2235, 2265, 2256, 2257, 2266, - 2294, 2295, 1609, 1621, 1651, 1706, 1840, 1858, 1875, 0, + 1671, 1724, 1732, 1710, 1722, 1754, 1745, 1740, 1758, 1750, + 1775, 1789, 1780, 1776, 1784, 1810, 1794, 1826, 1815, 1825, + 1834, 1844, 1828, 1843, 1860, 1869, 1879, 1897, 1882, 1900, + 1888, 1918, 1923, 1922, 1931, 1912, 1934, 1937, 1946, 1971, + 1976, 1952, 1962, 1974, 1986, 2008, 2019, 2000, 2024, 2016, + 2010, 2038, 2040, 2041, 2049, 2050, 2072, 2073, 2078, 2086, + 2083, 2082, 2084, 2108, 2112, 2127, 2116, 2138, 2124, 2126, + 2149, 2137, 2162, 2180, 2170, 2168, 2192, 2166, 2178, 2202, + 2221, 2206, 2224, 2235, 2247, 2250, 2265, 2260, 2264, 2289, + 2300, 2288, 1608, 1639, 1746, 1818, 1827, 1840, 1878, 0, - 1904, 0, 0, 1956, 1974, 1973, 0, 1980, 2006, 0, - 2045, 2067, 2069, 2118, 2165, 2204, 2216, 2239, 0, 0, - 2242, 2278, 2280, 2283, 2304, 2309, 2307, 0, 2294, 2314, - 0, 0, 2315, 2306, 0, 2309, 0, 0, 2319, 2307, - 2307, 2315, 2316, 2337, 0, 2323, 0, 0, 0, 2316, - 0, 2326, 0, 2340, 2334, 2340, 2338, 0, 2354, 2354, - 2346, 2348, 2354, 0, 2367, 2368, 2357, 2355, 2354, 2374, - 2364, 2364, 2376, 0, 2380, 2378, 2383, 2374, 0, 0, - 2371, 2373, 0, 2395, 2385, 2381, 2406, 2388, 2402, 2405, - 2403, 0, 2392, 0, 2413, 0, 0, 2423, 2425, 2417, + 1887, 0, 0, 0, 1876, 1936, 1935, 0, 1938, 1981, + 2099, 2111, 2156, 2217, 2246, 2233, 2256, 2268, 2279, 0, + 0, 2284, 2285, 2288, 2295, 2318, 2321, 2318, 0, 2304, + 2325, 0, 0, 2328, 2315, 0, 2323, 0, 0, 2333, + 2321, 2319, 2326, 2327, 2341, 0, 2335, 0, 0, 0, + 2334, 0, 2343, 0, 2352, 2341, 2354, 2345, 0, 2364, + 2363, 2351, 2355, 2363, 0, 2376, 2377, 2366, 2362, 2363, + 2383, 2378, 2378, 2390, 0, 2392, 2389, 2394, 2386, 0, + 0, 2383, 2389, 0, 2406, 2397, 2392, 2413, 2395, 2409, + 2412, 2413, 0, 2401, 0, 2418, 0, 0, 2427, 2428, - 2419, 2428, 2442, 2427, 2453, 2461, 2456, 2459, 2477, 2467, - 2482, 2490, 2496, 2493, 2499, 2521, 2515, 2530, 2536, 2547, - 2551, 2561, 2566, 2564, 2569, 2579, 2601, 2602, 2604, 2607, - 2636, 2615, 2620, 2623, 2637, 2641, 2652, 2673, 2671, 2658, - 2677, 2674, 2675, 2687, 2690, 2692, 2715, 2716, 2731, 2725, - 2741, 2726, 2727, 2749, 2750, 2759, 2780, 2764, 2781, 2789, - 2790, 2785, 2795, 2821, 2813, 2834, 2838, 2835, 2829, 2857, - 2863, 2844, 2875, 2872, 2869, 2897, 2898, 2903, 2900, 2906, - 2909, 2911, 2939, 2921, 2935, 2937, 2960, 2943, 2969, 2952, - 2965, 2975, 2991, 3003, 2973, 3014, 2977, 3009, 3015, 3019, + 2422, 2426, 2450, 2451, 2432, 2456, 2461, 2462, 2465, 2466, + 2491, 2496, 2494, 2495, 2504, 2525, 2517, 2528, 2520, 2550, + 2533, 2558, 2576, 2579, 2561, 2573, 2582, 2604, 2607, 2612, + 2621, 2617, 2647, 2630, 2633, 2646, 2656, 2638, 2662, 2675, + 2681, 2684, 2687, 2686, 2690, 2700, 2705, 2716, 2726, 2729, + 2738, 2721, 2750, 2744, 2754, 2755, 2772, 2759, 2783, 2780, + 2788, 2798, 2821, 2796, 2811, 2822, 2826, 2837, 2852, 2854, + 2855, 2860, 2870, 2878, 2891, 2888, 2909, 2912, 2914, 2924, + 2926, 2928, 2954, 2937, 2942, 2940, 2943, 2966, 2968, 2945, + 2978, 2991, 2994, 3006, 2997, 3020, 2996, 3028, 3030, 3036, - 3027, 3028, 0, 0, 2401, 0, 2491, 0, 2525, 2528, - 2544, 2555, 2572, 2653, 0, 2671, 2733, 2799, 0, 2814, - 2808, 2858, 2983, 3013, 3011, 3016, 3023, 3039, 3047, 0, - 0, 3034, 3044, 0, 3055, 0, 3044, 0, 0, 3045, - 3063, 3051, 3060, 0, 0, 0, 0, 3068, 0, 3073, - 3068, 3058, 0, 0, 3077, 3066, 3067, 3081, 3078, 0, - 3087, 3089, 3089, 3074, 3092, 3097, 3083, 3086, 3086, 3106, - 3107, 0, 3105, 3112, 3113, 0, 3100, 3121, 3123, 0, - 3122, 3123, 3127, 3125, 3131, 3133, 3135, 3137, 3156, 3166, - 3167, 3168, 3171, 3179, 3190, 3185, 3200, 3219, 3221, 3202, + 3034, 3042, 3045, 3046, 0, 0, 2509, 0, 2584, 0, + 2587, 2590, 2613, 2657, 2687, 2805, 0, 2830, 2834, 2860, + 2900, 0, 2973, 2993, 3023, 3051, 3060, 3049, 3053, 3056, + 3067, 3076, 0, 0, 3061, 3073, 0, 3080, 0, 3069, + 0, 0, 3070, 3086, 3074, 3083, 0, 0, 0, 0, + 3094, 0, 3100, 3096, 3085, 0, 0, 3102, 3091, 3092, + 3106, 3104, 0, 3114, 3118, 3117, 3103, 3120, 3124, 3108, + 3111, 3110, 3132, 3134, 0, 3134, 3137, 3138, 0, 3125, + 3144, 3146, 0, 3144, 3148, 3153, 3150, 3156, 3158, 3159, + 3182, 3184, 3172, 3207, 3196, 3198, 3222, 3228, 3230, 3212, - 3225, 3231, 3240, 3242, 3256, 3261, 3273, 3259, 3274, 3275, - 3304, 3285, 3307, 3296, 3299, 3310, 3313, 3329, 3315, 3325, - 3348, 3347, 3350, 3353, 3358, 3359, 3361, 3369, 3384, 3383, - 3393, 3399, 3401, 3402, 3423, 3407, 3433, 3412, 3445, 3451, - 3456, 3466, 3485, 3477, 3475, 3494, 3510, 3519, 3527, 3479, - 3509, 3518, 3528, 3531, 3549, 3564, 3572, 3553, 3134, 0, - 3192, 3207, 3239, 0, 3257, 0, 3365, 3349, 0, 3420, - 0, 3437, 0, 0, 0, 3461, 0, 3460, 3520, 0, - 0, 0, 0, 0, 3527, 3543, 0, 0, 3552, 3565, - 0, 3556, 3577, 3559, 0, 3583, 3584, 3569, 0, 0, + 3213, 3247, 3241, 3262, 3246, 3252, 3270, 3276, 3281, 3280, + 3304, 3286, 3305, 3315, 3314, 3316, 3338, 3319, 3344, 3349, + 3350, 3353, 3354, 3378, 3382, 3379, 3383, 3384, 3387, 3388, + 3393, 3421, 3433, 3412, 3418, 3422, 3423, 3451, 3461, 3446, + 3452, 3455, 3489, 3490, 3477, 3500, 3506, 3511, 3521, 3530, + 3525, 3555, 3560, 3467, 3519, 3564, 3549, 3554, 3559, 3565, + 3593, 3594, 3162, 0, 3179, 3194, 3222, 0, 3303, 0, + 3312, 3347, 3442, 0, 3498, 0, 3498, 0, 0, 0, + 3544, 0, 3586, 3582, 0, 0, 0, 0, 0, 3585, + 3599, 0, 0, 3596, 3608, 0, 3590, 3608, 3589, 0, - 0, 3578, 0, 3593, 3597, 3596, 3582, 0, 0, 0, - 0, 3588, 3595, 3603, 3605, 3613, 3607, 3617, 3615, 3636, - 3618, 3641, 3657, 3626, 3651, 3647, 3681, 3669, 3680, 3682, - 3685, 3690, 3711, 3703, 3695, 3713, 3714, 3719, 3724, 3735, - 3736, 3749, 3752, 3757, 3774, 3753, 3778, 3765, 3768, 3786, - 3789, 3810, 3818, 3802, 3807, 3819, 3824, 3823, 3852, 3860, - 3842, 3861, 3864, 3873, 3874, 3877, 3882, 3878, 0, 0, - 0, 0, 0, 3663, 0, 3754, 3775, 0, 0, 0, - 0, 3828, 0, 3815, 3841, 0, 0, 3848, 3880, 0, - 0, 3879, 3888, 3891, 3910, 0, 0, 3914, 3915, 3916, + 3612, 3617, 3603, 0, 0, 0, 3611, 0, 3623, 3627, + 3629, 3613, 0, 0, 0, 0, 3616, 3626, 3638, 3639, + 3643, 3647, 3648, 3649, 3657, 3651, 3653, 3683, 3672, 3682, + 3715, 3693, 3707, 3697, 3701, 3706, 3711, 3716, 3737, 3741, + 3725, 3747, 3749, 3750, 3751, 3766, 3755, 3760, 3765, 3801, + 3795, 3789, 3790, 3799, 3800, 3803, 3831, 3840, 3825, 3814, + 3843, 3844, 3855, 3849, 3857, 3883, 3888, 3885, 3854, 3894, + 3897, 3898, 3909, 3919, 0, 0, 0, 0, 0, 3868, + 3897, 0, 3907, 3896, 0, 0, 0, 0, 3918, 0, + 3910, 3928, 0, 0, 3916, 3927, 0, 0, 3924, 3932, - 3918, 3926, 3931, 3928, 3930, 3932, 3940, 3944, 3949, 3966, - 3970, 3972, 3981, 3980, 3982, 3983, 4005, 4006, 3984, 4014, - 4022, 4016, 4040, 4018, 4037, 4046, 3973, 0, 0, 4008, - 0, 4031, 0, 0, 4028, 4043, 4052, 0, 4059, 4058, - 4068, 4076, 4070, 4089, 4072, 4080, 4094, 4111, 4108, 4110, - 4077, 0, 4084, 0, 0, 4103, 4124, 4126, 4134, 4132, - 4142, 4150, 0, 0, 4111, 4145, 4156, 4182, 0, 4166, - 4278, 4247, 4252, 135, 4257, 4262, 4267, 4272 + 3927, 3947, 0, 0, 3948, 3951, 3952, 3957, 3961, 3962, + 3963, 3965, 3973, 3976, 3987, 3997, 4001, 4002, 4013, 4005, + 4026, 4015, 4016, 4027, 4030, 4031, 4041, 4055, 4056, 4059, + 4065, 4070, 4071, 4081, 0, 4069, 0, 0, 4072, 0, + 4076, 0, 0, 4073, 4084, 4095, 0, 4104, 4110, 4109, + 4113, 4119, 4115, 4145, 4121, 4123, 4127, 4144, 4149, 4159, + 4105, 0, 4149, 0, 0, 4157, 4173, 4175, 4183, 4178, + 4181, 4189, 0, 0, 4168, 4187, 4211, 4212, 0, 4213, + 4309, 4278, 4283, 135, 4288, 4293, 4298, 4303 } ; -static const flex_int16_t yy_def[1079] = +static const flex_int16_t yy_def[1089] = { 0, - 1071, 1, 1072, 1072, 1071, 5, 1071, 1071, 1071, 1071, - 1071, 1073, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1071, 1075, 1071, 1076, 1076, 1071, - 1076, 1077, 1076, 1076, 1076, 1076, 1076, 1076, 1076, 1076, - 1078, 1078, 62, 62, 62, 62, 62, 62, 62, 62, + 1081, 1, 1082, 1082, 1081, 5, 1081, 1081, 1081, 1081, + 1081, 1083, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1081, 1085, 1081, 1086, 1086, 1081, + 1086, 1087, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, + 1088, 1088, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, - 62, 62, 62, 62, 1076, 1071, 1071, 1073, 1071, 1071, - 1071, 1071, 1071, 1071, 1071, 1071, 1074, 1074, 1074, 1074, + 62, 62, 62, 62, 1086, 1081, 1081, 1083, 1081, 1081, + 1081, 1081, 1081, 1081, 1081, 1081, 1084, 1084, 1084, 1084, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1071, 1075, 1071, 1076, 1076, - 1076, 1077, 1076, 1076, 1076, 1076, 1076, 1076, 1076, 1076, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1081, 1085, 1081, 1086, 1086, + 1086, 1087, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, @@ -899,20 +901,20 @@ static const flex_int16_t yy_def[1079] = 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, - 62, 62, 62, 62, 62, 62, 62, 62, 62, 1076, - 1071, 1071, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 1086, + 1081, 1081, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1076, 1076, 62, 62, 62, 62, 62, 62, 62, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1086, 1086, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, @@ -924,18 +926,18 @@ static const flex_int16_t yy_def[1079] = 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, - 62, 62, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, + 62, 62, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 62, 62, 62, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, @@ -948,15 +950,15 @@ static const flex_int16_t yy_def[1079] = 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, - 62, 62, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, @@ -964,34 +966,35 @@ static const flex_int16_t yy_def[1079] = 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, - 62, 62, 62, 62, 62, 62, 62, 62, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 62, 62, 62, 62, 62, 62, 62, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, - 62, 62, 62, 62, 62, 62, 62, 62, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, - 62, 62, 62, 62, 62, 62, 1074, 1074, 1074, 1074, - 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 62, 62, + 62, 62, 62, 62, 1084, 1084, 1084, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1084, 1084, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, - 1074, 1074, 1074, 1074, 1074, 1074, 62, 62, 62, 62, - 62, 62, 1074, 1074, 1074, 62, 62, 62, 1074, 62, - 0, 1071, 1071, 1071, 1071, 1071, 1071, 1071 + 1084, 1084, 1084, 1084, 1084, 1084, 62, 62, 62, 62, + 62, 62, 1084, 1084, 1084, 62, 62, 62, 1084, 62, + 0, 1081, 1081, 1081, 1081, 1081, 1081, 1081 } ; -static const flex_int16_t yy_nxt[4346] = +static const flex_int16_t yy_nxt[4377] = { 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, @@ -1037,443 +1040,446 @@ static const flex_int16_t yy_nxt[4346] = 167, 179, 179, 269, 179, 179, 179, 179, 179, 179, 221, 179, 179, 179, 191, 191, 231, 192, 222, 193, - 232, 301, 191, 191, 223, 194, 233, 195, 291, 1071, + 232, 301, 191, 191, 223, 194, 233, 195, 291, 1081, 269, 196, 197, 302, 191, 303, 191, 221, 292, 304, - 47, 191, 191, 231, 192, 222, 193, 232, 47, 1071, + 47, 191, 191, 231, 192, 222, 193, 232, 47, 1081, 191, 223, 194, 233, 195, 291, 299, 300, 196, 197, - 302, 191, 303, 191, 1071, 292, 304, 179, 179, 179, - 1071, 179, 179, 179, 179, 179, 179, 234, 179, 179, + 302, 191, 303, 191, 1081, 292, 304, 179, 179, 179, + 1081, 179, 179, 179, 179, 179, 179, 234, 179, 179, 179, 235, 245, 299, 300, 198, 191, 236, 281, 282, 248, 293, 305, 246, 249, 311, 294, 191, 312, 247, - 250, 313, 283, 314, 234, 199, 191, 1071, 235, 245, + 250, 313, 283, 314, 234, 199, 191, 1081, 235, 245, 191, 315, 198, 191, 236, 281, 282, 248, 293, 305, 246, 249, 311, 294, 191, 312, 247, 250, 313, 283, 314, 316, 199, 191, 179, 200, 191, 191, 315, 191, 317, 318, 201, 319, 321, 262, 320, 263, 322, 202, - 264, 323, 203, 324, 1071, 329, 191, 265, 316, 191, - 1071, 191, 200, 191, 1071, 266, 191, 317, 318, 201, + 264, 323, 203, 324, 1081, 329, 191, 265, 316, 191, + 1081, 191, 200, 191, 1081, 266, 191, 317, 318, 201, 319, 321, 262, 320, 263, 322, 202, 264, 323, 203, 324, 191, 329, 191, 265, 330, 191, 204, 191, 331, 191, 205, 266, 267, 268, 206, 287, 288, 289, 332, - 290, 207, 1071, 333, 208, 334, 338, 1071, 191, 339, - 191, 191, 330, 1071, 204, 340, 331, 191, 205, 1071, + 290, 207, 1081, 333, 208, 334, 338, 1081, 191, 339, + 191, 191, 330, 1081, 204, 340, 331, 191, 205, 1081, 267, 268, 206, 287, 288, 289, 332, 290, 207, 295, 333, 208, 334, 338, 296, 341, 339, 191, 191, 191, - 297, 335, 340, 336, 342, 343, 209, 298, 210, 1071, - 344, 1071, 345, 211, 337, 1071, 295, 346, 212, 191, - 1071, 296, 341, 347, 1071, 348, 191, 297, 335, 349, + 297, 335, 340, 336, 342, 343, 209, 298, 210, 1081, + 344, 1081, 345, 211, 337, 1081, 295, 346, 212, 191, + 1081, 296, 341, 347, 1081, 348, 191, 297, 335, 349, 336, 342, 343, 209, 298, 210, 306, 344, 307, 345, 211, 337, 308, 352, 346, 212, 191, 213, 353, 309, 347, 191, 348, 310, 354, 214, 349, 355, 215, 356, - 1071, 216, 350, 306, 217, 307, 351, 218, 1071, 308, - 352, 191, 1071, 1071, 213, 353, 309, 1071, 191, 1071, + 1081, 216, 350, 306, 217, 307, 351, 218, 1081, 308, + 352, 191, 1081, 1081, 213, 353, 309, 1081, 191, 1081, 310, 354, 214, 360, 355, 215, 356, 325, 216, 350, - 361, 217, 1071, 351, 218, 357, 362, 326, 191, 191, + 361, 217, 1081, 351, 218, 357, 362, 326, 191, 191, 224, 363, 327, 328, 358, 364, 225, 226, 227, 366, - 360, 367, 359, 228, 325, 368, 365, 361, 1071, 191, - 1071, 373, 357, 362, 326, 369, 191, 224, 363, 327, + 360, 367, 359, 228, 325, 368, 365, 361, 1081, 191, + 1081, 373, 357, 362, 326, 369, 191, 224, 363, 327, 328, 358, 364, 225, 226, 227, 366, 374, 367, 359, - 228, 1071, 368, 365, 1071, 370, 191, 237, 373, 375, + 228, 1081, 368, 365, 1081, 370, 191, 237, 373, 375, 371, 191, 369, 372, 379, 376, 377, 380, 381, 191, - 1071, 238, 1071, 1071, 374, 493, 494, 239, 240, 378, - 495, 191, 370, 1071, 237, 1071, 375, 371, 191, 191, + 1081, 238, 1081, 1081, 374, 493, 494, 239, 240, 378, + 495, 191, 370, 1081, 237, 1081, 375, 371, 191, 191, 372, 379, 376, 377, 380, 381, 191, 191, 238, 384, 191, 191, 493, 494, 239, 240, 378, 495, 191, 191, - 241, 1071, 385, 191, 390, 496, 191, 191, 242, 1071, - 191, 191, 243, 1071, 191, 244, 384, 191, 191, 191, - 1071, 191, 1071, 191, 1071, 1071, 191, 241, 386, 385, - 191, 390, 496, 1071, 191, 242, 387, 191, 191, 243, + 241, 1081, 385, 191, 390, 496, 191, 191, 242, 1081, + 191, 191, 243, 1081, 191, 244, 384, 191, 191, 191, + 1081, 191, 1081, 191, 1081, 1081, 191, 241, 386, 385, + 191, 390, 496, 1081, 191, 242, 387, 191, 191, 243, 388, 191, 244, 389, 191, 497, 191, 251, 191, 252, - 191, 391, 253, 191, 498, 386, 499, 500, 503, 254, - 255, 1071, 1071, 387, 191, 1071, 1071, 388, 191, 191, - 389, 191, 497, 191, 251, 1071, 252, 1071, 391, 253, + 191, 391, 253, 191, 498, 386, 499, 500, 504, 254, + 255, 1081, 1081, 387, 191, 1081, 1081, 388, 191, 191, + 389, 191, 497, 191, 251, 1081, 252, 1081, 391, 253, - 191, 498, 504, 499, 500, 503, 254, 255, 191, 392, - 393, 191, 191, 191, 1071, 1071, 191, 256, 397, 395, - 191, 257, 191, 394, 258, 259, 396, 414, 191, 504, - 1071, 260, 191, 191, 261, 191, 392, 393, 505, 191, - 191, 191, 191, 1071, 256, 397, 395, 402, 257, 191, + 191, 498, 505, 499, 500, 504, 254, 255, 191, 392, + 393, 191, 191, 191, 1081, 1081, 191, 256, 397, 395, + 191, 257, 191, 394, 258, 259, 396, 414, 191, 505, + 1081, 260, 191, 191, 261, 191, 392, 393, 506, 191, + 191, 191, 191, 1081, 256, 397, 395, 402, 257, 191, 394, 258, 259, 396, 414, 191, 191, 403, 260, 191, - 191, 261, 1071, 1071, 506, 505, 1071, 191, 191, 191, - 191, 404, 191, 191, 402, 507, 405, 398, 399, 400, - 501, 401, 502, 191, 403, 410, 411, 508, 509, 412, - 191, 506, 191, 191, 191, 1071, 1071, 191, 404, 191, + 191, 261, 1081, 1081, 507, 506, 1081, 191, 191, 191, + 191, 404, 191, 191, 402, 508, 405, 398, 399, 400, + 509, 401, 510, 191, 403, 410, 411, 511, 512, 412, + 191, 507, 191, 191, 191, 1081, 1081, 191, 404, 191, - 191, 191, 507, 405, 398, 399, 400, 501, 401, 502, - 191, 413, 410, 411, 508, 509, 412, 191, 406, 191, - 191, 191, 191, 407, 191, 415, 191, 1071, 191, 408, - 191, 422, 416, 1071, 191, 510, 409, 191, 413, 1071, - 191, 511, 191, 1071, 191, 406, 191, 423, 191, 191, - 407, 191, 415, 191, 191, 1071, 408, 191, 422, 416, - 191, 191, 510, 409, 512, 191, 191, 191, 511, 191, - 191, 191, 1071, 191, 423, 424, 191, 1071, 515, 425, - 426, 191, 417, 427, 418, 191, 191, 191, 419, 1071, - 191, 512, 191, 191, 516, 420, 191, 191, 191, 421, + 191, 191, 508, 405, 398, 399, 400, 509, 401, 510, + 191, 413, 410, 411, 511, 512, 412, 191, 406, 191, + 191, 191, 191, 407, 191, 415, 191, 1081, 191, 408, + 191, 422, 416, 1081, 191, 513, 409, 191, 413, 1081, + 191, 516, 191, 1081, 191, 406, 191, 423, 191, 191, + 407, 191, 415, 191, 191, 1081, 408, 191, 422, 416, + 191, 191, 513, 409, 517, 191, 191, 191, 516, 191, + 191, 191, 1081, 191, 423, 424, 191, 1081, 518, 425, + 426, 191, 417, 427, 418, 191, 191, 191, 419, 1081, + 191, 517, 191, 191, 519, 420, 191, 191, 191, 421, - 191, 1071, 424, 191, 191, 515, 425, 426, 428, 417, + 191, 1081, 424, 191, 191, 518, 425, 426, 428, 417, 427, 418, 191, 191, 191, 419, 191, 191, 191, 191, - 442, 516, 420, 191, 429, 191, 421, 191, 432, 191, - 430, 191, 191, 431, 191, 428, 191, 1071, 191, 191, + 442, 519, 420, 191, 429, 191, 421, 191, 432, 191, + 430, 191, 191, 431, 191, 428, 191, 1081, 191, 191, 435, 191, 434, 191, 191, 191, 191, 442, 433, 191, 191, 429, 191, 440, 441, 432, 191, 430, 191, 191, - 431, 191, 1071, 191, 191, 191, 191, 435, 191, 434, - 191, 191, 191, 443, 1071, 433, 191, 191, 513, 191, - 440, 441, 1071, 1071, 517, 191, 436, 191, 191, 191, - 456, 191, 191, 514, 1071, 191, 437, 191, 191, 191, + 431, 191, 1081, 191, 191, 191, 191, 435, 191, 434, + 191, 191, 191, 443, 1081, 433, 191, 191, 514, 191, + 440, 441, 1081, 1081, 520, 191, 436, 191, 191, 191, + 456, 191, 191, 515, 1081, 191, 437, 191, 191, 191, - 443, 438, 439, 518, 444, 513, 445, 191, 446, 191, - 447, 517, 191, 436, 191, 191, 191, 456, 191, 191, - 514, 448, 519, 437, 1071, 191, 1071, 191, 438, 439, - 518, 444, 191, 445, 191, 446, 191, 447, 191, 191, - 449, 191, 191, 1071, 1071, 191, 520, 191, 448, 519, - 450, 451, 521, 452, 191, 191, 191, 1071, 191, 191, + 443, 438, 439, 521, 444, 514, 445, 191, 446, 191, + 447, 520, 191, 436, 191, 191, 191, 456, 191, 191, + 515, 448, 522, 437, 1081, 191, 1081, 191, 438, 439, + 521, 444, 191, 445, 191, 446, 191, 447, 191, 191, + 449, 191, 191, 1081, 1081, 191, 523, 191, 448, 522, + 450, 451, 524, 452, 191, 191, 191, 1081, 191, 191, 455, 191, 191, 454, 191, 191, 191, 449, 191, 191, - 453, 457, 191, 520, 191, 191, 191, 450, 451, 521, + 453, 457, 191, 523, 191, 191, 191, 450, 451, 524, 452, 458, 191, 191, 191, 191, 191, 455, 191, 191, - 454, 191, 191, 191, 191, 522, 460, 453, 457, 191, + 454, 191, 191, 191, 191, 525, 460, 453, 457, 191, - 191, 1071, 191, 191, 1071, 461, 1071, 459, 458, 462, - 191, 191, 465, 191, 191, 191, 523, 524, 525, 191, - 191, 191, 522, 460, 463, 191, 191, 191, 191, 464, - 191, 467, 461, 466, 459, 191, 462, 191, 1071, 465, - 1071, 191, 191, 523, 524, 525, 191, 191, 191, 1071, - 191, 463, 191, 191, 1071, 191, 464, 191, 467, 468, - 466, 191, 191, 472, 191, 473, 1071, 477, 469, 191, - 191, 526, 1071, 191, 471, 191, 470, 191, 1071, 474, - 1071, 191, 191, 1071, 191, 191, 468, 191, 191, 191, - 472, 191, 473, 475, 477, 469, 191, 191, 526, 191, + 191, 1081, 191, 191, 1081, 461, 1081, 459, 458, 462, + 191, 191, 465, 191, 191, 191, 526, 527, 528, 191, + 191, 191, 525, 460, 463, 191, 191, 191, 191, 464, + 191, 467, 461, 466, 459, 191, 462, 191, 1081, 465, + 1081, 191, 191, 526, 527, 528, 191, 191, 191, 1081, + 191, 463, 191, 191, 1081, 191, 464, 191, 467, 468, + 466, 191, 191, 472, 191, 473, 1081, 477, 469, 191, + 191, 529, 1081, 191, 471, 191, 470, 191, 1081, 474, + 1081, 191, 191, 1081, 191, 191, 468, 191, 191, 191, + 472, 191, 473, 475, 477, 469, 191, 191, 529, 191, - 527, 471, 191, 470, 476, 191, 474, 478, 191, 191, - 191, 191, 191, 1071, 191, 1071, 191, 1071, 480, 191, - 475, 479, 191, 484, 191, 528, 191, 527, 1071, 191, + 530, 471, 191, 470, 476, 191, 474, 478, 191, 191, + 191, 191, 191, 1081, 191, 1081, 191, 1081, 480, 191, + 475, 479, 191, 484, 191, 531, 191, 530, 1081, 191, 191, 476, 191, 490, 478, 191, 191, 191, 481, 485, - 482, 1071, 191, 483, 191, 480, 191, 1071, 479, 191, - 484, 191, 528, 191, 1071, 191, 191, 191, 191, 488, - 490, 191, 191, 191, 1071, 481, 485, 482, 486, 191, - 483, 191, 489, 491, 487, 529, 530, 531, 191, 191, - 191, 191, 191, 191, 1071, 191, 488, 492, 191, 532, - 533, 191, 534, 535, 536, 486, 537, 538, 539, 489, + 482, 1081, 191, 483, 191, 480, 191, 1081, 479, 191, + 484, 191, 531, 191, 1081, 191, 191, 191, 191, 488, + 490, 191, 191, 191, 1081, 481, 485, 482, 486, 191, + 483, 191, 489, 491, 487, 501, 532, 502, 191, 191, + 191, 191, 191, 191, 1081, 191, 488, 492, 191, 533, + 534, 191, 503, 535, 536, 486, 537, 538, 539, 489, - 491, 487, 529, 530, 531, 191, 191, 540, 191, 541, - 542, 191, 543, 546, 492, 547, 532, 533, 191, 534, - 535, 536, 544, 537, 538, 539, 548, 549, 550, 551, - 552, 553, 545, 554, 540, 555, 541, 542, 191, 543, - 546, 556, 547, 557, 558, 559, 560, 561, 562, 544, - 563, 564, 565, 548, 549, 550, 551, 552, 553, 545, + 491, 487, 501, 532, 502, 191, 191, 540, 191, 541, + 542, 191, 543, 544, 492, 547, 533, 534, 191, 503, + 535, 536, 545, 537, 538, 539, 548, 549, 550, 551, + 552, 553, 546, 554, 540, 555, 541, 542, 191, 543, + 544, 556, 547, 557, 558, 559, 560, 561, 562, 545, + 563, 564, 565, 548, 549, 550, 551, 552, 553, 546, 554, 566, 555, 567, 568, 569, 570, 571, 556, 572, 557, 558, 559, 560, 561, 562, 573, 563, 564, 565, 574, 575, 576, 577, 578, 579, 580, 581, 566, 582, - 567, 568, 569, 570, 571, 583, 572, 585, 587, 586, + 567, 568, 569, 570, 571, 583, 572, 584, 586, 588, - 588, 589, 590, 573, 584, 591, 592, 574, 575, 576, - 577, 578, 579, 580, 581, 593, 582, 594, 596, 597, - 191, 595, 583, 598, 585, 587, 586, 588, 589, 590, - 1071, 584, 591, 592, 191, 599, 1071, 191, 191, 703, - 191, 1071, 593, 191, 594, 596, 597, 191, 595, 191, - 598, 704, 1071, 191, 191, 191, 600, 191, 191, 191, - 1071, 191, 599, 602, 191, 191, 703, 191, 601, 191, - 191, 191, 191, 191, 1071, 603, 191, 604, 704, 191, - 191, 191, 191, 600, 191, 191, 191, 191, 705, 191, - 602, 191, 191, 191, 605, 601, 191, 191, 191, 191, + 587, 589, 590, 573, 591, 592, 585, 574, 575, 576, + 577, 578, 579, 580, 581, 593, 582, 594, 597, 595, + 598, 191, 583, 596, 584, 586, 588, 587, 589, 590, + 1081, 591, 592, 585, 599, 191, 600, 191, 705, 191, + 1081, 191, 593, 1081, 594, 597, 595, 598, 191, 602, + 596, 191, 1081, 191, 191, 191, 191, 191, 601, 191, + 1081, 599, 191, 600, 191, 705, 191, 191, 191, 706, + 191, 191, 191, 191, 604, 191, 602, 603, 191, 606, + 191, 191, 191, 191, 191, 601, 191, 191, 191, 1081, + 191, 1081, 191, 605, 191, 191, 706, 191, 191, 191, - 191, 606, 603, 607, 604, 609, 191, 191, 611, 191, - 608, 191, 1071, 191, 191, 705, 191, 191, 191, 191, - 191, 605, 613, 191, 191, 191, 191, 191, 606, 1071, - 607, 612, 609, 610, 191, 611, 191, 608, 191, 615, - 191, 614, 191, 706, 191, 191, 191, 191, 1071, 613, - 191, 617, 191, 191, 191, 191, 191, 1071, 612, 191, - 610, 621, 191, 616, 618, 620, 615, 191, 614, 191, - 706, 1071, 191, 191, 191, 191, 191, 625, 617, 619, - 191, 191, 191, 191, 191, 191, 191, 191, 621, 191, - 616, 618, 620, 623, 191, 622, 191, 191, 191, 627, + 191, 604, 191, 191, 603, 191, 606, 607, 614, 608, + 1081, 1081, 1081, 191, 191, 191, 610, 191, 191, 191, + 605, 611, 191, 191, 609, 191, 612, 617, 613, 191, + 191, 1081, 191, 191, 607, 614, 608, 615, 191, 191, + 191, 191, 1081, 610, 1081, 191, 1081, 191, 611, 191, + 191, 609, 191, 612, 617, 613, 191, 620, 619, 191, + 191, 191, 191, 616, 615, 191, 191, 623, 191, 191, + 1081, 191, 621, 622, 191, 191, 191, 191, 618, 1081, + 1081, 1081, 191, 707, 620, 619, 191, 191, 191, 191, + 616, 191, 191, 627, 623, 191, 191, 191, 191, 621, - 191, 1071, 191, 191, 625, 191, 619, 191, 191, 624, - 1071, 191, 191, 626, 191, 191, 191, 191, 191, 191, - 623, 191, 622, 191, 191, 191, 627, 191, 628, 629, - 191, 191, 191, 191, 631, 191, 624, 191, 630, 633, - 626, 191, 191, 191, 191, 191, 191, 632, 191, 1071, - 191, 191, 1071, 191, 1071, 628, 629, 191, 191, 191, - 191, 631, 191, 634, 191, 630, 633, 191, 191, 191, - 707, 191, 638, 191, 632, 191, 637, 191, 191, 635, - 191, 636, 1071, 1071, 708, 191, 191, 191, 1071, 191, - 634, 191, 709, 191, 191, 191, 191, 707, 191, 638, + 622, 191, 191, 625, 191, 618, 191, 624, 626, 191, + 707, 629, 191, 191, 191, 1081, 1081, 191, 191, 191, + 627, 191, 191, 628, 191, 1081, 191, 191, 191, 1081, + 625, 191, 191, 191, 624, 626, 1081, 1081, 629, 191, + 191, 630, 191, 191, 191, 635, 631, 191, 191, 632, + 628, 191, 191, 191, 191, 708, 636, 709, 191, 191, + 191, 191, 191, 191, 633, 191, 710, 1081, 630, 191, + 191, 191, 635, 631, 191, 634, 632, 191, 191, 191, + 191, 191, 708, 636, 709, 637, 191, 191, 191, 191, + 191, 633, 191, 710, 638, 711, 191, 191, 191, 191, - 191, 639, 191, 637, 191, 191, 635, 640, 636, 191, - 191, 708, 191, 641, 191, 191, 191, 710, 191, 709, - 191, 644, 191, 191, 191, 642, 191, 646, 639, 191, - 191, 191, 191, 645, 640, 191, 191, 191, 647, 643, - 641, 648, 191, 191, 710, 1071, 191, 191, 644, 649, - 191, 191, 642, 191, 646, 191, 191, 191, 191, 650, - 645, 191, 191, 191, 191, 647, 643, 654, 648, 191, - 191, 651, 652, 191, 191, 191, 649, 191, 1071, 656, - 191, 711, 191, 191, 191, 191, 650, 191, 191, 191, - 191, 191, 653, 655, 654, 712, 191, 191, 651, 652, + 712, 713, 634, 639, 191, 191, 191, 191, 191, 643, + 1081, 640, 637, 191, 191, 641, 191, 191, 1081, 191, + 642, 638, 711, 191, 191, 191, 191, 712, 713, 648, + 639, 1081, 191, 191, 191, 191, 643, 191, 640, 191, + 191, 191, 641, 191, 191, 646, 191, 642, 191, 191, + 644, 649, 191, 645, 650, 191, 648, 714, 647, 191, + 191, 191, 191, 651, 191, 715, 191, 191, 191, 191, + 716, 191, 646, 652, 191, 191, 191, 644, 649, 191, + 645, 650, 191, 191, 714, 647, 191, 191, 191, 191, + 651, 656, 715, 191, 655, 191, 191, 716, 191, 191, - 191, 657, 191, 713, 191, 191, 656, 191, 711, 191, - 191, 191, 714, 191, 191, 658, 191, 1071, 191, 653, - 655, 191, 712, 659, 191, 191, 191, 191, 657, 191, - 713, 191, 191, 191, 660, 1071, 191, 715, 191, 714, - 191, 191, 658, 1071, 661, 191, 191, 662, 191, 191, - 659, 191, 191, 191, 1071, 191, 191, 191, 191, 1071, - 191, 660, 663, 666, 715, 191, 191, 667, 191, 716, - 664, 661, 1071, 191, 662, 191, 191, 191, 191, 191, - 665, 668, 191, 191, 191, 191, 191, 191, 669, 663, - 666, 1071, 1071, 191, 667, 1071, 716, 664, 191, 191, + 652, 191, 654, 191, 653, 1081, 191, 657, 191, 1081, + 191, 191, 717, 191, 1081, 191, 191, 191, 656, 660, + 191, 655, 1081, 191, 658, 191, 191, 191, 1081, 654, + 191, 653, 659, 191, 657, 191, 191, 191, 191, 717, + 191, 191, 663, 661, 191, 191, 660, 191, 1081, 662, + 191, 658, 191, 191, 191, 191, 191, 191, 191, 659, + 191, 191, 1081, 191, 191, 665, 191, 191, 191, 663, + 661, 664, 191, 1081, 191, 191, 662, 191, 191, 666, + 191, 667, 191, 191, 191, 191, 191, 191, 191, 668, + 669, 670, 665, 191, 191, 191, 1081, 674, 664, 191, - 717, 718, 191, 191, 191, 191, 191, 665, 668, 670, - 191, 671, 191, 191, 191, 669, 672, 676, 191, 191, - 191, 191, 191, 191, 674, 191, 191, 717, 718, 675, - 191, 719, 191, 678, 673, 1071, 670, 191, 671, 191, - 191, 191, 191, 672, 676, 191, 191, 191, 191, 191, - 191, 674, 191, 191, 191, 191, 675, 1071, 719, 1071, - 678, 673, 677, 191, 191, 191, 191, 191, 191, 191, - 1071, 191, 191, 679, 191, 191, 683, 191, 680, 191, - 191, 191, 191, 191, 682, 191, 681, 1071, 1071, 677, - 191, 191, 191, 1071, 191, 720, 686, 191, 191, 191, + 191, 191, 191, 191, 191, 191, 666, 673, 667, 191, + 191, 672, 671, 191, 191, 191, 668, 669, 670, 191, + 191, 191, 191, 191, 674, 191, 191, 191, 191, 191, + 191, 718, 676, 678, 673, 719, 191, 191, 672, 671, + 675, 680, 191, 191, 191, 191, 191, 191, 191, 191, + 191, 677, 191, 191, 191, 191, 191, 1081, 718, 676, + 678, 191, 719, 191, 191, 679, 191, 675, 680, 682, + 191, 191, 191, 1081, 191, 191, 191, 1081, 677, 191, + 191, 191, 191, 688, 681, 191, 191, 191, 191, 720, + 191, 191, 679, 191, 683, 191, 682, 191, 685, 191, - 679, 191, 191, 683, 191, 680, 191, 191, 191, 684, - 191, 682, 191, 681, 191, 685, 191, 687, 191, 721, - 688, 191, 720, 686, 191, 1071, 191, 191, 191, 689, - 1071, 1071, 1071, 191, 191, 191, 684, 722, 191, 191, - 191, 191, 685, 191, 687, 1071, 721, 688, 690, 692, - 691, 191, 191, 191, 191, 191, 689, 693, 191, 191, - 694, 191, 1071, 723, 722, 191, 191, 191, 695, 1071, - 724, 191, 191, 191, 191, 690, 692, 691, 191, 191, - 696, 191, 191, 191, 693, 191, 191, 694, 191, 698, - 723, 697, 699, 191, 191, 695, 700, 724, 191, 191, + 686, 191, 191, 191, 684, 191, 191, 191, 1081, 191, + 688, 681, 191, 191, 191, 191, 720, 191, 687, 191, + 1081, 683, 191, 191, 191, 685, 191, 686, 689, 191, + 191, 684, 191, 692, 191, 693, 191, 1081, 690, 191, + 1081, 191, 191, 191, 191, 687, 191, 691, 695, 721, + 191, 694, 191, 1081, 1081, 689, 191, 1081, 191, 722, + 692, 191, 693, 723, 191, 690, 191, 191, 191, 1081, + 191, 724, 191, 696, 691, 695, 721, 191, 694, 191, + 698, 191, 191, 697, 191, 191, 722, 191, 191, 725, + 723, 191, 1081, 1081, 191, 699, 700, 191, 724, 191, - 191, 191, 191, 191, 1071, 1071, 725, 696, 191, 191, - 191, 191, 191, 726, 701, 727, 698, 728, 697, 699, - 191, 191, 729, 700, 730, 702, 731, 732, 733, 191, - 191, 191, 191, 725, 734, 735, 736, 737, 191, 191, - 726, 701, 727, 738, 728, 739, 740, 743, 744, 729, - 745, 730, 702, 731, 732, 733, 741, 746, 191, 191, - 749, 734, 735, 736, 737, 747, 748, 742, 750, 751, - 738, 752, 739, 740, 743, 744, 753, 745, 754, 755, - 756, 757, 758, 741, 746, 759, 760, 749, 761, 762, - 763, 764, 747, 748, 742, 750, 751, 765, 752, 766, + 696, 191, 191, 726, 191, 191, 191, 698, 191, 191, + 697, 191, 727, 728, 191, 701, 725, 191, 704, 702, + 703, 729, 699, 700, 191, 191, 191, 730, 191, 191, + 726, 731, 191, 191, 732, 733, 734, 191, 735, 727, + 728, 736, 701, 737, 191, 704, 702, 703, 729, 738, + 739, 740, 191, 191, 730, 741, 742, 743, 731, 746, + 744, 732, 733, 734, 191, 735, 747, 748, 736, 749, + 737, 745, 750, 751, 752, 753, 738, 739, 740, 754, + 755, 756, 741, 742, 743, 757, 746, 744, 758, 759, + 760, 761, 762, 747, 748, 763, 749, 764, 745, 750, - 767, 768, 769, 753, 770, 754, 755, 756, 757, 758, - 771, 772, 759, 760, 773, 761, 762, 763, 764, 774, - 775, 776, 777, 778, 765, 779, 766, 767, 768, 769, - 780, 770, 1071, 1071, 191, 1071, 191, 771, 772, 859, - 191, 773, 191, 1071, 787, 191, 774, 775, 776, 777, - 778, 1071, 779, 781, 783, 782, 784, 780, 785, 191, - 191, 191, 191, 191, 191, 191, 859, 191, 786, 191, - 191, 787, 191, 191, 788, 1071, 191, 1071, 191, 191, - 781, 783, 782, 784, 191, 785, 191, 191, 790, 191, - 191, 191, 191, 191, 191, 786, 191, 191, 191, 191, + 751, 752, 753, 765, 766, 767, 754, 755, 756, 768, + 769, 770, 757, 771, 772, 758, 759, 760, 761, 762, + 773, 774, 763, 775, 764, 776, 777, 778, 779, 780, + 765, 766, 767, 781, 782, 783, 768, 769, 770, 191, + 771, 772, 1081, 191, 191, 191, 1081, 773, 774, 790, + 775, 1081, 776, 777, 778, 779, 780, 784, 785, 786, + 781, 782, 783, 787, 191, 191, 191, 191, 191, 191, + 191, 191, 191, 191, 791, 1081, 790, 789, 191, 191, + 788, 1081, 191, 191, 784, 785, 786, 191, 191, 1081, + 787, 191, 191, 191, 191, 191, 191, 1081, 191, 191, - 191, 788, 789, 191, 191, 191, 191, 191, 860, 1071, - 191, 191, 791, 191, 191, 790, 191, 191, 1071, 191, - 191, 191, 1071, 191, 793, 191, 191, 191, 792, 789, - 191, 191, 191, 191, 191, 860, 191, 191, 191, 791, - 191, 191, 861, 191, 862, 794, 191, 191, 795, 797, - 1071, 793, 191, 191, 191, 792, 1071, 191, 191, 191, - 191, 1071, 796, 191, 191, 191, 799, 191, 191, 861, - 863, 862, 794, 191, 191, 795, 797, 798, 191, 191, - 191, 191, 800, 191, 191, 191, 191, 864, 191, 796, - 801, 191, 1071, 799, 191, 191, 191, 863, 191, 865, + 191, 791, 191, 191, 789, 191, 191, 788, 191, 191, + 191, 191, 191, 191, 191, 191, 792, 793, 1081, 1081, + 191, 191, 1081, 1081, 794, 191, 191, 1081, 191, 191, + 191, 191, 191, 191, 191, 191, 795, 191, 191, 191, + 191, 191, 191, 792, 793, 191, 801, 863, 191, 797, + 191, 794, 798, 799, 191, 191, 796, 191, 191, 191, + 191, 191, 191, 795, 191, 191, 1081, 191, 191, 191, + 191, 1081, 191, 801, 863, 191, 797, 191, 191, 798, + 799, 191, 800, 796, 191, 805, 1081, 191, 802, 191, + 191, 803, 191, 191, 191, 191, 191, 191, 191, 191, - 191, 191, 1071, 191, 798, 191, 191, 802, 191, 800, - 191, 191, 1071, 191, 864, 191, 191, 801, 191, 191, - 806, 191, 1071, 191, 191, 191, 865, 1071, 191, 803, - 191, 1071, 808, 191, 802, 804, 805, 191, 191, 191, - 191, 191, 1071, 191, 191, 191, 191, 806, 191, 807, - 810, 191, 191, 191, 191, 809, 803, 191, 191, 808, - 191, 1071, 804, 805, 191, 191, 191, 191, 191, 191, - 866, 191, 1071, 191, 191, 191, 807, 810, 191, 191, - 191, 191, 809, 1071, 191, 191, 811, 191, 191, 191, - 191, 191, 191, 1071, 191, 191, 191, 866, 867, 812, + 804, 864, 191, 1081, 865, 191, 866, 1081, 1081, 800, + 191, 1081, 805, 191, 191, 802, 191, 191, 803, 191, + 191, 191, 191, 191, 191, 191, 191, 804, 864, 191, + 810, 865, 806, 866, 191, 807, 1081, 191, 191, 867, + 191, 191, 1081, 191, 191, 808, 191, 812, 191, 191, + 191, 191, 1081, 809, 191, 191, 191, 810, 191, 806, + 811, 191, 807, 191, 191, 191, 867, 191, 191, 814, + 191, 191, 808, 191, 812, 191, 191, 191, 813, 191, + 809, 191, 191, 191, 191, 191, 1081, 811, 815, 868, + 191, 191, 191, 191, 191, 1081, 814, 191, 191, 191, - 191, 191, 191, 813, 814, 191, 1071, 191, 191, 191, - 191, 191, 191, 811, 191, 191, 191, 191, 191, 191, - 815, 191, 191, 1071, 191, 867, 812, 191, 816, 191, - 813, 814, 191, 191, 191, 191, 191, 191, 191, 191, - 1071, 191, 191, 191, 191, 817, 818, 815, 191, 1071, - 819, 191, 191, 191, 191, 816, 191, 868, 191, 191, - 191, 820, 191, 191, 191, 821, 191, 191, 191, 191, - 191, 191, 817, 818, 1071, 191, 191, 819, 191, 191, - 191, 191, 822, 1071, 868, 191, 191, 191, 820, 191, - 191, 191, 821, 191, 191, 191, 191, 191, 824, 1071, + 191, 191, 191, 191, 191, 813, 191, 191, 1081, 816, + 191, 191, 191, 817, 869, 815, 868, 818, 191, 191, + 191, 191, 191, 191, 191, 191, 191, 191, 191, 1081, + 191, 191, 1081, 191, 191, 819, 816, 191, 191, 191, + 817, 869, 191, 191, 818, 191, 191, 1081, 191, 191, + 191, 191, 820, 191, 191, 191, 821, 823, 191, 822, + 191, 191, 819, 191, 191, 191, 191, 191, 824, 191, + 191, 191, 191, 191, 825, 191, 191, 1081, 1081, 820, + 191, 191, 191, 821, 823, 191, 822, 191, 191, 191, + 191, 191, 191, 191, 191, 824, 191, 191, 191, 191, - 1071, 191, 191, 191, 823, 191, 191, 191, 191, 822, - 827, 1071, 191, 191, 191, 828, 869, 191, 191, 1071, - 825, 826, 191, 191, 191, 824, 191, 191, 191, 191, - 830, 823, 191, 191, 191, 870, 829, 827, 191, 191, - 871, 1071, 828, 869, 191, 191, 191, 825, 826, 191, - 191, 191, 191, 191, 191, 191, 1071, 830, 191, 191, - 833, 191, 870, 829, 831, 191, 191, 871, 832, 836, - 834, 191, 191, 191, 191, 191, 835, 191, 191, 191, - 191, 191, 191, 839, 872, 191, 191, 833, 191, 191, - 1071, 831, 191, 191, 191, 832, 836, 834, 191, 191, + 191, 825, 191, 191, 826, 828, 1081, 827, 191, 191, + 1081, 1081, 1081, 191, 191, 191, 191, 191, 191, 191, + 191, 1081, 870, 191, 191, 191, 832, 191, 191, 829, + 830, 826, 828, 191, 827, 191, 191, 833, 191, 191, + 191, 831, 191, 834, 191, 1081, 1081, 191, 191, 870, + 1081, 871, 191, 832, 191, 191, 829, 830, 191, 191, + 191, 872, 191, 191, 833, 191, 191, 835, 831, 191, + 834, 191, 191, 838, 191, 191, 1081, 191, 871, 837, + 1081, 191, 836, 839, 873, 191, 191, 191, 872, 191, + 191, 191, 191, 1081, 835, 191, 191, 191, 191, 191, - 191, 191, 191, 835, 838, 837, 191, 191, 191, 191, - 839, 872, 191, 191, 191, 191, 191, 191, 842, 191, - 191, 191, 840, 843, 841, 1071, 191, 191, 845, 1071, - 844, 838, 837, 191, 191, 191, 191, 191, 191, 191, - 191, 191, 191, 191, 191, 842, 191, 191, 191, 840, - 843, 841, 191, 191, 191, 845, 191, 844, 191, 1071, - 191, 191, 191, 1071, 191, 191, 846, 191, 847, 191, - 191, 1071, 191, 191, 191, 191, 191, 191, 850, 191, - 191, 191, 191, 191, 849, 191, 191, 191, 852, 191, - 855, 848, 191, 846, 191, 847, 191, 191, 851, 191, + 838, 191, 1081, 840, 191, 191, 837, 191, 191, 836, + 839, 873, 1081, 1081, 191, 191, 191, 874, 191, 191, + 842, 841, 191, 843, 191, 191, 191, 1081, 191, 191, + 840, 191, 191, 1081, 191, 191, 1081, 844, 1081, 846, + 845, 191, 191, 191, 874, 847, 191, 842, 841, 191, + 843, 191, 191, 191, 849, 191, 191, 191, 191, 191, + 191, 191, 191, 191, 844, 191, 846, 845, 191, 850, + 191, 191, 847, 191, 191, 848, 191, 191, 191, 191, + 191, 849, 191, 191, 191, 191, 191, 191, 191, 191, + 191, 191, 191, 853, 875, 191, 850, 851, 191, 852, - 873, 191, 191, 191, 191, 850, 191, 191, 191, 191, - 191, 849, 191, 191, 191, 852, 191, 855, 848, 191, - 191, 191, 854, 853, 191, 851, 191, 873, 191, 191, - 874, 191, 191, 191, 856, 191, 858, 191, 1071, 191, - 191, 191, 857, 875, 191, 191, 191, 191, 876, 854, - 853, 191, 191, 191, 877, 191, 191, 874, 191, 191, - 878, 856, 879, 858, 191, 191, 880, 191, 881, 857, - 875, 191, 191, 191, 882, 876, 883, 884, 191, 191, - 885, 877, 886, 191, 887, 888, 889, 878, 890, 879, - 891, 191, 191, 880, 892, 881, 893, 894, 895, 896, + 1081, 191, 848, 191, 191, 191, 191, 191, 191, 191, + 191, 191, 191, 859, 191, 191, 1081, 854, 191, 856, + 853, 875, 191, 191, 851, 876, 852, 855, 191, 857, + 191, 191, 191, 191, 191, 191, 1081, 191, 191, 858, + 859, 191, 191, 191, 854, 191, 856, 191, 860, 877, + 191, 191, 876, 191, 855, 191, 857, 191, 191, 862, + 191, 191, 191, 191, 191, 191, 858, 191, 878, 861, + 191, 191, 191, 191, 191, 860, 877, 879, 191, 191, + 191, 880, 191, 191, 191, 881, 862, 882, 883, 191, + 191, 884, 191, 885, 191, 878, 861, 886, 191, 887, - 897, 882, 898, 883, 884, 899, 900, 885, 901, 886, - 902, 887, 888, 889, 903, 890, 904, 891, 905, 906, - 907, 892, 908, 893, 894, 895, 896, 897, 909, 898, - 910, 911, 899, 900, 912, 901, 913, 902, 1071, 191, - 191, 903, 191, 904, 191, 905, 906, 907, 915, 908, - 191, 969, 916, 917, 191, 909, 1071, 910, 911, 191, - 191, 912, 191, 913, 191, 914, 191, 191, 191, 191, - 191, 191, 191, 191, 191, 915, 1071, 191, 969, 916, - 917, 191, 918, 191, 191, 921, 191, 191, 191, 191, - 1071, 191, 914, 191, 920, 191, 191, 191, 919, 191, + 191, 888, 889, 890, 879, 891, 191, 892, 880, 191, + 191, 893, 881, 894, 882, 883, 895, 896, 884, 897, + 885, 898, 899, 900, 886, 901, 887, 902, 888, 889, + 890, 903, 891, 904, 892, 905, 906, 907, 893, 908, + 894, 909, 910, 895, 896, 911, 897, 912, 898, 899, + 900, 913, 901, 914, 902, 915, 916, 917, 903, 918, + 904, 191, 905, 906, 907, 191, 908, 191, 909, 910, + 191, 1081, 911, 920, 912, 191, 921, 1081, 913, 975, + 914, 191, 915, 916, 917, 191, 918, 191, 191, 191, + 191, 919, 191, 191, 191, 191, 191, 191, 922, 191, - 191, 191, 924, 191, 191, 191, 922, 191, 191, 918, - 191, 191, 921, 1071, 923, 191, 191, 191, 970, 191, - 191, 920, 191, 191, 971, 919, 1071, 191, 927, 924, - 191, 191, 191, 922, 191, 191, 191, 191, 191, 191, - 925, 923, 928, 191, 191, 970, 191, 1071, 929, 191, - 1071, 971, 1071, 926, 191, 927, 191, 191, 191, 191, - 1071, 1071, 191, 191, 191, 191, 191, 925, 191, 928, - 972, 1071, 930, 191, 931, 929, 191, 191, 191, 191, - 926, 973, 933, 191, 191, 191, 191, 932, 934, 191, - 191, 191, 191, 191, 1071, 191, 191, 972, 191, 930, + 920, 191, 191, 921, 924, 976, 975, 1081, 191, 191, + 923, 977, 191, 926, 191, 191, 191, 191, 919, 191, + 191, 191, 191, 191, 191, 922, 191, 1081, 191, 930, + 191, 924, 976, 191, 925, 191, 191, 923, 977, 191, + 926, 1081, 191, 927, 191, 191, 191, 191, 191, 191, + 191, 191, 1081, 978, 929, 928, 930, 191, 191, 191, + 191, 925, 191, 934, 191, 191, 191, 191, 931, 935, + 927, 191, 191, 932, 191, 1081, 191, 191, 191, 191, + 978, 929, 928, 191, 191, 191, 191, 191, 933, 191, + 934, 191, 191, 191, 191, 931, 935, 191, 191, 191, - 191, 931, 191, 191, 191, 191, 191, 935, 973, 933, - 191, 191, 191, 191, 932, 934, 191, 191, 191, 191, - 191, 191, 191, 191, 191, 191, 937, 191, 936, 191, - 191, 938, 940, 191, 935, 1071, 191, 191, 191, 191, - 191, 191, 191, 191, 191, 1071, 191, 191, 191, 191, - 191, 191, 191, 937, 191, 936, 941, 191, 938, 940, - 191, 939, 191, 191, 191, 191, 191, 191, 191, 191, - 191, 191, 942, 191, 191, 191, 943, 191, 191, 191, - 974, 975, 944, 941, 191, 191, 191, 191, 939, 191, - 191, 191, 191, 191, 191, 191, 191, 191, 191, 942, + 932, 939, 936, 191, 1081, 191, 191, 191, 937, 1081, + 191, 191, 938, 191, 191, 933, 191, 191, 191, 940, + 191, 191, 191, 191, 191, 191, 191, 979, 939, 936, + 191, 191, 191, 191, 191, 937, 191, 980, 942, 938, + 191, 191, 191, 1081, 191, 191, 940, 941, 191, 191, + 191, 191, 191, 191, 979, 191, 191, 943, 191, 191, + 191, 191, 981, 191, 980, 942, 191, 191, 191, 191, + 191, 946, 1081, 1081, 941, 191, 944, 1081, 191, 191, + 191, 191, 191, 191, 943, 945, 191, 191, 191, 981, + 191, 191, 1081, 191, 191, 191, 191, 191, 946, 191, - 191, 191, 191, 943, 945, 191, 191, 974, 975, 944, - 191, 191, 191, 191, 191, 946, 191, 191, 947, 191, - 191, 191, 191, 191, 950, 191, 1071, 191, 191, 191, - 191, 945, 948, 191, 976, 1071, 191, 191, 191, 191, - 191, 1071, 946, 191, 191, 947, 191, 191, 191, 191, - 191, 950, 977, 949, 951, 1071, 191, 191, 952, 948, - 191, 976, 191, 191, 953, 191, 191, 191, 191, 1071, - 191, 191, 954, 191, 1071, 1071, 191, 191, 978, 977, - 949, 951, 191, 191, 1071, 952, 979, 191, 191, 191, - 957, 953, 191, 191, 191, 191, 191, 191, 955, 954, + 191, 191, 191, 944, 191, 949, 948, 1081, 191, 947, + 191, 1081, 945, 191, 191, 191, 191, 191, 191, 191, + 191, 191, 191, 191, 191, 191, 191, 191, 191, 191, + 191, 191, 949, 948, 950, 191, 947, 191, 191, 191, + 953, 1081, 191, 191, 952, 1081, 191, 191, 191, 191, + 191, 191, 191, 951, 1081, 191, 191, 191, 191, 191, + 191, 950, 191, 956, 1081, 191, 191, 953, 191, 191, + 191, 952, 191, 957, 982, 1081, 191, 191, 191, 1081, + 951, 954, 191, 191, 191, 191, 191, 191, 191, 191, + 956, 955, 191, 960, 191, 191, 191, 191, 191, 191, - 191, 956, 191, 191, 1071, 978, 958, 1071, 1071, 191, - 191, 191, 191, 979, 191, 191, 191, 957, 1071, 191, - 191, 191, 191, 191, 959, 955, 963, 191, 956, 191, - 191, 191, 961, 958, 964, 191, 191, 1071, 191, 191, - 962, 191, 960, 191, 191, 965, 191, 191, 191, 191, - 1071, 959, 980, 963, 191, 191, 191, 981, 191, 961, - 982, 964, 191, 191, 191, 191, 191, 962, 191, 960, - 191, 191, 965, 191, 191, 191, 983, 967, 984, 980, - 966, 191, 191, 191, 981, 968, 191, 982, 985, 191, - 191, 191, 191, 191, 986, 191, 987, 191, 988, 989, + 957, 982, 958, 959, 191, 191, 191, 191, 954, 1081, + 191, 191, 983, 984, 191, 191, 191, 191, 955, 191, + 960, 191, 962, 191, 963, 191, 191, 191, 191, 958, + 959, 191, 961, 191, 191, 1081, 969, 191, 191, 983, + 984, 191, 191, 191, 191, 1081, 1081, 191, 191, 962, + 191, 963, 964, 191, 191, 191, 191, 966, 191, 961, + 965, 985, 191, 969, 191, 191, 971, 191, 967, 191, + 191, 191, 191, 968, 191, 191, 191, 191, 973, 964, + 970, 191, 191, 191, 966, 191, 191, 965, 985, 191, + 972, 191, 191, 971, 191, 967, 191, 191, 191, 191, - 990, 191, 991, 983, 967, 984, 992, 966, 191, 191, - 993, 994, 968, 191, 995, 985, 191, 191, 996, 997, - 998, 986, 191, 987, 1000, 988, 989, 990, 191, 991, - 191, 1071, 191, 992, 191, 191, 191, 993, 994, 999, - 191, 995, 191, 191, 191, 996, 997, 998, 1001, 191, - 191, 1000, 191, 191, 191, 191, 1003, 191, 191, 191, - 1002, 191, 191, 191, 191, 1005, 999, 191, 191, 191, - 191, 191, 1071, 191, 191, 1001, 1027, 191, 191, 191, - 191, 191, 191, 1003, 191, 191, 191, 1002, 191, 1004, - 191, 191, 1005, 1071, 191, 191, 1006, 191, 191, 191, + 968, 191, 191, 191, 191, 973, 974, 970, 191, 191, + 191, 191, 986, 191, 987, 988, 989, 972, 191, 191, + 990, 991, 992, 191, 191, 993, 994, 995, 191, 191, + 191, 191, 996, 974, 997, 998, 999, 191, 191, 986, + 1000, 987, 988, 989, 1001, 1002, 1003, 990, 991, 992, + 1004, 1081, 993, 994, 995, 1005, 191, 191, 191, 996, + 191, 997, 998, 999, 1007, 191, 191, 1000, 191, 1006, + 191, 1001, 1002, 1003, 191, 191, 191, 1004, 1010, 1008, + 191, 1009, 1005, 191, 191, 191, 191, 191, 191, 191, + 191, 1007, 191, 191, 191, 191, 1006, 191, 1011, 191, - 191, 191, 1007, 1027, 1071, 191, 191, 191, 1071, 1071, - 1071, 191, 191, 191, 1071, 191, 1004, 191, 191, 191, - 191, 191, 191, 1006, 191, 191, 191, 191, 191, 1007, - 191, 191, 191, 191, 191, 1009, 191, 1008, 1071, 191, - 191, 191, 1071, 1071, 191, 191, 191, 191, 191, 191, - 191, 191, 191, 1011, 191, 191, 191, 191, 191, 191, - 1071, 191, 1009, 191, 1008, 1010, 191, 191, 191, 191, - 191, 1028, 191, 191, 191, 191, 1071, 191, 191, 191, - 1011, 1012, 1015, 191, 1071, 191, 191, 1013, 191, 191, - 191, 191, 1010, 191, 191, 191, 191, 191, 1028, 191, + 191, 191, 191, 191, 1012, 1010, 1008, 191, 1009, 191, + 191, 191, 191, 191, 191, 191, 191, 191, 191, 191, + 191, 191, 1014, 191, 191, 1011, 191, 191, 1015, 1013, + 191, 1012, 191, 191, 191, 1081, 191, 191, 191, 1081, + 1081, 191, 191, 191, 191, 191, 191, 191, 191, 1014, + 191, 191, 191, 191, 191, 1015, 1013, 191, 191, 191, + 191, 191, 191, 1016, 191, 191, 191, 191, 191, 191, + 191, 191, 1019, 1017, 191, 191, 1081, 191, 191, 191, + 191, 191, 191, 191, 191, 191, 191, 191, 191, 191, + 1016, 191, 191, 191, 191, 191, 1018, 191, 1081, 1019, - 191, 191, 191, 191, 1017, 1016, 191, 1029, 1012, 1015, - 1014, 191, 191, 191, 1013, 191, 191, 191, 191, 191, - 1071, 191, 191, 191, 191, 1018, 191, 191, 1071, 191, - 191, 1017, 1016, 191, 1029, 191, 191, 1014, 191, 191, - 191, 191, 191, 1030, 191, 1031, 191, 191, 1020, 1019, - 191, 191, 1018, 191, 191, 191, 191, 1023, 1032, 191, - 191, 191, 191, 191, 1071, 1021, 191, 191, 191, 191, - 1030, 191, 1031, 1022, 191, 1020, 1019, 191, 191, 191, - 1033, 191, 191, 191, 1023, 1032, 191, 191, 191, 191, - 191, 191, 1021, 1024, 191, 191, 191, 191, 191, 191, + 1017, 191, 191, 191, 191, 191, 191, 191, 1021, 191, + 191, 191, 191, 191, 191, 191, 1023, 191, 191, 191, + 191, 1081, 1022, 1018, 191, 1020, 191, 191, 1081, 191, + 191, 191, 191, 191, 191, 1021, 191, 1024, 191, 191, + 191, 1081, 191, 1023, 191, 191, 1025, 191, 191, 1022, + 1081, 191, 1020, 191, 191, 1026, 1027, 191, 191, 191, + 191, 191, 191, 191, 1024, 191, 191, 191, 191, 191, + 1029, 191, 191, 1025, 191, 191, 1081, 191, 191, 1028, + 191, 191, 1026, 1027, 191, 1035, 191, 191, 191, 191, + 1081, 191, 191, 191, 191, 191, 1030, 1029, 191, 191, - 1022, 191, 1026, 1034, 191, 191, 191, 1033, 191, 1035, - 191, 191, 1025, 1036, 191, 191, 191, 191, 191, 191, - 1024, 191, 191, 1037, 191, 191, 191, 1038, 191, 1026, - 1034, 191, 191, 191, 1071, 191, 1035, 191, 191, 1025, - 1036, 191, 191, 191, 1039, 191, 191, 1040, 191, 191, - 1037, 191, 191, 191, 1038, 191, 1071, 191, 191, 191, - 191, 191, 191, 191, 1041, 191, 191, 191, 191, 191, - 191, 1039, 191, 1071, 1040, 191, 191, 191, 191, 191, - 191, 191, 191, 191, 191, 1042, 191, 191, 191, 191, - 191, 1041, 191, 191, 191, 191, 191, 1044, 191, 191, + 191, 191, 191, 1031, 191, 191, 1028, 191, 191, 1081, + 1036, 191, 1035, 191, 191, 191, 1081, 1032, 191, 191, + 191, 191, 191, 1030, 1037, 191, 191, 191, 1038, 191, + 1031, 191, 191, 1039, 191, 191, 191, 1036, 191, 1033, + 1040, 191, 191, 1034, 1032, 1041, 191, 191, 1042, 191, + 1043, 1037, 191, 191, 1044, 1038, 191, 1045, 191, 1046, + 1039, 191, 191, 191, 1047, 191, 1033, 1040, 191, 191, + 1034, 1081, 1041, 191, 191, 1042, 1049, 1043, 191, 1048, + 191, 1044, 191, 191, 1045, 191, 1046, 1081, 191, 191, + 1050, 1047, 191, 191, 191, 191, 191, 1081, 191, 191, - 191, 191, 1071, 191, 191, 1051, 1071, 191, 191, 191, - 191, 1043, 1042, 191, 191, 1071, 191, 191, 191, 191, - 191, 191, 191, 191, 1044, 191, 191, 191, 191, 1046, - 191, 191, 1051, 191, 191, 1050, 191, 1045, 1043, 191, - 1052, 1048, 191, 191, 191, 191, 191, 191, 191, 191, - 191, 191, 1047, 191, 191, 191, 1046, 191, 191, 191, - 191, 1053, 1050, 191, 1045, 1054, 191, 1052, 1048, 191, - 191, 1055, 1049, 1056, 191, 191, 191, 191, 191, 1047, - 191, 191, 191, 191, 191, 191, 191, 191, 1053, 191, - 191, 1057, 1054, 191, 1063, 191, 191, 191, 1055, 1049, + 191, 191, 191, 1049, 191, 191, 1048, 191, 1051, 191, + 191, 1081, 191, 191, 191, 191, 191, 1050, 191, 191, + 191, 191, 191, 1081, 191, 191, 191, 191, 1052, 191, + 191, 191, 1054, 191, 191, 1051, 1081, 191, 191, 191, + 191, 191, 191, 191, 191, 191, 191, 191, 191, 191, + 191, 191, 191, 191, 1056, 1052, 1053, 191, 191, 1054, + 191, 191, 1055, 191, 191, 191, 191, 191, 191, 191, + 191, 191, 191, 191, 191, 191, 191, 191, 191, 191, + 191, 1056, 191, 1053, 1058, 191, 1057, 1060, 191, 1055, + 191, 191, 191, 191, 191, 191, 191, 1059, 191, 191, - 1056, 191, 191, 191, 191, 191, 191, 191, 1058, 191, - 191, 191, 191, 191, 191, 1064, 191, 191, 1057, 1059, - 191, 1063, 191, 191, 191, 191, 191, 191, 191, 1062, - 1065, 1060, 191, 191, 191, 1058, 191, 1069, 191, 1061, - 191, 1066, 1064, 191, 191, 191, 1059, 191, 191, 191, - 1071, 191, 191, 191, 191, 191, 1062, 1065, 1060, 191, - 1071, 191, 191, 191, 1069, 1067, 1061, 191, 1066, 191, - 191, 191, 191, 191, 191, 191, 191, 1068, 191, 191, - 1071, 1071, 191, 191, 1071, 1071, 191, 191, 191, 191, - 191, 1071, 1067, 191, 191, 1071, 191, 1071, 191, 191, + 191, 1061, 191, 191, 1062, 191, 1063, 191, 191, 191, + 1064, 1058, 1065, 1057, 1060, 191, 1066, 1081, 191, 191, + 191, 191, 1073, 191, 1059, 191, 191, 191, 1061, 191, + 191, 1062, 191, 1063, 191, 191, 191, 1064, 191, 1065, + 191, 191, 1067, 1066, 191, 191, 191, 191, 191, 1073, + 191, 1068, 191, 191, 191, 1081, 191, 191, 191, 191, + 191, 191, 191, 191, 1070, 191, 191, 191, 191, 1067, + 1072, 191, 1071, 191, 191, 1069, 191, 191, 1068, 191, + 1074, 191, 191, 191, 1075, 191, 191, 191, 191, 191, + 1076, 1070, 191, 191, 1079, 191, 191, 1072, 191, 1071, - 191, 1071, 1071, 191, 1068, 1071, 191, 1071, 1070, 191, - 191, 1071, 1071, 1071, 191, 1071, 1071, 1071, 1071, 191, - 191, 1071, 1071, 1071, 1071, 1071, 191, 1071, 1071, 1071, - 191, 1071, 1071, 1071, 1071, 1070, 1071, 1071, 1071, 1071, - 1071, 1071, 1071, 1071, 1071, 1071, 191, 46, 46, 46, - 46, 46, 88, 1071, 1071, 88, 88, 177, 177, 177, - 1071, 177, 179, 1071, 179, 179, 179, 182, 1071, 182, - 182, 182, 191, 1071, 191, 191, 191, 7, 1071, 1071, - 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, - 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, + 191, 1081, 1069, 191, 191, 1081, 191, 1074, 191, 191, + 191, 1075, 191, 191, 1077, 191, 1078, 1076, 191, 191, + 191, 1079, 191, 191, 191, 191, 191, 191, 191, 191, + 191, 191, 1081, 191, 1081, 1081, 1081, 191, 1080, 191, + 1081, 1077, 191, 1078, 1081, 191, 1081, 191, 191, 191, + 191, 191, 1081, 191, 1081, 191, 191, 191, 1081, 1081, + 1081, 1081, 1081, 1081, 1081, 1080, 1081, 1081, 1081, 1081, + 1081, 1081, 1081, 1081, 1081, 191, 191, 191, 46, 46, + 46, 46, 46, 88, 1081, 1081, 88, 88, 177, 177, + 177, 1081, 177, 179, 1081, 179, 179, 179, 182, 1081, - 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, - 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, - 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, - 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, - 1071, 1071, 1071, 1071, 1071 + 182, 182, 182, 191, 1081, 191, 191, 191, 7, 1081, + 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, + 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, + 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, + 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, + 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, + 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, + 1081, 1081, 1081, 1081, 1081, 1081 } ; -static const flex_int16_t yy_chk[4346] = +static const flex_int16_t yy_chk[4377] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -1489,7 +1495,7 @@ static const flex_int16_t yy_chk[4346] = 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, - 5, 5, 5, 5, 9, 9, 10, 10, 15, 1074, + 5, 5, 5, 5, 9, 9, 10, 10, 15, 1084, 15, 17, 17, 18, 18, 21, 22, 21, 24, 383, 23, 30, 24, 21, 272, 21, 24, 23, 31, 21, 21, 44, 24, 98, 23, 24, 22, 23, 55, 25, @@ -1582,377 +1588,380 @@ static const flex_int16_t yy_chk[4346] = 198, 80, 80, 200, 209, 198, 204, 203, 80, 200, 209, 80, 0, 0, 289, 288, 0, 203, 80, 201, 202, 204, 206, 207, 203, 290, 204, 202, 202, 202, - 285, 202, 285, 204, 203, 206, 206, 291, 292, 207, + 291, 202, 292, 204, 203, 206, 206, 293, 295, 207, 202, 289, 206, 207, 203, 0, 0, 202, 204, 206, - 207, 208, 290, 204, 202, 202, 202, 285, 202, 285, - 224, 208, 206, 206, 291, 292, 207, 202, 205, 206, + 207, 208, 290, 204, 202, 202, 202, 291, 202, 292, + 224, 208, 206, 206, 293, 295, 207, 202, 205, 206, 207, 208, 205, 205, 213, 210, 210, 0, 208, 205, - 224, 213, 211, 0, 211, 293, 205, 224, 208, 0, - 214, 295, 205, 0, 213, 205, 210, 214, 208, 205, + 224, 213, 211, 0, 211, 296, 205, 224, 208, 0, + 214, 298, 205, 0, 213, 205, 210, 214, 208, 205, 205, 213, 210, 210, 211, 0, 205, 224, 213, 211, - 214, 211, 293, 205, 296, 215, 216, 214, 295, 205, - 217, 213, 0, 210, 214, 215, 218, 0, 298, 216, + 214, 211, 296, 205, 299, 215, 216, 214, 298, 205, + 217, 213, 0, 210, 214, 215, 218, 0, 300, 216, 217, 211, 212, 218, 212, 215, 216, 214, 212, 0, - 217, 296, 215, 216, 299, 212, 218, 217, 219, 212, + 217, 299, 215, 216, 301, 212, 218, 217, 219, 212, - 230, 0, 215, 218, 212, 298, 216, 217, 219, 212, + 230, 0, 215, 218, 212, 300, 216, 217, 219, 212, 218, 212, 215, 216, 220, 212, 221, 217, 219, 222, - 230, 299, 212, 218, 220, 219, 212, 230, 222, 226, + 230, 301, 212, 218, 220, 219, 212, 230, 222, 226, 221, 212, 223, 221, 220, 219, 221, 0, 225, 222, 226, 220, 225, 221, 228, 219, 222, 230, 223, 226, 229, 220, 223, 228, 229, 222, 226, 221, 225, 223, 221, 220, 0, 221, 228, 225, 222, 226, 242, 225, 229, 228, 231, 231, 0, 223, 226, 229, 297, 223, - 228, 229, 0, 0, 300, 225, 227, 227, 242, 241, + 228, 229, 0, 0, 302, 225, 227, 227, 242, 241, 241, 228, 231, 297, 0, 242, 227, 229, 232, 231, - 231, 227, 227, 301, 232, 297, 232, 227, 233, 241, - 233, 300, 233, 227, 227, 242, 241, 241, 232, 231, - 297, 233, 302, 227, 0, 232, 0, 234, 227, 227, - 301, 232, 233, 232, 227, 233, 241, 233, 237, 233, - 234, 235, 236, 0, 0, 232, 303, 234, 233, 302, - 235, 236, 305, 237, 234, 238, 239, 0, 237, 233, + 231, 227, 227, 303, 232, 297, 232, 227, 233, 241, + 233, 302, 233, 227, 227, 242, 241, 241, 232, 231, + 297, 233, 305, 227, 0, 232, 0, 234, 227, 227, + 303, 232, 233, 232, 227, 233, 241, 233, 237, 233, + 234, 235, 236, 0, 0, 232, 306, 234, 233, 305, + 235, 236, 307, 237, 234, 238, 239, 0, 237, 233, 240, 235, 236, 239, 240, 237, 244, 234, 235, 236, - 238, 243, 243, 303, 234, 238, 239, 235, 236, 305, + 238, 243, 243, 306, 234, 238, 239, 235, 236, 307, 237, 244, 238, 239, 240, 237, 244, 240, 235, 236, - 239, 240, 243, 244, 245, 306, 246, 238, 243, 243, + 239, 240, 243, 244, 245, 308, 246, 238, 243, 243, 246, 0, 238, 239, 0, 247, 0, 245, 244, 247, - 249, 240, 249, 244, 245, 248, 307, 308, 309, 243, - 246, 245, 306, 246, 248, 247, 250, 246, 251, 248, + 249, 240, 249, 244, 245, 248, 309, 310, 311, 243, + 246, 245, 308, 246, 248, 247, 250, 246, 251, 248, 249, 251, 247, 250, 245, 248, 247, 249, 0, 249, - 0, 245, 248, 307, 308, 309, 250, 246, 251, 0, + 0, 245, 248, 309, 310, 311, 250, 246, 251, 0, 254, 248, 247, 250, 0, 251, 248, 249, 251, 252, 250, 252, 248, 254, 253, 255, 0, 258, 252, 255, - 254, 310, 0, 250, 253, 251, 252, 254, 0, 256, + 254, 312, 0, 250, 253, 251, 252, 254, 0, 256, 0, 252, 256, 0, 253, 257, 252, 258, 252, 255, - 254, 253, 255, 257, 258, 252, 255, 254, 310, 259, + 254, 253, 255, 257, 258, 252, 255, 254, 312, 259, - 311, 253, 256, 252, 257, 257, 256, 259, 252, 256, + 313, 253, 256, 252, 257, 257, 256, 259, 252, 256, 260, 253, 257, 0, 258, 0, 255, 0, 261, 259, - 257, 260, 261, 263, 263, 312, 259, 311, 0, 256, + 257, 260, 261, 263, 263, 314, 259, 313, 0, 256, 260, 257, 257, 267, 259, 264, 262, 260, 261, 264, 262, 0, 261, 262, 263, 261, 259, 0, 260, 261, - 263, 263, 312, 267, 0, 264, 262, 260, 268, 266, + 263, 263, 314, 267, 0, 264, 262, 260, 268, 266, 267, 265, 264, 262, 0, 261, 264, 262, 265, 261, - 262, 263, 266, 268, 265, 313, 314, 315, 268, 266, + 262, 263, 266, 268, 265, 285, 315, 285, 268, 266, 267, 265, 264, 262, 0, 268, 266, 269, 265, 316, - 317, 269, 318, 319, 320, 265, 321, 322, 323, 266, + 317, 269, 285, 318, 319, 265, 320, 321, 322, 266, - 268, 265, 313, 314, 315, 268, 266, 324, 265, 325, - 326, 269, 327, 329, 269, 330, 316, 317, 269, 318, - 319, 320, 328, 321, 322, 323, 332, 333, 334, 335, - 336, 337, 328, 338, 324, 339, 325, 326, 269, 327, - 329, 340, 330, 341, 343, 344, 345, 346, 347, 328, - 348, 349, 350, 332, 333, 334, 335, 336, 337, 328, - 338, 351, 339, 352, 353, 354, 355, 356, 340, 357, - 341, 343, 344, 345, 346, 347, 358, 348, 349, 350, - 360, 361, 362, 363, 364, 365, 366, 367, 351, 369, - 352, 353, 354, 355, 356, 370, 357, 371, 372, 371, + 268, 265, 285, 315, 285, 268, 266, 323, 265, 324, + 325, 269, 326, 327, 269, 329, 316, 317, 269, 285, + 318, 319, 328, 320, 321, 322, 330, 332, 333, 334, + 335, 336, 328, 337, 323, 338, 324, 325, 269, 326, + 327, 339, 329, 340, 341, 343, 344, 345, 346, 328, + 347, 348, 349, 330, 332, 333, 334, 335, 336, 328, + 337, 350, 338, 351, 352, 353, 354, 355, 339, 356, + 340, 341, 343, 344, 345, 346, 357, 347, 348, 349, + 358, 360, 361, 362, 363, 364, 365, 366, 350, 367, + 351, 352, 353, 354, 355, 369, 356, 370, 371, 372, - 373, 374, 375, 358, 370, 376, 377, 360, 361, 362, - 363, 364, 365, 366, 367, 378, 369, 379, 380, 381, - 384, 379, 370, 385, 371, 372, 371, 373, 374, 375, - 0, 370, 376, 377, 386, 387, 0, 389, 391, 493, - 384, 0, 378, 385, 379, 380, 381, 384, 379, 388, - 385, 494, 0, 392, 386, 387, 388, 389, 391, 394, - 0, 386, 387, 392, 389, 391, 493, 384, 390, 388, - 385, 393, 390, 392, 0, 393, 388, 394, 494, 394, - 392, 386, 387, 388, 389, 391, 394, 395, 495, 398, - 392, 393, 390, 400, 395, 390, 388, 397, 393, 390, + 371, 373, 374, 357, 375, 376, 370, 358, 360, 361, + 362, 363, 364, 365, 366, 377, 367, 378, 380, 379, + 381, 384, 369, 379, 370, 371, 372, 371, 373, 374, + 0, 375, 376, 370, 385, 386, 387, 389, 493, 391, + 0, 384, 377, 0, 378, 380, 379, 381, 384, 390, + 379, 388, 0, 390, 385, 386, 387, 389, 388, 391, + 0, 385, 386, 387, 389, 493, 391, 392, 384, 494, + 393, 388, 395, 390, 393, 394, 390, 392, 388, 395, + 390, 385, 386, 387, 389, 388, 391, 392, 401, 0, + 393, 0, 395, 394, 392, 394, 494, 393, 388, 395, - 392, 396, 393, 396, 394, 398, 394, 395, 400, 398, - 397, 401, 0, 400, 395, 495, 398, 397, 393, 390, - 400, 395, 402, 396, 397, 399, 402, 403, 396, 0, - 396, 401, 398, 399, 395, 400, 398, 397, 401, 404, - 400, 403, 405, 496, 397, 399, 402, 403, 0, 402, - 396, 407, 399, 402, 403, 407, 406, 0, 401, 404, - 399, 410, 405, 406, 408, 409, 404, 409, 403, 405, - 496, 0, 399, 402, 403, 407, 406, 414, 407, 408, - 411, 410, 407, 406, 408, 415, 404, 409, 410, 405, - 406, 408, 409, 412, 409, 411, 412, 414, 413, 417, + 390, 393, 394, 397, 392, 398, 395, 396, 401, 396, + 0, 0, 0, 400, 392, 401, 397, 393, 399, 395, + 394, 398, 394, 397, 396, 398, 399, 404, 400, 396, + 397, 0, 398, 400, 396, 401, 396, 402, 399, 405, + 400, 402, 0, 397, 0, 399, 0, 404, 398, 403, + 397, 396, 398, 399, 404, 400, 396, 408, 407, 405, + 400, 402, 407, 403, 402, 399, 405, 410, 402, 403, + 0, 406, 408, 409, 404, 409, 403, 408, 406, 0, + 0, 0, 407, 495, 408, 407, 405, 410, 402, 407, + 403, 406, 411, 414, 410, 409, 403, 413, 406, 408, - 411, 0, 407, 406, 414, 415, 408, 411, 410, 413, - 0, 408, 415, 416, 409, 419, 412, 416, 413, 417, - 412, 421, 411, 412, 414, 413, 417, 411, 418, 419, - 418, 420, 415, 422, 421, 419, 413, 416, 420, 423, - 416, 421, 419, 412, 416, 413, 417, 422, 421, 0, - 418, 420, 0, 422, 0, 418, 419, 418, 420, 423, - 422, 421, 419, 424, 416, 420, 423, 424, 421, 427, - 497, 425, 428, 426, 422, 428, 427, 418, 420, 425, - 422, 426, 0, 0, 498, 429, 423, 424, 0, 427, - 424, 425, 499, 426, 424, 428, 427, 497, 425, 428, + 409, 415, 409, 412, 408, 406, 412, 411, 413, 407, + 495, 417, 411, 414, 410, 0, 0, 413, 406, 411, + 414, 415, 409, 416, 413, 0, 412, 416, 415, 0, + 412, 417, 419, 412, 411, 413, 0, 0, 417, 411, + 414, 418, 420, 418, 413, 423, 419, 416, 415, 420, + 416, 421, 419, 412, 416, 496, 424, 497, 417, 419, + 424, 422, 420, 418, 421, 423, 498, 0, 418, 420, + 418, 421, 423, 419, 416, 422, 420, 425, 421, 419, + 424, 422, 496, 424, 497, 425, 426, 424, 422, 420, + 418, 421, 423, 498, 426, 499, 427, 425, 421, 429, - 426, 429, 428, 427, 430, 429, 425, 430, 426, 431, - 432, 498, 429, 431, 424, 434, 427, 501, 425, 499, - 426, 434, 428, 435, 430, 432, 433, 436, 429, 431, - 432, 430, 429, 435, 430, 434, 431, 432, 437, 433, - 431, 438, 434, 435, 501, 0, 433, 436, 434, 439, - 435, 430, 432, 433, 436, 440, 431, 432, 437, 439, - 435, 438, 434, 441, 442, 437, 433, 444, 438, 439, - 435, 440, 441, 433, 436, 440, 439, 443, 0, 446, - 446, 504, 440, 441, 442, 437, 439, 444, 438, 445, - 441, 442, 443, 445, 444, 505, 439, 443, 440, 441, + 501, 505, 422, 427, 425, 431, 426, 424, 422, 431, + 0, 428, 425, 426, 428, 429, 427, 430, 0, 429, + 430, 426, 499, 427, 425, 431, 429, 501, 505, 436, + 427, 0, 431, 426, 428, 432, 431, 430, 428, 434, + 433, 428, 429, 427, 430, 434, 429, 430, 435, 436, + 432, 437, 431, 433, 438, 432, 436, 506, 435, 434, + 433, 428, 432, 439, 430, 507, 434, 433, 435, 442, + 509, 437, 434, 439, 438, 435, 436, 432, 437, 443, + 433, 438, 432, 439, 506, 435, 434, 433, 440, 442, + 439, 444, 507, 441, 443, 435, 442, 509, 437, 443, - 446, 447, 440, 506, 443, 447, 446, 446, 504, 445, - 441, 442, 508, 448, 444, 448, 445, 0, 450, 443, - 445, 449, 505, 449, 443, 447, 453, 446, 447, 451, - 506, 452, 447, 448, 450, 0, 445, 509, 450, 508, - 448, 449, 448, 0, 451, 450, 453, 452, 449, 451, - 449, 452, 447, 453, 0, 454, 451, 455, 452, 0, - 448, 450, 454, 457, 509, 450, 456, 458, 449, 511, - 455, 451, 0, 453, 452, 454, 451, 455, 452, 460, - 456, 459, 454, 457, 455, 459, 456, 458, 460, 454, - 457, 0, 0, 456, 458, 0, 511, 455, 461, 460, + 439, 438, 441, 445, 440, 0, 443, 445, 440, 0, + 439, 444, 510, 441, 0, 440, 442, 448, 444, 448, + 441, 443, 0, 445, 446, 446, 443, 451, 0, 441, + 445, 440, 447, 450, 445, 440, 447, 448, 444, 510, + 441, 449, 451, 449, 448, 446, 448, 451, 0, 450, + 445, 446, 446, 450, 451, 452, 447, 453, 454, 447, + 450, 449, 0, 447, 448, 454, 455, 456, 449, 451, + 449, 452, 446, 0, 451, 452, 450, 453, 454, 455, + 450, 456, 452, 447, 453, 454, 455, 456, 449, 457, + 458, 459, 454, 455, 456, 459, 0, 463, 452, 462, - 512, 513, 454, 462, 455, 459, 460, 456, 459, 461, - 457, 462, 459, 456, 458, 460, 463, 467, 461, 464, - 463, 465, 466, 462, 465, 461, 460, 512, 513, 466, - 462, 514, 459, 469, 464, 0, 461, 467, 462, 464, - 463, 465, 466, 463, 467, 461, 464, 463, 465, 466, - 462, 465, 468, 469, 470, 471, 466, 0, 514, 0, - 469, 464, 468, 472, 467, 475, 464, 463, 465, 466, - 0, 473, 468, 471, 470, 471, 475, 474, 472, 468, - 469, 470, 471, 472, 474, 475, 473, 0, 0, 468, - 472, 473, 475, 0, 476, 515, 478, 474, 473, 468, + 461, 463, 452, 460, 453, 454, 455, 462, 456, 457, + 458, 461, 460, 455, 456, 459, 457, 458, 459, 462, + 461, 463, 459, 460, 463, 464, 462, 461, 463, 465, + 460, 511, 465, 467, 462, 512, 457, 458, 461, 460, + 464, 469, 459, 470, 466, 464, 462, 461, 463, 465, + 460, 466, 464, 467, 472, 468, 465, 0, 511, 465, + 467, 469, 512, 470, 466, 468, 471, 464, 469, 472, + 470, 466, 464, 0, 472, 468, 465, 0, 466, 473, + 467, 472, 468, 478, 471, 476, 471, 475, 469, 513, + 470, 466, 468, 471, 473, 479, 472, 474, 475, 473, - 471, 470, 471, 475, 474, 472, 477, 479, 480, 476, - 472, 474, 475, 473, 476, 477, 478, 480, 473, 516, - 481, 476, 515, 478, 474, 0, 477, 479, 480, 481, - 0, 0, 0, 477, 479, 480, 476, 517, 482, 483, - 481, 476, 477, 478, 480, 0, 516, 481, 482, 483, - 482, 485, 486, 477, 479, 480, 481, 484, 482, 483, - 485, 484, 0, 518, 517, 482, 483, 481, 486, 0, - 521, 485, 486, 488, 489, 482, 483, 482, 485, 486, - 487, 484, 487, 490, 484, 482, 483, 485, 484, 489, - 518, 488, 490, 488, 489, 486, 490, 521, 485, 486, + 476, 472, 468, 478, 474, 476, 473, 475, 0, 477, + 478, 471, 476, 471, 475, 479, 513, 474, 477, 480, + 0, 473, 479, 482, 474, 475, 473, 476, 480, 477, + 478, 474, 476, 482, 475, 482, 477, 0, 481, 480, + 0, 483, 479, 482, 474, 477, 480, 481, 484, 514, + 482, 483, 484, 0, 0, 480, 477, 0, 481, 515, + 482, 483, 482, 516, 485, 481, 480, 486, 483, 0, + 482, 517, 484, 485, 481, 484, 514, 488, 483, 484, + 487, 489, 487, 486, 485, 481, 515, 486, 483, 518, + 516, 485, 0, 0, 486, 488, 489, 488, 517, 484, - 488, 489, 487, 490, 0, 0, 522, 487, 484, 487, - 490, 491, 492, 523, 491, 524, 489, 525, 488, 490, - 488, 489, 526, 490, 527, 492, 529, 530, 533, 487, - 490, 491, 492, 522, 534, 536, 539, 540, 491, 492, - 523, 491, 524, 541, 525, 542, 543, 546, 550, 526, - 552, 527, 492, 529, 530, 533, 544, 554, 491, 492, - 556, 534, 536, 539, 540, 555, 555, 544, 557, 559, - 541, 560, 542, 543, 546, 550, 561, 552, 562, 563, - 565, 566, 567, 544, 554, 568, 569, 556, 570, 571, - 572, 573, 555, 555, 544, 557, 559, 575, 560, 576, + 485, 489, 487, 519, 488, 492, 490, 487, 489, 487, + 486, 485, 522, 523, 486, 490, 518, 491, 492, 490, + 491, 524, 488, 489, 488, 492, 490, 525, 489, 487, + 519, 526, 492, 490, 527, 528, 530, 491, 531, 522, + 523, 534, 490, 535, 491, 492, 490, 491, 524, 537, + 540, 541, 492, 490, 525, 542, 543, 544, 526, 547, + 545, 527, 528, 530, 491, 531, 551, 553, 534, 555, + 535, 545, 556, 556, 557, 558, 537, 540, 541, 560, + 561, 562, 542, 543, 544, 563, 547, 545, 564, 566, + 567, 568, 569, 551, 553, 570, 555, 571, 545, 556, - 577, 578, 581, 561, 582, 562, 563, 565, 566, 567, - 584, 585, 568, 569, 586, 570, 571, 572, 573, 587, - 588, 589, 590, 591, 575, 593, 576, 577, 578, 581, - 595, 582, 0, 0, 600, 0, 601, 584, 585, 705, - 598, 586, 599, 0, 604, 602, 587, 588, 589, 590, - 591, 0, 593, 598, 600, 599, 601, 595, 602, 603, - 598, 600, 599, 601, 604, 602, 705, 598, 603, 599, - 605, 604, 602, 607, 606, 0, 608, 0, 606, 603, - 598, 600, 599, 601, 610, 602, 603, 598, 610, 599, - 605, 604, 602, 607, 609, 603, 608, 605, 606, 611, + 556, 557, 558, 572, 573, 574, 560, 561, 562, 576, + 577, 578, 563, 579, 582, 564, 566, 567, 568, 569, + 583, 585, 570, 586, 571, 587, 588, 589, 590, 591, + 572, 573, 574, 592, 594, 596, 576, 577, 578, 601, + 579, 582, 0, 602, 599, 600, 0, 583, 585, 605, + 586, 0, 587, 588, 589, 590, 591, 599, 600, 601, + 592, 594, 596, 602, 599, 600, 601, 603, 604, 605, + 602, 599, 600, 606, 607, 0, 605, 604, 607, 608, + 603, 0, 609, 610, 599, 600, 601, 603, 604, 0, + 602, 599, 600, 606, 603, 604, 605, 0, 607, 608, - 607, 606, 609, 608, 610, 606, 603, 612, 707, 0, - 614, 610, 611, 613, 609, 610, 615, 605, 0, 611, - 607, 609, 0, 608, 614, 606, 611, 612, 613, 609, - 614, 610, 617, 613, 612, 707, 615, 614, 616, 611, - 613, 609, 709, 615, 710, 616, 611, 618, 617, 619, - 0, 614, 617, 619, 612, 613, 0, 614, 616, 617, - 613, 0, 618, 615, 620, 616, 621, 618, 621, 709, - 711, 710, 616, 619, 618, 617, 619, 620, 622, 617, - 619, 624, 622, 623, 620, 616, 625, 712, 621, 618, - 623, 620, 0, 621, 618, 621, 626, 711, 622, 713, + 606, 607, 609, 610, 604, 607, 608, 603, 611, 609, + 610, 613, 614, 612, 603, 604, 611, 612, 0, 0, + 606, 615, 0, 0, 613, 607, 608, 0, 611, 609, + 610, 613, 614, 612, 617, 611, 615, 619, 613, 614, + 612, 615, 616, 611, 612, 618, 621, 707, 615, 617, + 621, 613, 618, 619, 617, 611, 616, 619, 613, 614, + 612, 617, 616, 615, 619, 618, 0, 620, 615, 616, + 621, 0, 618, 621, 707, 622, 617, 621, 625, 618, + 619, 617, 620, 616, 619, 625, 0, 620, 622, 616, + 626, 623, 618, 623, 620, 622, 624, 621, 625, 627, - 619, 624, 0, 623, 620, 622, 625, 626, 624, 622, - 623, 620, 0, 625, 712, 621, 626, 623, 627, 628, - 630, 629, 0, 626, 630, 622, 713, 0, 624, 627, - 623, 0, 632, 625, 626, 628, 629, 633, 627, 628, - 634, 629, 0, 626, 630, 627, 628, 630, 629, 631, - 635, 630, 632, 631, 635, 634, 627, 633, 636, 632, - 634, 0, 628, 629, 633, 627, 628, 634, 629, 637, - 714, 630, 0, 631, 635, 640, 631, 635, 636, 632, - 631, 635, 634, 0, 633, 636, 638, 634, 639, 637, - 638, 642, 643, 0, 641, 640, 637, 714, 716, 639, + 624, 709, 622, 0, 711, 625, 712, 0, 0, 620, + 626, 0, 625, 623, 620, 622, 624, 626, 623, 627, + 623, 628, 622, 624, 629, 625, 627, 624, 709, 630, + 632, 711, 628, 712, 632, 629, 0, 626, 631, 713, + 623, 628, 0, 624, 629, 630, 627, 634, 628, 630, + 635, 629, 0, 631, 632, 638, 630, 632, 631, 628, + 633, 632, 629, 636, 633, 631, 713, 634, 628, 637, + 635, 629, 630, 637, 634, 638, 630, 635, 636, 639, + 631, 632, 638, 636, 633, 631, 0, 633, 640, 714, + 636, 633, 640, 637, 634, 0, 637, 635, 641, 639, - 631, 635, 640, 641, 644, 636, 0, 645, 639, 646, - 638, 642, 643, 638, 641, 639, 637, 638, 642, 643, - 645, 641, 640, 0, 644, 716, 639, 645, 646, 646, - 641, 644, 647, 648, 645, 639, 646, 638, 642, 643, - 0, 641, 650, 652, 653, 647, 648, 645, 649, 0, - 649, 644, 647, 648, 645, 646, 646, 717, 651, 647, - 648, 649, 650, 652, 653, 651, 654, 655, 649, 650, - 652, 653, 647, 648, 0, 649, 656, 649, 651, 647, - 648, 658, 655, 0, 717, 651, 654, 655, 649, 650, - 652, 653, 651, 654, 655, 649, 656, 657, 659, 0, + 637, 642, 638, 644, 643, 636, 639, 645, 0, 641, + 636, 633, 640, 643, 715, 640, 714, 646, 641, 640, + 637, 642, 647, 644, 643, 641, 639, 645, 642, 0, + 644, 643, 0, 648, 645, 647, 641, 646, 652, 640, + 643, 715, 647, 649, 646, 641, 650, 0, 642, 647, + 644, 643, 648, 648, 645, 651, 649, 651, 652, 650, + 648, 654, 647, 649, 646, 652, 650, 653, 651, 647, + 649, 655, 656, 650, 653, 651, 658, 0, 0, 648, + 648, 654, 651, 649, 651, 652, 650, 653, 654, 657, + 649, 655, 656, 650, 653, 651, 658, 660, 655, 656, - 0, 658, 662, 656, 657, 651, 660, 661, 658, 655, - 661, 0, 663, 654, 655, 662, 718, 657, 659, 0, - 660, 660, 662, 656, 657, 659, 660, 661, 658, 662, - 665, 657, 663, 660, 661, 720, 664, 661, 664, 663, - 721, 0, 662, 718, 657, 659, 669, 660, 660, 662, - 665, 666, 668, 660, 661, 667, 0, 665, 664, 663, - 668, 672, 720, 664, 666, 664, 669, 721, 667, 672, - 670, 666, 668, 669, 670, 667, 671, 665, 666, 668, - 671, 672, 667, 675, 722, 664, 675, 668, 672, 674, - 0, 666, 673, 669, 670, 667, 672, 670, 666, 668, + 659, 653, 651, 658, 657, 661, 0, 659, 654, 657, + 0, 0, 0, 664, 653, 662, 657, 660, 655, 656, + 659, 0, 716, 658, 660, 661, 664, 659, 665, 662, + 662, 657, 661, 664, 659, 662, 657, 666, 663, 666, + 664, 663, 662, 667, 660, 0, 0, 659, 665, 716, + 0, 718, 661, 664, 668, 665, 662, 662, 663, 666, + 664, 719, 662, 667, 666, 663, 666, 668, 663, 669, + 667, 670, 671, 672, 668, 665, 0, 672, 718, 670, + 0, 668, 669, 673, 720, 663, 666, 673, 719, 669, + 667, 670, 671, 0, 668, 674, 669, 672, 670, 671, - 671, 670, 667, 671, 674, 673, 675, 671, 672, 674, - 675, 722, 673, 675, 676, 677, 674, 679, 678, 673, - 678, 670, 676, 680, 677, 0, 681, 671, 682, 0, - 681, 674, 673, 675, 676, 677, 674, 679, 684, 673, - 678, 676, 677, 680, 679, 678, 681, 678, 682, 676, - 680, 677, 685, 681, 686, 682, 683, 681, 684, 0, - 688, 676, 677, 0, 679, 684, 683, 678, 686, 690, - 680, 0, 685, 681, 686, 682, 683, 687, 690, 685, - 688, 686, 691, 683, 689, 684, 689, 688, 692, 690, - 695, 687, 692, 683, 697, 686, 690, 687, 691, 685, + 672, 668, 0, 674, 672, 676, 670, 673, 675, 669, + 673, 720, 0, 0, 673, 674, 669, 721, 670, 671, + 676, 675, 674, 677, 672, 676, 677, 0, 675, 678, + 674, 679, 676, 0, 673, 675, 0, 678, 0, 680, + 679, 680, 674, 681, 721, 682, 677, 676, 675, 678, + 677, 679, 676, 677, 684, 675, 678, 686, 679, 685, + 687, 680, 690, 681, 678, 682, 680, 679, 680, 685, + 681, 683, 682, 677, 684, 683, 678, 686, 679, 685, + 687, 684, 690, 688, 686, 689, 685, 687, 680, 690, + 681, 683, 682, 691, 723, 691, 685, 688, 683, 689, - 723, 686, 691, 683, 687, 690, 689, 688, 693, 691, - 695, 689, 692, 689, 697, 692, 690, 695, 687, 692, - 694, 697, 694, 693, 687, 691, 698, 723, 693, 691, - 724, 696, 699, 689, 696, 693, 700, 695, 0, 692, - 694, 697, 698, 725, 701, 702, 698, 694, 726, 694, - 693, 696, 699, 698, 727, 693, 700, 724, 696, 699, - 728, 696, 729, 700, 701, 702, 732, 694, 733, 698, - 725, 701, 702, 698, 735, 726, 737, 740, 696, 699, - 741, 727, 742, 700, 743, 748, 750, 728, 751, 729, - 752, 701, 702, 732, 755, 733, 756, 757, 758, 759, + 0, 684, 683, 688, 686, 689, 685, 687, 692, 690, + 688, 693, 689, 697, 695, 691, 0, 692, 683, 694, + 691, 723, 691, 694, 688, 724, 689, 693, 692, 695, + 688, 693, 689, 697, 695, 692, 0, 696, 693, 696, + 697, 695, 691, 694, 692, 698, 694, 699, 698, 725, + 694, 701, 724, 700, 693, 692, 695, 696, 693, 702, + 697, 695, 703, 704, 696, 698, 696, 699, 726, 700, + 694, 701, 698, 700, 699, 698, 725, 727, 701, 702, + 700, 728, 703, 704, 696, 729, 702, 730, 731, 703, + 704, 732, 698, 735, 699, 726, 700, 736, 701, 738, - 761, 735, 762, 737, 740, 763, 764, 741, 765, 742, - 766, 743, 748, 750, 767, 751, 768, 752, 769, 770, - 771, 755, 773, 756, 757, 758, 759, 761, 774, 762, - 775, 777, 763, 764, 778, 765, 779, 766, 0, 781, - 782, 767, 784, 768, 783, 769, 770, 771, 785, 773, - 786, 859, 787, 788, 788, 774, 0, 775, 777, 781, - 782, 778, 784, 779, 783, 783, 781, 782, 785, 784, - 786, 783, 787, 789, 788, 785, 0, 786, 859, 787, - 788, 788, 789, 790, 791, 792, 781, 782, 793, 784, - 0, 783, 783, 789, 791, 785, 794, 786, 790, 787, + 700, 740, 743, 744, 727, 745, 702, 746, 728, 703, + 704, 751, 729, 753, 730, 731, 754, 755, 732, 758, + 735, 759, 760, 761, 736, 762, 738, 764, 740, 743, + 744, 765, 745, 766, 746, 767, 768, 769, 751, 770, + 753, 771, 772, 754, 755, 773, 758, 774, 759, 760, + 761, 776, 762, 777, 764, 778, 780, 781, 765, 782, + 766, 784, 767, 768, 769, 785, 770, 787, 771, 772, + 786, 0, 773, 788, 774, 789, 790, 0, 776, 863, + 777, 784, 778, 780, 781, 785, 782, 787, 784, 793, + 786, 786, 785, 788, 787, 789, 790, 786, 791, 791, - 789, 788, 796, 790, 791, 792, 794, 795, 793, 789, - 790, 791, 792, 0, 795, 793, 794, 797, 861, 800, - 789, 791, 796, 794, 862, 790, 0, 795, 800, 796, - 790, 791, 792, 794, 795, 793, 798, 797, 799, 800, - 798, 795, 801, 794, 797, 861, 800, 0, 802, 796, - 0, 862, 0, 799, 795, 800, 798, 803, 799, 804, - 0, 0, 801, 798, 797, 799, 800, 798, 802, 801, - 863, 0, 803, 805, 804, 802, 808, 803, 806, 804, - 799, 865, 806, 798, 803, 799, 804, 805, 807, 801, - 807, 809, 810, 805, 0, 802, 808, 863, 806, 803, + 788, 792, 789, 790, 793, 865, 863, 0, 784, 793, + 792, 866, 785, 795, 787, 796, 793, 786, 786, 791, + 788, 792, 789, 790, 794, 791, 791, 0, 792, 800, + 801, 793, 865, 795, 794, 796, 793, 792, 866, 797, + 795, 0, 796, 797, 794, 798, 791, 799, 792, 800, + 801, 794, 0, 867, 799, 798, 800, 801, 803, 797, + 795, 794, 796, 805, 802, 798, 797, 799, 802, 806, + 797, 794, 798, 803, 799, 0, 800, 801, 803, 804, + 867, 799, 798, 805, 802, 803, 797, 807, 804, 806, + 805, 802, 798, 808, 799, 802, 806, 810, 809, 804, - 805, 804, 812, 808, 803, 806, 804, 810, 865, 806, - 807, 809, 810, 814, 805, 807, 815, 807, 809, 810, - 805, 811, 812, 808, 813, 806, 813, 816, 811, 812, - 817, 815, 819, 814, 810, 0, 815, 807, 809, 810, - 814, 811, 820, 815, 813, 0, 818, 816, 811, 812, - 817, 813, 819, 813, 816, 811, 820, 817, 815, 819, - 814, 818, 820, 815, 822, 821, 818, 823, 811, 820, - 824, 813, 821, 818, 816, 825, 826, 817, 827, 819, - 867, 868, 828, 820, 822, 821, 828, 823, 818, 820, - 824, 822, 821, 818, 823, 825, 826, 824, 827, 821, + 803, 810, 807, 812, 0, 803, 804, 807, 808, 0, + 805, 802, 809, 808, 807, 804, 806, 810, 809, 811, + 808, 811, 813, 812, 810, 809, 804, 869, 810, 807, + 812, 815, 814, 816, 807, 808, 818, 871, 815, 809, + 808, 811, 813, 0, 810, 809, 811, 814, 811, 813, + 812, 815, 814, 816, 869, 817, 818, 817, 815, 814, + 816, 819, 872, 818, 871, 815, 820, 821, 811, 813, + 822, 823, 0, 0, 814, 817, 819, 0, 815, 814, + 816, 819, 817, 818, 817, 822, 820, 821, 819, 872, + 822, 823, 0, 820, 821, 824, 826, 822, 823, 825, - 830, 829, 825, 826, 829, 827, 828, 867, 868, 828, - 831, 822, 821, 828, 823, 830, 832, 824, 833, 834, - 830, 829, 825, 826, 836, 827, 0, 830, 829, 838, - 831, 829, 834, 828, 870, 0, 832, 831, 833, 834, - 835, 0, 830, 832, 836, 833, 834, 830, 829, 838, - 837, 836, 872, 835, 837, 0, 838, 831, 839, 834, - 835, 870, 839, 832, 840, 833, 834, 835, 840, 0, - 837, 836, 841, 841, 0, 0, 838, 837, 876, 872, - 835, 837, 839, 842, 0, 839, 878, 835, 840, 839, - 844, 840, 845, 841, 844, 840, 850, 837, 842, 841, + 827, 828, 817, 819, 829, 830, 825, 0, 819, 824, + 831, 0, 822, 820, 821, 824, 826, 822, 823, 825, + 827, 828, 824, 826, 829, 830, 825, 827, 828, 834, + 831, 829, 830, 825, 832, 835, 824, 831, 832, 836, + 837, 0, 824, 826, 834, 0, 825, 827, 828, 834, + 833, 829, 830, 833, 0, 835, 834, 831, 832, 836, + 837, 832, 835, 840, 0, 832, 836, 837, 838, 841, + 833, 834, 842, 841, 873, 0, 834, 833, 839, 0, + 833, 838, 835, 840, 854, 832, 836, 837, 838, 841, + 840, 839, 842, 845, 845, 838, 841, 833, 839, 842, - 841, 843, 843, 842, 0, 876, 845, 0, 0, 839, - 842, 846, 845, 878, 844, 840, 850, 844, 0, 845, - 841, 844, 843, 850, 846, 842, 851, 847, 843, 843, - 842, 846, 848, 845, 852, 852, 848, 0, 846, 845, - 849, 844, 847, 850, 849, 853, 851, 847, 854, 843, - 0, 846, 879, 851, 847, 852, 848, 885, 846, 848, - 886, 852, 852, 848, 849, 853, 855, 849, 854, 847, - 858, 849, 853, 851, 847, 854, 889, 856, 890, 879, - 855, 856, 852, 848, 885, 857, 855, 886, 892, 857, - 858, 849, 853, 855, 893, 854, 894, 858, 896, 897, + 841, 873, 843, 844, 854, 839, 843, 844, 838, 0, + 840, 854, 875, 877, 845, 838, 841, 846, 839, 842, + 845, 845, 847, 847, 848, 839, 843, 844, 848, 843, + 844, 854, 846, 843, 844, 0, 855, 846, 849, 875, + 877, 845, 851, 847, 846, 0, 0, 850, 848, 847, + 847, 848, 849, 843, 844, 848, 855, 851, 849, 846, + 850, 881, 851, 855, 846, 849, 857, 850, 852, 851, + 847, 858, 852, 853, 850, 848, 859, 853, 860, 849, + 856, 856, 860, 855, 851, 849, 857, 850, 881, 851, + 859, 858, 852, 857, 850, 852, 859, 853, 858, 852, - 898, 856, 902, 889, 856, 890, 904, 855, 856, 857, - 905, 906, 857, 855, 907, 892, 857, 858, 912, 913, - 914, 893, 915, 894, 917, 896, 897, 898, 856, 902, - 916, 0, 919, 904, 918, 921, 857, 905, 906, 916, - 914, 907, 915, 924, 917, 912, 913, 914, 918, 915, - 916, 917, 919, 920, 918, 921, 922, 916, 922, 919, - 920, 918, 921, 924, 926, 925, 916, 914, 925, 915, - 924, 917, 0, 920, 923, 918, 974, 916, 922, 919, - 920, 918, 921, 922, 926, 922, 928, 920, 925, 923, - 924, 926, 925, 0, 923, 925, 927, 929, 927, 930, + 853, 856, 860, 859, 853, 860, 861, 856, 856, 860, + 861, 862, 883, 857, 884, 890, 891, 859, 858, 852, + 894, 895, 897, 859, 853, 898, 899, 901, 856, 860, + 861, 862, 902, 861, 903, 907, 909, 861, 862, 883, + 910, 884, 890, 891, 911, 912, 917, 894, 895, 897, + 918, 0, 898, 899, 901, 919, 920, 861, 862, 902, + 921, 903, 907, 909, 922, 923, 924, 910, 926, 921, + 927, 911, 912, 917, 925, 919, 920, 918, 927, 923, + 921, 925, 919, 920, 922, 923, 924, 921, 926, 929, + 927, 922, 923, 924, 925, 926, 921, 927, 928, 930, - 920, 923, 931, 974, 0, 922, 928, 932, 0, 0, - 0, 926, 935, 928, 0, 925, 923, 929, 927, 930, - 934, 923, 931, 927, 929, 927, 930, 932, 933, 931, - 936, 937, 935, 928, 932, 934, 938, 933, 0, 935, - 934, 939, 0, 0, 929, 927, 930, 934, 933, 931, - 936, 937, 940, 941, 932, 933, 938, 936, 937, 935, - 0, 939, 934, 938, 933, 940, 942, 934, 939, 943, - 946, 976, 940, 941, 944, 933, 0, 936, 937, 940, - 941, 944, 948, 938, 0, 949, 942, 945, 939, 943, - 946, 945, 940, 942, 944, 947, 943, 946, 976, 940, + 928, 925, 919, 920, 929, 927, 923, 921, 925, 929, + 932, 922, 923, 924, 934, 926, 929, 927, 935, 930, + 928, 925, 933, 936, 933, 928, 930, 928, 937, 931, + 932, 929, 931, 938, 934, 0, 929, 932, 935, 0, + 0, 934, 941, 936, 933, 935, 930, 928, 937, 933, + 936, 933, 931, 938, 939, 937, 931, 932, 940, 931, + 938, 934, 941, 939, 942, 935, 943, 944, 945, 941, + 936, 933, 947, 940, 939, 937, 0, 948, 940, 931, + 938, 939, 949, 946, 942, 940, 943, 944, 945, 941, + 939, 942, 947, 943, 944, 945, 946, 948, 0, 947, - 941, 944, 948, 950, 951, 949, 951, 977, 944, 948, - 947, 945, 949, 942, 945, 947, 943, 946, 945, 954, - 0, 944, 947, 950, 955, 952, 951, 952, 0, 948, - 950, 951, 949, 951, 977, 953, 956, 947, 945, 954, - 958, 957, 947, 982, 955, 984, 954, 952, 957, 953, - 950, 955, 952, 951, 952, 953, 956, 961, 985, 961, - 958, 957, 953, 956, 0, 959, 954, 958, 957, 959, - 982, 955, 984, 960, 952, 957, 953, 960, 962, 961, - 988, 963, 953, 956, 961, 985, 961, 958, 957, 959, - 964, 965, 959, 962, 966, 968, 959, 960, 962, 967, + 940, 939, 949, 946, 948, 940, 952, 953, 951, 949, + 946, 942, 951, 943, 944, 945, 954, 955, 950, 947, + 956, 0, 953, 946, 948, 950, 952, 953, 0, 949, + 946, 960, 951, 952, 953, 951, 954, 955, 950, 951, + 956, 0, 959, 954, 955, 950, 957, 956, 957, 953, + 0, 960, 950, 952, 953, 958, 959, 958, 960, 951, + 961, 962, 959, 954, 955, 950, 964, 956, 957, 959, + 965, 969, 963, 957, 965, 957, 0, 958, 960, 963, + 961, 962, 958, 959, 958, 980, 964, 961, 962, 959, + 0, 969, 963, 964, 965, 957, 966, 965, 969, 963, - 960, 963, 968, 989, 960, 962, 961, 988, 963, 992, - 964, 965, 967, 993, 966, 968, 959, 964, 965, 967, - 962, 966, 968, 994, 960, 962, 967, 995, 963, 968, - 989, 998, 999, 1000, 0, 1001, 992, 964, 965, 967, - 993, 966, 968, 1002, 1003, 1004, 967, 1005, 1003, 1006, - 994, 998, 999, 1000, 995, 1001, 0, 1007, 998, 999, - 1000, 1008, 1001, 1002, 1006, 1004, 1009, 1005, 1003, 1006, - 1002, 1003, 1004, 0, 1005, 1003, 1006, 1007, 998, 999, - 1000, 1008, 1001, 1010, 1007, 1011, 1009, 1011, 1008, 1012, - 1002, 1006, 1004, 1009, 1005, 1003, 1006, 1014, 1013, 1015, + 966, 965, 968, 967, 958, 967, 963, 961, 962, 0, + 981, 970, 980, 964, 971, 972, 0, 968, 969, 963, + 966, 965, 968, 966, 983, 967, 973, 966, 984, 968, + 967, 970, 967, 989, 971, 972, 974, 981, 970, 973, + 991, 971, 972, 974, 968, 992, 973, 966, 995, 968, + 996, 983, 967, 973, 999, 984, 974, 1000, 970, 1001, + 989, 971, 972, 974, 1002, 1005, 973, 991, 1006, 1007, + 974, 0, 992, 973, 1008, 995, 1011, 996, 1009, 1010, + 1011, 999, 1012, 974, 1000, 1005, 1001, 0, 1006, 1007, + 1013, 1002, 1005, 1014, 1008, 1006, 1007, 0, 1009, 1010, - 1016, 1019, 0, 1010, 1007, 1027, 0, 1011, 1008, 1012, - 1010, 1013, 1011, 1009, 1011, 0, 1012, 1014, 1013, 1015, - 1016, 1019, 1017, 1018, 1014, 1013, 1015, 1016, 1019, 1018, - 1010, 1020, 1027, 1022, 1011, 1024, 1012, 1017, 1013, 1021, - 1030, 1022, 1017, 1018, 1014, 1013, 1015, 1016, 1019, 1017, - 1018, 1020, 1021, 1022, 1025, 1024, 1018, 1023, 1020, 1021, - 1022, 1032, 1024, 1026, 1017, 1035, 1021, 1030, 1022, 1017, - 1018, 1036, 1023, 1037, 1025, 1040, 1039, 1023, 1020, 1021, - 1022, 1025, 1024, 1026, 1023, 1041, 1021, 1043, 1032, 1045, - 1026, 1039, 1035, 1042, 1051, 1040, 1039, 1046, 1036, 1023, + 1011, 1008, 1012, 1011, 1015, 1009, 1010, 1011, 1014, 1012, + 1013, 0, 1005, 1014, 1016, 1006, 1007, 1013, 1017, 1018, + 1014, 1008, 1020, 0, 1015, 1009, 1010, 1011, 1019, 1012, + 1019, 1015, 1022, 1023, 1016, 1014, 0, 1013, 1017, 1018, + 1014, 1016, 1020, 1021, 1024, 1017, 1018, 1025, 1026, 1020, + 1019, 1015, 1022, 1023, 1026, 1019, 1021, 1019, 1027, 1022, + 1023, 1016, 1025, 1021, 1024, 1017, 1018, 1025, 1026, 1020, + 1021, 1024, 1028, 1029, 1025, 1026, 1030, 1019, 1027, 1022, + 1023, 1026, 1031, 1021, 1030, 1027, 1029, 1032, 1033, 1025, + 1021, 1024, 1028, 1029, 1025, 1026, 1030, 1031, 1034, 1028, - 1037, 1025, 1040, 1039, 1023, 1041, 1044, 1043, 1042, 1045, - 1026, 1047, 1041, 1042, 1043, 1053, 1045, 1046, 1039, 1044, - 1042, 1051, 1040, 1039, 1046, 1049, 1044, 1050, 1048, 1049, - 1056, 1047, 1041, 1044, 1043, 1042, 1045, 1065, 1047, 1048, - 1042, 1057, 1053, 1058, 1046, 1049, 1044, 1050, 1048, 1060, - 0, 1059, 1049, 1044, 1050, 1048, 1049, 1056, 1047, 1061, - 0, 1057, 1066, 1058, 1065, 1059, 1048, 1062, 1057, 1060, - 1058, 1059, 1049, 1067, 1050, 1048, 1060, 1062, 1059, 1061, - 0, 0, 1066, 1070, 0, 0, 1061, 1062, 1057, 1066, - 1058, 0, 1059, 1067, 1062, 0, 1060, 0, 1059, 1068, + 1029, 1036, 1031, 1030, 1039, 1027, 1041, 1032, 1033, 1031, + 1044, 1030, 1045, 1029, 1032, 1033, 1046, 0, 1034, 1028, + 1029, 1048, 1061, 1030, 1031, 1034, 1050, 1049, 1036, 1031, + 1051, 1039, 1053, 1041, 1032, 1033, 1052, 1044, 1055, 1045, + 1056, 1048, 1049, 1046, 1057, 1034, 1050, 1049, 1048, 1061, + 1051, 1052, 1053, 1050, 1049, 0, 1052, 1051, 1055, 1053, + 1056, 1058, 1054, 1052, 1057, 1055, 1059, 1056, 1048, 1049, + 1059, 1057, 1058, 1050, 1049, 1054, 1060, 1051, 1052, 1053, + 1063, 1058, 1054, 1052, 1066, 1055, 1059, 1056, 1058, 1054, + 1067, 1057, 1068, 1059, 1075, 1070, 1060, 1059, 1071, 1058, - 1067, 0, 0, 1070, 1062, 0, 1061, 0, 1068, 1066, - 1070, 0, 0, 0, 1062, 0, 0, 0, 0, 1068, - 1067, 0, 0, 0, 0, 0, 1068, 0, 0, 0, - 1070, 0, 0, 0, 0, 1068, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1068, 1072, 1072, 1072, - 1072, 1072, 1073, 0, 0, 1073, 1073, 1075, 1075, 1075, - 0, 1075, 1076, 0, 1076, 1076, 1076, 1077, 0, 1077, - 1077, 1077, 1078, 0, 1078, 1078, 1078, 1071, 1071, 1071, - 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, - 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, + 1069, 0, 1054, 1060, 1076, 0, 1072, 1063, 1058, 1054, + 1067, 1066, 1068, 1059, 1069, 1070, 1072, 1067, 1071, 1068, + 1069, 1075, 1070, 1060, 1076, 1071, 1072, 1069, 1077, 1078, + 1080, 1076, 0, 1072, 0, 0, 0, 1067, 1078, 1068, + 0, 1069, 1070, 1072, 0, 1071, 0, 1069, 1077, 1078, + 1080, 1076, 0, 1072, 0, 1077, 1078, 1080, 0, 0, + 0, 0, 0, 0, 0, 1078, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1077, 1078, 1080, 1082, 1082, + 1082, 1082, 1082, 1083, 0, 0, 1083, 1083, 1085, 1085, + 1085, 0, 1085, 1086, 0, 1086, 1086, 1086, 1087, 0, - 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, - 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, - 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, - 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, 1071, - 1071, 1071, 1071, 1071, 1071 + 1087, 1087, 1087, 1088, 0, 1088, 1088, 1088, 1081, 1081, + 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, + 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, + 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, + 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, + 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, + 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, 1081, + 1081, 1081, 1081, 1081, 1081, 1081 } ; /* The intent behind this definition is that it'll catch @@ -1982,7 +1991,7 @@ static const flex_int16_t yy_chk[4346] = static thread_local std::stringstream strbuf; -#line 1985 "flex_lexer.cpp" +#line 1994 "flex_lexer.cpp" /*************************** ** Section 2: Rules @@ -1996,7 +2005,7 @@ static thread_local std::stringstream strbuf; /*************************** ** Section 3: Rules ***************************/ -#line 1999 "flex_lexer.cpp" +#line 2008 "flex_lexer.cpp" #define INITIAL 0 #define singlequotedstring 1 @@ -2283,7 +2292,7 @@ YY_DECL #line 56 "flex_lexer.l" -#line 2286 "flex_lexer.cpp" +#line 2295 "flex_lexer.cpp" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { @@ -2310,13 +2319,13 @@ yy_match: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 1072 ) + if ( yy_current_state >= 1082 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; ++yy_cp; } - while ( yy_current_state != 1071 ); + while ( yy_current_state != 1081 ); yy_cp = yyg->yy_last_accepting_cpos; yy_current_state = yyg->yy_last_accepting_state; @@ -2541,610 +2550,620 @@ TOKEN(EXTRACT) case 41: YY_RULE_SETUP #line 100 "flex_lexer.l" -TOKEN(FORMAT) +TOKEN(CAST) YY_BREAK case 42: YY_RULE_SETUP #line 101 "flex_lexer.l" -TOKEN(GLOBAL) +TOKEN(FORMAT) YY_BREAK case 43: YY_RULE_SETUP #line 102 "flex_lexer.l" -TOKEN(HAVING) +TOKEN(GLOBAL) YY_BREAK case 44: YY_RULE_SETUP #line 103 "flex_lexer.l" -TOKEN(IMPORT) +TOKEN(HAVING) YY_BREAK case 45: YY_RULE_SETUP #line 104 "flex_lexer.l" -TOKEN(INSERT) +TOKEN(IMPORT) YY_BREAK case 46: YY_RULE_SETUP #line 105 "flex_lexer.l" -TOKEN(ISNULL) +TOKEN(INSERT) YY_BREAK case 47: YY_RULE_SETUP #line 106 "flex_lexer.l" -TOKEN(OFFSET) +TOKEN(ISNULL) YY_BREAK case 48: YY_RULE_SETUP #line 107 "flex_lexer.l" -TOKEN(RENAME) +TOKEN(OFFSET) YY_BREAK case 49: YY_RULE_SETUP #line 108 "flex_lexer.l" -TOKEN(SCHEMA) +TOKEN(RENAME) YY_BREAK case 50: YY_RULE_SETUP #line 109 "flex_lexer.l" -TOKEN(SELECT) +TOKEN(SCHEMA) YY_BREAK case 51: YY_RULE_SETUP #line 110 "flex_lexer.l" -TOKEN(SORTED) +TOKEN(SELECT) YY_BREAK case 52: YY_RULE_SETUP #line 111 "flex_lexer.l" -TOKEN(TABLES) +TOKEN(SORTED) YY_BREAK case 53: YY_RULE_SETUP #line 112 "flex_lexer.l" -TOKEN(UNIQUE) +TOKEN(TABLES) YY_BREAK case 54: YY_RULE_SETUP #line 113 "flex_lexer.l" -TOKEN(UNLOAD) +TOKEN(UNIQUE) YY_BREAK case 55: YY_RULE_SETUP #line 114 "flex_lexer.l" -TOKEN(UPDATE) +TOKEN(UNLOAD) YY_BREAK case 56: YY_RULE_SETUP #line 115 "flex_lexer.l" -TOKEN(VALUES) +TOKEN(UPDATE) YY_BREAK case 57: YY_RULE_SETUP #line 116 "flex_lexer.l" -TOKEN(AFTER) +TOKEN(VALUES) YY_BREAK case 58: YY_RULE_SETUP #line 117 "flex_lexer.l" -TOKEN(ALTER) +TOKEN(AFTER) YY_BREAK case 59: YY_RULE_SETUP #line 118 "flex_lexer.l" -TOKEN(ARRAY) +TOKEN(ALTER) YY_BREAK case 60: YY_RULE_SETUP #line 119 "flex_lexer.l" -TOKEN(CROSS) +TOKEN(ARRAY) YY_BREAK case 61: YY_RULE_SETUP #line 120 "flex_lexer.l" -TOKEN(DELTA) +TOKEN(CROSS) YY_BREAK case 62: YY_RULE_SETUP #line 121 "flex_lexer.l" -TOKEN(FLOAT) +TOKEN(DELTA) YY_BREAK case 63: YY_RULE_SETUP #line 122 "flex_lexer.l" -TOKEN(GROUP) +TOKEN(FLOAT) YY_BREAK case 64: YY_RULE_SETUP #line 123 "flex_lexer.l" -TOKEN(INDEX) +TOKEN(GROUP) YY_BREAK case 65: YY_RULE_SETUP #line 124 "flex_lexer.l" -TOKEN(INNER) +TOKEN(INDEX) YY_BREAK case 66: YY_RULE_SETUP #line 125 "flex_lexer.l" -TOKEN(LIMIT) +TOKEN(INNER) YY_BREAK case 67: YY_RULE_SETUP #line 126 "flex_lexer.l" -TOKEN(LOCAL) +TOKEN(LIMIT) YY_BREAK case 68: YY_RULE_SETUP #line 127 "flex_lexer.l" -TOKEN(MERGE) +TOKEN(LOCAL) YY_BREAK case 69: YY_RULE_SETUP #line 128 "flex_lexer.l" -TOKEN(MINUS) +TOKEN(MERGE) YY_BREAK case 70: YY_RULE_SETUP #line 129 "flex_lexer.l" -TOKEN(ORDER) +TOKEN(MINUS) YY_BREAK case 71: YY_RULE_SETUP #line 130 "flex_lexer.l" -TOKEN(OUTER) +TOKEN(ORDER) YY_BREAK case 72: YY_RULE_SETUP #line 131 "flex_lexer.l" -TOKEN(RIGHT) +TOKEN(OUTER) YY_BREAK case 73: YY_RULE_SETUP #line 132 "flex_lexer.l" -TOKEN(TABLE) +TOKEN(RIGHT) YY_BREAK case 74: YY_RULE_SETUP #line 133 "flex_lexer.l" -TOKEN(UNION) +TOKEN(TABLE) YY_BREAK case 75: YY_RULE_SETUP #line 134 "flex_lexer.l" -TOKEN(INTERSECT) +TOKEN(UNION) YY_BREAK case 76: YY_RULE_SETUP #line 135 "flex_lexer.l" -TOKEN(EXCEPT) +TOKEN(INTERSECT) YY_BREAK case 77: YY_RULE_SETUP #line 136 "flex_lexer.l" -TOKEN(USING) +TOKEN(EXCEPT) YY_BREAK case 78: YY_RULE_SETUP #line 137 "flex_lexer.l" -TOKEN(WHERE) +TOKEN(USING) YY_BREAK case 79: YY_RULE_SETUP #line 138 "flex_lexer.l" -TOKEN(CALL) +TOKEN(WHERE) YY_BREAK case 80: YY_RULE_SETUP #line 139 "flex_lexer.l" -TOKEN(CASE) +TOKEN(CALL) YY_BREAK case 81: YY_RULE_SETUP #line 140 "flex_lexer.l" -TOKEN(CHAR) +TOKEN(CASE) YY_BREAK case 82: YY_RULE_SETUP #line 141 "flex_lexer.l" -TOKEN(COPY) +TOKEN(CHAR) YY_BREAK case 83: YY_RULE_SETUP #line 142 "flex_lexer.l" -TOKEN(DATE) +TOKEN(COPY) YY_BREAK case 84: YY_RULE_SETUP #line 143 "flex_lexer.l" -TOKEN(DESC) +TOKEN(DATE) YY_BREAK case 85: YY_RULE_SETUP #line 144 "flex_lexer.l" -TOKEN(DROP) +TOKEN(DATETIME) YY_BREAK case 86: YY_RULE_SETUP #line 145 "flex_lexer.l" -TOKEN(ELSE) +TOKEN(DESC) YY_BREAK case 87: YY_RULE_SETUP #line 146 "flex_lexer.l" -TOKEN(FILE) +TOKEN(DROP) YY_BREAK case 88: YY_RULE_SETUP #line 147 "flex_lexer.l" -TOKEN(FROM) +TOKEN(ELSE) YY_BREAK case 89: YY_RULE_SETUP #line 148 "flex_lexer.l" -TOKEN(FULL) +TOKEN(FILE) YY_BREAK case 90: YY_RULE_SETUP #line 149 "flex_lexer.l" -TOKEN(HASH) +TOKEN(FROM) YY_BREAK case 91: YY_RULE_SETUP #line 150 "flex_lexer.l" -TOKEN(HINT) +TOKEN(FULL) YY_BREAK case 92: YY_RULE_SETUP #line 151 "flex_lexer.l" -TOKEN(INTO) +TOKEN(HASH) YY_BREAK case 93: YY_RULE_SETUP #line 152 "flex_lexer.l" -TOKEN(JOIN) +TOKEN(HINT) YY_BREAK case 94: YY_RULE_SETUP #line 153 "flex_lexer.l" -TOKEN(LEFT) +TOKEN(INTO) YY_BREAK case 95: YY_RULE_SETUP #line 154 "flex_lexer.l" -TOKEN(LIKE) +TOKEN(JOIN) YY_BREAK case 96: YY_RULE_SETUP #line 155 "flex_lexer.l" -TOKEN(ILIKE) +TOKEN(LEFT) YY_BREAK case 97: YY_RULE_SETUP #line 156 "flex_lexer.l" -TOKEN(LOAD) +TOKEN(LIKE) YY_BREAK case 98: YY_RULE_SETUP #line 157 "flex_lexer.l" -TOKEN(LONG) +TOKEN(ILIKE) YY_BREAK case 99: YY_RULE_SETUP #line 158 "flex_lexer.l" -TOKEN(NULL) +TOKEN(LOAD) YY_BREAK case 100: YY_RULE_SETUP #line 159 "flex_lexer.l" -TOKEN(PLAN) +TOKEN(LONG) YY_BREAK case 101: YY_RULE_SETUP #line 160 "flex_lexer.l" -TOKEN(SHOW) +TOKEN(NULL) YY_BREAK case 102: YY_RULE_SETUP #line 161 "flex_lexer.l" -TOKEN(TEXT) +TOKEN(PLAN) YY_BREAK case 103: YY_RULE_SETUP #line 162 "flex_lexer.l" -TOKEN(THEN) +TOKEN(SHOW) YY_BREAK case 104: YY_RULE_SETUP #line 163 "flex_lexer.l" -TOKEN(TIME) +TOKEN(TEXT) YY_BREAK case 105: YY_RULE_SETUP #line 164 "flex_lexer.l" -TOKEN(VIEW) +TOKEN(THEN) YY_BREAK case 106: YY_RULE_SETUP #line 165 "flex_lexer.l" -TOKEN(WHEN) +TOKEN(TIME) YY_BREAK case 107: YY_RULE_SETUP #line 166 "flex_lexer.l" -TOKEN(WITH) +TOKEN(VIEW) YY_BREAK case 108: YY_RULE_SETUP #line 167 "flex_lexer.l" -TOKEN(ADD) +TOKEN(WHEN) YY_BREAK case 109: YY_RULE_SETUP #line 168 "flex_lexer.l" -TOKEN(ALL) +TOKEN(WITH) YY_BREAK case 110: YY_RULE_SETUP #line 169 "flex_lexer.l" -TOKEN(AND) +TOKEN(ADD) YY_BREAK case 111: YY_RULE_SETUP #line 170 "flex_lexer.l" -TOKEN(ASC) +TOKEN(ALL) YY_BREAK case 112: YY_RULE_SETUP #line 171 "flex_lexer.l" -TOKEN(END) +TOKEN(AND) YY_BREAK case 113: YY_RULE_SETUP #line 172 "flex_lexer.l" -TOKEN(FOR) +TOKEN(ASC) YY_BREAK case 114: YY_RULE_SETUP #line 173 "flex_lexer.l" -TOKEN(INT) +TOKEN(END) YY_BREAK case 115: YY_RULE_SETUP #line 174 "flex_lexer.l" -TOKEN(KEY) +TOKEN(FOR) YY_BREAK case 116: YY_RULE_SETUP #line 175 "flex_lexer.l" -TOKEN(NOT) +TOKEN(INT) YY_BREAK case 117: YY_RULE_SETUP #line 176 "flex_lexer.l" -TOKEN(OFF) +TOKEN(KEY) YY_BREAK case 118: YY_RULE_SETUP #line 177 "flex_lexer.l" -TOKEN(SET) +TOKEN(NOT) YY_BREAK case 119: YY_RULE_SETUP #line 178 "flex_lexer.l" -TOKEN(TOP) +TOKEN(OFF) YY_BREAK case 120: YY_RULE_SETUP #line 179 "flex_lexer.l" -TOKEN(AS) +TOKEN(SET) YY_BREAK case 121: YY_RULE_SETUP #line 180 "flex_lexer.l" -TOKEN(BY) +TOKEN(TOP) YY_BREAK case 122: YY_RULE_SETUP #line 181 "flex_lexer.l" -TOKEN(IF) +TOKEN(AS) YY_BREAK case 123: YY_RULE_SETUP #line 182 "flex_lexer.l" -TOKEN(IN) +TOKEN(BY) YY_BREAK case 124: YY_RULE_SETUP #line 183 "flex_lexer.l" -TOKEN(IS) +TOKEN(IF) YY_BREAK case 125: YY_RULE_SETUP #line 184 "flex_lexer.l" -TOKEN(OF) +TOKEN(IN) YY_BREAK case 126: YY_RULE_SETUP #line 185 "flex_lexer.l" -TOKEN(ON) +TOKEN(IS) YY_BREAK case 127: YY_RULE_SETUP #line 186 "flex_lexer.l" -TOKEN(OR) +TOKEN(OF) YY_BREAK case 128: YY_RULE_SETUP #line 187 "flex_lexer.l" -TOKEN(TO) +TOKEN(ON) YY_BREAK case 129: YY_RULE_SETUP #line 188 "flex_lexer.l" -TOKEN(SECOND) +TOKEN(OR) YY_BREAK case 130: YY_RULE_SETUP #line 189 "flex_lexer.l" -TOKEN(MINUTE) +TOKEN(TO) YY_BREAK case 131: YY_RULE_SETUP #line 190 "flex_lexer.l" -TOKEN(HOUR) +TOKEN(SECOND) YY_BREAK case 132: YY_RULE_SETUP #line 191 "flex_lexer.l" -TOKEN(DAY) +TOKEN(MINUTE) YY_BREAK case 133: YY_RULE_SETUP #line 192 "flex_lexer.l" -TOKEN(MONTH) +TOKEN(HOUR) YY_BREAK case 134: YY_RULE_SETUP #line 193 "flex_lexer.l" -TOKEN(YEAR) +TOKEN(DAY) YY_BREAK case 135: YY_RULE_SETUP #line 194 "flex_lexer.l" -TOKEN(TRUE) +TOKEN(MONTH) YY_BREAK case 136: YY_RULE_SETUP #line 195 "flex_lexer.l" -TOKEN(FALSE) +TOKEN(YEAR) YY_BREAK case 137: YY_RULE_SETUP #line 196 "flex_lexer.l" -TOKEN(TRANSACTION) +TOKEN(TRUE) YY_BREAK case 138: YY_RULE_SETUP #line 197 "flex_lexer.l" -TOKEN(BEGIN) +TOKEN(FALSE) YY_BREAK case 139: YY_RULE_SETUP #line 198 "flex_lexer.l" -TOKEN(ROLLBACK) +TOKEN(TRANSACTION) YY_BREAK case 140: YY_RULE_SETUP #line 199 "flex_lexer.l" -TOKEN(COMMIT) +TOKEN(BEGIN) YY_BREAK -/* Allow =/== see https://sqlite.org/lang_expr.html#collateop */ case 141: YY_RULE_SETUP -#line 202 "flex_lexer.l" -TOKEN(EQUALS) +#line 200 "flex_lexer.l" +TOKEN(ROLLBACK) YY_BREAK case 142: YY_RULE_SETUP -#line 203 "flex_lexer.l" -TOKEN(NOTEQUALS) +#line 201 "flex_lexer.l" +TOKEN(COMMIT) YY_BREAK +/* Allow =/== see https://sqlite.org/lang_expr.html#collateop */ case 143: YY_RULE_SETUP #line 204 "flex_lexer.l" -TOKEN(NOTEQUALS) +TOKEN(EQUALS) YY_BREAK case 144: YY_RULE_SETUP #line 205 "flex_lexer.l" -TOKEN(LESSEQ) +TOKEN(NOTEQUALS) YY_BREAK case 145: YY_RULE_SETUP #line 206 "flex_lexer.l" -TOKEN(GREATEREQ) +TOKEN(NOTEQUALS) YY_BREAK case 146: YY_RULE_SETUP #line 207 "flex_lexer.l" -TOKEN(CONCAT) +TOKEN(LESSEQ) YY_BREAK case 147: YY_RULE_SETUP -#line 209 "flex_lexer.l" -{ return yytext[0]; } +#line 208 "flex_lexer.l" +TOKEN(GREATEREQ) YY_BREAK case 148: -#line 212 "flex_lexer.l" +YY_RULE_SETUP +#line 209 "flex_lexer.l" +TOKEN(CONCAT) + YY_BREAK case 149: YY_RULE_SETUP -#line 212 "flex_lexer.l" +#line 211 "flex_lexer.l" +{ return yytext[0]; } + YY_BREAK +case 150: +#line 214 "flex_lexer.l" +case 151: +YY_RULE_SETUP +#line 214 "flex_lexer.l" { yylval->fval = atof(yytext); return SQL_FLOATVAL; } YY_BREAK -case 150: +case 152: YY_RULE_SETUP -#line 217 "flex_lexer.l" +#line 219 "flex_lexer.l" { yylval->ival = atol(yytext); return SQL_INTVAL; } YY_BREAK -case 151: +case 153: YY_RULE_SETUP -#line 222 "flex_lexer.l" +#line 224 "flex_lexer.l" { // Crop the leading and trailing quote char yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); return SQL_IDENTIFIER; } YY_BREAK -case 152: +case 154: YY_RULE_SETUP -#line 228 "flex_lexer.l" +#line 230 "flex_lexer.l" { yylval->sval = strdup(yytext); return SQL_IDENTIFIER; } YY_BREAK -case 153: -YY_RULE_SETUP -#line 233 "flex_lexer.l" -{ BEGIN singlequotedstring; strbuf = std::stringstream{}; } - YY_BREAK -case 154: -YY_RULE_SETUP -#line 234 "flex_lexer.l" -{ strbuf << '\''; } - YY_BREAK case 155: -/* rule 155 can match eol */ YY_RULE_SETUP #line 235 "flex_lexer.l" -{ strbuf << yytext; } +{ BEGIN singlequotedstring; strbuf = std::stringstream{}; } YY_BREAK case 156: YY_RULE_SETUP #line 236 "flex_lexer.l" -{ BEGIN 0; yylval->sval = strdup(strbuf.str().c_str()); return SQL_STRING; } - YY_BREAK -case YY_STATE_EOF(singlequotedstring): -#line 237 "flex_lexer.l" -{ fprintf(stderr, "[SQL-Lexer-Error] Unterminated string\n"); return 0; } +{ strbuf << '\''; } YY_BREAK case 157: +/* rule 157 can match eol */ YY_RULE_SETUP -#line 239 "flex_lexer.l" -{ fprintf(stderr, "[SQL-Lexer-Error] Unknown Character: %c\n", yytext[0]); return 0; } +#line 237 "flex_lexer.l" +{ strbuf << yytext; } YY_BREAK case 158: YY_RULE_SETUP -#line 242 "flex_lexer.l" +#line 238 "flex_lexer.l" +{ BEGIN 0; yylval->sval = strdup(strbuf.str().c_str()); return SQL_STRING; } + YY_BREAK +case YY_STATE_EOF(singlequotedstring): +#line 239 "flex_lexer.l" +{ fprintf(stderr, "[SQL-Lexer-Error] Unterminated string\n"); return 0; } + YY_BREAK +case 159: +YY_RULE_SETUP +#line 241 "flex_lexer.l" +{ fprintf(stderr, "[SQL-Lexer-Error] Unknown Character: %c\n", yytext[0]); return 0; } + YY_BREAK +case 160: +YY_RULE_SETUP +#line 244 "flex_lexer.l" ECHO; YY_BREAK -#line 3147 "flex_lexer.cpp" +#line 3166 "flex_lexer.cpp" case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(COMMENT): yyterminate(); @@ -3445,7 +3464,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 1072 ) + if ( yy_current_state >= 1082 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; @@ -3474,11 +3493,11 @@ static int yy_get_next_buffer (yyscan_t yyscanner) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 1072 ) + if ( yy_current_state >= 1082 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - yy_is_jam = (yy_current_state == 1071); + yy_is_jam = (yy_current_state == 1081); (void)yyg; return yy_is_jam ? 0 : yy_current_state; @@ -4301,7 +4320,7 @@ void yyfree (void * ptr , yyscan_t yyscanner) #define YYTABLES_NAME "yytables" -#line 242 "flex_lexer.l" +#line 244 "flex_lexer.l" /*************************** ** Section 3: User code diff --git a/src/parser/flex_lexer.h b/src/parser/flex_lexer.h index dbe1dd1..98e4759 100644 --- a/src/parser/flex_lexer.h +++ b/src/parser/flex_lexer.h @@ -730,7 +730,7 @@ extern int yylex \ #undef yyTABLES_NAME #endif -#line 242 "flex_lexer.l" +#line 244 "flex_lexer.l" #line 736 "flex_lexer.h" diff --git a/src/parser/flex_lexer.l b/src/parser/flex_lexer.l index b858a07..42e2990 100644 --- a/src/parser/flex_lexer.l +++ b/src/parser/flex_lexer.l @@ -97,6 +97,7 @@ ESCAPE TOKEN(ESCAPE) EXCEPT TOKEN(EXCEPT) EXISTS TOKEN(EXISTS) EXTRACT TOKEN(EXTRACT) +CAST TOKEN(CAST) FORMAT TOKEN(FORMAT) GLOBAL TOKEN(GLOBAL) HAVING TOKEN(HAVING) @@ -140,6 +141,7 @@ CASE TOKEN(CASE) CHAR TOKEN(CHAR) COPY TOKEN(COPY) DATE TOKEN(DATE) +DATETIME TOKEN(DATETIME) DESC TOKEN(DESC) DROP TOKEN(DROP) ELSE TOKEN(ELSE) diff --git a/src/sql/ColumnType.h b/src/sql/ColumnType.h new file mode 100755 index 0000000..43d7802 --- /dev/null +++ b/src/sql/ColumnType.h @@ -0,0 +1,33 @@ +#ifndef SQLPARSER_COLUMN_TYPE_H +#define SQLPARSER_COLUMN_TYPE_H + +#include + +namespace hsql { + enum class DataType { + UNKNOWN, + INT, + LONG, + FLOAT, + DOUBLE, + CHAR, + VARCHAR, + TEXT, + DATETIME + }; + + // Represents the type of a column, e.g., FLOAT or VARCHAR(10) + struct ColumnType { + ColumnType() = default; + ColumnType(DataType data_type, int64_t length = 0); + DataType data_type; + int64_t length; // Used for, e.g., VARCHAR(10) + }; + + bool operator==(const ColumnType& lhs, const ColumnType& rhs); + bool operator!=(const ColumnType& lhs, const ColumnType& rhs); + std::ostream& operator<<(std::ostream&, const ColumnType&); + +} // namespace hsql + +#endif diff --git a/src/sql/CreateStatement.h b/src/sql/CreateStatement.h index 01a98d0..2263663 100755 --- a/src/sql/CreateStatement.h +++ b/src/sql/CreateStatement.h @@ -2,6 +2,7 @@ #define SQLPARSER_CREATE_STATEMENT_H #include "SQLStatement.h" +#include "ColumnType.h" #include @@ -9,29 +10,6 @@ namespace hsql { struct SelectStatement; - enum class DataType { - UNKNOWN, - INT, - LONG, - FLOAT, - DOUBLE, - CHAR, - VARCHAR, - TEXT - }; - - // Represents the type of a column, e.g., FLOAT or VARCHAR(10) - struct ColumnType { - ColumnType() = default; - ColumnType(DataType data_type, int64_t length = 0); - DataType data_type; - int64_t length; // Used for, e.g., VARCHAR(10) - }; - - bool operator==(const ColumnType& lhs, const ColumnType& rhs); - bool operator!=(const ColumnType& lhs, const ColumnType& rhs); - std::ostream& operator<<(std::ostream&, const ColumnType&); - // Represents definition of a table column struct ColumnDefinition { ColumnDefinition(char* name, ColumnType type, bool nullable); diff --git a/src/sql/Expr.cpp b/src/sql/Expr.cpp index e1ee8f6..c2103a3 100644 --- a/src/sql/Expr.cpp +++ b/src/sql/Expr.cpp @@ -18,6 +18,7 @@ Expr::Expr(ExprType type) ival(0), ival2(0), datetimeField(kDatetimeNone), + columnType(DataType::UNKNOWN, 0), isBoolLiteral(false), opType(kOpNone), distinct(false){}; @@ -224,6 +225,14 @@ Expr* Expr::makeExtract(DatetimeField datetimeField, Expr* expr) { return e; } +Expr* Expr::makeCast(Expr* expr, ColumnType columnType) { + Expr* e = new Expr(kExprFunctionRef); + e->name = strdup("CAST"); + e->columnType = columnType; + e->expr = expr; + return e; +} + bool Expr::isType(ExprType exprType) const { return exprType == type; } bool Expr::isLiteral() const { diff --git a/src/sql/Expr.h b/src/sql/Expr.h index 0107cb6..6939e3f 100644 --- a/src/sql/Expr.h +++ b/src/sql/Expr.h @@ -4,6 +4,7 @@ #include #include #include +#include "ColumnType.h" namespace hsql { struct SelectStatement; @@ -102,6 +103,7 @@ struct Expr { int64_t ival; int64_t ival2; DatetimeField datetimeField; + ColumnType columnType; bool isBoolLiteral; OperatorType opType; @@ -173,6 +175,8 @@ struct Expr { static Expr* makeInOperator(Expr* expr, SelectStatement* select); static Expr* makeExtract(DatetimeField datetimeField1, Expr* expr); + + static Expr* makeCast(Expr* expr, ColumnType columnType); }; // Zero initializes an Expr object and assigns it to a space in the heap diff --git a/src/sql/statements.cpp b/src/sql/statements.cpp index 104a4d1..b075659 100755 --- a/src/sql/statements.cpp +++ b/src/sql/statements.cpp @@ -54,6 +54,9 @@ namespace hsql { case DataType::TEXT: stream << "TEXT"; break; + case DataType::DATETIME: + stream << "DATETIME"; + break; } return stream; } diff --git a/test/sql_tests.cpp b/test/sql_tests.cpp index 22727c6..f7858cf 100644 --- a/test/sql_tests.cpp +++ b/test/sql_tests.cpp @@ -528,4 +528,20 @@ TEST(CommitTransactionTest) { ASSERT_EQ(transaction_stmt->command, kCommitTransaction); } +TEST(CastAsType) { + + TEST_PARSE_SINGLE_SQL( + "SELECT CAST(ID AS VARCHAR(8)) FROM TEST", + kStmtSelect, + SelectStatement, + result, + stmt); + + ASSERT_TRUE(result.isValid()); + ASSERT_EQ(1, stmt->selectList->size()); + ASSERT_STREQ("CAST", stmt->selectList->front()->name); + ASSERT_EQ(DataType::VARCHAR, stmt->selectList->front()->columnType.data_type); + ASSERT_EQ(8, stmt->selectList->front()->columnType.length); +} + TEST_MAIN();