47 #define YYBISON_VERSION "3.0.2"
50 #define YYSKELETON_NAME "yacc.c"
63 #define yyparse execute_parse
64 #define yylex execute_lex
65 #define yyerror execute_error
66 #define yydebug execute_debug
67 #define yynerrs execute_nerrs
71 #line 40 "drizzled/execute/parser.yy"
77 #include "drizzled/execute/common.h"
78 #include <drizzled/execute/scanner.h>
81 #ifndef __INTEL_COMPILER
82 # pragma GCC diagnostic ignored "-Wold-style-cast"
85 #line 70 "drizzled/execute/parser.yy"
88 #define YYENABLE_NLS 0
89 #define YYLTYPE_IS_TRIVIAL 0
92 #define parser_abort(A, B) do { parser::abort_func((A), (B)); YYABORT; } while (0)
94 namespace drizzled {
namespace execute {
class Context; }}
98 if (not context->end())
107 #line 108 "drizzled/execute/parser.cc"
110 # if defined __cplusplus && 201103L <= __cplusplus
111 # define YY_NULLPTR nullptr
113 # define YY_NULLPTR 0
118 #ifdef YYERROR_VERBOSE
119 # undef YYERROR_VERBOSE
120 # define YYERROR_VERBOSE 1
122 # define YYERROR_VERBOSE 1
127 #ifndef YY_EXECUTE_DRIZZLED_EXECUTE_PARSER_H_INCLUDED
128 # define YY_EXECUTE_DRIZZLED_EXECUTE_PARSER_H_INCLUDED
134 extern int execute_debug;
149 #define QUOTED_STRING 259
162 #line 163 "drizzled/execute/parser.cc"
169 typedef YYTYPE_UINT8 yytype_uint8;
171 typedef unsigned char yytype_uint8;
175 typedef YYTYPE_INT8 yytype_int8;
177 typedef signed char yytype_int8;
181 typedef YYTYPE_UINT16 yytype_uint16;
183 typedef unsigned short int yytype_uint16;
187 typedef YYTYPE_INT16 yytype_int16;
189 typedef short int yytype_int16;
193 # ifdef __SIZE_TYPE__
194 # define YYSIZE_T __SIZE_TYPE__
195 # elif defined size_t
196 # define YYSIZE_T size_t
197 # elif ! defined YYSIZE_T
199 # define YYSIZE_T size_t
201 # define YYSIZE_T unsigned int
205 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
208 # if defined YYENABLE_NLS && YYENABLE_NLS
210 # include <libintl.h>
211 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
215 # define YY_(Msgid) Msgid
220 # if (defined __GNUC__ \
221 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
222 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
223 # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
225 # define YY_ATTRIBUTE(Spec)
229 #ifndef YY_ATTRIBUTE_PURE
230 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
233 #ifndef YY_ATTRIBUTE_UNUSED
234 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
237 #if !defined _Noreturn \
238 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
239 # if defined _MSC_VER && 1200 <= _MSC_VER
240 # define _Noreturn __declspec (noreturn)
242 # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
247 #if ! defined lint || defined __GNUC__
248 # define YYUSE(E) ((void) (E))
253 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
255 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
256 _Pragma ("GCC diagnostic push") \
257 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
258 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
259 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
260 _Pragma ("GCC diagnostic pop")
262 # define YY_INITIAL_VALUE(Value) Value
264 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
265 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
266 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
268 #ifndef YY_INITIAL_VALUE
269 # define YY_INITIAL_VALUE(Value)
273 #if ! defined yyoverflow || YYERROR_VERBOSE
277 # ifdef YYSTACK_USE_ALLOCA
278 # if YYSTACK_USE_ALLOCA
280 # define YYSTACK_ALLOC __builtin_alloca
281 # elif defined __BUILTIN_VA_ARG_INCR
284 # define YYSTACK_ALLOC __alloca
285 # elif defined _MSC_VER
287 # define alloca _alloca
289 # define YYSTACK_ALLOC alloca
290 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
293 # ifndef EXIT_SUCCESS
294 # define EXIT_SUCCESS 0
301 # ifdef YYSTACK_ALLOC
303 # define YYSTACK_FREE(Ptr) do { ; } while (0)
304 # ifndef YYSTACK_ALLOC_MAXIMUM
309 # define YYSTACK_ALLOC_MAXIMUM 4032
312 # define YYSTACK_ALLOC YYMALLOC
313 # define YYSTACK_FREE YYFREE
314 # ifndef YYSTACK_ALLOC_MAXIMUM
315 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
317 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
318 && ! ((defined YYMALLOC || defined malloc) \
319 && (defined YYFREE || defined free)))
321 # ifndef EXIT_SUCCESS
322 # define EXIT_SUCCESS 0
326 # define YYMALLOC malloc
327 # if ! defined malloc && ! defined EXIT_SUCCESS
328 void *malloc (YYSIZE_T);
333 # if ! defined free && ! defined EXIT_SUCCESS
341 #if (! defined yyoverflow \
342 && (! defined __cplusplus \
343 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
348 yytype_int16 yyss_alloc;
353 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
357 # define YYSTACK_BYTES(N) \
358 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
359 + YYSTACK_GAP_MAXIMUM)
361 # define YYCOPY_NEEDED 1
368 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
371 YYSIZE_T yynewbytes; \
372 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
373 Stack = &yyptr->Stack_alloc; \
374 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
375 yyptr += yynewbytes / sizeof (*yyptr); \
381 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
385 # if defined __GNUC__ && 1 < __GNUC__
386 # define YYCOPY(Dst, Src, Count) \
387 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
389 # define YYCOPY(Dst, Src, Count) \
393 for (yyi = 0; yyi < (Count); yyi++) \
394 (Dst)[yyi] = (Src)[yyi]; \
418 #define YYMAXUTOK 260
420 #define YYTRANSLATE(YYX) \
421 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
425 static const yytype_uint8 yytranslate[] =
427 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
428 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
429 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
430 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
431 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
432 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
433 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
434 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
435 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
436 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
437 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
438 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
439 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
440 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
441 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
442 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
443 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
444 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
445 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
446 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
447 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
448 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
449 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
450 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
451 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
452 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
458 static const yytype_uint8 yyrline[] =
464 #if YYDEBUG || YYERROR_VERBOSE || 1
467 static const char *
const yytname[] =
469 "$end",
"error",
"$undefined",
"STRING",
"QUOTED_STRING",
"UNKNOWN",
470 "$accept",
"begin", YY_NULLPTR
477 static const yytype_uint16 yytoknum[] =
479 0, 256, 257, 258, 259, 260
483 #define YYPACT_NINF -3
485 #define yypact_value_is_default(Yystate) \
486 (!!((Yystate) == (-3)))
488 #define YYTABLE_NINF -1
490 #define yytable_value_is_error(Yytable_value) \
495 static const yytype_int8 yypact[] =
503 static const yytype_uint8 yydefact[] =
509 static const yytype_int8 yypgoto[] =
515 static const yytype_int8 yydefgoto[] =
523 static const yytype_uint8 yytable[] =
528 static const yytype_int8 yycheck[] =
535 static const yytype_uint8 yystos[] =
541 static const yytype_uint8 yyr1[] =
547 static const yytype_uint8 yyr2[] =
553 #define yyerrok (yyerrstatus = 0)
554 #define yyclearin (yychar = YYEMPTY)
558 #define YYACCEPT goto yyacceptlab
559 #define YYABORT goto yyabortlab
560 #define YYERROR goto yyerrorlab
563 #define YYRECOVERING() (!!yyerrstatus)
565 #define YYBACKUP(Token, Value) \
567 if (yychar == YYEMPTY) \
571 YYPOPSTACK (yylen); \
577 yyerror (context, scanner, YY_("syntax error: cannot back up")); \
584 #define YYERRCODE 256
593 # define YYFPRINTF fprintf
596 # define YYDPRINTF(Args) \
603 #ifndef YY_LOCATION_PRINT
604 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
608 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
612 YYFPRINTF (stderr, "%s ", Title); \
613 yy_symbol_print (stderr, \
614 Type, Value, context, scanner); \
615 YYFPRINTF (stderr, "\n"); \
627 FILE *yyo = yyoutput;
634 if (yytype < YYNTOKENS)
635 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
648 YYFPRINTF (yyoutput,
"%s %s (",
649 yytype < YYNTOKENS ?
"token" :
"nterm", yytname[yytype]);
651 yy_symbol_value_print (yyoutput, yytype, yyvaluep, context, scanner);
652 YYFPRINTF (yyoutput,
")");
661 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
663 YYFPRINTF (stderr,
"Stack now");
664 for (; yybottom <= yytop; yybottom++)
666 int yybot = *yybottom;
667 YYFPRINTF (stderr,
" %d", yybot);
669 YYFPRINTF (stderr,
"\n");
672 # define YY_STACK_PRINT(Bottom, Top) \
675 yy_stack_print ((Bottom), (Top)); \
686 unsigned long int yylno = yyrline[yyrule];
687 int yynrhs = yyr2[yyrule];
689 YYFPRINTF (stderr,
"Reducing stack by rule %d (line %lu):\n",
692 for (yyi = 0; yyi < yynrhs; yyi++)
694 YYFPRINTF (stderr,
" $%d = ", yyi + 1);
695 yy_symbol_print (stderr,
696 yystos[yyssp[yyi + 1 - yynrhs]],
697 &(yyvsp[(yyi + 1) - (yynrhs)])
699 YYFPRINTF (stderr,
"\n");
703 # define YY_REDUCE_PRINT(Rule) \
706 yy_reduce_print (yyssp, yyvsp, Rule, context, scanner); \
713 # define YYDPRINTF(Args)
714 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
715 # define YY_STACK_PRINT(Bottom, Top)
716 # define YY_REDUCE_PRINT(Rule)
722 # define YYINITDEPTH 200
733 # define YYMAXDEPTH 10000
740 # if defined __GLIBC__ && defined _STRING_H
741 # define yystrlen strlen
745 yystrlen (
const char *yystr)
748 for (yylen = 0; yystr[yylen]; yylen++)
756 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
757 # define yystpcpy stpcpy
762 yystpcpy (
char *yydest,
const char *yysrc)
765 const char *yys = yysrc;
767 while ((*yyd++ = *yys++) !=
'\0')
784 yytnamerr (
char *yyres,
const char *yystr)
789 char const *yyp = yystr;
796 goto do_not_strip_quotes;
800 goto do_not_strip_quotes;
813 do_not_strip_quotes: ;
817 return yystrlen (yystr);
819 return yystpcpy (yyres, yystr) - yyres;
832 yysyntax_error (YYSIZE_T *yymsg_alloc,
char **yymsg,
833 yytype_int16 *yyssp,
int yytoken)
835 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
836 YYSIZE_T yysize = yysize0;
837 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
839 const char *yyformat = YY_NULLPTR;
841 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
869 if (yytoken != YYEMPTY)
871 int yyn = yypact[*yyssp];
872 yyarg[yycount++] = yytname[yytoken];
873 if (!yypact_value_is_default (yyn))
878 int yyxbegin = yyn < 0 ? -yyn : 0;
880 int yychecklim = YYLAST - yyn + 1;
881 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
884 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
885 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
886 && !yytable_value_is_error (yytable[yyx + yyn]))
888 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
894 yyarg[yycount++] = yytname[yyx];
896 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
897 if (! (yysize <= yysize1
898 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
908 # define YYCASE_(N, S) \
912 YYCASE_(0, YY_(
"syntax error"));
913 YYCASE_(1, YY_(
"syntax error, unexpected %s"));
914 YYCASE_(2, YY_(
"syntax error, unexpected %s, expecting %s"));
915 YYCASE_(3, YY_(
"syntax error, unexpected %s, expecting %s or %s"));
916 YYCASE_(4, YY_(
"syntax error, unexpected %s, expecting %s or %s or %s"));
917 YYCASE_(5, YY_(
"syntax error, unexpected %s, expecting %s or %s or %s or %s"));
922 YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
923 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
928 if (*yymsg_alloc < yysize)
930 *yymsg_alloc = 2 * yysize;
931 if (! (yysize <= *yymsg_alloc
932 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
933 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
943 while ((*yyp = *yyformat) !=
'\0')
944 if (*yyp ==
'%' && yyformat[1] ==
's' && yyi < yycount)
946 yyp += yytnamerr (yyp, yyarg[yyi++]);
971 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
973 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
975 YY_IGNORE_MAYBE_UNINITIALIZED_END
995 YY_INITIAL_VALUE (
static YYSTYPE yyval_default;)
996 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
1013 yytype_int16 yyssa[YYINITDEPTH];
1015 yytype_int16 *yyssp;
1022 YYSIZE_T yystacksize;
1035 char *yymsg = yymsgbuf;
1036 YYSIZE_T yymsg_alloc =
sizeof yymsgbuf;
1039 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1045 yyssp = yyss = yyssa;
1046 yyvsp = yyvs = yyvsa;
1047 yystacksize = YYINITDEPTH;
1049 YYDPRINTF ((stderr,
"Starting parse\n"));
1068 if (yyss + yystacksize - 1 <= yyssp)
1071 YYSIZE_T yysize = yyssp - yyss + 1;
1079 yytype_int16 *yyss1 = yyss;
1085 yyoverflow (YY_(
"memory exhausted"),
1086 &yyss1, yysize *
sizeof (*yyssp),
1087 &yyvs1, yysize *
sizeof (*yyvsp),
1094 # ifndef YYSTACK_RELOCATE
1095 goto yyexhaustedlab;
1098 if (YYMAXDEPTH <= yystacksize)
1099 goto yyexhaustedlab;
1101 if (YYMAXDEPTH < yystacksize)
1102 yystacksize = YYMAXDEPTH;
1105 yytype_int16 *yyss1 = yyss;
1107 (
union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1109 goto yyexhaustedlab;
1110 YYSTACK_RELOCATE (yyss_alloc, yyss);
1111 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1112 # undef YYSTACK_RELOCATE
1114 YYSTACK_FREE (yyss1);
1119 yyssp = yyss + yysize - 1;
1120 yyvsp = yyvs + yysize - 1;
1122 YYDPRINTF ((stderr,
"Stack size increased to %lu\n",
1123 (
unsigned long int) yystacksize));
1125 if (yyss + yystacksize - 1 <= yyssp)
1129 YYDPRINTF ((stderr,
"Entering state %d\n", yystate));
1131 if (yystate == YYFINAL)
1145 yyn = yypact[yystate];
1146 if (yypact_value_is_default (yyn))
1152 if (yychar == YYEMPTY)
1154 YYDPRINTF ((stderr,
"Reading a token: "));
1155 yychar = yylex (&yylval, scanner);
1158 if (yychar <= YYEOF)
1160 yychar = yytoken = YYEOF;
1161 YYDPRINTF ((stderr,
"Now at end of input.\n"));
1165 yytoken = YYTRANSLATE (yychar);
1166 YY_SYMBOL_PRINT (
"Next token is", yytoken, &yylval, &yylloc);
1172 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1177 if (yytable_value_is_error (yyn))
1189 YY_SYMBOL_PRINT (
"Shifting", yytoken, &yylval, &yylloc);
1195 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1197 YY_IGNORE_MAYBE_UNINITIALIZED_END
1206 yyn = yydefact[yystate];
1227 yyval = yyvsp[1-yylen];
1230 YY_REDUCE_PRINT (yyn);
1234 #line 101 "drizzled/execute/parser.yy"
1236 query.append((yyvsp[0].
string).data(), (yyvsp[0].
string).size());
1237 query.push_back(
' ');
1239 #line 1240 "drizzled/execute/parser.cc"
1243 #line 107 "drizzled/execute/parser.yy"
1245 query.append((yyvsp[0].
string).data(), (yyvsp[0].
string).size());
1246 query.push_back(
' ');
1248 #line 1249 "drizzled/execute/parser.cc"
1252 #line 1253 "drizzled/execute/parser.cc"
1266 YY_SYMBOL_PRINT (
"-> $$ =", yyr1[yyn], &yyval, &yyloc);
1270 YY_STACK_PRINT (yyss, yyssp);
1280 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1281 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1282 yystate = yytable[yystate];
1284 yystate = yydefgoto[yyn - YYNTOKENS];
1295 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1301 #if ! YYERROR_VERBOSE
1302 yyerror (context, scanner, YY_(
"syntax error"));
1304 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1307 char const *yymsgp = YY_(
"syntax error");
1308 int yysyntax_error_status;
1309 yysyntax_error_status = YYSYNTAX_ERROR;
1310 if (yysyntax_error_status == 0)
1312 else if (yysyntax_error_status == 1)
1314 if (yymsg != yymsgbuf)
1315 YYSTACK_FREE (yymsg);
1316 yymsg = (
char *) YYSTACK_ALLOC (yymsg_alloc);
1320 yymsg_alloc =
sizeof yymsgbuf;
1321 yysyntax_error_status = 2;
1325 yysyntax_error_status = YYSYNTAX_ERROR;
1329 yyerror (context, scanner, yymsgp);
1330 if (yysyntax_error_status == 2)
1331 goto yyexhaustedlab;
1333 # undef YYSYNTAX_ERROR
1339 if (yyerrstatus == 3)
1344 if (yychar <= YYEOF)
1347 if (yychar == YYEOF)
1352 yydestruct (
"Error: discarding",
1353 yytoken, &yylval, context, scanner);
1378 YY_STACK_PRINT (yyss, yyssp);
1391 yyn = yypact[yystate];
1392 if (!yypact_value_is_default (yyn))
1395 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1408 yydestruct (
"Error: popping",
1409 yystos[yystate], yyvsp, context, scanner);
1412 YY_STACK_PRINT (yyss, yyssp);
1415 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1417 YY_IGNORE_MAYBE_UNINITIALIZED_END
1421 YY_SYMBOL_PRINT (
"Shifting", yystos[yyn], yyvsp, yylsp);
1441 #if !defined yyoverflow || YYERROR_VERBOSE
1446 yyerror (context, scanner, YY_(
"memory exhausted"));
1452 if (yychar != YYEMPTY)
1456 yytoken = YYTRANSLATE (yychar);
1457 yydestruct (
"Cleanup: discarding lookahead",
1458 yytoken, &yylval, context, scanner);
1463 YY_STACK_PRINT (yyss, yyssp);
1464 while (yyssp != yyss)
1466 yydestruct (
"Cleanup: popping",
1467 yystos[*yyssp], yyvsp, context, scanner);
1472 YYSTACK_FREE (yyss);
1475 if (yymsg != yymsgbuf)
1476 YYSTACK_FREE (yymsg);
1480 #line 114 "drizzled/execute/parser.yy"
1487 std::vector<std::string> Context::start()
1489 execute_parse(
this, (
void **)scanner);
1490 std::vector<std::string> parsed_queries;
1491 size_t start_pos= 0;
1492 while ((pos= query.find(
';', start_pos)) != std::string::npos)
1494 if ((pos > 0) && (query[pos-1] ==
'\\'))
1499 parsed_queries.push_back(query.substr(0, pos));
1501 if (query[pos] ==
' ')
1505 query.erase(0, pos);
1507 parsed_queries.push_back(query);
1510 return parsed_queries;
TODO: Rename this file - func.h is stupid.
UNIV_INTERN void yyerror(const char *s)