Warning, file /libraries/kdb/src/parser/generated/sqlparser.cpp was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).
0001 /* A Bison parser, made by GNU Bison 3.0.4. */ 0002 0003 /* Bison implementation for Yacc-like parsers in C 0004 0005 Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. 0006 0007 This program is free software: you can redistribute it and/or modify 0008 it under the terms of the GNU General Public License as published by 0009 the Free Software Foundation, either version 3 of the License, or 0010 (at your option) any later version. 0011 0012 This program is distributed in the hope that it will be useful, 0013 but WITHOUT ANY WARRANTY; without even the implied warranty of 0014 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 0015 GNU General Public License for more details. 0016 0017 You should have received a copy of the GNU General Public License 0018 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 0019 0020 /* As a special exception, you may create a larger work that contains 0021 part or all of the Bison parser skeleton and distribute that work 0022 under terms of your choice, so long as that work isn't itself a 0023 parser generator using the skeleton or a modified version thereof 0024 as a parser skeleton. Alternatively, if you modify or redistribute 0025 the parser skeleton itself, you may (at your option) remove this 0026 special exception, which will cause the skeleton and the resulting 0027 Bison output files to be licensed under the GNU General Public 0028 License without this special exception. 0029 0030 This special exception was added by the Free Software Foundation in 0031 version 2.2 of Bison. */ 0032 0033 /* C LALR(1) parser skeleton written by Richard Stallman, by 0034 simplifying the original so-called "semantic" parser. */ 0035 0036 /* All symbols defined below should begin with yy or YY, to avoid 0037 infringing on user name space. This should be done even for local 0038 variables, as they might otherwise be expanded by user macros. 0039 There are some unavoidable exceptions within include files to 0040 define necessary library symbols; they are noted "INFRINGES ON 0041 USER NAME SPACE" below. */ 0042 0043 /* Identify Bison output. */ 0044 #define YYBISON 1 0045 0046 /* Bison version. */ 0047 #define YYBISON_VERSION "3.0.4" 0048 0049 /* Skeleton name. */ 0050 #define YYSKELETON_NAME "yacc.c" 0051 0052 /* Pure parsers. */ 0053 #define YYPURE 0 0054 0055 /* Push parsers. */ 0056 #define YYPUSH 0 0057 0058 /* Pull parsers. */ 0059 #define YYPULL 1 0060 0061 0062 0063 0064 /* Copy the first part of user declarations. */ 0065 #line 435 "KDbSqlParser.y" /* yacc.c:339 */ 0066 0067 #include <stdio.h> 0068 #include <string.h> 0069 #include <string> 0070 #include <iostream> 0071 #include <limits.h> 0072 //! @todo OK? 0073 #ifdef Q_OS_WIN 0074 //workaround for bug on msvc 0075 # undef LLONG_MIN 0076 #endif 0077 #ifndef LLONG_MAX 0078 # define LLONG_MAX 0x7fffffffffffffffLL 0079 #endif 0080 #ifndef LLONG_MIN 0081 # define LLONG_MIN 0x8000000000000000LL 0082 #endif 0083 #ifndef LLONG_MAX 0084 # define ULLONG_MAX 0xffffffffffffffffLL 0085 #endif 0086 0087 #ifdef _WIN32 0088 # include <malloc.h> 0089 #endif 0090 0091 #include <QObject> 0092 #include <QVariant> 0093 #include <QPoint> 0094 0095 #include "KDbConnection.h" 0096 #include "KDbDateTime.h" 0097 #include "KDbExpression.h" 0098 #include "KDbField.h" 0099 #include "KDbOrderByColumn.h" 0100 #include "KDbParser.h" 0101 #include "KDbParser_p.h" 0102 #include "KDbQuerySchema.h" 0103 #include "KDbQuerySchema_p.h" 0104 #include "KDbSqlTypes.h" 0105 #include "KDbTableSchema.h" 0106 #include "kdb_debug.h" 0107 0108 struct OrderByColumnInternal; 0109 0110 #ifdef Q_OS_SOLARIS 0111 #include <alloca.h> 0112 #endif 0113 0114 QDebug operator<<(QDebug dbg, const KDbExpressionPtr& expr) 0115 { 0116 dbg.nospace() << expr.e; 0117 return dbg.space(); 0118 } 0119 0120 int yylex(); 0121 0122 #define YY_NO_UNPUT 0123 #define YYSTACK_USE_ALLOCA 1 0124 #define YYMAXDEPTH 255 0125 0126 extern "C" 0127 { 0128 int yywrap() 0129 { 0130 return 1; 0131 } 0132 } 0133 0134 0135 #line 136 "sqlparser.cpp" /* yacc.c:339 */ 0136 0137 # ifndef YY_NULLPTR 0138 # if defined __cplusplus && 201103L <= __cplusplus 0139 # define YY_NULLPTR nullptr 0140 # else 0141 # define YY_NULLPTR 0 0142 # endif 0143 # endif 0144 0145 /* Enabling verbose error messages. */ 0146 #ifdef YYERROR_VERBOSE 0147 # undef YYERROR_VERBOSE 0148 # define YYERROR_VERBOSE 1 0149 #else 0150 # define YYERROR_VERBOSE 0 0151 #endif 0152 0153 /* In a future release of Bison, this section will be replaced 0154 by #include "KDbSqlParser.tab.h". */ 0155 #ifndef YY_YY_KDBSQLPARSER_TAB_H_INCLUDED 0156 # define YY_YY_KDBSQLPARSER_TAB_H_INCLUDED 0157 /* Debug traces. */ 0158 #ifndef YYDEBUG 0159 # define YYDEBUG 0 0160 #endif 0161 #if YYDEBUG 0162 extern int yydebug; 0163 #endif 0164 0165 /* Token type. */ 0166 #ifndef YYTOKENTYPE 0167 # define YYTOKENTYPE 0168 enum yytokentype 0169 { 0170 SQL_TYPE = 258, 0171 AS = 259, 0172 AS_EMPTY = 260, 0173 ASC = 261, 0174 AUTO_INCREMENT = 262, 0175 BIT = 263, 0176 BITWISE_SHIFT_LEFT = 264, 0177 BITWISE_SHIFT_RIGHT = 265, 0178 BY = 266, 0179 CHARACTER_STRING_LITERAL = 267, 0180 CONCATENATION = 268, 0181 CREATE = 269, 0182 DESC = 270, 0183 DISTINCT = 271, 0184 DOUBLE_QUOTED_STRING = 272, 0185 FROM = 273, 0186 JOIN = 274, 0187 KEY = 275, 0188 LEFT = 276, 0189 LESS_OR_EQUAL = 277, 0190 GREATER_OR_EQUAL = 278, 0191 SQL_NULL = 279, 0192 SQL_IS = 280, 0193 SQL_IS_NULL = 281, 0194 SQL_IS_NOT_NULL = 282, 0195 ORDER = 283, 0196 PRIMARY = 284, 0197 SELECT = 285, 0198 INTEGER_CONST = 286, 0199 REAL_CONST = 287, 0200 RIGHT = 288, 0201 SQL_ON = 289, 0202 DATE_CONST = 290, 0203 DATETIME_CONST = 291, 0204 TIME_CONST = 292, 0205 TABLE = 293, 0206 IDENTIFIER = 294, 0207 IDENTIFIER_DOT_ASTERISK = 295, 0208 QUERY_PARAMETER = 296, 0209 VARCHAR = 297, 0210 WHERE = 298, 0211 SQL = 299, 0212 SQL_TRUE = 300, 0213 SQL_FALSE = 301, 0214 UNION = 302, 0215 SCAN_ERROR = 303, 0216 AND = 304, 0217 BETWEEN = 305, 0218 NOT_BETWEEN = 306, 0219 EXCEPT = 307, 0220 SQL_IN = 308, 0221 INTERSECT = 309, 0222 LIKE = 310, 0223 ILIKE = 311, 0224 NOT_LIKE = 312, 0225 NOT = 313, 0226 NOT_EQUAL = 314, 0227 NOT_EQUAL2 = 315, 0228 OR = 316, 0229 SIMILAR_TO = 317, 0230 NOT_SIMILAR_TO = 318, 0231 XOR = 319, 0232 UMINUS = 320, 0233 TABS_OR_SPACES = 321, 0234 DATE_TIME_INTEGER = 322, 0235 TIME_AM = 323, 0236 TIME_PM = 324 0237 }; 0238 #endif 0239 0240 /* Value type. */ 0241 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 0242 0243 union YYSTYPE 0244 { 0245 #line 505 "KDbSqlParser.y" /* yacc.c:355 */ 0246 0247 QString* stringValue; 0248 QByteArray* binaryValue; 0249 qint64 integerValue; 0250 bool booleanValue; 0251 KDbDate* dateValue; 0252 KDbYear* yearValue; 0253 KDbTime* timeValue; 0254 KDbTime::Period timePeriodValue; 0255 KDbDateTime* dateTimeValue; 0256 KDbOrderByColumn::SortOrder sortOrderValue; 0257 KDbField::Type colType; 0258 KDbField *field; 0259 KDbExpression *expr; 0260 KDbNArgExpression *exprList; 0261 KDbConstExpression *constExpression; 0262 KDbQuerySchema *querySchema; 0263 SelectOptionsInternal *selectOptions; 0264 QList<OrderByColumnInternal> *orderByColumns; 0265 QVariant *variantValue; 0266 0267 #line 268 "sqlparser.cpp" /* yacc.c:355 */ 0268 }; 0269 0270 typedef union YYSTYPE YYSTYPE; 0271 # define YYSTYPE_IS_TRIVIAL 1 0272 # define YYSTYPE_IS_DECLARED 1 0273 #endif 0274 0275 0276 extern YYSTYPE yylval; 0277 0278 int yyparse (void); 0279 0280 #endif /* !YY_YY_KDBSQLPARSER_TAB_H_INCLUDED */ 0281 0282 /* Copy the second part of user declarations. */ 0283 0284 #line 285 "sqlparser.cpp" /* yacc.c:358 */ 0285 0286 #ifdef short 0287 # undef short 0288 #endif 0289 0290 #ifdef YYTYPE_UINT8 0291 typedef YYTYPE_UINT8 yytype_uint8; 0292 #else 0293 typedef unsigned char yytype_uint8; 0294 #endif 0295 0296 #ifdef YYTYPE_INT8 0297 typedef YYTYPE_INT8 yytype_int8; 0298 #else 0299 typedef signed char yytype_int8; 0300 #endif 0301 0302 #ifdef YYTYPE_UINT16 0303 typedef YYTYPE_UINT16 yytype_uint16; 0304 #else 0305 typedef unsigned short int yytype_uint16; 0306 #endif 0307 0308 #ifdef YYTYPE_INT16 0309 typedef YYTYPE_INT16 yytype_int16; 0310 #else 0311 typedef short int yytype_int16; 0312 #endif 0313 0314 #ifndef YYSIZE_T 0315 # ifdef __SIZE_TYPE__ 0316 # define YYSIZE_T __SIZE_TYPE__ 0317 # elif defined size_t 0318 # define YYSIZE_T size_t 0319 # elif ! defined YYSIZE_T 0320 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 0321 # define YYSIZE_T size_t 0322 # else 0323 # define YYSIZE_T unsigned int 0324 # endif 0325 #endif 0326 0327 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 0328 0329 #ifndef YY_ 0330 # if defined YYENABLE_NLS && YYENABLE_NLS 0331 # if ENABLE_NLS 0332 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 0333 # define YY_(Msgid) dgettext ("bison-runtime", Msgid) 0334 # endif 0335 # endif 0336 # ifndef YY_ 0337 # define YY_(Msgid) Msgid 0338 # endif 0339 #endif 0340 0341 #ifndef YY_ATTRIBUTE 0342 # if (defined __GNUC__ \ 0343 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ 0344 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C 0345 # define YY_ATTRIBUTE(Spec) __attribute__(Spec) 0346 # else 0347 # define YY_ATTRIBUTE(Spec) /* empty */ 0348 # endif 0349 #endif 0350 0351 #ifndef YY_ATTRIBUTE_PURE 0352 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) 0353 #endif 0354 0355 #ifndef YY_ATTRIBUTE_UNUSED 0356 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) 0357 #endif 0358 0359 #if !defined _Noreturn \ 0360 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) 0361 # if defined _MSC_VER && 1200 <= _MSC_VER 0362 # define _Noreturn __declspec (noreturn) 0363 # else 0364 # define _Noreturn YY_ATTRIBUTE ((__noreturn__)) 0365 # endif 0366 #endif 0367 0368 /* Suppress unused-variable warnings by "using" E. */ 0369 #if ! defined lint || defined __GNUC__ 0370 # define YYUSE(E) ((void) (E)) 0371 #else 0372 # define YYUSE(E) /* empty */ 0373 #endif 0374 0375 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ 0376 /* Suppress an incorrect diagnostic about yylval being uninitialized. */ 0377 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 0378 _Pragma ("GCC diagnostic push") \ 0379 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ 0380 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 0381 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ 0382 _Pragma ("GCC diagnostic pop") 0383 #else 0384 # define YY_INITIAL_VALUE(Value) Value 0385 #endif 0386 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 0387 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 0388 # define YY_IGNORE_MAYBE_UNINITIALIZED_END 0389 #endif 0390 #ifndef YY_INITIAL_VALUE 0391 # define YY_INITIAL_VALUE(Value) /* Nothing. */ 0392 #endif 0393 0394 0395 #if ! defined yyoverflow || YYERROR_VERBOSE 0396 0397 /* The parser invokes alloca or malloc; define the necessary symbols. */ 0398 0399 # ifdef YYSTACK_USE_ALLOCA 0400 # if YYSTACK_USE_ALLOCA 0401 # ifdef __GNUC__ 0402 # define YYSTACK_ALLOC __builtin_alloca 0403 # elif defined __BUILTIN_VA_ARG_INCR 0404 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 0405 # elif defined _AIX 0406 # define YYSTACK_ALLOC __alloca 0407 # elif defined _MSC_VER 0408 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 0409 # define alloca _alloca 0410 # else 0411 # define YYSTACK_ALLOC alloca 0412 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS 0413 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 0414 /* Use EXIT_SUCCESS as a witness for stdlib.h. */ 0415 # ifndef EXIT_SUCCESS 0416 # define EXIT_SUCCESS 0 0417 # endif 0418 # endif 0419 # endif 0420 # endif 0421 # endif 0422 0423 # ifdef YYSTACK_ALLOC 0424 /* Pacify GCC's 'empty if-body' warning. */ 0425 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 0426 # ifndef YYSTACK_ALLOC_MAXIMUM 0427 /* The OS might guarantee only one guard page at the bottom of the stack, 0428 and a page size can be as small as 4096 bytes. So we cannot safely 0429 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 0430 to allow for a few compiler-allocated temporary stack slots. */ 0431 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 0432 # endif 0433 # else 0434 # define YYSTACK_ALLOC YYMALLOC 0435 # define YYSTACK_FREE YYFREE 0436 # ifndef YYSTACK_ALLOC_MAXIMUM 0437 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 0438 # endif 0439 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 0440 && ! ((defined YYMALLOC || defined malloc) \ 0441 && (defined YYFREE || defined free))) 0442 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 0443 # ifndef EXIT_SUCCESS 0444 # define EXIT_SUCCESS 0 0445 # endif 0446 # endif 0447 # ifndef YYMALLOC 0448 # define YYMALLOC malloc 0449 # if ! defined malloc && ! defined EXIT_SUCCESS 0450 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 0451 # endif 0452 # endif 0453 # ifndef YYFREE 0454 # define YYFREE free 0455 # if ! defined free && ! defined EXIT_SUCCESS 0456 void free (void *); /* INFRINGES ON USER NAME SPACE */ 0457 # endif 0458 # endif 0459 # endif 0460 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 0461 0462 0463 #if (! defined yyoverflow \ 0464 && (! defined __cplusplus \ 0465 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 0466 0467 /* A type that is properly aligned for any stack member. */ 0468 union yyalloc 0469 { 0470 yytype_int16 yyss_alloc; 0471 YYSTYPE yyvs_alloc; 0472 }; 0473 0474 /* The size of the maximum gap between one aligned stack and the next. */ 0475 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 0476 0477 /* The size of an array large to enough to hold all stacks, each with 0478 N elements. */ 0479 # define YYSTACK_BYTES(N) \ 0480 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 0481 + YYSTACK_GAP_MAXIMUM) 0482 0483 # define YYCOPY_NEEDED 1 0484 0485 /* Relocate STACK from its old location to the new one. The 0486 local variables YYSIZE and YYSTACKSIZE give the old and new number of 0487 elements in the stack, and YYPTR gives the new location of the 0488 stack. Advance YYPTR to a properly aligned location for the next 0489 stack. */ 0490 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 0491 do \ 0492 { \ 0493 YYSIZE_T yynewbytes; \ 0494 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 0495 Stack = &yyptr->Stack_alloc; \ 0496 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 0497 yyptr += yynewbytes / sizeof (*yyptr); \ 0498 } \ 0499 while (0) 0500 0501 #endif 0502 0503 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 0504 /* Copy COUNT objects from SRC to DST. The source and destination do 0505 not overlap. */ 0506 # ifndef YYCOPY 0507 # if defined __GNUC__ && 1 < __GNUC__ 0508 # define YYCOPY(Dst, Src, Count) \ 0509 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) 0510 # else 0511 # define YYCOPY(Dst, Src, Count) \ 0512 do \ 0513 { \ 0514 YYSIZE_T yyi; \ 0515 for (yyi = 0; yyi < (Count); yyi++) \ 0516 (Dst)[yyi] = (Src)[yyi]; \ 0517 } \ 0518 while (0) 0519 # endif 0520 # endif 0521 #endif /* !YYCOPY_NEEDED */ 0522 0523 /* YYFINAL -- State number of the termination state. */ 0524 #define YYFINAL 7 0525 /* YYLAST -- Last index in YYTABLE. */ 0526 #define YYLAST 231 0527 0528 /* YYNTOKENS -- Number of terminals. */ 0529 #define YYNTOKENS 88 0530 /* YYNNTS -- Number of nonterminals. */ 0531 #define YYNNTS 38 0532 /* YYNRULES -- Number of rules. */ 0533 #define YYNRULES 119 0534 /* YYNSTATES -- Number of states. */ 0535 #define YYNSTATES 201 0536 0537 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned 0538 by yylex, with out-of-bounds checking. */ 0539 #define YYUNDEFTOK 2 0540 #define YYMAXUTOK 324 0541 0542 #define YYTRANSLATE(YYX) \ 0543 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 0544 0545 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM 0546 as returned by yylex, without out-of-bounds checking. */ 0547 static const yytype_uint8 yytranslate[] = 0548 { 0549 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0550 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0551 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0552 2, 2, 2, 2, 2, 84, 2, 82, 78, 2, 0553 86, 87, 81, 76, 71, 77, 72, 80, 2, 2, 0554 2, 2, 2, 2, 2, 2, 2, 2, 85, 70, 0555 74, 75, 73, 2, 2, 2, 2, 2, 2, 2, 0556 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0557 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0558 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0559 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0560 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0561 2, 2, 2, 2, 79, 2, 83, 2, 2, 2, 0562 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0563 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0564 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0565 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0566 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0567 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0568 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0569 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0570 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0571 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0572 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0573 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0574 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 0575 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0576 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 0577 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 0578 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 0579 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 0580 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 0581 65, 66, 67, 68, 69 0582 }; 0583 0584 #if YYDEBUG 0585 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ 0586 static const yytype_uint16 yyrline[] = 0587 { 0588 0, 564, 564, 574, 578, 579, 594, 693, 699, 706, 0589 711, 717, 723, 729, 738, 746, 753, 759, 767, 778, 0590 787, 796, 806, 814, 826, 832, 839, 846, 850, 857, 0591 862, 869, 875, 882, 887, 893, 899, 905, 911, 918, 0592 923, 929, 935, 941, 947, 953, 959, 965, 975, 986, 0593 991, 996, 1002, 1007, 1013, 1020, 1025, 1031, 1037, 1043, 0594 1049, 1056, 1061, 1067, 1073, 1080, 1086, 1091, 1096, 1101, 0595 1106, 1114, 1120, 1128, 1135, 1142, 1146, 1150, 1156, 1173, 0596 1179, 1185, 1191, 1198, 1202, 1210, 1218, 1229, 1235, 1241, 0597 1250, 1258, 1266, 1278, 1282, 1289, 1293, 1297, 1304, 1314, 0598 1323, 1327, 1334, 1340, 1349, 1394, 1400, 1409, 1437, 1447, 0599 1462, 1469, 1479, 1488, 1493, 1503, 1516, 1562, 1571, 1580 0600 }; 0601 #endif 0602 0603 #if YYDEBUG || YYERROR_VERBOSE || 0 0604 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 0605 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 0606 static const char *const yytname[] = 0607 { 0608 "$end", "error", "$undefined", "SQL_TYPE", "AS", "AS_EMPTY", "ASC", 0609 "AUTO_INCREMENT", "BIT", "BITWISE_SHIFT_LEFT", "BITWISE_SHIFT_RIGHT", 0610 "BY", "CHARACTER_STRING_LITERAL", "CONCATENATION", "CREATE", "DESC", 0611 "DISTINCT", "DOUBLE_QUOTED_STRING", "FROM", "JOIN", "KEY", "LEFT", 0612 "LESS_OR_EQUAL", "GREATER_OR_EQUAL", "SQL_NULL", "SQL_IS", "SQL_IS_NULL", 0613 "SQL_IS_NOT_NULL", "ORDER", "PRIMARY", "SELECT", "INTEGER_CONST", 0614 "REAL_CONST", "RIGHT", "SQL_ON", "DATE_CONST", "DATETIME_CONST", 0615 "TIME_CONST", "TABLE", "IDENTIFIER", "IDENTIFIER_DOT_ASTERISK", 0616 "QUERY_PARAMETER", "VARCHAR", "WHERE", "SQL", "SQL_TRUE", "SQL_FALSE", 0617 "UNION", "SCAN_ERROR", "AND", "BETWEEN", "NOT_BETWEEN", "EXCEPT", 0618 "SQL_IN", "INTERSECT", "LIKE", "ILIKE", "NOT_LIKE", "NOT", "NOT_EQUAL", 0619 "NOT_EQUAL2", "OR", "SIMILAR_TO", "NOT_SIMILAR_TO", "XOR", "UMINUS", 0620 "TABS_OR_SPACES", "DATE_TIME_INTEGER", "TIME_AM", "TIME_PM", "';'", 0621 "','", "'.'", "'>'", "'<'", "'='", "'+'", "'-'", "'&'", "'|'", "'/'", 0622 "'*'", "'%'", "'~'", "'#'", "':'", "'('", "')'", "$accept", 0623 "TopLevelStatement", "StatementList", "Statement", "SelectStatement", 0624 "Select", "SelectOptions", "WhereClause", "OrderByClause", 0625 "OrderByColumnId", "OrderByOption", "aExpr", "aExpr2", "aExpr3", 0626 "aExpr4", "aExpr5", "aExpr6", "aExpr7", "aExpr8", "aExpr9", "DateConst", 0627 "DateValue", "YearConst", "TimeConst", "TimeValue", "TimeMs", 0628 "TimePeriod", "DateTimeConst", "aExpr10", "aExprList", "aExprList2", 0629 "Tables", "FlatTableList", "FlatTable", "ColViews", "ColItem", 0630 "ColExpression", "ColWildCard", YY_NULLPTR 0631 }; 0632 #endif 0633 0634 # ifdef YYPRINT 0635 /* YYTOKNUM[NUM] -- (External) token number corresponding to the 0636 (internal) symbol number NUM (which must be that of a token). */ 0637 static const yytype_uint16 yytoknum[] = 0638 { 0639 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0640 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 0641 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 0642 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 0643 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 0644 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 0645 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 0646 59, 44, 46, 62, 60, 61, 43, 45, 38, 124, 0647 47, 42, 37, 126, 35, 58, 40, 41 0648 }; 0649 # endif 0650 0651 #define YYPACT_NINF -143 0652 0653 #define yypact_value_is_default(Yystate) \ 0654 (!!((Yystate) == (-143))) 0655 0656 #define YYTABLE_NINF -1 0657 0658 #define yytable_value_is_error(Yytable_value) \ 0659 0 0660 0661 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 0662 STATE-NUM. */ 0663 static const yytype_int16 yypact[] = 0664 { 0665 1, -143, 52, -143, -8, -143, 22, -143, 1, -143, 0666 -27, 25, -143, -143, -143, -60, -143, -143, -143, 126, 0667 126, 126, -143, 126, 44, 126, -143, -143, -16, 13, 0668 163, -143, 86, 0, 64, -143, -143, -143, -143, -11, 0669 29, -143, 10, -143, -143, 102, 11, -5, -143, -23, 0670 -2, -143, -21, -143, -143, -143, -143, -61, 4, 26, 0671 -43, 24, 20, 35, 126, 126, 126, 126, 126, 126, 0672 126, 126, -143, -143, 126, 126, 126, 126, 126, 126, 0673 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 0674 126, 126, 126, 96, 126, -143, 84, 78, -143, -11, 0675 74, -143, 38, 98, -143, 25, -143, -143, -143, 71, 0676 48, 110, 89, 99, -143, -143, 101, -143, 103, -143, 0677 -143, -143, -143, -143, -143, -143, -143, -143, -143, 114, 0678 120, -143, -143, -143, -143, -143, -143, -143, -143, -143, 0679 -143, -143, -143, -143, -143, -143, -143, -143, 58, -143, 0680 172, -143, -143, -143, -143, -143, -143, 126, -143, 111, 0681 -12, 112, 115, 121, 126, 126, -143, 128, 144, 12, 0682 58, -143, 63, 134, 137, -48, -143, 138, -143, -143, 0683 167, -143, -143, -143, 58, 136, -143, -143, -143, -143, 0684 139, -143, -143, -143, -143, -143, -143, 58, -48, -143, 0685 -143 0686 }; 0687 0688 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. 0689 Performed when YYTABLE does not specify something else to do. Zero 0690 means the default is an error. */ 0691 static const yytype_uint8 yydefact[] = 0692 { 0693 0, 14, 0, 2, 4, 6, 7, 1, 5, 77, 0694 0, 0, 74, 78, 79, 70, 71, 75, 76, 0, 0695 0, 0, 118, 0, 0, 0, 116, 29, 33, 39, 0696 49, 52, 55, 61, 65, 80, 81, 82, 83, 10, 0697 8, 111, 112, 113, 3, 0, 107, 104, 106, 0, 0698 0, 72, 70, 69, 67, 66, 68, 87, 0, 0, 0699 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0700 0, 0, 50, 51, 0, 0, 0, 0, 0, 0, 0701 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0702 0, 0, 0, 0, 0, 12, 15, 0, 11, 9, 0703 0, 115, 0, 0, 108, 0, 73, 119, 101, 103, 0704 0, 0, 0, 0, 88, 89, 0, 84, 0, 90, 0705 99, 30, 31, 32, 37, 35, 34, 36, 38, 0, 0706 0, 44, 42, 43, 40, 41, 45, 46, 53, 54, 0707 57, 56, 58, 59, 60, 62, 63, 64, 0, 19, 0708 0, 110, 13, 114, 117, 109, 105, 0, 100, 0, 0709 94, 0, 0, 0, 0, 0, 26, 24, 16, 20, 0710 0, 102, 0, 0, 0, 97, 98, 0, 47, 48, 0711 0, 18, 27, 28, 0, 21, 17, 87, 86, 93, 0712 94, 95, 96, 91, 85, 25, 22, 0, 97, 23, 0713 92 0714 }; 0715 0716 /* YYPGOTO[NTERM-NUM]. */ 0717 static const yytype_int16 yypgoto[] = 0718 { 0719 -143, -143, 200, -143, -143, -143, -29, 47, -142, -143, 0720 -143, -25, 87, 106, -73, -143, 32, 107, 90, 108, 0721 -143, -143, 45, -143, 105, 34, 21, -143, -143, -143, 0722 70, 188, -143, 124, -143, 133, 186, -143 0723 }; 0724 0725 /* YYDEFGOTO[NTERM-NUM]. */ 0726 static const yytype_int16 yydefgoto[] = 0727 { 0728 -1, 2, 3, 4, 5, 6, 95, 96, 168, 169, 0729 185, 26, 27, 28, 29, 30, 31, 32, 33, 34, 0730 35, 60, 61, 36, 62, 175, 193, 37, 38, 51, 0731 110, 39, 47, 48, 40, 41, 42, 43 0732 }; 0733 0734 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If 0735 positive, shift that token. If negative, reduce the rule whose 0736 number is the opposite. If YYTABLE_NINF, syntax error. */ 0737 static const yytype_uint8 yytable[] = 0738 { 0739 63, 129, 130, 131, 132, 133, 134, 135, 136, 137, 0740 9, 98, 49, 85, 100, 103, 106, 93, 182, 112, 0741 191, 192, 12, 116, 113, 109, 50, 183, 186, 13, 0742 14, 1, 94, 64, 9, 67, 68, 52, 10, 16, 0743 11, 117, 196, 17, 18, 65, 12, 11, 66, 101, 0744 104, 111, 7, 13, 14, 199, 19, 93, 107, 45, 0745 173, 15, 8, 16, 46, 50, 105, 17, 18, 149, 0746 152, 114, 94, 174, 20, 21, 86, 87, 88, 89, 0747 19, 23, 24, 184, 25, 108, 69, 70, 71, 166, 0748 9, 178, 179, 115, 10, 83, 84, 167, 20, 21, 0749 97, 118, 12, 22, 119, 23, 24, 148, 25, 13, 0750 14, 57, 150, 153, 9, 138, 139, 15, 10, 16, 0751 58, 59, 120, 17, 18, 154, 12, 53, 54, 55, 0752 187, 56, 109, 13, 14, 158, 19, 155, 9, 58, 0753 59, 52, 157, 16, 90, 91, 92, 17, 18, 106, 0754 12, 121, 122, 123, 20, 21, 159, 13, 14, 22, 0755 19, 23, 24, 164, 25, 52, 160, 16, 161, 165, 0756 163, 17, 18, 124, 125, 126, 127, 128, 20, 21, 0757 145, 146, 147, 170, 19, 23, 24, 94, 25, 72, 0758 73, 172, 140, 141, 142, 143, 144, 113, 177, 176, 0759 180, 189, 20, 21, 190, 194, 195, 197, 44, 23, 0760 24, 173, 25, 74, 75, 181, 76, 188, 77, 200, 0761 78, 162, 79, 80, 198, 81, 82, 171, 99, 156, 0762 151, 102 0763 }; 0764 0765 static const yytype_uint8 yycheck[] = 0766 { 0767 25, 74, 75, 76, 77, 78, 79, 80, 81, 82, 0768 12, 40, 72, 13, 4, 4, 39, 28, 6, 80, 0769 68, 69, 24, 66, 85, 50, 86, 15, 170, 31, 0770 32, 30, 43, 49, 12, 22, 23, 39, 16, 41, 0771 18, 84, 184, 45, 46, 61, 24, 18, 64, 39, 0772 39, 72, 0, 31, 32, 197, 58, 28, 81, 86, 0773 72, 39, 70, 41, 39, 86, 71, 45, 46, 94, 0774 99, 67, 43, 85, 76, 77, 76, 77, 78, 79, 0775 58, 83, 84, 71, 86, 87, 73, 74, 75, 31, 0776 12, 164, 165, 67, 16, 9, 10, 39, 76, 77, 0777 71, 77, 24, 81, 84, 83, 84, 11, 86, 31, 0778 32, 67, 28, 39, 12, 83, 84, 39, 16, 41, 0779 76, 77, 87, 45, 46, 87, 24, 19, 20, 21, 0780 67, 23, 157, 31, 32, 87, 58, 39, 12, 76, 0781 77, 39, 71, 41, 80, 81, 82, 45, 46, 39, 0782 24, 64, 65, 66, 76, 77, 67, 31, 32, 81, 0783 58, 83, 84, 49, 86, 39, 67, 41, 67, 49, 0784 67, 45, 46, 67, 68, 69, 70, 71, 76, 77, 0785 90, 91, 92, 11, 58, 83, 84, 43, 86, 26, 0786 27, 80, 85, 86, 87, 88, 89, 85, 77, 84, 0787 72, 67, 76, 77, 67, 67, 39, 71, 8, 83, 0788 84, 72, 86, 50, 51, 168, 53, 172, 55, 198, 0789 57, 116, 59, 60, 190, 62, 63, 157, 40, 105, 0790 97, 45 0791 }; 0792 0793 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 0794 symbol of state STATE-NUM. */ 0795 static const yytype_uint8 yystos[] = 0796 { 0797 0, 30, 89, 90, 91, 92, 93, 0, 70, 12, 0798 16, 18, 24, 31, 32, 39, 41, 45, 46, 58, 0799 76, 77, 81, 83, 84, 86, 99, 100, 101, 102, 0800 103, 104, 105, 106, 107, 108, 111, 115, 116, 119, 0801 122, 123, 124, 125, 90, 86, 39, 120, 121, 72, 0802 86, 117, 39, 107, 107, 107, 107, 67, 76, 77, 0803 109, 110, 112, 99, 49, 61, 64, 22, 23, 73, 0804 74, 75, 26, 27, 50, 51, 53, 55, 57, 59, 0805 60, 62, 63, 9, 10, 13, 76, 77, 78, 79, 0806 80, 81, 82, 28, 43, 94, 95, 71, 94, 119, 0807 4, 39, 124, 4, 39, 71, 39, 81, 87, 99, 0808 118, 72, 80, 85, 67, 67, 66, 84, 77, 84, 0809 87, 100, 100, 100, 101, 101, 101, 101, 101, 102, 0810 102, 102, 102, 102, 102, 102, 102, 102, 104, 104, 0811 105, 105, 105, 105, 105, 106, 106, 106, 11, 99, 0812 28, 123, 94, 39, 87, 39, 121, 71, 87, 67, 0813 67, 67, 112, 67, 49, 49, 31, 39, 96, 97, 0814 11, 118, 80, 72, 85, 113, 84, 77, 102, 102, 0815 72, 95, 6, 15, 71, 98, 96, 67, 110, 67, 0816 67, 68, 69, 114, 67, 39, 96, 71, 113, 96, 0817 114 0818 }; 0819 0820 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 0821 static const yytype_uint8 yyr1[] = 0822 { 0823 0, 88, 89, 90, 90, 90, 91, 92, 92, 92, 0824 92, 92, 92, 92, 93, 94, 94, 94, 94, 95, 0825 96, 96, 96, 96, 97, 97, 97, 98, 98, 99, 0826 100, 100, 100, 100, 101, 101, 101, 101, 101, 101, 0827 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 0828 103, 103, 103, 104, 104, 104, 105, 105, 105, 105, 0829 105, 105, 106, 106, 106, 106, 107, 107, 107, 107, 0830 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 0831 107, 107, 107, 107, 108, 109, 109, 110, 110, 110, 0832 111, 112, 112, 113, 113, 114, 114, 114, 115, 116, 0833 117, 117, 118, 118, 119, 120, 120, 121, 121, 121, 0834 122, 122, 123, 123, 123, 123, 124, 124, 125, 125 0835 }; 0836 0837 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ 0838 static const yytype_uint8 yyr2[] = 0839 { 0840 0, 2, 1, 3, 1, 2, 1, 1, 2, 3, 0841 2, 3, 3, 4, 1, 1, 3, 4, 4, 2, 0842 1, 2, 3, 4, 1, 3, 1, 1, 1, 1, 0843 3, 3, 3, 1, 3, 3, 3, 3, 3, 1, 0844 3, 3, 3, 3, 3, 3, 3, 5, 5, 1, 0845 2, 2, 1, 3, 3, 1, 3, 3, 3, 3, 0846 3, 1, 3, 3, 3, 1, 2, 2, 2, 2, 0847 1, 1, 2, 3, 1, 1, 1, 1, 1, 1, 0848 1, 1, 1, 1, 3, 5, 5, 1, 2, 2, 0849 3, 5, 7, 2, 0, 1, 1, 0, 5, 3, 0850 3, 2, 3, 1, 2, 3, 1, 1, 2, 3, 0851 3, 1, 1, 1, 3, 2, 1, 4, 1, 3 0852 }; 0853 0854 0855 #define yyerrok (yyerrstatus = 0) 0856 #define yyclearin (yychar = YYEMPTY) 0857 #define YYEMPTY (-2) 0858 #define YYEOF 0 0859 0860 #define YYACCEPT goto yyacceptlab 0861 #define YYABORT goto yyabortlab 0862 #define YYERROR goto yyerrorlab 0863 0864 0865 #define YYRECOVERING() (!!yyerrstatus) 0866 0867 #define YYBACKUP(Token, Value) \ 0868 do \ 0869 if (yychar == YYEMPTY) \ 0870 { \ 0871 yychar = (Token); \ 0872 yylval = (Value); \ 0873 YYPOPSTACK (yylen); \ 0874 yystate = *yyssp; \ 0875 goto yybackup; \ 0876 } \ 0877 else \ 0878 { \ 0879 yyerror (YY_("syntax error: cannot back up")); \ 0880 YYERROR; \ 0881 } \ 0882 while (0) 0883 0884 /* Error token number */ 0885 #define YYTERROR 1 0886 #define YYERRCODE 256 0887 0888 0889 0890 /* Enable debugging if requested. */ 0891 #if YYDEBUG 0892 0893 # ifndef YYFPRINTF 0894 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 0895 # define YYFPRINTF fprintf 0896 # endif 0897 0898 # define YYDPRINTF(Args) \ 0899 do { \ 0900 if (yydebug) \ 0901 YYFPRINTF Args; \ 0902 } while (0) 0903 0904 /* This macro is provided for backward compatibility. */ 0905 #ifndef YY_LOCATION_PRINT 0906 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 0907 #endif 0908 0909 0910 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 0911 do { \ 0912 if (yydebug) \ 0913 { \ 0914 YYFPRINTF (stderr, "%s ", Title); \ 0915 yy_symbol_print (stderr, \ 0916 Type, Value); \ 0917 YYFPRINTF (stderr, "\n"); \ 0918 } \ 0919 } while (0) 0920 0921 0922 /*----------------------------------------. 0923 | Print this symbol's value on YYOUTPUT. | 0924 `----------------------------------------*/ 0925 0926 static void 0927 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 0928 { 0929 FILE *yyo = yyoutput; 0930 YYUSE (yyo); 0931 if (!yyvaluep) 0932 return; 0933 # ifdef YYPRINT 0934 if (yytype < YYNTOKENS) 0935 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 0936 # endif 0937 YYUSE (yytype); 0938 } 0939 0940 0941 /*--------------------------------. 0942 | Print this symbol on YYOUTPUT. | 0943 `--------------------------------*/ 0944 0945 static void 0946 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 0947 { 0948 YYFPRINTF (yyoutput, "%s %s (", 0949 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); 0950 0951 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 0952 YYFPRINTF (yyoutput, ")"); 0953 } 0954 0955 /*------------------------------------------------------------------. 0956 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 0957 | TOP (included). | 0958 `------------------------------------------------------------------*/ 0959 0960 static void 0961 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 0962 { 0963 YYFPRINTF (stderr, "Stack now"); 0964 for (; yybottom <= yytop; yybottom++) 0965 { 0966 int yybot = *yybottom; 0967 YYFPRINTF (stderr, " %d", yybot); 0968 } 0969 YYFPRINTF (stderr, "\n"); 0970 } 0971 0972 # define YY_STACK_PRINT(Bottom, Top) \ 0973 do { \ 0974 if (yydebug) \ 0975 yy_stack_print ((Bottom), (Top)); \ 0976 } while (0) 0977 0978 0979 /*------------------------------------------------. 0980 | Report that the YYRULE is going to be reduced. | 0981 `------------------------------------------------*/ 0982 0983 static void 0984 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule) 0985 { 0986 unsigned long int yylno = yyrline[yyrule]; 0987 int yynrhs = yyr2[yyrule]; 0988 int yyi; 0989 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 0990 yyrule - 1, yylno); 0991 /* The symbols being reduced. */ 0992 for (yyi = 0; yyi < yynrhs; yyi++) 0993 { 0994 YYFPRINTF (stderr, " $%d = ", yyi + 1); 0995 yy_symbol_print (stderr, 0996 yystos[yyssp[yyi + 1 - yynrhs]], 0997 &(yyvsp[(yyi + 1) - (yynrhs)]) 0998 ); 0999 YYFPRINTF (stderr, "\n"); 1000 } 1001 } 1002 1003 # define YY_REDUCE_PRINT(Rule) \ 1004 do { \ 1005 if (yydebug) \ 1006 yy_reduce_print (yyssp, yyvsp, Rule); \ 1007 } while (0) 1008 1009 /* Nonzero means print parse trace. It is left uninitialized so that 1010 multiple parsers can coexist. */ 1011 int yydebug; 1012 #else /* !YYDEBUG */ 1013 # define YYDPRINTF(Args) 1014 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1015 # define YY_STACK_PRINT(Bottom, Top) 1016 # define YY_REDUCE_PRINT(Rule) 1017 #endif /* !YYDEBUG */ 1018 1019 1020 /* YYINITDEPTH -- initial size of the parser's stacks. */ 1021 #ifndef YYINITDEPTH 1022 # define YYINITDEPTH 200 1023 #endif 1024 1025 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1026 if the built-in stack extension method is used). 1027 1028 Do not make this value too large; the results are undefined if 1029 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1030 evaluated with infinite-precision integer arithmetic. */ 1031 1032 #ifndef YYMAXDEPTH 1033 # define YYMAXDEPTH 10000 1034 #endif 1035 1036 1037 #if YYERROR_VERBOSE 1038 1039 # ifndef yystrlen 1040 # if defined __GLIBC__ && defined _STRING_H 1041 # define yystrlen strlen 1042 # else 1043 /* Return the length of YYSTR. */ 1044 static YYSIZE_T 1045 yystrlen (const char *yystr) 1046 { 1047 YYSIZE_T yylen; 1048 for (yylen = 0; yystr[yylen]; yylen++) 1049 continue; 1050 return yylen; 1051 } 1052 # endif 1053 # endif 1054 1055 # ifndef yystpcpy 1056 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1057 # define yystpcpy stpcpy 1058 # else 1059 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1060 YYDEST. */ 1061 static char * 1062 yystpcpy (char *yydest, const char *yysrc) 1063 { 1064 char *yyd = yydest; 1065 const char *yys = yysrc; 1066 1067 while ((*yyd++ = *yys++) != '\0') 1068 continue; 1069 1070 return yyd - 1; 1071 } 1072 # endif 1073 # endif 1074 1075 # ifndef yytnamerr 1076 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1077 quotes and backslashes, so that it's suitable for yyerror. The 1078 heuristic is that double-quoting is unnecessary unless the string 1079 contains an apostrophe, a comma, or backslash (other than 1080 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1081 null, do not copy; instead, return the length of what the result 1082 would have been. */ 1083 static YYSIZE_T 1084 yytnamerr (char *yyres, const char *yystr) 1085 { 1086 if (*yystr == '"') 1087 { 1088 YYSIZE_T yyn = 0; 1089 char const *yyp = yystr; 1090 1091 for (;;) 1092 switch (*++yyp) 1093 { 1094 case '\'': 1095 case ',': 1096 goto do_not_strip_quotes; 1097 1098 case '\\': 1099 if (*++yyp != '\\') 1100 goto do_not_strip_quotes; 1101 /* Fall through. */ 1102 default: 1103 if (yyres) 1104 yyres[yyn] = *yyp; 1105 yyn++; 1106 break; 1107 1108 case '"': 1109 if (yyres) 1110 yyres[yyn] = '\0'; 1111 return yyn; 1112 } 1113 do_not_strip_quotes: ; 1114 } 1115 1116 if (! yyres) 1117 return yystrlen (yystr); 1118 1119 return yystpcpy (yyres, yystr) - yyres; 1120 } 1121 # endif 1122 1123 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 1124 about the unexpected token YYTOKEN for the state stack whose top is 1125 YYSSP. 1126 1127 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 1128 not large enough to hold the message. In that case, also set 1129 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 1130 required number of bytes is too large to store. */ 1131 static int 1132 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 1133 yytype_int16 *yyssp, int yytoken) 1134 { 1135 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); 1136 YYSIZE_T yysize = yysize0; 1137 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1138 /* Internationalized format string. */ 1139 const char *yyformat = YY_NULLPTR; 1140 /* Arguments of yyformat. */ 1141 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1142 /* Number of reported tokens (one for the "unexpected", one per 1143 "expected"). */ 1144 int yycount = 0; 1145 1146 /* There are many possibilities here to consider: 1147 - If this state is a consistent state with a default action, then 1148 the only way this function was invoked is if the default action 1149 is an error action. In that case, don't check for expected 1150 tokens because there are none. 1151 - The only way there can be no lookahead present (in yychar) is if 1152 this state is a consistent state with a default action. Thus, 1153 detecting the absence of a lookahead is sufficient to determine 1154 that there is no unexpected or expected token to report. In that 1155 case, just report a simple "syntax error". 1156 - Don't assume there isn't a lookahead just because this state is a 1157 consistent state with a default action. There might have been a 1158 previous inconsistent state, consistent state with a non-default 1159 action, or user semantic action that manipulated yychar. 1160 - Of course, the expected token list depends on states to have 1161 correct lookahead information, and it depends on the parser not 1162 to perform extra reductions after fetching a lookahead from the 1163 scanner and before detecting a syntax error. Thus, state merging 1164 (from LALR or IELR) and default reductions corrupt the expected 1165 token list. However, the list is correct for canonical LR with 1166 one exception: it will still contain any token that will not be 1167 accepted due to an error action in a later state. 1168 */ 1169 if (yytoken != YYEMPTY) 1170 { 1171 int yyn = yypact[*yyssp]; 1172 yyarg[yycount++] = yytname[yytoken]; 1173 if (!yypact_value_is_default (yyn)) 1174 { 1175 /* Start YYX at -YYN if negative to avoid negative indexes in 1176 YYCHECK. In other words, skip the first -YYN actions for 1177 this state because they are default actions. */ 1178 int yyxbegin = yyn < 0 ? -yyn : 0; 1179 /* Stay within bounds of both yycheck and yytname. */ 1180 int yychecklim = YYLAST - yyn + 1; 1181 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1182 int yyx; 1183 1184 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1185 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 1186 && !yytable_value_is_error (yytable[yyx + yyn])) 1187 { 1188 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1189 { 1190 yycount = 1; 1191 yysize = yysize0; 1192 break; 1193 } 1194 yyarg[yycount++] = yytname[yyx]; 1195 { 1196 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); 1197 if (! (yysize <= yysize1 1198 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1199 return 2; 1200 yysize = yysize1; 1201 } 1202 } 1203 } 1204 } 1205 1206 switch (yycount) 1207 { 1208 # define YYCASE_(N, S) \ 1209 case N: \ 1210 yyformat = S; \ 1211 break 1212 YYCASE_(0, YY_("syntax error")); 1213 YYCASE_(1, YY_("syntax error, unexpected %s")); 1214 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 1215 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 1216 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 1217 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 1218 # undef YYCASE_ 1219 } 1220 1221 { 1222 YYSIZE_T yysize1 = yysize + yystrlen (yyformat); 1223 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1224 return 2; 1225 yysize = yysize1; 1226 } 1227 1228 if (*yymsg_alloc < yysize) 1229 { 1230 *yymsg_alloc = 2 * yysize; 1231 if (! (yysize <= *yymsg_alloc 1232 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 1233 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 1234 return 1; 1235 } 1236 1237 /* Avoid sprintf, as that infringes on the user's name space. 1238 Don't have undefined behavior even if the translation 1239 produced a string with the wrong number of "%s"s. */ 1240 { 1241 char *yyp = *yymsg; 1242 int yyi = 0; 1243 while ((*yyp = *yyformat) != '\0') 1244 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 1245 { 1246 yyp += yytnamerr (yyp, yyarg[yyi++]); 1247 yyformat += 2; 1248 } 1249 else 1250 { 1251 yyp++; 1252 yyformat++; 1253 } 1254 } 1255 return 0; 1256 } 1257 #endif /* YYERROR_VERBOSE */ 1258 1259 /*-----------------------------------------------. 1260 | Release the memory associated to this symbol. | 1261 `-----------------------------------------------*/ 1262 1263 static void 1264 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1265 { 1266 YYUSE (yyvaluep); 1267 if (!yymsg) 1268 yymsg = "Deleting"; 1269 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1270 1271 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1272 YYUSE (yytype); 1273 YY_IGNORE_MAYBE_UNINITIALIZED_END 1274 } 1275 1276 1277 1278 1279 /* The lookahead symbol. */ 1280 int yychar; 1281 1282 /* The semantic value of the lookahead symbol. */ 1283 YYSTYPE yylval; 1284 /* Number of syntax errors so far. */ 1285 int yynerrs; 1286 1287 1288 /*----------. 1289 | yyparse. | 1290 `----------*/ 1291 1292 int 1293 yyparse (void) 1294 { 1295 int yystate; 1296 /* Number of tokens to shift before error messages enabled. */ 1297 int yyerrstatus; 1298 1299 /* The stacks and their tools: 1300 'yyss': related to states. 1301 'yyvs': related to semantic values. 1302 1303 Refer to the stacks through separate pointers, to allow yyoverflow 1304 to reallocate them elsewhere. */ 1305 1306 /* The state stack. */ 1307 yytype_int16 yyssa[YYINITDEPTH]; 1308 yytype_int16 *yyss; 1309 yytype_int16 *yyssp; 1310 1311 /* The semantic value stack. */ 1312 YYSTYPE yyvsa[YYINITDEPTH]; 1313 YYSTYPE *yyvs; 1314 YYSTYPE *yyvsp; 1315 1316 YYSIZE_T yystacksize; 1317 1318 int yyn; 1319 int yyresult; 1320 /* Lookahead token as an internal (translated) token number. */ 1321 int yytoken = 0; 1322 /* The variables used to return semantic value and location from the 1323 action routines. */ 1324 YYSTYPE yyval; 1325 1326 #if YYERROR_VERBOSE 1327 /* Buffer for error messages, and its allocated size. */ 1328 char yymsgbuf[128]; 1329 char *yymsg = yymsgbuf; 1330 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1331 #endif 1332 1333 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1334 1335 /* The number of symbols on the RHS of the reduced rule. 1336 Keep to zero when no symbol should be popped. */ 1337 int yylen = 0; 1338 1339 yyssp = yyss = yyssa; 1340 yyvsp = yyvs = yyvsa; 1341 yystacksize = YYINITDEPTH; 1342 1343 YYDPRINTF ((stderr, "Starting parse\n")); 1344 1345 yystate = 0; 1346 yyerrstatus = 0; 1347 yynerrs = 0; 1348 yychar = YYEMPTY; /* Cause a token to be read. */ 1349 goto yysetstate; 1350 1351 /*------------------------------------------------------------. 1352 | yynewstate -- Push a new state, which is found in yystate. | 1353 `------------------------------------------------------------*/ 1354 yynewstate: 1355 /* In all cases, when you get here, the value and location stacks 1356 have just been pushed. So pushing a state here evens the stacks. */ 1357 yyssp++; 1358 1359 yysetstate: 1360 *yyssp = yystate; 1361 1362 if (yyss + yystacksize - 1 <= yyssp) 1363 { 1364 /* Get the current used size of the three stacks, in elements. */ 1365 YYSIZE_T yysize = yyssp - yyss + 1; 1366 1367 #ifdef yyoverflow 1368 { 1369 /* Give user a chance to reallocate the stack. Use copies of 1370 these so that the &'s don't force the real ones into 1371 memory. */ 1372 YYSTYPE *yyvs1 = yyvs; 1373 yytype_int16 *yyss1 = yyss; 1374 1375 /* Each stack pointer address is followed by the size of the 1376 data in use in that stack, in bytes. This used to be a 1377 conditional around just the two extra args, but that might 1378 be undefined if yyoverflow is a macro. */ 1379 yyoverflow (YY_("memory exhausted"), 1380 &yyss1, yysize * sizeof (*yyssp), 1381 &yyvs1, yysize * sizeof (*yyvsp), 1382 &yystacksize); 1383 1384 yyss = yyss1; 1385 yyvs = yyvs1; 1386 } 1387 #else /* no yyoverflow */ 1388 # ifndef YYSTACK_RELOCATE 1389 goto yyexhaustedlab; 1390 # else 1391 /* Extend the stack our own way. */ 1392 if (YYMAXDEPTH <= yystacksize) 1393 goto yyexhaustedlab; 1394 yystacksize *= 2; 1395 if (YYMAXDEPTH < yystacksize) 1396 yystacksize = YYMAXDEPTH; 1397 1398 { 1399 yytype_int16 *yyss1 = yyss; 1400 union yyalloc *yyptr = 1401 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1402 if (! yyptr) 1403 goto yyexhaustedlab; 1404 YYSTACK_RELOCATE (yyss_alloc, yyss); 1405 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1406 # undef YYSTACK_RELOCATE 1407 if (yyss1 != yyssa) 1408 YYSTACK_FREE (yyss1); 1409 } 1410 # endif 1411 #endif /* no yyoverflow */ 1412 1413 yyssp = yyss + yysize - 1; 1414 yyvsp = yyvs + yysize - 1; 1415 1416 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1417 (unsigned long int) yystacksize)); 1418 1419 if (yyss + yystacksize - 1 <= yyssp) 1420 YYABORT; 1421 } 1422 1423 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1424 1425 if (yystate == YYFINAL) 1426 YYACCEPT; 1427 1428 goto yybackup; 1429 1430 /*-----------. 1431 | yybackup. | 1432 `-----------*/ 1433 yybackup: 1434 1435 /* Do appropriate processing given the current state. Read a 1436 lookahead token if we need one and don't already have one. */ 1437 1438 /* First try to decide what to do without reference to lookahead token. */ 1439 yyn = yypact[yystate]; 1440 if (yypact_value_is_default (yyn)) 1441 goto yydefault; 1442 1443 /* Not known => get a lookahead token if don't already have one. */ 1444 1445 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1446 if (yychar == YYEMPTY) 1447 { 1448 YYDPRINTF ((stderr, "Reading a token: ")); 1449 yychar = yylex (); 1450 } 1451 1452 if (yychar <= YYEOF) 1453 { 1454 yychar = yytoken = YYEOF; 1455 YYDPRINTF ((stderr, "Now at end of input.\n")); 1456 } 1457 else 1458 { 1459 yytoken = YYTRANSLATE (yychar); 1460 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1461 } 1462 1463 /* If the proper action on seeing token YYTOKEN is to reduce or to 1464 detect an error, take that action. */ 1465 yyn += yytoken; 1466 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1467 goto yydefault; 1468 yyn = yytable[yyn]; 1469 if (yyn <= 0) 1470 { 1471 if (yytable_value_is_error (yyn)) 1472 goto yyerrlab; 1473 yyn = -yyn; 1474 goto yyreduce; 1475 } 1476 1477 /* Count tokens shifted since error; after three, turn off error 1478 status. */ 1479 if (yyerrstatus) 1480 yyerrstatus--; 1481 1482 /* Shift the lookahead token. */ 1483 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1484 1485 /* Discard the shifted token. */ 1486 yychar = YYEMPTY; 1487 1488 yystate = yyn; 1489 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1490 *++yyvsp = yylval; 1491 YY_IGNORE_MAYBE_UNINITIALIZED_END 1492 1493 goto yynewstate; 1494 1495 1496 /*-----------------------------------------------------------. 1497 | yydefault -- do the default action for the current state. | 1498 `-----------------------------------------------------------*/ 1499 yydefault: 1500 yyn = yydefact[yystate]; 1501 if (yyn == 0) 1502 goto yyerrlab; 1503 goto yyreduce; 1504 1505 1506 /*-----------------------------. 1507 | yyreduce -- Do a reduction. | 1508 `-----------------------------*/ 1509 yyreduce: 1510 /* yyn is the number of a rule to reduce with. */ 1511 yylen = yyr2[yyn]; 1512 1513 /* If YYLEN is nonzero, implement the default value of the action: 1514 '$$ = $1'. 1515 1516 Otherwise, the following line sets YYVAL to garbage. 1517 This behavior is undocumented and Bison 1518 users should not rely upon it. Assigning to YYVAL 1519 unconditionally makes the parser a bit smaller, and it avoids a 1520 GCC warning that YYVAL may be used uninitialized. */ 1521 yyval = yyvsp[1-yylen]; 1522 1523 1524 YY_REDUCE_PRINT (yyn); 1525 switch (yyn) 1526 { 1527 case 2: 1528 #line 565 "KDbSqlParser.y" /* yacc.c:1646 */ 1529 { 1530 //todo: multiple statements 1531 //todo: not only "select" statements 1532 KDbParserPrivate::get(globalParser)->setStatementType(KDbParser::Select); 1533 KDbParserPrivate::get(globalParser)->setQuerySchema((yyvsp[0].querySchema)); 1534 } 1535 #line 1536 "sqlparser.cpp" /* yacc.c:1646 */ 1536 break; 1537 1538 case 3: 1539 #line 575 "KDbSqlParser.y" /* yacc.c:1646 */ 1540 { 1541 //todo: multiple statements 1542 } 1543 #line 1544 "sqlparser.cpp" /* yacc.c:1646 */ 1544 break; 1545 1546 case 5: 1547 #line 580 "KDbSqlParser.y" /* yacc.c:1646 */ 1548 { 1549 (yyval.querySchema) = (yyvsp[-1].querySchema); 1550 } 1551 #line 1552 "sqlparser.cpp" /* yacc.c:1646 */ 1552 break; 1553 1554 case 6: 1555 #line 595 "KDbSqlParser.y" /* yacc.c:1646 */ 1556 { 1557 (yyval.querySchema) = (yyvsp[0].querySchema); 1558 } 1559 #line 1560 "sqlparser.cpp" /* yacc.c:1646 */ 1560 break; 1561 1562 case 7: 1563 #line 694 "KDbSqlParser.y" /* yacc.c:1646 */ 1564 { 1565 sqlParserDebug() << "Select"; 1566 if (!((yyval.querySchema) = buildSelectQuery( (yyvsp[0].querySchema), nullptr ))) 1567 YYABORT; 1568 } 1569 #line 1570 "sqlparser.cpp" /* yacc.c:1646 */ 1570 break; 1571 1572 case 8: 1573 #line 700 "KDbSqlParser.y" /* yacc.c:1646 */ 1574 { 1575 sqlParserDebug() << "Select ColViews=" << *(yyvsp[0].exprList); 1576 1577 if (!((yyval.querySchema) = buildSelectQuery( (yyvsp[-1].querySchema), (yyvsp[0].exprList) ))) 1578 YYABORT; 1579 } 1580 #line 1581 "sqlparser.cpp" /* yacc.c:1646 */ 1581 break; 1582 1583 case 9: 1584 #line 707 "KDbSqlParser.y" /* yacc.c:1646 */ 1585 { 1586 if (!((yyval.querySchema) = buildSelectQuery( (yyvsp[-2].querySchema), (yyvsp[-1].exprList), (yyvsp[0].exprList) ))) 1587 YYABORT; 1588 } 1589 #line 1590 "sqlparser.cpp" /* yacc.c:1646 */ 1590 break; 1591 1592 case 10: 1593 #line 712 "KDbSqlParser.y" /* yacc.c:1646 */ 1594 { 1595 sqlParserDebug() << "Select ColViews Tables"; 1596 if (!((yyval.querySchema) = buildSelectQuery( (yyvsp[-1].querySchema), nullptr, (yyvsp[0].exprList) ))) 1597 YYABORT; 1598 } 1599 #line 1600 "sqlparser.cpp" /* yacc.c:1646 */ 1600 break; 1601 1602 case 11: 1603 #line 718 "KDbSqlParser.y" /* yacc.c:1646 */ 1604 { 1605 sqlParserDebug() << "Select ColViews Conditions"; 1606 if (!((yyval.querySchema) = buildSelectQuery( (yyvsp[-2].querySchema), (yyvsp[-1].exprList), nullptr, (yyvsp[0].selectOptions) ))) 1607 YYABORT; 1608 } 1609 #line 1610 "sqlparser.cpp" /* yacc.c:1646 */ 1610 break; 1611 1612 case 12: 1613 #line 724 "KDbSqlParser.y" /* yacc.c:1646 */ 1614 { 1615 sqlParserDebug() << "Select Tables SelectOptions"; 1616 if (!((yyval.querySchema) = buildSelectQuery( (yyvsp[-2].querySchema), nullptr, (yyvsp[-1].exprList), (yyvsp[0].selectOptions) ))) 1617 YYABORT; 1618 } 1619 #line 1620 "sqlparser.cpp" /* yacc.c:1646 */ 1620 break; 1621 1622 case 13: 1623 #line 730 "KDbSqlParser.y" /* yacc.c:1646 */ 1624 { 1625 sqlParserDebug() << "Select ColViews Tables SelectOptions"; 1626 if (!((yyval.querySchema) = buildSelectQuery( (yyvsp[-3].querySchema), (yyvsp[-2].exprList), (yyvsp[-1].exprList), (yyvsp[0].selectOptions) ))) 1627 YYABORT; 1628 } 1629 #line 1630 "sqlparser.cpp" /* yacc.c:1646 */ 1630 break; 1631 1632 case 14: 1633 #line 739 "KDbSqlParser.y" /* yacc.c:1646 */ 1634 { 1635 sqlParserDebug() << "SELECT"; 1636 (yyval.querySchema) = KDbParserPrivate::get(globalParser)->createQuery(); 1637 } 1638 #line 1639 "sqlparser.cpp" /* yacc.c:1646 */ 1639 break; 1640 1641 case 15: 1642 #line 747 "KDbSqlParser.y" /* yacc.c:1646 */ 1643 { 1644 sqlParserDebug() << "WhereClause"; 1645 (yyval.selectOptions) = new SelectOptionsInternal; 1646 (yyval.selectOptions)->whereExpr = *(yyvsp[0].expr); 1647 delete (yyvsp[0].expr); 1648 } 1649 #line 1650 "sqlparser.cpp" /* yacc.c:1646 */ 1650 break; 1651 1652 case 16: 1653 #line 754 "KDbSqlParser.y" /* yacc.c:1646 */ 1654 { 1655 sqlParserDebug() << "OrderByClause"; 1656 (yyval.selectOptions) = new SelectOptionsInternal; 1657 (yyval.selectOptions)->orderByColumns = (yyvsp[0].orderByColumns); 1658 } 1659 #line 1660 "sqlparser.cpp" /* yacc.c:1646 */ 1660 break; 1661 1662 case 17: 1663 #line 760 "KDbSqlParser.y" /* yacc.c:1646 */ 1664 { 1665 sqlParserDebug() << "WhereClause ORDER BY OrderByClause"; 1666 (yyval.selectOptions) = new SelectOptionsInternal; 1667 (yyval.selectOptions)->whereExpr = *(yyvsp[-3].expr); 1668 delete (yyvsp[-3].expr); 1669 (yyval.selectOptions)->orderByColumns = (yyvsp[0].orderByColumns); 1670 } 1671 #line 1672 "sqlparser.cpp" /* yacc.c:1646 */ 1672 break; 1673 1674 case 18: 1675 #line 768 "KDbSqlParser.y" /* yacc.c:1646 */ 1676 { 1677 sqlParserDebug() << "OrderByClause WhereClause"; 1678 (yyval.selectOptions) = new SelectOptionsInternal; 1679 (yyval.selectOptions)->whereExpr = *(yyvsp[0].expr); 1680 delete (yyvsp[0].expr); 1681 (yyval.selectOptions)->orderByColumns = (yyvsp[-1].orderByColumns); 1682 } 1683 #line 1684 "sqlparser.cpp" /* yacc.c:1646 */ 1684 break; 1685 1686 case 19: 1687 #line 779 "KDbSqlParser.y" /* yacc.c:1646 */ 1688 { 1689 (yyval.expr) = (yyvsp[0].expr); 1690 } 1691 #line 1692 "sqlparser.cpp" /* yacc.c:1646 */ 1692 break; 1693 1694 case 20: 1695 #line 788 "KDbSqlParser.y" /* yacc.c:1646 */ 1696 { 1697 sqlParserDebug() << "ORDER BY IDENTIFIER"; 1698 (yyval.orderByColumns) = new QList<OrderByColumnInternal>; 1699 OrderByColumnInternal orderByColumn; 1700 orderByColumn.setColumnByNameOrNumber( *(yyvsp[0].variantValue) ); 1701 (yyval.orderByColumns)->append( orderByColumn ); 1702 delete (yyvsp[0].variantValue); 1703 } 1704 #line 1705 "sqlparser.cpp" /* yacc.c:1646 */ 1705 break; 1706 1707 case 21: 1708 #line 797 "KDbSqlParser.y" /* yacc.c:1646 */ 1709 { 1710 sqlParserDebug() << "ORDER BY IDENTIFIER OrderByOption"; 1711 (yyval.orderByColumns) = new QList<OrderByColumnInternal>; 1712 OrderByColumnInternal orderByColumn; 1713 orderByColumn.setColumnByNameOrNumber( *(yyvsp[-1].variantValue) ); 1714 orderByColumn.order = (yyvsp[0].sortOrderValue); 1715 (yyval.orderByColumns)->append( orderByColumn ); 1716 delete (yyvsp[-1].variantValue); 1717 } 1718 #line 1719 "sqlparser.cpp" /* yacc.c:1646 */ 1719 break; 1720 1721 case 22: 1722 #line 807 "KDbSqlParser.y" /* yacc.c:1646 */ 1723 { 1724 (yyval.orderByColumns) = (yyvsp[0].orderByColumns); 1725 OrderByColumnInternal orderByColumn; 1726 orderByColumn.setColumnByNameOrNumber( *(yyvsp[-2].variantValue) ); 1727 (yyval.orderByColumns)->append( orderByColumn ); 1728 delete (yyvsp[-2].variantValue); 1729 } 1730 #line 1731 "sqlparser.cpp" /* yacc.c:1646 */ 1731 break; 1732 1733 case 23: 1734 #line 815 "KDbSqlParser.y" /* yacc.c:1646 */ 1735 { 1736 (yyval.orderByColumns) = (yyvsp[0].orderByColumns); 1737 OrderByColumnInternal orderByColumn; 1738 orderByColumn.setColumnByNameOrNumber( *(yyvsp[-3].variantValue) ); 1739 orderByColumn.order = (yyvsp[-2].sortOrderValue); 1740 (yyval.orderByColumns)->append( orderByColumn ); 1741 delete (yyvsp[-3].variantValue); 1742 } 1743 #line 1744 "sqlparser.cpp" /* yacc.c:1646 */ 1744 break; 1745 1746 case 24: 1747 #line 827 "KDbSqlParser.y" /* yacc.c:1646 */ 1748 { 1749 (yyval.variantValue) = new QVariant( *(yyvsp[0].stringValue) ); 1750 sqlParserDebug() << "OrderByColumnId: " << *(yyval.variantValue); 1751 delete (yyvsp[0].stringValue); 1752 } 1753 #line 1754 "sqlparser.cpp" /* yacc.c:1646 */ 1754 break; 1755 1756 case 25: 1757 #line 833 "KDbSqlParser.y" /* yacc.c:1646 */ 1758 { 1759 (yyval.variantValue) = new QVariant( *(yyvsp[-2].stringValue) + QLatin1Char('.') + *(yyvsp[0].stringValue) ); 1760 sqlParserDebug() << "OrderByColumnId: " << *(yyval.variantValue); 1761 delete (yyvsp[-2].stringValue); 1762 delete (yyvsp[0].stringValue); 1763 } 1764 #line 1765 "sqlparser.cpp" /* yacc.c:1646 */ 1765 break; 1766 1767 case 26: 1768 #line 840 "KDbSqlParser.y" /* yacc.c:1646 */ 1769 { 1770 (yyval.variantValue) = new QVariant((yyvsp[0].integerValue)); 1771 sqlParserDebug() << "OrderByColumnId: " << *(yyval.variantValue); 1772 } 1773 #line 1774 "sqlparser.cpp" /* yacc.c:1646 */ 1774 break; 1775 1776 case 27: 1777 #line 847 "KDbSqlParser.y" /* yacc.c:1646 */ 1778 { 1779 (yyval.sortOrderValue) = KDbOrderByColumn::SortOrder::Ascending; 1780 } 1781 #line 1782 "sqlparser.cpp" /* yacc.c:1646 */ 1782 break; 1783 1784 case 28: 1785 #line 851 "KDbSqlParser.y" /* yacc.c:1646 */ 1786 { 1787 (yyval.sortOrderValue) = KDbOrderByColumn::SortOrder::Descending; 1788 } 1789 #line 1790 "sqlparser.cpp" /* yacc.c:1646 */ 1790 break; 1791 1792 case 30: 1793 #line 863 "KDbSqlParser.y" /* yacc.c:1646 */ 1794 { 1795 // sqlParserDebug() << "AND " << $3.debugString(); 1796 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), KDbToken::AND, *(yyvsp[0].expr)); 1797 delete (yyvsp[-2].expr); 1798 delete (yyvsp[0].expr); 1799 } 1800 #line 1801 "sqlparser.cpp" /* yacc.c:1646 */ 1801 break; 1802 1803 case 31: 1804 #line 870 "KDbSqlParser.y" /* yacc.c:1646 */ 1805 { 1806 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), KDbToken::OR, *(yyvsp[0].expr)); 1807 delete (yyvsp[-2].expr); 1808 delete (yyvsp[0].expr); 1809 } 1810 #line 1811 "sqlparser.cpp" /* yacc.c:1646 */ 1811 break; 1812 1813 case 32: 1814 #line 876 "KDbSqlParser.y" /* yacc.c:1646 */ 1815 { 1816 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), KDbToken::XOR, *(yyvsp[0].expr)); 1817 delete (yyvsp[-2].expr); 1818 delete (yyvsp[0].expr); 1819 } 1820 #line 1821 "sqlparser.cpp" /* yacc.c:1646 */ 1821 break; 1822 1823 case 34: 1824 #line 888 "KDbSqlParser.y" /* yacc.c:1646 */ 1825 { 1826 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), '>', *(yyvsp[0].expr)); 1827 delete (yyvsp[-2].expr); 1828 delete (yyvsp[0].expr); 1829 } 1830 #line 1831 "sqlparser.cpp" /* yacc.c:1646 */ 1831 break; 1832 1833 case 35: 1834 #line 894 "KDbSqlParser.y" /* yacc.c:1646 */ 1835 { 1836 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), KDbToken::GREATER_OR_EQUAL, *(yyvsp[0].expr)); 1837 delete (yyvsp[-2].expr); 1838 delete (yyvsp[0].expr); 1839 } 1840 #line 1841 "sqlparser.cpp" /* yacc.c:1646 */ 1841 break; 1842 1843 case 36: 1844 #line 900 "KDbSqlParser.y" /* yacc.c:1646 */ 1845 { 1846 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), '<', *(yyvsp[0].expr)); 1847 delete (yyvsp[-2].expr); 1848 delete (yyvsp[0].expr); 1849 } 1850 #line 1851 "sqlparser.cpp" /* yacc.c:1646 */ 1851 break; 1852 1853 case 37: 1854 #line 906 "KDbSqlParser.y" /* yacc.c:1646 */ 1855 { 1856 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), KDbToken::LESS_OR_EQUAL, *(yyvsp[0].expr)); 1857 delete (yyvsp[-2].expr); 1858 delete (yyvsp[0].expr); 1859 } 1860 #line 1861 "sqlparser.cpp" /* yacc.c:1646 */ 1861 break; 1862 1863 case 38: 1864 #line 912 "KDbSqlParser.y" /* yacc.c:1646 */ 1865 { 1866 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), '=', *(yyvsp[0].expr)); 1867 delete (yyvsp[-2].expr); 1868 delete (yyvsp[0].expr); 1869 } 1870 #line 1871 "sqlparser.cpp" /* yacc.c:1646 */ 1871 break; 1872 1873 case 40: 1874 #line 924 "KDbSqlParser.y" /* yacc.c:1646 */ 1875 { 1876 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), KDbToken::NOT_EQUAL, *(yyvsp[0].expr)); 1877 delete (yyvsp[-2].expr); 1878 delete (yyvsp[0].expr); 1879 } 1880 #line 1881 "sqlparser.cpp" /* yacc.c:1646 */ 1881 break; 1882 1883 case 41: 1884 #line 930 "KDbSqlParser.y" /* yacc.c:1646 */ 1885 { 1886 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), KDbToken::NOT_EQUAL2, *(yyvsp[0].expr)); 1887 delete (yyvsp[-2].expr); 1888 delete (yyvsp[0].expr); 1889 } 1890 #line 1891 "sqlparser.cpp" /* yacc.c:1646 */ 1891 break; 1892 1893 case 42: 1894 #line 936 "KDbSqlParser.y" /* yacc.c:1646 */ 1895 { 1896 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), KDbToken::LIKE, *(yyvsp[0].expr)); 1897 delete (yyvsp[-2].expr); 1898 delete (yyvsp[0].expr); 1899 } 1900 #line 1901 "sqlparser.cpp" /* yacc.c:1646 */ 1901 break; 1902 1903 case 43: 1904 #line 942 "KDbSqlParser.y" /* yacc.c:1646 */ 1905 { 1906 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), KDbToken::NOT_LIKE, *(yyvsp[0].expr)); 1907 delete (yyvsp[-2].expr); 1908 delete (yyvsp[0].expr); 1909 } 1910 #line 1911 "sqlparser.cpp" /* yacc.c:1646 */ 1911 break; 1912 1913 case 44: 1914 #line 948 "KDbSqlParser.y" /* yacc.c:1646 */ 1915 { 1916 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), KDbToken::SQL_IN, *(yyvsp[0].expr)); 1917 delete (yyvsp[-2].expr); 1918 delete (yyvsp[0].expr); 1919 } 1920 #line 1921 "sqlparser.cpp" /* yacc.c:1646 */ 1921 break; 1922 1923 case 45: 1924 #line 954 "KDbSqlParser.y" /* yacc.c:1646 */ 1925 { 1926 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), KDbToken::SIMILAR_TO, *(yyvsp[0].expr)); 1927 delete (yyvsp[-2].expr); 1928 delete (yyvsp[0].expr); 1929 } 1930 #line 1931 "sqlparser.cpp" /* yacc.c:1646 */ 1931 break; 1932 1933 case 46: 1934 #line 960 "KDbSqlParser.y" /* yacc.c:1646 */ 1935 { 1936 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), KDbToken::NOT_SIMILAR_TO, *(yyvsp[0].expr)); 1937 delete (yyvsp[-2].expr); 1938 delete (yyvsp[0].expr); 1939 } 1940 #line 1941 "sqlparser.cpp" /* yacc.c:1646 */ 1941 break; 1942 1943 case 47: 1944 #line 966 "KDbSqlParser.y" /* yacc.c:1646 */ 1945 { 1946 (yyval.expr) = new KDbNArgExpression(KDb::RelationalExpression, KDbToken::BETWEEN_AND); 1947 (yyval.expr)->toNArg().append( *(yyvsp[-4].expr) ); 1948 (yyval.expr)->toNArg().append( *(yyvsp[-2].expr) ); 1949 (yyval.expr)->toNArg().append( *(yyvsp[0].expr) ); 1950 delete (yyvsp[-4].expr); 1951 delete (yyvsp[-2].expr); 1952 delete (yyvsp[0].expr); 1953 } 1954 #line 1955 "sqlparser.cpp" /* yacc.c:1646 */ 1955 break; 1956 1957 case 48: 1958 #line 976 "KDbSqlParser.y" /* yacc.c:1646 */ 1959 { 1960 (yyval.expr) = new KDbNArgExpression(KDb::RelationalExpression, KDbToken::NOT_BETWEEN_AND); 1961 (yyval.expr)->toNArg().append( *(yyvsp[-4].expr) ); 1962 (yyval.expr)->toNArg().append( *(yyvsp[-2].expr) ); 1963 (yyval.expr)->toNArg().append( *(yyvsp[0].expr) ); 1964 delete (yyvsp[-4].expr); 1965 delete (yyvsp[-2].expr); 1966 delete (yyvsp[0].expr); 1967 } 1968 #line 1969 "sqlparser.cpp" /* yacc.c:1646 */ 1969 break; 1970 1971 case 50: 1972 #line 992 "KDbSqlParser.y" /* yacc.c:1646 */ 1973 { 1974 (yyval.expr) = new KDbUnaryExpression( KDbToken::SQL_IS_NULL, *(yyvsp[-1].expr) ); 1975 delete (yyvsp[-1].expr); 1976 } 1977 #line 1978 "sqlparser.cpp" /* yacc.c:1646 */ 1978 break; 1979 1980 case 51: 1981 #line 997 "KDbSqlParser.y" /* yacc.c:1646 */ 1982 { 1983 (yyval.expr) = new KDbUnaryExpression( KDbToken::SQL_IS_NOT_NULL, *(yyvsp[-1].expr) ); 1984 delete (yyvsp[-1].expr); 1985 } 1986 #line 1987 "sqlparser.cpp" /* yacc.c:1646 */ 1987 break; 1988 1989 case 53: 1990 #line 1008 "KDbSqlParser.y" /* yacc.c:1646 */ 1991 { 1992 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), KDbToken::BITWISE_SHIFT_LEFT, *(yyvsp[0].expr)); 1993 delete (yyvsp[-2].expr); 1994 delete (yyvsp[0].expr); 1995 } 1996 #line 1997 "sqlparser.cpp" /* yacc.c:1646 */ 1997 break; 1998 1999 case 54: 2000 #line 1014 "KDbSqlParser.y" /* yacc.c:1646 */ 2001 { 2002 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), KDbToken::BITWISE_SHIFT_RIGHT, *(yyvsp[0].expr)); 2003 delete (yyvsp[-2].expr); 2004 delete (yyvsp[0].expr); 2005 } 2006 #line 2007 "sqlparser.cpp" /* yacc.c:1646 */ 2007 break; 2008 2009 case 56: 2010 #line 1026 "KDbSqlParser.y" /* yacc.c:1646 */ 2011 { 2012 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), '+', *(yyvsp[0].expr)); 2013 delete (yyvsp[-2].expr); 2014 delete (yyvsp[0].expr); 2015 } 2016 #line 2017 "sqlparser.cpp" /* yacc.c:1646 */ 2017 break; 2018 2019 case 57: 2020 #line 1032 "KDbSqlParser.y" /* yacc.c:1646 */ 2021 { 2022 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), KDbToken::CONCATENATION, *(yyvsp[0].expr)); 2023 delete (yyvsp[-2].expr); 2024 delete (yyvsp[0].expr); 2025 } 2026 #line 2027 "sqlparser.cpp" /* yacc.c:1646 */ 2027 break; 2028 2029 case 58: 2030 #line 1038 "KDbSqlParser.y" /* yacc.c:1646 */ 2031 { 2032 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), '-', *(yyvsp[0].expr)); 2033 delete (yyvsp[-2].expr); 2034 delete (yyvsp[0].expr); 2035 } 2036 #line 2037 "sqlparser.cpp" /* yacc.c:1646 */ 2037 break; 2038 2039 case 59: 2040 #line 1044 "KDbSqlParser.y" /* yacc.c:1646 */ 2041 { 2042 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), '&', *(yyvsp[0].expr)); 2043 delete (yyvsp[-2].expr); 2044 delete (yyvsp[0].expr); 2045 } 2046 #line 2047 "sqlparser.cpp" /* yacc.c:1646 */ 2047 break; 2048 2049 case 60: 2050 #line 1050 "KDbSqlParser.y" /* yacc.c:1646 */ 2051 { 2052 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), '|', *(yyvsp[0].expr)); 2053 delete (yyvsp[-2].expr); 2054 delete (yyvsp[0].expr); 2055 } 2056 #line 2057 "sqlparser.cpp" /* yacc.c:1646 */ 2057 break; 2058 2059 case 62: 2060 #line 1062 "KDbSqlParser.y" /* yacc.c:1646 */ 2061 { 2062 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), '/', *(yyvsp[0].expr)); 2063 delete (yyvsp[-2].expr); 2064 delete (yyvsp[0].expr); 2065 } 2066 #line 2067 "sqlparser.cpp" /* yacc.c:1646 */ 2067 break; 2068 2069 case 63: 2070 #line 1068 "KDbSqlParser.y" /* yacc.c:1646 */ 2071 { 2072 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), '*', *(yyvsp[0].expr)); 2073 delete (yyvsp[-2].expr); 2074 delete (yyvsp[0].expr); 2075 } 2076 #line 2077 "sqlparser.cpp" /* yacc.c:1646 */ 2077 break; 2078 2079 case 64: 2080 #line 1074 "KDbSqlParser.y" /* yacc.c:1646 */ 2081 { 2082 (yyval.expr) = new KDbBinaryExpression(*(yyvsp[-2].expr), '%', *(yyvsp[0].expr)); 2083 delete (yyvsp[-2].expr); 2084 delete (yyvsp[0].expr); 2085 } 2086 #line 2087 "sqlparser.cpp" /* yacc.c:1646 */ 2087 break; 2088 2089 case 66: 2090 #line 1087 "KDbSqlParser.y" /* yacc.c:1646 */ 2091 { 2092 (yyval.expr) = new KDbUnaryExpression( '-', *(yyvsp[0].expr) ); 2093 delete (yyvsp[0].expr); 2094 } 2095 #line 2096 "sqlparser.cpp" /* yacc.c:1646 */ 2096 break; 2097 2098 case 67: 2099 #line 1092 "KDbSqlParser.y" /* yacc.c:1646 */ 2100 { 2101 (yyval.expr) = new KDbUnaryExpression( '+', *(yyvsp[0].expr) ); 2102 delete (yyvsp[0].expr); 2103 } 2104 #line 2105 "sqlparser.cpp" /* yacc.c:1646 */ 2105 break; 2106 2107 case 68: 2108 #line 1097 "KDbSqlParser.y" /* yacc.c:1646 */ 2109 { 2110 (yyval.expr) = new KDbUnaryExpression( '~', *(yyvsp[0].expr) ); 2111 delete (yyvsp[0].expr); 2112 } 2113 #line 2114 "sqlparser.cpp" /* yacc.c:1646 */ 2114 break; 2115 2116 case 69: 2117 #line 1102 "KDbSqlParser.y" /* yacc.c:1646 */ 2118 { 2119 (yyval.expr) = new KDbUnaryExpression( KDbToken::NOT, *(yyvsp[0].expr) ); 2120 delete (yyvsp[0].expr); 2121 } 2122 #line 2123 "sqlparser.cpp" /* yacc.c:1646 */ 2123 break; 2124 2125 case 70: 2126 #line 1107 "KDbSqlParser.y" /* yacc.c:1646 */ 2127 { 2128 (yyval.expr) = new KDbVariableExpression( *(yyvsp[0].stringValue) ); 2129 2130 //! @todo simplify this later if that's 'only one field name' expression 2131 sqlParserDebug() << " + identifier: " << *(yyvsp[0].stringValue); 2132 delete (yyvsp[0].stringValue); 2133 } 2134 #line 2135 "sqlparser.cpp" /* yacc.c:1646 */ 2135 break; 2136 2137 case 71: 2138 #line 1115 "KDbSqlParser.y" /* yacc.c:1646 */ 2139 { 2140 (yyval.expr) = new KDbQueryParameterExpression( *(yyvsp[0].stringValue) ); 2141 sqlParserDebug() << " + query parameter:" << *(yyval.expr); 2142 delete (yyvsp[0].stringValue); 2143 } 2144 #line 2145 "sqlparser.cpp" /* yacc.c:1646 */ 2145 break; 2146 2147 case 72: 2148 #line 1121 "KDbSqlParser.y" /* yacc.c:1646 */ 2149 { 2150 sqlParserDebug() << " + function:" << *(yyvsp[-1].stringValue) << "(" << *(yyvsp[0].exprList) << ")"; 2151 (yyval.expr) = new KDbFunctionExpression(*(yyvsp[-1].stringValue), *(yyvsp[0].exprList)); 2152 delete (yyvsp[-1].stringValue); 2153 delete (yyvsp[0].exprList); 2154 } 2155 #line 2156 "sqlparser.cpp" /* yacc.c:1646 */ 2156 break; 2157 2158 case 73: 2159 #line 1129 "KDbSqlParser.y" /* yacc.c:1646 */ 2160 { 2161 (yyval.expr) = new KDbVariableExpression( *(yyvsp[-2].stringValue) + QLatin1Char('.') + *(yyvsp[0].stringValue) ); 2162 sqlParserDebug() << " + identifier.identifier:" << *(yyvsp[-2].stringValue) << "." << *(yyvsp[0].stringValue); 2163 delete (yyvsp[-2].stringValue); 2164 delete (yyvsp[0].stringValue); 2165 } 2166 #line 2167 "sqlparser.cpp" /* yacc.c:1646 */ 2167 break; 2168 2169 case 74: 2170 #line 1136 "KDbSqlParser.y" /* yacc.c:1646 */ 2171 { 2172 (yyval.expr) = new KDbConstExpression( KDbToken::SQL_NULL, QVariant() ); 2173 sqlParserDebug() << " + NULL"; 2174 // $$ = new KDbField(); 2175 //$$->setName(QString::null); 2176 } 2177 #line 2178 "sqlparser.cpp" /* yacc.c:1646 */ 2178 break; 2179 2180 case 75: 2181 #line 1143 "KDbSqlParser.y" /* yacc.c:1646 */ 2182 { 2183 (yyval.expr) = new KDbConstExpression( KDbToken::SQL_TRUE, true ); 2184 } 2185 #line 2186 "sqlparser.cpp" /* yacc.c:1646 */ 2186 break; 2187 2188 case 76: 2189 #line 1147 "KDbSqlParser.y" /* yacc.c:1646 */ 2190 { 2191 (yyval.expr) = new KDbConstExpression( KDbToken::SQL_FALSE, false ); 2192 } 2193 #line 2194 "sqlparser.cpp" /* yacc.c:1646 */ 2194 break; 2195 2196 case 77: 2197 #line 1151 "KDbSqlParser.y" /* yacc.c:1646 */ 2198 { 2199 (yyval.expr) = new KDbConstExpression( KDbToken::CHARACTER_STRING_LITERAL, *(yyvsp[0].stringValue) ); 2200 sqlParserDebug() << " + constant " << (yyvsp[0].stringValue); 2201 delete (yyvsp[0].stringValue); 2202 } 2203 #line 2204 "sqlparser.cpp" /* yacc.c:1646 */ 2204 break; 2205 2206 case 78: 2207 #line 1157 "KDbSqlParser.y" /* yacc.c:1646 */ 2208 { 2209 QVariant val; 2210 if ((yyvsp[0].integerValue) <= INT_MAX && (yyvsp[0].integerValue) >= INT_MIN) 2211 val = (int)(yyvsp[0].integerValue); 2212 else if ((yyvsp[0].integerValue) <= UINT_MAX && (yyvsp[0].integerValue) >= 0) 2213 val = (uint)(yyvsp[0].integerValue); 2214 else if ((yyvsp[0].integerValue) <= LLONG_MAX && (yyvsp[0].integerValue) >= LLONG_MIN) 2215 val = (qint64)(yyvsp[0].integerValue); 2216 2217 // if ($1 < ULLONG_MAX) 2218 // val = (quint64)$1; 2219 //! @todo ok? 2220 2221 (yyval.expr) = new KDbConstExpression( KDbToken::INTEGER_CONST, val ); 2222 sqlParserDebug() << " + int constant: " << val.toString(); 2223 } 2224 #line 2225 "sqlparser.cpp" /* yacc.c:1646 */ 2225 break; 2226 2227 case 79: 2228 #line 1174 "KDbSqlParser.y" /* yacc.c:1646 */ 2229 { 2230 (yyval.expr) = new KDbConstExpression( KDbToken::REAL_CONST, *(yyvsp[0].binaryValue) ); 2231 sqlParserDebug() << " + real constant: " << *(yyvsp[0].binaryValue); 2232 delete (yyvsp[0].binaryValue); 2233 } 2234 #line 2235 "sqlparser.cpp" /* yacc.c:1646 */ 2235 break; 2236 2237 case 80: 2238 #line 1180 "KDbSqlParser.y" /* yacc.c:1646 */ 2239 { 2240 (yyval.expr) = new KDbConstExpression(KDbToken::DATE_CONST, QVariant::fromValue(*(yyvsp[0].dateValue))); 2241 sqlParserDebug() << " + date constant:" << *(yyvsp[0].dateValue); 2242 delete (yyvsp[0].dateValue); 2243 } 2244 #line 2245 "sqlparser.cpp" /* yacc.c:1646 */ 2245 break; 2246 2247 case 81: 2248 #line 1186 "KDbSqlParser.y" /* yacc.c:1646 */ 2249 { 2250 (yyval.expr) = new KDbConstExpression(KDbToken::TIME_CONST, QVariant::fromValue(*(yyvsp[0].timeValue))); 2251 sqlParserDebug() << " + time constant:" << *(yyvsp[0].timeValue); 2252 delete (yyvsp[0].timeValue); 2253 } 2254 #line 2255 "sqlparser.cpp" /* yacc.c:1646 */ 2255 break; 2256 2257 case 82: 2258 #line 1192 "KDbSqlParser.y" /* yacc.c:1646 */ 2259 { 2260 (yyval.expr) = new KDbConstExpression(KDbToken::DATETIME_CONST, QVariant::fromValue(*(yyvsp[0].dateTimeValue))); 2261 sqlParserDebug() << " + datetime constant:" << *(yyvsp[0].dateTimeValue); 2262 delete (yyvsp[0].dateTimeValue); 2263 } 2264 #line 2265 "sqlparser.cpp" /* yacc.c:1646 */ 2265 break; 2266 2267 case 84: 2268 #line 1203 "KDbSqlParser.y" /* yacc.c:1646 */ 2269 { 2270 (yyval.dateValue) = (yyvsp[-1].dateValue); 2271 sqlParserDebug() << "DateConst:" << *(yyval.dateValue); 2272 } 2273 #line 2274 "sqlparser.cpp" /* yacc.c:1646 */ 2274 break; 2275 2276 case 85: 2277 #line 1211 "KDbSqlParser.y" /* yacc.c:1646 */ 2278 { 2279 (yyval.dateValue) = new KDbDate(*(yyvsp[-4].yearValue), *(yyvsp[-2].binaryValue), *(yyvsp[0].binaryValue)); 2280 sqlParserDebug() << "DateValue:" << *(yyval.dateValue); 2281 delete (yyvsp[-4].yearValue); 2282 delete (yyvsp[-2].binaryValue); 2283 delete (yyvsp[0].binaryValue); 2284 } 2285 #line 2286 "sqlparser.cpp" /* yacc.c:1646 */ 2286 break; 2287 2288 case 86: 2289 #line 1219 "KDbSqlParser.y" /* yacc.c:1646 */ 2290 { 2291 (yyval.dateValue) = new KDbDate(*(yyvsp[0].yearValue), *(yyvsp[-4].binaryValue), *(yyvsp[-2].binaryValue)); 2292 sqlParserDebug() << "DateValue:" << *(yyval.dateValue); 2293 delete (yyvsp[-4].binaryValue); 2294 delete (yyvsp[-2].binaryValue); 2295 delete (yyvsp[0].yearValue); 2296 } 2297 #line 2298 "sqlparser.cpp" /* yacc.c:1646 */ 2298 break; 2299 2300 case 87: 2301 #line 1230 "KDbSqlParser.y" /* yacc.c:1646 */ 2302 { 2303 (yyval.yearValue) = new KDbYear(KDbYear::Sign::None, *(yyvsp[0].binaryValue)); 2304 sqlParserDebug() << "YearConst:" << *(yyval.yearValue); 2305 delete (yyvsp[0].binaryValue); 2306 } 2307 #line 2308 "sqlparser.cpp" /* yacc.c:1646 */ 2308 break; 2309 2310 case 88: 2311 #line 1236 "KDbSqlParser.y" /* yacc.c:1646 */ 2312 { 2313 (yyval.yearValue) = new KDbYear(KDbYear::Sign::Plus, *(yyvsp[0].binaryValue)); 2314 sqlParserDebug() << "YearConst:" << *(yyval.yearValue); 2315 delete (yyvsp[0].binaryValue); 2316 } 2317 #line 2318 "sqlparser.cpp" /* yacc.c:1646 */ 2318 break; 2319 2320 case 89: 2321 #line 1242 "KDbSqlParser.y" /* yacc.c:1646 */ 2322 { 2323 (yyval.yearValue) = new KDbYear(KDbYear::Sign::Minus, *(yyvsp[0].binaryValue)); 2324 sqlParserDebug() << "YearConst:" << *(yyval.yearValue); 2325 delete (yyvsp[0].binaryValue); 2326 } 2327 #line 2328 "sqlparser.cpp" /* yacc.c:1646 */ 2328 break; 2329 2330 case 90: 2331 #line 1251 "KDbSqlParser.y" /* yacc.c:1646 */ 2332 { 2333 (yyval.timeValue) = (yyvsp[-1].timeValue); 2334 sqlParserDebug() << "TimeConst:" << *(yyval.timeValue); 2335 } 2336 #line 2337 "sqlparser.cpp" /* yacc.c:1646 */ 2337 break; 2338 2339 case 91: 2340 #line 1259 "KDbSqlParser.y" /* yacc.c:1646 */ 2341 { 2342 (yyval.timeValue) = new KDbTime(*(yyvsp[-4].binaryValue), *(yyvsp[-2].binaryValue), {}, *(yyvsp[-1].binaryValue), (yyvsp[0].timePeriodValue)); 2343 sqlParserDebug() << "TimeValue:" << *(yyval.timeValue); 2344 delete (yyvsp[-4].binaryValue); 2345 delete (yyvsp[-2].binaryValue); 2346 delete (yyvsp[-1].binaryValue); 2347 } 2348 #line 2349 "sqlparser.cpp" /* yacc.c:1646 */ 2349 break; 2350 2351 case 92: 2352 #line 1267 "KDbSqlParser.y" /* yacc.c:1646 */ 2353 { 2354 (yyval.timeValue) = new KDbTime(*(yyvsp[-6].binaryValue), *(yyvsp[-4].binaryValue), *(yyvsp[-2].binaryValue), *(yyvsp[-1].binaryValue), (yyvsp[0].timePeriodValue)); 2355 sqlParserDebug() << "TimeValue:" << *(yyval.timeValue); 2356 delete (yyvsp[-6].binaryValue); 2357 delete (yyvsp[-4].binaryValue); 2358 delete (yyvsp[-2].binaryValue); 2359 delete (yyvsp[-1].binaryValue); 2360 } 2361 #line 2362 "sqlparser.cpp" /* yacc.c:1646 */ 2362 break; 2363 2364 case 93: 2365 #line 1279 "KDbSqlParser.y" /* yacc.c:1646 */ 2366 { 2367 (yyval.binaryValue) = (yyvsp[0].binaryValue); 2368 } 2369 #line 2370 "sqlparser.cpp" /* yacc.c:1646 */ 2370 break; 2371 2372 case 94: 2373 #line 1283 "KDbSqlParser.y" /* yacc.c:1646 */ 2374 { 2375 (yyval.binaryValue) = new QByteArray; 2376 } 2377 #line 2378 "sqlparser.cpp" /* yacc.c:1646 */ 2378 break; 2379 2380 case 95: 2381 #line 1290 "KDbSqlParser.y" /* yacc.c:1646 */ 2382 { 2383 (yyval.timePeriodValue) = KDbTime::Period::Am; 2384 } 2385 #line 2386 "sqlparser.cpp" /* yacc.c:1646 */ 2386 break; 2387 2388 case 96: 2389 #line 1294 "KDbSqlParser.y" /* yacc.c:1646 */ 2390 { 2391 (yyval.timePeriodValue) = KDbTime::Period::Pm; 2392 } 2393 #line 2394 "sqlparser.cpp" /* yacc.c:1646 */ 2394 break; 2395 2396 case 97: 2397 #line 1298 "KDbSqlParser.y" /* yacc.c:1646 */ 2398 { 2399 (yyval.timePeriodValue) = KDbTime::Period::None; 2400 } 2401 #line 2402 "sqlparser.cpp" /* yacc.c:1646 */ 2402 break; 2403 2404 case 98: 2405 #line 1305 "KDbSqlParser.y" /* yacc.c:1646 */ 2406 { 2407 (yyval.dateTimeValue) = new KDbDateTime(*(yyvsp[-3].dateValue), *(yyvsp[-1].timeValue)); 2408 sqlParserDebug() << "DateTimeConst:" << *(yyval.dateTimeValue); 2409 delete (yyvsp[-3].dateValue); 2410 delete (yyvsp[-1].timeValue); 2411 } 2412 #line 2413 "sqlparser.cpp" /* yacc.c:1646 */ 2413 break; 2414 2415 case 99: 2416 #line 1315 "KDbSqlParser.y" /* yacc.c:1646 */ 2417 { 2418 sqlParserDebug() << "(expr)"; 2419 (yyval.expr) = new KDbUnaryExpression('(', *(yyvsp[-1].expr)); 2420 delete (yyvsp[-1].expr); 2421 } 2422 #line 2423 "sqlparser.cpp" /* yacc.c:1646 */ 2423 break; 2424 2425 case 100: 2426 #line 1324 "KDbSqlParser.y" /* yacc.c:1646 */ 2427 { 2428 (yyval.exprList) = (yyvsp[-1].exprList); 2429 } 2430 #line 2431 "sqlparser.cpp" /* yacc.c:1646 */ 2431 break; 2432 2433 case 101: 2434 #line 1328 "KDbSqlParser.y" /* yacc.c:1646 */ 2435 { 2436 (yyval.exprList) = new KDbNArgExpression(KDb::ArgumentListExpression, ','); 2437 } 2438 #line 2439 "sqlparser.cpp" /* yacc.c:1646 */ 2439 break; 2440 2441 case 102: 2442 #line 1335 "KDbSqlParser.y" /* yacc.c:1646 */ 2443 { 2444 (yyval.exprList) = (yyvsp[0].exprList); 2445 (yyval.exprList)->prepend( *(yyvsp[-2].expr) ); 2446 delete (yyvsp[-2].expr); 2447 } 2448 #line 2449 "sqlparser.cpp" /* yacc.c:1646 */ 2449 break; 2450 2451 case 103: 2452 #line 1341 "KDbSqlParser.y" /* yacc.c:1646 */ 2453 { 2454 (yyval.exprList) = new KDbNArgExpression(KDb::ArgumentListExpression, ','); 2455 (yyval.exprList)->append( *(yyvsp[0].expr) ); 2456 delete (yyvsp[0].expr); 2457 } 2458 #line 2459 "sqlparser.cpp" /* yacc.c:1646 */ 2459 break; 2460 2461 case 104: 2462 #line 1350 "KDbSqlParser.y" /* yacc.c:1646 */ 2463 { 2464 (yyval.exprList) = (yyvsp[0].exprList); 2465 } 2466 #line 2467 "sqlparser.cpp" /* yacc.c:1646 */ 2467 break; 2468 2469 case 105: 2470 #line 1395 "KDbSqlParser.y" /* yacc.c:1646 */ 2471 { 2472 (yyval.exprList) = (yyvsp[-2].exprList); 2473 (yyval.exprList)->append(*(yyvsp[0].expr)); 2474 delete (yyvsp[0].expr); 2475 } 2476 #line 2477 "sqlparser.cpp" /* yacc.c:1646 */ 2477 break; 2478 2479 case 106: 2480 #line 1401 "KDbSqlParser.y" /* yacc.c:1646 */ 2481 { 2482 (yyval.exprList) = new KDbNArgExpression(KDb::TableListExpression, KDbToken::IDENTIFIER); //ok? 2483 (yyval.exprList)->append(*(yyvsp[0].expr)); 2484 delete (yyvsp[0].expr); 2485 } 2486 #line 2487 "sqlparser.cpp" /* yacc.c:1646 */ 2487 break; 2488 2489 case 107: 2490 #line 1410 "KDbSqlParser.y" /* yacc.c:1646 */ 2491 { 2492 sqlParserDebug() << "FROM: '" << *(yyvsp[0].stringValue) << "'"; 2493 (yyval.expr) = new KDbVariableExpression(*(yyvsp[0].stringValue)); 2494 2495 //! @todo this isn't ok for more tables: 2496 /* 2497 KDbField::ListIterator it = globalParser->query()->fieldsIterator(); 2498 for(KDbField *item; (item = it.current()); ++it) 2499 { 2500 if(item->table() == dummy) 2501 { 2502 item->setTable(schema); 2503 } 2504 2505 if(item->table() && !item->isQueryAsterisk()) 2506 { 2507 KDbField *f = item->table()->field(item->name()); 2508 if(!f) 2509 { 2510 KDbParserError err(KDbParser::tr("Field List Error"), KDbParser::tr("Unknown column '%1' in table '%2'",item->name(),schema->name()), ctoken, current); 2511 globalParser->setError(err); 2512 yyerror("fieldlisterror"); 2513 } 2514 } 2515 }*/ 2516 delete (yyvsp[0].stringValue); 2517 } 2518 #line 2519 "sqlparser.cpp" /* yacc.c:1646 */ 2519 break; 2520 2521 case 108: 2522 #line 1438 "KDbSqlParser.y" /* yacc.c:1646 */ 2523 { 2524 //table + alias 2525 (yyval.expr) = new KDbBinaryExpression( 2526 KDbVariableExpression(*(yyvsp[-1].stringValue)), KDbToken::AS_EMPTY, 2527 KDbVariableExpression(*(yyvsp[0].stringValue)) 2528 ); 2529 delete (yyvsp[-1].stringValue); 2530 delete (yyvsp[0].stringValue); 2531 } 2532 #line 2533 "sqlparser.cpp" /* yacc.c:1646 */ 2533 break; 2534 2535 case 109: 2536 #line 1448 "KDbSqlParser.y" /* yacc.c:1646 */ 2537 { 2538 //table + alias 2539 (yyval.expr) = new KDbBinaryExpression( 2540 KDbVariableExpression(*(yyvsp[-2].stringValue)), KDbToken::AS, 2541 KDbVariableExpression(*(yyvsp[0].stringValue)) 2542 ); 2543 delete (yyvsp[-2].stringValue); 2544 delete (yyvsp[0].stringValue); 2545 } 2546 #line 2547 "sqlparser.cpp" /* yacc.c:1646 */ 2547 break; 2548 2549 case 110: 2550 #line 1463 "KDbSqlParser.y" /* yacc.c:1646 */ 2551 { 2552 (yyval.exprList) = (yyvsp[-2].exprList); 2553 (yyval.exprList)->append(*(yyvsp[0].expr)); 2554 delete (yyvsp[0].expr); 2555 sqlParserDebug() << "ColViews: ColViews , ColItem"; 2556 } 2557 #line 2558 "sqlparser.cpp" /* yacc.c:1646 */ 2558 break; 2559 2560 case 111: 2561 #line 1470 "KDbSqlParser.y" /* yacc.c:1646 */ 2562 { 2563 (yyval.exprList) = new KDbNArgExpression(KDb::FieldListExpression, KDbToken()); 2564 (yyval.exprList)->append(*(yyvsp[0].expr)); 2565 delete (yyvsp[0].expr); 2566 sqlParserDebug() << "ColViews: ColItem"; 2567 } 2568 #line 2569 "sqlparser.cpp" /* yacc.c:1646 */ 2569 break; 2570 2571 case 112: 2572 #line 1480 "KDbSqlParser.y" /* yacc.c:1646 */ 2573 { 2574 // $$ = new KDbField(); 2575 // dummy->addField($$); 2576 // $$->setExpression( $1 ); 2577 // globalParser->query()->addField($$); 2578 (yyval.expr) = (yyvsp[0].expr); 2579 sqlParserDebug() << " added column expr:" << *(yyvsp[0].expr); 2580 } 2581 #line 2582 "sqlparser.cpp" /* yacc.c:1646 */ 2582 break; 2583 2584 case 113: 2585 #line 1489 "KDbSqlParser.y" /* yacc.c:1646 */ 2586 { 2587 (yyval.expr) = (yyvsp[0].expr); 2588 sqlParserDebug() << " added column wildcard:" << *(yyvsp[0].expr); 2589 } 2590 #line 2591 "sqlparser.cpp" /* yacc.c:1646 */ 2591 break; 2592 2593 case 114: 2594 #line 1494 "KDbSqlParser.y" /* yacc.c:1646 */ 2595 { 2596 (yyval.expr) = new KDbBinaryExpression( 2597 *(yyvsp[-2].expr), KDbToken::AS, 2598 KDbVariableExpression(*(yyvsp[0].stringValue)) 2599 ); 2600 sqlParserDebug() << " added column expr:" << *(yyval.expr); 2601 delete (yyvsp[-2].expr); 2602 delete (yyvsp[0].stringValue); 2603 } 2604 #line 2605 "sqlparser.cpp" /* yacc.c:1646 */ 2605 break; 2606 2607 case 115: 2608 #line 1504 "KDbSqlParser.y" /* yacc.c:1646 */ 2609 { 2610 (yyval.expr) = new KDbBinaryExpression( 2611 *(yyvsp[-1].expr), KDbToken::AS_EMPTY, 2612 KDbVariableExpression(*(yyvsp[0].stringValue)) 2613 ); 2614 sqlParserDebug() << " added column expr:" << *(yyval.expr); 2615 delete (yyvsp[-1].expr); 2616 delete (yyvsp[0].stringValue); 2617 } 2618 #line 2619 "sqlparser.cpp" /* yacc.c:1646 */ 2619 break; 2620 2621 case 116: 2622 #line 1517 "KDbSqlParser.y" /* yacc.c:1646 */ 2623 { 2624 (yyval.expr) = (yyvsp[0].expr); 2625 } 2626 #line 2627 "sqlparser.cpp" /* yacc.c:1646 */ 2627 break; 2628 2629 case 117: 2630 #line 1563 "KDbSqlParser.y" /* yacc.c:1646 */ 2631 { 2632 (yyval.expr) = (yyvsp[-1].expr); 2633 //! @todo DISTINCT '(' ColExpression ')' 2634 // $$->setName("DISTINCT(" + $3->name() + ")"); 2635 } 2636 #line 2637 "sqlparser.cpp" /* yacc.c:1646 */ 2637 break; 2638 2639 case 118: 2640 #line 1572 "KDbSqlParser.y" /* yacc.c:1646 */ 2641 { 2642 (yyval.expr) = new KDbVariableExpression(QLatin1String("*")); 2643 sqlParserDebug() << "all columns"; 2644 2645 // KDbQueryAsterisk *ast = new KDbQueryAsterisk(globalParser->query(), dummy); 2646 // globalParser->query()->addAsterisk(ast); 2647 // requiresTable = true; 2648 } 2649 #line 2650 "sqlparser.cpp" /* yacc.c:1646 */ 2650 break; 2651 2652 case 119: 2653 #line 1581 "KDbSqlParser.y" /* yacc.c:1646 */ 2654 { 2655 QString s( *(yyvsp[-2].stringValue) ); 2656 s += QLatin1String(".*"); 2657 (yyval.expr) = new KDbVariableExpression(s); 2658 sqlParserDebug() << " + all columns from " << s; 2659 delete (yyvsp[-2].stringValue); 2660 } 2661 #line 2662 "sqlparser.cpp" /* yacc.c:1646 */ 2662 break; 2663 2664 2665 #line 2666 "sqlparser.cpp" /* yacc.c:1646 */ 2666 default: break; 2667 } 2668 /* User semantic actions sometimes alter yychar, and that requires 2669 that yytoken be updated with the new translation. We take the 2670 approach of translating immediately before every use of yytoken. 2671 One alternative is translating here after every semantic action, 2672 but that translation would be missed if the semantic action invokes 2673 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 2674 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 2675 incorrect destructor might then be invoked immediately. In the 2676 case of YYERROR or YYBACKUP, subsequent parser actions might lead 2677 to an incorrect destructor call or verbose syntax error message 2678 before the lookahead is translated. */ 2679 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 2680 2681 YYPOPSTACK (yylen); 2682 yylen = 0; 2683 YY_STACK_PRINT (yyss, yyssp); 2684 2685 *++yyvsp = yyval; 2686 2687 /* Now 'shift' the result of the reduction. Determine what state 2688 that goes to, based on the state we popped back to and the rule 2689 number reduced by. */ 2690 2691 yyn = yyr1[yyn]; 2692 2693 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 2694 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 2695 yystate = yytable[yystate]; 2696 else 2697 yystate = yydefgoto[yyn - YYNTOKENS]; 2698 2699 goto yynewstate; 2700 2701 2702 /*--------------------------------------. 2703 | yyerrlab -- here on detecting error. | 2704 `--------------------------------------*/ 2705 yyerrlab: 2706 /* Make sure we have latest lookahead translation. See comments at 2707 user semantic actions for why this is necessary. */ 2708 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 2709 2710 /* If not already recovering from an error, report this error. */ 2711 if (!yyerrstatus) 2712 { 2713 ++yynerrs; 2714 #if ! YYERROR_VERBOSE 2715 yyerror (YY_("syntax error")); 2716 #else 2717 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 2718 yyssp, yytoken) 2719 { 2720 char const *yymsgp = YY_("syntax error"); 2721 int yysyntax_error_status; 2722 yysyntax_error_status = YYSYNTAX_ERROR; 2723 if (yysyntax_error_status == 0) 2724 yymsgp = yymsg; 2725 else if (yysyntax_error_status == 1) 2726 { 2727 if (yymsg != yymsgbuf) 2728 YYSTACK_FREE (yymsg); 2729 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 2730 if (!yymsg) 2731 { 2732 yymsg = yymsgbuf; 2733 yymsg_alloc = sizeof yymsgbuf; 2734 yysyntax_error_status = 2; 2735 } 2736 else 2737 { 2738 yysyntax_error_status = YYSYNTAX_ERROR; 2739 yymsgp = yymsg; 2740 } 2741 } 2742 yyerror (yymsgp); 2743 if (yysyntax_error_status == 2) 2744 goto yyexhaustedlab; 2745 } 2746 # undef YYSYNTAX_ERROR 2747 #endif 2748 } 2749 2750 2751 2752 if (yyerrstatus == 3) 2753 { 2754 /* If just tried and failed to reuse lookahead token after an 2755 error, discard it. */ 2756 2757 if (yychar <= YYEOF) 2758 { 2759 /* Return failure if at end of input. */ 2760 if (yychar == YYEOF) 2761 YYABORT; 2762 } 2763 else 2764 { 2765 yydestruct ("Error: discarding", 2766 yytoken, &yylval); 2767 yychar = YYEMPTY; 2768 } 2769 } 2770 2771 /* Else will try to reuse lookahead token after shifting the error 2772 token. */ 2773 goto yyerrlab1; 2774 2775 2776 /*---------------------------------------------------. 2777 | yyerrorlab -- error raised explicitly by YYERROR. | 2778 `---------------------------------------------------*/ 2779 yyerrorlab: 2780 2781 /* Pacify compilers like GCC when the user code never invokes 2782 YYERROR and the label yyerrorlab therefore never appears in user 2783 code. */ 2784 if (/*CONSTCOND*/ 0) 2785 goto yyerrorlab; 2786 2787 /* Do not reclaim the symbols of the rule whose action triggered 2788 this YYERROR. */ 2789 YYPOPSTACK (yylen); 2790 yylen = 0; 2791 YY_STACK_PRINT (yyss, yyssp); 2792 yystate = *yyssp; 2793 goto yyerrlab1; 2794 2795 2796 /*-------------------------------------------------------------. 2797 | yyerrlab1 -- common code for both syntax error and YYERROR. | 2798 `-------------------------------------------------------------*/ 2799 yyerrlab1: 2800 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2801 2802 for (;;) 2803 { 2804 yyn = yypact[yystate]; 2805 if (!yypact_value_is_default (yyn)) 2806 { 2807 yyn += YYTERROR; 2808 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2809 { 2810 yyn = yytable[yyn]; 2811 if (0 < yyn) 2812 break; 2813 } 2814 } 2815 2816 /* Pop the current state because it cannot handle the error token. */ 2817 if (yyssp == yyss) 2818 YYABORT; 2819 2820 2821 yydestruct ("Error: popping", 2822 yystos[yystate], yyvsp); 2823 YYPOPSTACK (1); 2824 yystate = *yyssp; 2825 YY_STACK_PRINT (yyss, yyssp); 2826 } 2827 2828 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2829 *++yyvsp = yylval; 2830 YY_IGNORE_MAYBE_UNINITIALIZED_END 2831 2832 2833 /* Shift the error token. */ 2834 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2835 2836 yystate = yyn; 2837 goto yynewstate; 2838 2839 2840 /*-------------------------------------. 2841 | yyacceptlab -- YYACCEPT comes here. | 2842 `-------------------------------------*/ 2843 yyacceptlab: 2844 yyresult = 0; 2845 goto yyreturn; 2846 2847 /*-----------------------------------. 2848 | yyabortlab -- YYABORT comes here. | 2849 `-----------------------------------*/ 2850 yyabortlab: 2851 yyresult = 1; 2852 goto yyreturn; 2853 2854 #if !defined yyoverflow || YYERROR_VERBOSE 2855 /*-------------------------------------------------. 2856 | yyexhaustedlab -- memory exhaustion comes here. | 2857 `-------------------------------------------------*/ 2858 yyexhaustedlab: 2859 yyerror (YY_("memory exhausted")); 2860 yyresult = 2; 2861 /* Fall through. */ 2862 #endif 2863 2864 yyreturn: 2865 if (yychar != YYEMPTY) 2866 { 2867 /* Make sure we have latest lookahead translation. See comments at 2868 user semantic actions for why this is necessary. */ 2869 yytoken = YYTRANSLATE (yychar); 2870 yydestruct ("Cleanup: discarding lookahead", 2871 yytoken, &yylval); 2872 } 2873 /* Do not reclaim the symbols of the rule whose action triggered 2874 this YYABORT or YYACCEPT. */ 2875 YYPOPSTACK (yylen); 2876 YY_STACK_PRINT (yyss, yyssp); 2877 while (yyssp != yyss) 2878 { 2879 yydestruct ("Cleanup: popping", 2880 yystos[*yyssp], yyvsp); 2881 YYPOPSTACK (1); 2882 } 2883 #ifndef yyoverflow 2884 if (yyss != yyssa) 2885 YYSTACK_FREE (yyss); 2886 #endif 2887 #if YYERROR_VERBOSE 2888 if (yymsg != yymsgbuf) 2889 YYSTACK_FREE (yymsg); 2890 #endif 2891 return yyresult; 2892 } 2893 #line 1596 "KDbSqlParser.y" /* yacc.c:1906 */ 2894 2895 2896 KDB_TESTING_EXPORT const char* g_tokenName(unsigned int offset) { 2897 const int t = YYTRANSLATE(offset); 2898 if (t >= YYTRANSLATE(::SQL_TYPE)) { 2899 return yytname[t]; 2900 } 2901 return nullptr; 2902 } 2903 2904 //static 2905 const int KDbToken::maxCharTokenValue = 253; 2906 2907 //static 2908 const int KDbToken::maxTokenValue = YYMAXUTOK;