LLVMFuzzerTestOneInput: 21| 5.59k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 22| 5.59k| std::string input(reinterpret_cast(data), size); 23| 5.59k| SQLParserResult res; 24| 5.59k| SQLParser::parse(input, &res); 25| 5.59k| return 0; 26| 5.59k|} _ZN4hsql9SQLParser5parseERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_15SQLParserResultE: 13| 5.59k|bool SQLParser::parse(const std::string& sql, SQLParserResult* result) { 14| 5.59k| yyscan_t scanner; 15| 5.59k| YY_BUFFER_STATE state; 16| | 17| 5.59k| if (hsql_lex_init(&scanner)) { ------------------ | Branch (17:7): [True: 0, False: 5.59k] ------------------ 18| | // Couldn't initialize the lexer. 19| 0| fprintf(stderr, "SQLParser: Error when initializing lexer!\n"); 20| 0| return false; 21| 0| } 22| 5.59k| const char* text = sql.c_str(); 23| 5.59k| state = hsql__scan_string(text, scanner); 24| | 25| | // Parse the tokens. 26| | // If parsing fails, the result will contain an error object. 27| 5.59k| int ret = hsql_parse(result, scanner); 28| 5.59k| bool success = (ret == 0); 29| 5.59k| result->setIsValid(success); 30| | 31| 5.59k| hsql__delete_buffer(state, scanner); 32| 5.59k| hsql_lex_destroy(scanner); 33| | 34| 5.59k| return true; 35| 5.59k|} _ZN4hsql15SQLParserResultC2Ev: 7| 5.59k|SQLParserResult::SQLParserResult() : isValid_(false), errorMsg_(nullptr) {} _ZN4hsql15SQLParserResultD2Ev: 24| 5.59k|SQLParserResult::~SQLParserResult() { reset(); } _ZN4hsql15SQLParserResult12addStatementEPNS_12SQLStatementE: 26| 71.9k|void SQLParserResult::addStatement(SQLStatement* stmt) { statements_.push_back(stmt); } _ZNK4hsql15SQLParserResult8errorMsgEv: 36| 1.33k|const char* SQLParserResult::errorMsg() const { return errorMsg_; } _ZN4hsql15SQLParserResult10setIsValidEb: 42| 10.7k|void SQLParserResult::setIsValid(bool isValid) { isValid_ = isValid; } _ZN4hsql15SQLParserResult15setErrorDetailsEPcii: 44| 5.16k|void SQLParserResult::setErrorDetails(char* errorMsg, int errorLine, int errorColumn) { 45| 5.16k| errorMsg_ = errorMsg; 46| 5.16k| errorLine_ = errorLine; 47| 5.16k| errorColumn_ = errorColumn; 48| 5.16k|} _ZN4hsql15SQLParserResult5resetEv: 60| 5.59k|void SQLParserResult::reset() { 61| 71.9k| for (SQLStatement* statement : statements_) { ------------------ | Branch (61:32): [True: 71.9k, False: 5.59k] ------------------ 62| 71.9k| delete statement; 63| 71.9k| } 64| 5.59k| statements_.clear(); 65| | 66| 5.59k| isValid_ = false; 67| | 68| 5.59k| free(errorMsg_); 69| 5.59k| errorMsg_ = nullptr; 70| 5.59k| errorLine_ = -1; 71| 5.59k| errorColumn_ = -1; 72| 5.59k|} _ZN4hsql15SQLParserResult12addParameterEPNS_4ExprE: 75| 304k|void SQLParserResult::addParameter(Expr* parameter) { 76| 304k| parameters_.push_back(parameter); 77| 304k| std::sort(parameters_.begin(), parameters_.end(), [](const Expr* a, const Expr* b) { return a->ival < b->ival; }); 78| 304k|} SQLParserResult.cpp:_ZZN4hsql15SQLParserResult12addParameterEPNS_4ExprEENK3$_0clEPKS1_S5_: 77| 2.55G| std::sort(parameters_.begin(), parameters_.end(), [](const Expr* a, const Expr* b) { return a->ival < b->ival; }); _Z10hsql_errorP15HSQL_CUST_LTYPEPN4hsql15SQLParserResultEPvPKc: 100| 5.16k|int yyerror(YYLTYPE* llocp, SQLParserResult* result, yyscan_t scanner, const char* msg) { 101| 5.16k| result->setIsValid(false); 102| 5.16k| result->setErrorDetails(strdup(msg), llocp->first_line, llocp->first_column); 103| 5.16k| return 0; 104| 5.16k|} _Z10hsql_parsePN4hsql15SQLParserResultEPv: 2900| 5.59k|{ 2901| |/* Lookahead token kind. */ 2902| 5.59k|int yychar; 2903| | 2904| | 2905| |/* The semantic value of the lookahead symbol. */ 2906| |/* Default value used for initialization, for pacifying older GCCs 2907| | or non-GCC compilers. */ 2908| 5.59k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 619| 5.59k|# define YY_INITIAL_VALUE(Value) Value ------------------ 2909| 5.59k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 11| 5.59k|#define YYSTYPE HSQL_STYPE ------------------ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 619| 5.59k|# define YY_INITIAL_VALUE(Value) Value ------------------ 2910| | 2911| |/* Location data for the lookahead symbol. */ 2912| 5.59k|static YYLTYPE yyloc_default 2913| |# if defined HSQL_LTYPE_IS_TRIVIAL && HSQL_LTYPE_IS_TRIVIAL 2914| | = { 1, 1, 1, 1 } 2915| |# endif 2916| 5.59k|; 2917| 5.59k|YYLTYPE yylloc = yyloc_default; ------------------ | | 12| 5.59k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.59k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2918| | 2919| | /* Number of syntax errors so far. */ 2920| 5.59k| int yynerrs = 0; 2921| | 2922| 5.59k| yy_state_fast_t yystate = 0; 2923| | /* Number of tokens to shift before error messages enabled. */ 2924| 5.59k| int yyerrstatus = 0; 2925| | 2926| | /* Refer to the stacks through separate pointers, to allow yyoverflow 2927| | to reallocate them elsewhere. */ 2928| | 2929| | /* Their size. */ 2930| 5.59k| YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 526| 5.59k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 1726| 5.59k|# define YYINITDEPTH 200 ------------------ 2931| | 2932| | /* The state stack: array, bottom, top. */ 2933| 5.59k| yy_state_t yyssa[YYINITDEPTH]; 2934| 5.59k| yy_state_t *yyss = yyssa; 2935| 5.59k| yy_state_t *yyssp = yyss; 2936| | 2937| | /* The semantic value stack: array, bottom, top. */ 2938| 5.59k| YYSTYPE yyvsa[YYINITDEPTH]; ------------------ | | 11| 5.59k|#define YYSTYPE HSQL_STYPE ------------------ 2939| 5.59k| YYSTYPE *yyvs = yyvsa; ------------------ | | 11| 5.59k|#define YYSTYPE HSQL_STYPE ------------------ 2940| 5.59k| YYSTYPE *yyvsp = yyvs; ------------------ | | 11| 5.59k|#define YYSTYPE HSQL_STYPE ------------------ 2941| | 2942| | /* The location stack: array, bottom, top. */ 2943| 5.59k| YYLTYPE yylsa[YYINITDEPTH]; ------------------ | | 12| 5.59k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.59k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2944| 5.59k| YYLTYPE *yyls = yylsa; ------------------ | | 12| 5.59k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.59k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2945| 5.59k| YYLTYPE *yylsp = yyls; ------------------ | | 12| 5.59k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.59k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2946| | 2947| 5.59k| int yyn; 2948| | /* The return value of yyparse. */ 2949| 5.59k| int yyresult; 2950| | /* Lookahead symbol kind. */ 2951| 5.59k| yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 2952| | /* The variables used to return semantic value and location from the 2953| | action routines. */ 2954| 5.59k| YYSTYPE yyval; ------------------ | | 11| 5.59k|#define YYSTYPE HSQL_STYPE ------------------ 2955| 5.59k| YYLTYPE yyloc; ------------------ | | 12| 5.59k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.59k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2956| | 2957| | /* The locations where the error started and ended. */ 2958| 5.59k| YYLTYPE yyerror_range[3]; ------------------ | | 12| 5.59k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.59k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2959| | 2960| | /* Buffer for error messages, and its allocated size. */ 2961| 5.59k| char yymsgbuf[128]; 2962| 5.59k| char *yymsg = yymsgbuf; 2963| 5.59k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; ------------------ | | 526| 5.59k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 2964| | 2965| 5.59k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) 2966| | 2967| | /* The number of symbols on the RHS of the reduced rule. 2968| | Keep to zero when no symbol should be popped. */ 2969| 5.59k| int yylen = 0; 2970| | 2971| 5.59k| YYDPRINTF ((stderr, "Starting parse\n")); ------------------ | | 1717| 5.59k|# define YYDPRINTF(Args) ((void) 0) ------------------ 2972| | 2973| 5.59k| yychar = SQL_HSQL_EMPTY; /* Cause a token to be read. */ 2974| | 2975| | 2976| |/* User initialization code. */ 2977| 5.59k|#line 75 "bison_parser.y" 2978| 5.59k|{ 2979| | // Initialize 2980| 5.59k| yylloc.first_column = 0; 2981| 5.59k| yylloc.last_column = 0; 2982| 5.59k| yylloc.first_line = 0; 2983| 5.59k| yylloc.last_line = 0; 2984| 5.59k| yylloc.total_column = 0; 2985| 5.59k| yylloc.string_length = 0; 2986| 5.59k|} 2987| | 2988| 5.59k|#line 2989 "bison_parser.cpp" 2989| | 2990| 5.59k| yylsp[0] = yylloc; 2991| 5.59k| goto yysetstate; 2992| | 2993| | 2994| |/*------------------------------------------------------------. 2995| || yynewstate -- push a new state, which is found in yystate. | 2996| |`------------------------------------------------------------*/ 2997| 36.9M|yynewstate: 2998| | /* In all cases, when you get here, the value and location stacks 2999| | have just been pushed. So pushing a state here evens the stacks. */ 3000| 36.9M| yyssp++; 3001| | 3002| | 3003| |/*--------------------------------------------------------------------. 3004| || yysetstate -- set current state (the top of the stack) to yystate. | 3005| |`--------------------------------------------------------------------*/ 3006| 36.9M|yysetstate: 3007| 36.9M| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); ------------------ | | 1717| 36.9M|# define YYDPRINTF(Args) ((void) 0) ------------------ 3008| 36.9M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 642| 36.9M|#define YY_ASSERT(E) ((void) (0 && (E))) | | ------------------ | | | Branch (642:31): [Folded - Ignored] | | | Branch (642:37): [True: 0, False: 0] | | | Branch (642:37): [True: 0, False: 0] | | ------------------ ------------------ 3009| 36.9M| YY_IGNORE_USELESS_CAST_BEGIN 3010| 36.9M| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 111| 36.9M|# define YY_CAST(Type, Val) static_cast (Val) ------------------ 3011| 36.9M| YY_IGNORE_USELESS_CAST_END 3012| 36.9M| YY_STACK_PRINT (yyss, yyssp); 3013| | 3014| 36.9M| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (3014:7): [True: 16, False: 36.9M] ------------------ 3015| 16|#if !defined yyoverflow && !defined YYSTACK_RELOCATE 3016| 16| YYNOMEM; ------------------ | | 1481| 16|#define YYNOMEM goto yyexhaustedlab ------------------ 3017| |#else 3018| | { 3019| | /* Get the current used size of the three stacks, in elements. */ 3020| | YYPTRDIFF_T yysize = yyssp - yyss + 1; 3021| | 3022| |# if defined yyoverflow 3023| | { 3024| | /* Give user a chance to reallocate the stack. Use copies of 3025| | these so that the &'s don't force the real ones into 3026| | memory. */ 3027| | yy_state_t *yyss1 = yyss; 3028| | YYSTYPE *yyvs1 = yyvs; 3029| | YYLTYPE *yyls1 = yyls; 3030| | 3031| | /* Each stack pointer address is followed by the size of the 3032| | data in use in that stack, in bytes. This used to be a 3033| | conditional around just the two extra args, but that might 3034| | be undefined if yyoverflow is a macro. */ 3035| | yyoverflow (YY_("memory exhausted"), 3036| | &yyss1, yysize * YYSIZEOF (*yyssp), 3037| | &yyvs1, yysize * YYSIZEOF (*yyvsp), 3038| | &yyls1, yysize * YYSIZEOF (*yylsp), 3039| | &yystacksize); 3040| | yyss = yyss1; 3041| | yyvs = yyvs1; 3042| | yyls = yyls1; 3043| | } 3044| |# else /* defined YYSTACK_RELOCATE */ 3045| | /* Extend the stack our own way. */ 3046| | if (YYMAXDEPTH <= yystacksize) 3047| | YYNOMEM; 3048| | yystacksize *= 2; 3049| | if (YYMAXDEPTH < yystacksize) 3050| | yystacksize = YYMAXDEPTH; 3051| | 3052| | { 3053| | yy_state_t *yyss1 = yyss; 3054| | union yyalloc *yyptr = 3055| | YY_CAST (union yyalloc *, 3056| | YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 3057| | if (! yyptr) 3058| | YYNOMEM; 3059| | YYSTACK_RELOCATE (yyss_alloc, yyss); 3060| | YYSTACK_RELOCATE (yyvs_alloc, yyvs); 3061| | YYSTACK_RELOCATE (yyls_alloc, yyls); 3062| |# undef YYSTACK_RELOCATE 3063| | if (yyss1 != yyssa) 3064| | YYSTACK_FREE (yyss1); 3065| | } 3066| |# endif 3067| | 3068| | yyssp = yyss + yysize - 1; 3069| | yyvsp = yyvs + yysize - 1; 3070| | yylsp = yyls + yysize - 1; 3071| | 3072| | YY_IGNORE_USELESS_CAST_BEGIN 3073| | YYDPRINTF ((stderr, "Stack size increased to %ld\n", 3074| | YY_CAST (long, yystacksize))); 3075| | YY_IGNORE_USELESS_CAST_END 3076| | 3077| | if (yyss + yystacksize - 1 <= yyssp) 3078| | YYABORT; 3079| | } 3080| |#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 3081| | 3082| | 3083| 36.9M| if (yystate == YYFINAL) ------------------ | | 775| 36.9M|#define YYFINAL 69 ------------------ | Branch (3083:7): [True: 1.69k, False: 36.9M] ------------------ 3084| 1.69k| YYACCEPT; ------------------ | | 1478| 1.69k|#define YYACCEPT goto yyacceptlab ------------------ 3085| | 3086| 36.9M| goto yybackup; 3087| | 3088| | 3089| |/*-----------. 3090| || yybackup. | 3091| |`-----------*/ 3092| 36.9M|yybackup: 3093| | /* Do appropriate processing given the current state. Read a 3094| | lookahead token if we need one and don't already have one. */ 3095| | 3096| | /* First try to decide what to do without reference to lookahead token. */ 3097| 36.9M| yyn = yypact[yystate]; 3098| 36.9M| if (yypact_value_is_default (yyn)) ------------------ | | 971| 36.9M| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 968| 36.9M|#define YYPACT_NINF (-337) | | ------------------ | | | Branch (971:3): [True: 17.0M, False: 19.9M] | | ------------------ ------------------ 3099| 17.0M| goto yydefault; 3100| | 3101| | /* Not known => get a lookahead token if don't already have one. */ 3102| | 3103| | /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ 3104| 19.9M| if (yychar == SQL_HSQL_EMPTY) ------------------ | Branch (3104:7): [True: 10.8M, False: 9.04M] ------------------ 3105| 10.8M| { 3106| 10.8M| YYDPRINTF ((stderr, "Reading a token\n")); ------------------ | | 1717| 10.8M|# define YYDPRINTF(Args) ((void) 0) ------------------ 3107| 10.8M| yychar = yylex (&yylval, &yylloc, scanner); ------------------ | | 71| 10.8M|#define yylex hsql_lex ------------------ 3108| 10.8M| } 3109| | 3110| 19.9M| if (yychar <= SQL_YYEOF) ------------------ | Branch (3110:7): [True: 30.6k, False: 19.8M] ------------------ 3111| 30.6k| { 3112| 30.6k| yychar = SQL_YYEOF; 3113| 30.6k| yytoken = YYSYMBOL_YYEOF; 3114| 30.6k| YYDPRINTF ((stderr, "Now at end of input.\n")); ------------------ | | 1717| 30.6k|# define YYDPRINTF(Args) ((void) 0) ------------------ 3115| 30.6k| } 3116| 19.8M| else if (yychar == SQL_HSQL_error) ------------------ | Branch (3116:12): [True: 0, False: 19.8M] ------------------ 3117| 0| { 3118| | /* The scanner already issued an error message, process directly 3119| | to error recovery. But do not keep the error token as 3120| | lookahead, it is too special and may lead us to an endless 3121| | loop in error recovery. */ 3122| 0| yychar = SQL_HSQL_UNDEF; 3123| 0| yytoken = YYSYMBOL_YYerror; 3124| 0| yyerror_range[1] = yylloc; 3125| 0| goto yyerrlab1; 3126| 0| } 3127| 19.8M| else 3128| 19.8M| { 3129| 19.8M| yytoken = YYTRANSLATE (yychar); ------------------ | | 795| 19.8M| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 789| 19.8M|#define YYMAXUTOK 424 | | ------------------ | | | Branch (795:4): [True: 19.8M, False: 0] | | | Branch (795:18): [True: 19.8M, False: 0] | | ------------------ | | 796| 19.8M| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 111| 19.8M|# define YY_CAST(Type, Val) static_cast (Val) | | ------------------ | | 797| 19.8M| : YYSYMBOL_YYUNDEF) ------------------ 3130| 19.8M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 3131| 19.8M| } 3132| | 3133| | /* If the proper action on seeing token YYTOKEN is to reduce or to 3134| | detect an error, take that action. */ 3135| 19.9M| yyn += yytoken; 3136| 19.9M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 777| 19.9M|#define YYLAST 883 ------------------ | Branch (3136:7): [True: 10.9k, False: 19.9M] | Branch (3136:18): [True: 4.61k, False: 19.9M] | Branch (3136:34): [True: 8.39M, False: 11.5M] ------------------ 3137| 8.40M| goto yydefault; 3138| 11.5M| yyn = yytable[yyn]; 3139| 11.5M| if (yyn <= 0) ------------------ | Branch (3139:7): [True: 639k, False: 10.8M] ------------------ 3140| 639k| { 3141| 639k| if (yytable_value_is_error (yyn)) ------------------ | | 976| 639k| ((Yyn) == YYTABLE_NINF) | | ------------------ | | | | 973| 639k|#define YYTABLE_NINF (-318) | | ------------------ | | | Branch (976:3): [True: 16, False: 639k] | | ------------------ ------------------ 3142| 16| goto yyerrlab; 3143| 639k| yyn = -yyn; 3144| 639k| goto yyreduce; 3145| 639k| } 3146| | 3147| | /* Count tokens shifted since error; after three, turn off error 3148| | status. */ 3149| 10.8M| if (yyerrstatus) ------------------ | Branch (3149:7): [True: 0, False: 10.8M] ------------------ 3150| 0| yyerrstatus--; 3151| | 3152| | /* Shift the lookahead token. */ 3153| 10.8M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 3154| 10.8M| yystate = yyn; 3155| 10.8M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 3156| 10.8M| *++yyvsp = yylval; 3157| 10.8M| YY_IGNORE_MAYBE_UNINITIALIZED_END 3158| 10.8M| *++yylsp = yylloc; 3159| | 3160| | /* Discard the shifted token. */ 3161| 10.8M| yychar = SQL_HSQL_EMPTY; 3162| 10.8M| goto yynewstate; 3163| | 3164| | 3165| |/*-----------------------------------------------------------. 3166| || yydefault -- do the default action for the current state. | 3167| |`-----------------------------------------------------------*/ 3168| 25.4M|yydefault: 3169| 25.4M| yyn = yydefact[yystate]; 3170| 25.4M| if (yyn == 0) ------------------ | Branch (3170:7): [True: 3.42k, False: 25.4M] ------------------ 3171| 3.42k| goto yyerrlab; 3172| 25.4M| goto yyreduce; 3173| | 3174| | 3175| |/*-----------------------------. 3176| || yyreduce -- do a reduction. | 3177| |`-----------------------------*/ 3178| 26.1M|yyreduce: 3179| | /* yyn is the number of a rule to reduce with. */ 3180| 26.1M| yylen = yyr2[yyn]; 3181| | 3182| | /* If YYLEN is nonzero, implement the default value of the action: 3183| | '$$ = $1'. 3184| | 3185| | Otherwise, the following line sets YYVAL to garbage. 3186| | This behavior is undocumented and Bison 3187| | users should not rely upon it. Assigning to YYVAL 3188| | unconditionally makes the parser a bit smaller, and it avoids a 3189| | GCC warning that YYVAL may be used uninitialized. */ 3190| 26.1M| yyval = yyvsp[1-yylen]; 3191| | 3192| | /* Default location. */ 3193| 26.1M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); ------------------ | | 1513| 26.1M| do \ | | 1514| 26.1M| if (N) \ | | ------------------ | | | Branch (1514:11): [True: 22.8M, False: 3.28M] | | ------------------ | | 1515| 26.1M| { \ | | 1516| 22.8M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ | | ------------------ | | | | 1531| 22.8M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1517| 22.8M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ | | ------------------ | | | | 1531| 22.8M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1518| 22.8M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ | | ------------------ | | | | 1531| 22.8M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1519| 22.8M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ | | ------------------ | | | | 1531| 22.8M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1520| 22.8M| } \ | | 1521| 26.1M| else \ | | 1522| 26.1M| { \ | | 1523| 3.28M| (Current).first_line = (Current).last_line = \ | | 1524| 3.28M| YYRHSLOC (Rhs, 0).last_line; \ | | ------------------ | | | | 1531| 3.28M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1525| 3.28M| (Current).first_column = (Current).last_column = \ | | 1526| 3.28M| YYRHSLOC (Rhs, 0).last_column; \ | | ------------------ | | | | 1531| 3.28M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1527| 3.28M| } \ | | 1528| 26.1M| while (0) | | ------------------ | | | Branch (1528:12): [Folded - Ignored] | | ------------------ ------------------ 3194| 26.1M| yyerror_range[1] = yyloc; 3195| 26.1M| YY_REDUCE_PRINT (yyn); 3196| 26.1M| switch (yyn) 3197| 26.1M| { 3198| 1.90k| case 2: /* input: statement_list opt_semicolon */ ------------------ | Branch (3198:3): [True: 1.90k, False: 26.1M] ------------------ 3199| 1.90k|#line 313 "bison_parser.y" 3200| 1.90k| { 3201| 71.9k| for (SQLStatement* stmt : *(yyvsp[-1].stmt_vec)) { ------------------ | Branch (3201:27): [True: 71.9k, False: 1.90k] ------------------ 3202| | // Transfers ownership of the statement. 3203| 71.9k| result->addStatement(stmt); 3204| 71.9k| } 3205| | 3206| 1.90k| unsigned param_id = 0; 3207| 304k| for (void* param : yyloc.param_list) { ------------------ | Branch (3207:20): [True: 304k, False: 1.90k] ------------------ 3208| 304k| if (param) { ------------------ | Branch (3208:9): [True: 304k, False: 0] ------------------ 3209| 304k| Expr* expr = (Expr*)param; 3210| 304k| expr->ival = param_id; 3211| 304k| result->addParameter(expr); 3212| 304k| ++param_id; 3213| 304k| } 3214| 304k| } 3215| 1.90k| delete (yyvsp[-1].stmt_vec); 3216| 1.90k| } 3217| 1.90k|#line 3218 "bison_parser.cpp" 3218| 1.90k| break; 3219| | 3220| 2.38k| case 3: /* statement_list: statement */ ------------------ | Branch (3220:3): [True: 2.38k, False: 26.1M] ------------------ 3221| 2.38k|#line 332 "bison_parser.y" 3222| 2.38k| { 3223| 2.38k| (yyvsp[0].statement)->stringLength = yylloc.string_length; 3224| 2.38k| yylloc.string_length = 0; 3225| 2.38k| (yyval.stmt_vec) = new std::vector(); 3226| 2.38k| (yyval.stmt_vec)->push_back((yyvsp[0].statement)); 3227| 2.38k|} 3228| 2.38k|#line 3229 "bison_parser.cpp" 3229| 2.38k| break; 3230| | 3231| 296k| case 4: /* statement_list: statement_list ';' statement */ ------------------ | Branch (3231:3): [True: 296k, False: 25.8M] ------------------ 3232| 296k|#line 338 "bison_parser.y" 3233| 296k| { 3234| 296k| (yyvsp[0].statement)->stringLength = yylloc.string_length; 3235| 296k| yylloc.string_length = 0; 3236| 296k| (yyvsp[-2].stmt_vec)->push_back((yyvsp[0].statement)); 3237| 296k| (yyval.stmt_vec) = (yyvsp[-2].stmt_vec); 3238| 296k|} 3239| 296k|#line 3240 "bison_parser.cpp" 3240| 296k| break; 3241| | 3242| 814| case 5: /* statement: prepare_statement opt_hints */ ------------------ | Branch (3242:3): [True: 814, False: 26.1M] ------------------ 3243| 814|#line 345 "bison_parser.y" 3244| 814| { 3245| 814| (yyval.statement) = (yyvsp[-1].prep_stmt); 3246| 814| (yyval.statement)->hints = (yyvsp[0].expr_vec); 3247| 814|} 3248| 814|#line 3249 "bison_parser.cpp" 3249| 814| break; 3250| | 3251| 294k| case 6: /* statement: preparable_statement opt_hints */ ------------------ | Branch (3251:3): [True: 294k, False: 25.8M] ------------------ 3252| 294k|#line 349 "bison_parser.y" 3253| 294k| { 3254| 294k| (yyval.statement) = (yyvsp[-1].statement); 3255| 294k| (yyval.statement)->hints = (yyvsp[0].expr_vec); 3256| 294k|} 3257| 294k|#line 3258 "bison_parser.cpp" 3258| 294k| break; 3259| | 3260| 2.81k| case 7: /* statement: show_statement */ ------------------ | Branch (3260:3): [True: 2.81k, False: 26.1M] ------------------ 3261| 2.81k|#line 353 "bison_parser.y" 3262| 2.81k| { (yyval.statement) = (yyvsp[0].show_stmt); } 3263| 2.81k|#line 3264 "bison_parser.cpp" 3264| 2.81k| break; 3265| | 3266| 561| case 8: /* statement: import_statement */ ------------------ | Branch (3266:3): [True: 561, False: 26.1M] ------------------ 3267| 561|#line 354 "bison_parser.y" 3268| 561| { (yyval.statement) = (yyvsp[0].import_stmt); } 3269| 561|#line 3270 "bison_parser.cpp" 3270| 561| break; 3271| | 3272| 873| case 9: /* statement: export_statement */ ------------------ | Branch (3272:3): [True: 873, False: 26.1M] ------------------ 3273| 873|#line 355 "bison_parser.y" 3274| 873| { (yyval.statement) = (yyvsp[0].export_stmt); } 3275| 873|#line 3276 "bison_parser.cpp" 3276| 873| break; 3277| | 3278| 11.9k| case 10: /* preparable_statement: select_statement */ ------------------ | Branch (3278:3): [True: 11.9k, False: 26.0M] ------------------ 3279| 11.9k|#line 357 "bison_parser.y" 3280| 11.9k| { (yyval.statement) = (yyvsp[0].select_stmt); } 3281| 11.9k|#line 3282 "bison_parser.cpp" 3282| 11.9k| break; 3283| | 3284| 3.27k| case 11: /* preparable_statement: create_statement */ ------------------ | Branch (3284:3): [True: 3.27k, False: 26.1M] ------------------ 3285| 3.27k|#line 358 "bison_parser.y" 3286| 3.27k| { (yyval.statement) = (yyvsp[0].create_stmt); } 3287| 3.27k|#line 3288 "bison_parser.cpp" 3288| 3.27k| break; 3289| | 3290| 2.48k| case 12: /* preparable_statement: insert_statement */ ------------------ | Branch (3290:3): [True: 2.48k, False: 26.1M] ------------------ 3291| 2.48k|#line 359 "bison_parser.y" 3292| 2.48k| { (yyval.statement) = (yyvsp[0].insert_stmt); } 3293| 2.48k|#line 3294 "bison_parser.cpp" 3294| 2.48k| break; 3295| | 3296| 1.28k| case 13: /* preparable_statement: delete_statement */ ------------------ | Branch (3296:3): [True: 1.28k, False: 26.1M] ------------------ 3297| 1.28k|#line 360 "bison_parser.y" 3298| 1.28k| { (yyval.statement) = (yyvsp[0].delete_stmt); } 3299| 1.28k|#line 3300 "bison_parser.cpp" 3300| 1.28k| break; 3301| | 3302| 581| case 14: /* preparable_statement: truncate_statement */ ------------------ | Branch (3302:3): [True: 581, False: 26.1M] ------------------ 3303| 581|#line 361 "bison_parser.y" 3304| 581| { (yyval.statement) = (yyvsp[0].delete_stmt); } 3305| 581|#line 3306 "bison_parser.cpp" 3306| 581| break; 3307| | 3308| 1.19k| case 15: /* preparable_statement: update_statement */ ------------------ | Branch (3308:3): [True: 1.19k, False: 26.1M] ------------------ 3309| 1.19k|#line 362 "bison_parser.y" 3310| 1.19k| { (yyval.statement) = (yyvsp[0].update_stmt); } 3311| 1.19k|#line 3312 "bison_parser.cpp" 3312| 1.19k| break; 3313| | 3314| 3.85k| case 16: /* preparable_statement: drop_statement */ ------------------ | Branch (3314:3): [True: 3.85k, False: 26.1M] ------------------ 3315| 3.85k|#line 363 "bison_parser.y" 3316| 3.85k| { (yyval.statement) = (yyvsp[0].drop_stmt); } 3317| 3.85k|#line 3318 "bison_parser.cpp" 3318| 3.85k| break; 3319| | 3320| 0| case 17: /* preparable_statement: alter_statement */ ------------------ | Branch (3320:3): [True: 0, False: 26.1M] ------------------ 3321| 0|#line 364 "bison_parser.y" 3322| 0| { (yyval.statement) = (yyvsp[0].alter_stmt); } 3323| 0|#line 3324 "bison_parser.cpp" 3324| 0| break; 3325| | 3326| 1.56k| case 18: /* preparable_statement: execute_statement */ ------------------ | Branch (3326:3): [True: 1.56k, False: 26.1M] ------------------ 3327| 1.56k|#line 365 "bison_parser.y" 3328| 1.56k| { (yyval.statement) = (yyvsp[0].exec_stmt); } 3329| 1.56k|#line 3330 "bison_parser.cpp" 3330| 1.56k| break; 3331| | 3332| 268k| case 19: /* preparable_statement: transaction_statement */ ------------------ | Branch (3332:3): [True: 268k, False: 25.8M] ------------------ 3333| 268k|#line 366 "bison_parser.y" 3334| 268k| { (yyval.statement) = (yyvsp[0].transaction_stmt); } 3335| 268k|#line 3336 "bison_parser.cpp" 3336| 268k| break; 3337| | 3338| 1.27k| case 20: /* opt_hints: WITH HINT '(' hint_list ')' */ ------------------ | Branch (3338:3): [True: 1.27k, False: 26.1M] ------------------ 3339| 1.27k|#line 372 "bison_parser.y" 3340| 1.27k| { (yyval.expr_vec) = (yyvsp[-1].expr_vec); } 3341| 1.27k|#line 3342 "bison_parser.cpp" 3342| 1.27k| break; 3343| | 3344| 293k| case 21: /* opt_hints: %empty */ ------------------ | Branch (3344:3): [True: 293k, False: 25.8M] ------------------ 3345| 293k|#line 373 "bison_parser.y" 3346| 293k| { (yyval.expr_vec) = nullptr; } 3347| 293k|#line 3348 "bison_parser.cpp" 3348| 293k| break; 3349| | 3350| 1.31k| case 22: /* hint_list: hint */ ------------------ | Branch (3350:3): [True: 1.31k, False: 26.1M] ------------------ 3351| 1.31k|#line 375 "bison_parser.y" 3352| 1.31k| { 3353| 1.31k| (yyval.expr_vec) = new std::vector(); 3354| 1.31k| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 3355| 1.31k|} 3356| 1.31k|#line 3357 "bison_parser.cpp" 3357| 1.31k| break; 3358| | 3359| 1.32k| case 23: /* hint_list: hint_list ',' hint */ ------------------ | Branch (3359:3): [True: 1.32k, False: 26.1M] ------------------ 3360| 1.32k|#line 379 "bison_parser.y" 3361| 1.32k| { 3362| 1.32k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 3363| 1.32k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 3364| 1.32k|} 3365| 1.32k|#line 3366 "bison_parser.cpp" 3366| 1.32k| break; 3367| | 3368| 2.36k| case 24: /* hint: IDENTIFIER */ ------------------ | Branch (3368:3): [True: 2.36k, False: 26.1M] ------------------ 3369| 2.36k|#line 384 "bison_parser.y" 3370| 2.36k| { 3371| 2.36k| (yyval.expr) = Expr::make(kExprHint); 3372| 2.36k| (yyval.expr)->name = (yyvsp[0].sval); 3373| 2.36k|} 3374| 2.36k|#line 3375 "bison_parser.cpp" 3375| 2.36k| break; 3376| | 3377| 280| case 25: /* hint: IDENTIFIER '(' literal_list ')' */ ------------------ | Branch (3377:3): [True: 280, False: 26.1M] ------------------ 3378| 280|#line 388 "bison_parser.y" 3379| 280| { 3380| 280| (yyval.expr) = Expr::make(kExprHint); 3381| 280| (yyval.expr)->name = (yyvsp[-3].sval); 3382| 280| (yyval.expr)->exprList = (yyvsp[-1].expr_vec); 3383| 280|} 3384| 280|#line 3385 "bison_parser.cpp" 3385| 280| break; 3386| | 3387| 266k| case 26: /* transaction_statement: BEGIN opt_transaction_keyword */ ------------------ | Branch (3387:3): [True: 266k, False: 25.8M] ------------------ 3388| 266k|#line 398 "bison_parser.y" 3389| 266k| { (yyval.transaction_stmt) = new TransactionStatement(kBeginTransaction); } 3390| 266k|#line 3391 "bison_parser.cpp" 3391| 266k| break; 3392| | 3393| 677| case 27: /* transaction_statement: ROLLBACK opt_transaction_keyword */ ------------------ | Branch (3393:3): [True: 677, False: 26.1M] ------------------ 3394| 677|#line 399 "bison_parser.y" 3395| 677| { (yyval.transaction_stmt) = new TransactionStatement(kRollbackTransaction); } 3396| 677|#line 3397 "bison_parser.cpp" 3397| 677| break; 3398| | 3399| 762| case 28: /* transaction_statement: COMMIT opt_transaction_keyword */ ------------------ | Branch (3399:3): [True: 762, False: 26.1M] ------------------ 3400| 762|#line 400 "bison_parser.y" 3401| 762| { (yyval.transaction_stmt) = new TransactionStatement(kCommitTransaction); } 3402| 762|#line 3403 "bison_parser.cpp" 3403| 762| break; 3404| | 3405| 815| case 31: /* prepare_statement: PREPARE IDENTIFIER FROM prepare_target_query */ ------------------ | Branch (3405:3): [True: 815, False: 26.1M] ------------------ 3406| 815|#line 408 "bison_parser.y" 3407| 815| { 3408| 815| (yyval.prep_stmt) = new PrepareStatement(); 3409| 815| (yyval.prep_stmt)->name = (yyvsp[-2].sval); 3410| 815| (yyval.prep_stmt)->query = (yyvsp[0].sval); 3411| 815|} 3412| 815|#line 3413 "bison_parser.cpp" 3413| 815| break; 3414| | 3415| 789| case 33: /* execute_statement: EXECUTE IDENTIFIER */ ------------------ | Branch (3415:3): [True: 789, False: 26.1M] ------------------ 3416| 789|#line 416 "bison_parser.y" 3417| 789| { 3418| 789| (yyval.exec_stmt) = new ExecuteStatement(); 3419| 789| (yyval.exec_stmt)->name = (yyvsp[0].sval); 3420| 789|} 3421| 789|#line 3422 "bison_parser.cpp" 3422| 789| break; 3423| | 3424| 771| case 34: /* execute_statement: EXECUTE IDENTIFIER '(' opt_literal_list ')' */ ------------------ | Branch (3424:3): [True: 771, False: 26.1M] ------------------ 3425| 771|#line 420 "bison_parser.y" 3426| 771| { 3427| 771| (yyval.exec_stmt) = new ExecuteStatement(); 3428| 771| (yyval.exec_stmt)->name = (yyvsp[-3].sval); 3429| 771| (yyval.exec_stmt)->parameters = (yyvsp[-1].expr_vec); 3430| 771|} 3431| 771|#line 3432 "bison_parser.cpp" 3432| 771| break; 3433| | 3434| 0| case 35: /* import_statement: IMPORT FROM file_type FILE file_path INTO table_name */ ------------------ | Branch (3434:3): [True: 0, False: 26.1M] ------------------ 3435| 0|#line 431 "bison_parser.y" 3436| 0| { 3437| 0| (yyval.import_stmt) = new ImportStatement((yyvsp[-4].import_type_t)); 3438| 0| (yyval.import_stmt)->filePath = (yyvsp[-2].sval); 3439| 0| (yyval.import_stmt)->schema = (yyvsp[0].table_name).schema; 3440| 0| (yyval.import_stmt)->tableName = (yyvsp[0].table_name).name; 3441| 0|} 3442| 0|#line 3443 "bison_parser.cpp" 3443| 0| break; 3444| | 3445| 561| case 36: /* import_statement: COPY table_name FROM file_path opt_file_type opt_where */ ------------------ | Branch (3445:3): [True: 561, False: 26.1M] ------------------ 3446| 561|#line 437 "bison_parser.y" 3447| 561| { 3448| 561| (yyval.import_stmt) = new ImportStatement((yyvsp[-1].import_type_t)); 3449| 561| (yyval.import_stmt)->filePath = (yyvsp[-2].sval); 3450| 561| (yyval.import_stmt)->schema = (yyvsp[-4].table_name).schema; 3451| 561| (yyval.import_stmt)->tableName = (yyvsp[-4].table_name).name; 3452| 561| (yyval.import_stmt)->whereClause = (yyvsp[0].expr); 3453| 561|} 3454| 561|#line 3455 "bison_parser.cpp" 3455| 561| break; 3456| | 3457| 116| case 37: /* file_type: IDENTIFIER */ ------------------ | Branch (3457:3): [True: 116, False: 26.1M] ------------------ 3458| 116|#line 445 "bison_parser.y" 3459| 116| { 3460| 116| if (strcasecmp((yyvsp[0].sval), "csv") == 0) { ------------------ | Branch (3460:7): [True: 1, False: 115] ------------------ 3461| 1| (yyval.import_type_t) = kImportCSV; 3462| 115| } else if (strcasecmp((yyvsp[0].sval), "tbl") == 0) { ------------------ | Branch (3462:14): [True: 1, False: 114] ------------------ 3463| 1| (yyval.import_type_t) = kImportTbl; 3464| 114| } else if (strcasecmp((yyvsp[0].sval), "binary") == 0 || strcasecmp((yyvsp[0].sval), "bin") == 0) { ------------------ | Branch (3464:14): [True: 1, False: 113] | Branch (3464:60): [True: 1, False: 112] ------------------ 3465| 2| (yyval.import_type_t) = kImportBinary; 3466| 112| } else { 3467| 112| free((yyvsp[0].sval)); 3468| 112| yyerror(&yyloc, result, scanner, "File type is unknown."); ------------------ | | 72| 112|#define yyerror hsql_error ------------------ 3469| 112| YYERROR; ------------------ | | 1480| 112|#define YYERROR goto yyerrorlab ------------------ 3470| 112| } 3471| 4| free((yyvsp[0].sval)); 3472| 4|} 3473| 0|#line 3474 "bison_parser.cpp" 3474| 0| break; 3475| | 3476| 1.43k| case 38: /* file_path: string_literal */ ------------------ | Branch (3476:3): [True: 1.43k, False: 26.1M] ------------------ 3477| 1.43k|#line 460 "bison_parser.y" 3478| 1.43k| { 3479| 1.43k| (yyval.sval) = strdup((yyvsp[0].expr)->name); 3480| 1.43k| delete (yyvsp[0].expr); 3481| 1.43k|} 3482| 1.43k|#line 3483 "bison_parser.cpp" 3483| 1.43k| break; 3484| | 3485| 0| case 39: /* opt_file_type: WITH FORMAT file_type */ ------------------ | Branch (3485:3): [True: 0, False: 26.1M] ------------------ 3486| 0|#line 465 "bison_parser.y" 3487| 0| { (yyval.import_type_t) = (yyvsp[0].import_type_t); } 3488| 0|#line 3489 "bison_parser.cpp" 3489| 0| break; 3490| | 3491| 1.43k| case 40: /* opt_file_type: %empty */ ------------------ | Branch (3491:3): [True: 1.43k, False: 26.1M] ------------------ 3492| 1.43k|#line 466 "bison_parser.y" 3493| 1.43k| { (yyval.import_type_t) = kImportAuto; } 3494| 1.43k|#line 3495 "bison_parser.cpp" 3495| 1.43k| break; 3496| | 3497| 676| case 41: /* export_statement: COPY table_name TO file_path opt_file_type */ ------------------ | Branch (3497:3): [True: 676, False: 26.1M] ------------------ 3498| 676|#line 472 "bison_parser.y" 3499| 676| { 3500| 676| (yyval.export_stmt) = new ExportStatement((yyvsp[0].import_type_t)); 3501| 676| (yyval.export_stmt)->filePath = (yyvsp[-1].sval); 3502| 676| (yyval.export_stmt)->schema = (yyvsp[-3].table_name).schema; 3503| 676| (yyval.export_stmt)->tableName = (yyvsp[-3].table_name).name; 3504| 676|} 3505| 676|#line 3506 "bison_parser.cpp" 3506| 676| break; 3507| | 3508| 197| case 42: /* export_statement: COPY select_with_paren TO file_path opt_file_type */ ------------------ | Branch (3508:3): [True: 197, False: 26.1M] ------------------ 3509| 197|#line 478 "bison_parser.y" 3510| 197| { 3511| 197| (yyval.export_stmt) = new ExportStatement((yyvsp[0].import_type_t)); 3512| 197| (yyval.export_stmt)->filePath = (yyvsp[-1].sval); 3513| 197| (yyval.export_stmt)->select = (yyvsp[-3].select_stmt); 3514| 197|} 3515| 197|#line 3516 "bison_parser.cpp" 3516| 197| break; 3517| | 3518| 1.40k| case 43: /* show_statement: SHOW TABLES */ ------------------ | Branch (3518:3): [True: 1.40k, False: 26.1M] ------------------ 3519| 1.40k|#line 489 "bison_parser.y" 3520| 1.40k| { (yyval.show_stmt) = new ShowStatement(kShowTables); } 3521| 1.40k|#line 3522 "bison_parser.cpp" 3522| 1.40k| break; 3523| | 3524| 790| case 44: /* show_statement: SHOW COLUMNS table_name */ ------------------ | Branch (3524:3): [True: 790, False: 26.1M] ------------------ 3525| 790|#line 490 "bison_parser.y" 3526| 790| { 3527| 790| (yyval.show_stmt) = new ShowStatement(kShowColumns); 3528| 790| (yyval.show_stmt)->schema = (yyvsp[0].table_name).schema; 3529| 790| (yyval.show_stmt)->name = (yyvsp[0].table_name).name; 3530| 790|} 3531| 790|#line 3532 "bison_parser.cpp" 3532| 790| break; 3533| | 3534| 617| case 45: /* show_statement: DESCRIBE table_name */ ------------------ | Branch (3534:3): [True: 617, False: 26.1M] ------------------ 3535| 617|#line 495 "bison_parser.y" 3536| 617| { 3537| 617| (yyval.show_stmt) = new ShowStatement(kShowColumns); 3538| 617| (yyval.show_stmt)->schema = (yyvsp[0].table_name).schema; 3539| 617| (yyval.show_stmt)->name = (yyvsp[0].table_name).name; 3540| 617|} 3541| 617|#line 3542 "bison_parser.cpp" 3542| 617| break; 3543| | 3544| 0| case 46: /* create_statement: CREATE TABLE opt_not_exists table_name FROM IDENTIFIER FILE file_path */ ------------------ | Branch (3544:3): [True: 0, False: 26.1M] ------------------ 3545| 0|#line 506 "bison_parser.y" 3546| 0| { 3547| 0| (yyval.create_stmt) = new CreateStatement(kCreateTableFromTbl); 3548| 0| (yyval.create_stmt)->ifNotExists = (yyvsp[-5].bval); 3549| 0| (yyval.create_stmt)->schema = (yyvsp[-4].table_name).schema; 3550| 0| (yyval.create_stmt)->tableName = (yyvsp[-4].table_name).name; 3551| 0| if (strcasecmp((yyvsp[-2].sval), "tbl") != 0) { ------------------ | Branch (3551:7): [True: 0, False: 0] ------------------ 3552| 0| free((yyvsp[-2].sval)); 3553| 0| yyerror(&yyloc, result, scanner, "File type is unknown."); ------------------ | | 72| 0|#define yyerror hsql_error ------------------ 3554| 0| YYERROR; ------------------ | | 1480| 0|#define YYERROR goto yyerrorlab ------------------ 3555| 0| } 3556| 0| free((yyvsp[-2].sval)); 3557| 0| (yyval.create_stmt)->filePath = (yyvsp[0].sval); 3558| 0|} 3559| 0|#line 3560 "bison_parser.cpp" 3560| 0| break; 3561| | 3562| 1.33k| case 47: /* create_statement: CREATE TABLE opt_not_exists table_name '(' table_elem_commalist ')' */ ------------------ | Branch (3562:3): [True: 1.33k, False: 26.1M] ------------------ 3563| 1.33k|#line 519 "bison_parser.y" 3564| 1.33k| { 3565| 1.33k| (yyval.create_stmt) = new CreateStatement(kCreateTable); 3566| 1.33k| (yyval.create_stmt)->ifNotExists = (yyvsp[-4].bval); 3567| 1.33k| (yyval.create_stmt)->schema = (yyvsp[-3].table_name).schema; 3568| 1.33k| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3569| 1.33k| (yyval.create_stmt)->setColumnDefsAndConstraints((yyvsp[-1].table_element_vec)); 3570| 1.33k| delete (yyvsp[-1].table_element_vec); 3571| 1.33k| if (result->errorMsg()) { ------------------ | Branch (3571:7): [True: 1, False: 1.33k] ------------------ 3572| 1| delete (yyval.create_stmt); 3573| 1| YYERROR; ------------------ | | 1480| 1|#define YYERROR goto yyerrorlab ------------------ 3574| 1| } 3575| 1.33k|} 3576| 1.33k|#line 3577 "bison_parser.cpp" 3577| 1.33k| break; 3578| | 3579| 1.33k| case 48: /* create_statement: CREATE TABLE opt_not_exists table_name AS select_statement */ ------------------ | Branch (3579:3): [True: 194, False: 26.1M] ------------------ 3580| 194|#line 531 "bison_parser.y" 3581| 194| { 3582| 194| (yyval.create_stmt) = new CreateStatement(kCreateTable); 3583| 194| (yyval.create_stmt)->ifNotExists = (yyvsp[-3].bval); 3584| 194| (yyval.create_stmt)->schema = (yyvsp[-2].table_name).schema; 3585| 194| (yyval.create_stmt)->tableName = (yyvsp[-2].table_name).name; 3586| 194| (yyval.create_stmt)->select = (yyvsp[0].select_stmt); 3587| 194|} 3588| 194|#line 3589 "bison_parser.cpp" 3589| 194| break; 3590| | 3591| 1.42k| case 49: /* create_statement: CREATE INDEX opt_not_exists opt_index_name ON table_name '(' ident_commalist ')' */ ------------------ | Branch (3591:3): [True: 1.42k, False: 26.1M] ------------------ 3592| 1.42k|#line 538 "bison_parser.y" 3593| 1.42k| { 3594| 1.42k| (yyval.create_stmt) = new CreateStatement(kCreateIndex); 3595| 1.42k| (yyval.create_stmt)->indexName = (yyvsp[-5].sval); 3596| 1.42k| (yyval.create_stmt)->ifNotExists = (yyvsp[-6].bval); 3597| 1.42k| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3598| 1.42k| (yyval.create_stmt)->indexColumns = (yyvsp[-1].str_vec); 3599| 1.42k|} 3600| 1.42k|#line 3601 "bison_parser.cpp" 3601| 1.42k| break; 3602| | 3603| 327| case 50: /* create_statement: CREATE VIEW opt_not_exists table_name opt_column_list AS select_statement */ ------------------ | Branch (3603:3): [True: 327, False: 26.1M] ------------------ 3604| 327|#line 545 "bison_parser.y" 3605| 327| { 3606| 327| (yyval.create_stmt) = new CreateStatement(kCreateView); 3607| 327| (yyval.create_stmt)->ifNotExists = (yyvsp[-4].bval); 3608| 327| (yyval.create_stmt)->schema = (yyvsp[-3].table_name).schema; 3609| 327| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3610| 327| (yyval.create_stmt)->viewColumns = (yyvsp[-2].str_vec); 3611| 327| (yyval.create_stmt)->select = (yyvsp[0].select_stmt); 3612| 327|} 3613| 327|#line 3614 "bison_parser.cpp" 3614| 327| break; 3615| | 3616| 194| case 51: /* opt_not_exists: IF NOT EXISTS */ ------------------ | Branch (3616:3): [True: 194, False: 26.1M] ------------------ 3617| 194|#line 554 "bison_parser.y" 3618| 194| { (yyval.bval) = true; } 3619| 194|#line 3620 "bison_parser.cpp" 3620| 194| break; 3621| | 3622| 3.72k| case 52: /* opt_not_exists: %empty */ ------------------ | Branch (3622:3): [True: 3.72k, False: 26.1M] ------------------ 3623| 3.72k|#line 555 "bison_parser.y" 3624| 3.72k| { (yyval.bval) = false; } 3625| 3.72k|#line 3626 "bison_parser.cpp" 3626| 3.72k| break; 3627| | 3628| 1.92k| case 53: /* table_elem_commalist: table_elem */ ------------------ | Branch (3628:3): [True: 1.92k, False: 26.1M] ------------------ 3629| 1.92k|#line 557 "bison_parser.y" 3630| 1.92k| { 3631| 1.92k| (yyval.table_element_vec) = new std::vector(); 3632| 1.92k| (yyval.table_element_vec)->push_back((yyvsp[0].table_element_t)); 3633| 1.92k|} 3634| 1.92k|#line 3635 "bison_parser.cpp" 3635| 1.92k| break; 3636| | 3637| 356k| case 54: /* table_elem_commalist: table_elem_commalist ',' table_elem */ ------------------ | Branch (3637:3): [True: 356k, False: 25.7M] ------------------ 3638| 356k|#line 561 "bison_parser.y" 3639| 356k| { 3640| 356k| (yyvsp[-2].table_element_vec)->push_back((yyvsp[0].table_element_t)); 3641| 356k| (yyval.table_element_vec) = (yyvsp[-2].table_element_vec); 3642| 356k|} 3643| 356k|#line 3644 "bison_parser.cpp" 3644| 356k| break; 3645| | 3646| 214k| case 55: /* table_elem: column_def */ ------------------ | Branch (3646:3): [True: 214k, False: 25.8M] ------------------ 3647| 214k|#line 566 "bison_parser.y" 3648| 214k| { (yyval.table_element_t) = (yyvsp[0].column_t); } 3649| 214k|#line 3650 "bison_parser.cpp" 3650| 214k| break; 3651| | 3652| 144k| case 56: /* table_elem: table_constraint */ ------------------ | Branch (3652:3): [True: 144k, False: 25.9M] ------------------ 3653| 144k|#line 567 "bison_parser.y" 3654| 144k| { (yyval.table_element_t) = (yyvsp[0].table_constraint_t); } 3655| 144k|#line 3656 "bison_parser.cpp" 3656| 144k| break; 3657| | 3658| 214k| case 57: /* column_def: IDENTIFIER column_type opt_column_constraints */ ------------------ | Branch (3658:3): [True: 214k, False: 25.8M] ------------------ 3659| 214k|#line 569 "bison_parser.y" 3660| 214k| { 3661| 214k| (yyval.column_t) = new ColumnDefinition((yyvsp[-2].sval), (yyvsp[-1].column_type_t), (yyvsp[0].column_constraint_set)); 3662| 214k| if (!(yyval.column_t)->trySetNullableExplicit()) { ------------------ | Branch (3662:7): [True: 1.25k, False: 213k] ------------------ 3663| 1.25k| yyerror(&yyloc, result, scanner, ("Conflicting nullability constraints for " + std::string{(yyvsp[-2].sval)}).c_str()); ------------------ | | 72| 1.25k|#define yyerror hsql_error ------------------ 3664| 1.25k| } 3665| 214k|} 3666| 214k|#line 3667 "bison_parser.cpp" 3667| 214k| break; 3668| | 3669| 814| case 58: /* column_type: BIGINT */ ------------------ | Branch (3669:3): [True: 814, False: 26.1M] ------------------ 3670| 814|#line 576 "bison_parser.y" 3671| 814| { (yyval.column_type_t) = ColumnType{DataType::BIGINT}; } 3672| 814|#line 3673 "bison_parser.cpp" 3673| 814| break; 3674| | 3675| 622| case 59: /* column_type: BOOLEAN */ ------------------ | Branch (3675:3): [True: 622, False: 26.1M] ------------------ 3676| 622|#line 577 "bison_parser.y" 3677| 622| { (yyval.column_type_t) = ColumnType{DataType::BOOLEAN}; } 3678| 622|#line 3679 "bison_parser.cpp" 3679| 622| break; 3680| | 3681| 561| case 60: /* column_type: CHAR '(' INTVAL ')' */ ------------------ | Branch (3681:3): [True: 561, False: 26.1M] ------------------ 3682| 561|#line 578 "bison_parser.y" 3683| 561| { (yyval.column_type_t) = ColumnType{DataType::CHAR, (yyvsp[-1].ival)}; } 3684| 561|#line 3685 "bison_parser.cpp" 3685| 561| break; 3686| | 3687| 0| case 61: /* column_type: CHARACTER_VARYING '(' INTVAL ')' */ ------------------ | Branch (3687:3): [True: 0, False: 26.1M] ------------------ 3688| 0|#line 579 "bison_parser.y" 3689| 0| { (yyval.column_type_t) = ColumnType{DataType::VARCHAR, (yyvsp[-1].ival)}; } 3690| 0|#line 3691 "bison_parser.cpp" 3691| 0| break; 3692| | 3693| 536| case 62: /* column_type: DATE */ ------------------ | Branch (3693:3): [True: 536, False: 26.1M] ------------------ 3694| 536|#line 580 "bison_parser.y" 3695| 536| { (yyval.column_type_t) = ColumnType{DataType::DATE}; } 3696| 536|#line 3697 "bison_parser.cpp" 3697| 536| break; 3698| | 3699| 559| case 63: /* column_type: DATETIME */ ------------------ | Branch (3699:3): [True: 559, False: 26.1M] ------------------ 3700| 559|#line 581 "bison_parser.y" 3701| 559| { (yyval.column_type_t) = ColumnType{DataType::DATETIME}; } 3702| 559|#line 3703 "bison_parser.cpp" 3703| 559| break; 3704| | 3705| 1.03k| case 64: /* column_type: DECIMAL opt_decimal_specification */ ------------------ | Branch (3705:3): [True: 1.03k, False: 26.1M] ------------------ 3706| 1.03k|#line 582 "bison_parser.y" 3707| 1.03k| { 3708| 1.03k| (yyval.column_type_t) = ColumnType{DataType::DECIMAL, 0, (yyvsp[0].ival_pair)->first, (yyvsp[0].ival_pair)->second}; 3709| 1.03k| delete (yyvsp[0].ival_pair); 3710| 1.03k|} 3711| 1.03k|#line 3712 "bison_parser.cpp" 3712| 1.03k| break; 3713| | 3714| 771| case 65: /* column_type: DOUBLE */ ------------------ | Branch (3714:3): [True: 771, False: 26.1M] ------------------ 3715| 771|#line 586 "bison_parser.y" 3716| 771| { (yyval.column_type_t) = ColumnType{DataType::DOUBLE}; } 3717| 771|#line 3718 "bison_parser.cpp" 3718| 771| break; 3719| | 3720| 715| case 66: /* column_type: FLOAT */ ------------------ | Branch (3720:3): [True: 715, False: 26.1M] ------------------ 3721| 715|#line 587 "bison_parser.y" 3722| 715| { (yyval.column_type_t) = ColumnType{DataType::FLOAT}; } 3723| 715|#line 3724 "bison_parser.cpp" 3724| 715| break; 3725| | 3726| 39.6k| case 67: /* column_type: INT */ ------------------ | Branch (3726:3): [True: 39.6k, False: 26.0M] ------------------ 3727| 39.6k|#line 588 "bison_parser.y" 3728| 39.6k| { (yyval.column_type_t) = ColumnType{DataType::INT}; } 3729| 39.6k|#line 3730 "bison_parser.cpp" 3730| 39.6k| break; 3731| | 3732| 665| case 68: /* column_type: INTEGER */ ------------------ | Branch (3732:3): [True: 665, False: 26.1M] ------------------ 3733| 665|#line 589 "bison_parser.y" 3734| 665| { (yyval.column_type_t) = ColumnType{DataType::INT}; } 3735| 665|#line 3736 "bison_parser.cpp" 3736| 665| break; 3737| | 3738| 523| case 69: /* column_type: LONG */ ------------------ | Branch (3738:3): [True: 523, False: 26.1M] ------------------ 3739| 523|#line 590 "bison_parser.y" 3740| 523| { (yyval.column_type_t) = ColumnType{DataType::LONG}; } 3741| 523|#line 3742 "bison_parser.cpp" 3742| 523| break; 3743| | 3744| 553| case 70: /* column_type: REAL */ ------------------ | Branch (3744:3): [True: 553, False: 26.1M] ------------------ 3745| 553|#line 591 "bison_parser.y" 3746| 553| { (yyval.column_type_t) = ColumnType{DataType::REAL}; } 3747| 553|#line 3748 "bison_parser.cpp" 3748| 553| break; 3749| | 3750| 553| case 71: /* column_type: SMALLINT */ ------------------ | Branch (3750:3): [True: 553, False: 26.1M] ------------------ 3751| 553|#line 592 "bison_parser.y" 3752| 553| { (yyval.column_type_t) = ColumnType{DataType::SMALLINT}; } 3753| 553|#line 3754 "bison_parser.cpp" 3754| 553| break; 3755| | 3756| 567| case 72: /* column_type: TEXT */ ------------------ | Branch (3756:3): [True: 567, False: 26.1M] ------------------ 3757| 567|#line 593 "bison_parser.y" 3758| 567| { (yyval.column_type_t) = ColumnType{DataType::TEXT}; } 3759| 567|#line 3760 "bison_parser.cpp" 3760| 567| break; 3761| | 3762| 109k| case 73: /* column_type: TIME opt_time_precision */ ------------------ | Branch (3762:3): [True: 109k, False: 25.9M] ------------------ 3763| 109k|#line 594 "bison_parser.y" 3764| 109k| { (yyval.column_type_t) = ColumnType{DataType::TIME, 0, (yyvsp[0].ival)}; } 3765| 109k|#line 3766 "bison_parser.cpp" 3766| 109k| break; 3767| | 3768| 56.7k| case 74: /* column_type: TIMESTAMP */ ------------------ | Branch (3768:3): [True: 56.7k, False: 26.0M] ------------------ 3769| 56.7k|#line 595 "bison_parser.y" 3770| 56.7k| { (yyval.column_type_t) = ColumnType{DataType::DATETIME}; } 3771| 56.7k|#line 3772 "bison_parser.cpp" 3772| 56.7k| break; 3773| | 3774| 787| case 75: /* column_type: VARCHAR '(' INTVAL ')' */ ------------------ | Branch (3774:3): [True: 787, False: 26.1M] ------------------ 3775| 787|#line 596 "bison_parser.y" 3776| 787| { (yyval.column_type_t) = ColumnType{DataType::VARCHAR, (yyvsp[-1].ival)}; } 3777| 787|#line 3778 "bison_parser.cpp" 3778| 787| break; 3779| | 3780| 194| case 76: /* opt_time_precision: '(' INTVAL ')' */ ------------------ | Branch (3780:3): [True: 194, False: 26.1M] ------------------ 3781| 194|#line 598 "bison_parser.y" 3782| 194| { (yyval.ival) = (yyvsp[-1].ival); } 3783| 194|#line 3784 "bison_parser.cpp" 3784| 194| break; 3785| | 3786| 109k| case 77: /* opt_time_precision: %empty */ ------------------ | Branch (3786:3): [True: 109k, False: 25.9M] ------------------ 3787| 109k|#line 599 "bison_parser.y" 3788| 109k| { (yyval.ival) = 0; } 3789| 109k|#line 3790 "bison_parser.cpp" 3790| 109k| break; 3791| | 3792| 194| case 78: /* opt_decimal_specification: '(' INTVAL ',' INTVAL ')' */ ------------------ | Branch (3792:3): [True: 194, False: 26.1M] ------------------ 3793| 194|#line 601 "bison_parser.y" 3794| 194| { (yyval.ival_pair) = new std::pair{(yyvsp[-3].ival), (yyvsp[-1].ival)}; } 3795| 194|#line 3796 "bison_parser.cpp" 3796| 194| break; 3797| | 3798| 194| case 79: /* opt_decimal_specification: '(' INTVAL ')' */ ------------------ | Branch (3798:3): [True: 194, False: 26.1M] ------------------ 3799| 194|#line 602 "bison_parser.y" 3800| 194| { (yyval.ival_pair) = new std::pair{(yyvsp[-1].ival), 0}; } 3801| 194|#line 3802 "bison_parser.cpp" 3802| 194| break; 3803| | 3804| 642| case 80: /* opt_decimal_specification: %empty */ ------------------ | Branch (3804:3): [True: 642, False: 26.1M] ------------------ 3805| 642|#line 603 "bison_parser.y" 3806| 642| { (yyval.ival_pair) = new std::pair{0, 0}; } 3807| 642|#line 3808 "bison_parser.cpp" 3808| 642| break; 3809| | 3810| 3.26k| case 81: /* opt_column_constraints: column_constraint_set */ ------------------ | Branch (3810:3): [True: 3.26k, False: 26.1M] ------------------ 3811| 3.26k|#line 605 "bison_parser.y" 3812| 3.26k| { (yyval.column_constraint_set) = (yyvsp[0].column_constraint_set); } 3813| 3.26k|#line 3814 "bison_parser.cpp" 3814| 3.26k| break; 3815| | 3816| 211k| case 82: /* opt_column_constraints: %empty */ ------------------ | Branch (3816:3): [True: 211k, False: 25.8M] ------------------ 3817| 211k|#line 606 "bison_parser.y" 3818| 211k| { (yyval.column_constraint_set) = new std::unordered_set(); } 3819| 211k|#line 3820 "bison_parser.cpp" 3820| 211k| break; 3821| | 3822| 3.27k| case 83: /* column_constraint_set: column_constraint */ ------------------ | Branch (3822:3): [True: 3.27k, False: 26.1M] ------------------ 3823| 3.27k|#line 608 "bison_parser.y" 3824| 3.27k| { 3825| 3.27k| (yyval.column_constraint_set) = new std::unordered_set(); 3826| 3.27k| (yyval.column_constraint_set)->insert((yyvsp[0].column_constraint_t)); 3827| 3.27k|} 3828| 3.27k|#line 3829 "bison_parser.cpp" 3829| 3.27k| break; 3830| | 3831| 6.02k| case 84: /* column_constraint_set: column_constraint_set column_constraint */ ------------------ | Branch (3831:3): [True: 6.02k, False: 26.1M] ------------------ 3832| 6.02k|#line 612 "bison_parser.y" 3833| 6.02k| { 3834| 6.02k| (yyvsp[-1].column_constraint_set)->insert((yyvsp[0].column_constraint_t)); 3835| 6.02k| (yyval.column_constraint_set) = (yyvsp[-1].column_constraint_set); 3836| 6.02k|} 3837| 6.02k|#line 3838 "bison_parser.cpp" 3838| 6.02k| break; 3839| | 3840| 2.34k| case 85: /* column_constraint: PRIMARY KEY */ ------------------ | Branch (3840:3): [True: 2.34k, False: 26.1M] ------------------ 3841| 2.34k|#line 617 "bison_parser.y" 3842| 2.34k| { (yyval.column_constraint_t) = ConstraintType::PrimaryKey; } 3843| 2.34k|#line 3844 "bison_parser.cpp" 3844| 2.34k| break; 3845| | 3846| 2.30k| case 86: /* column_constraint: UNIQUE */ ------------------ | Branch (3846:3): [True: 2.30k, False: 26.1M] ------------------ 3847| 2.30k|#line 618 "bison_parser.y" 3848| 2.30k| { (yyval.column_constraint_t) = ConstraintType::Unique; } 3849| 2.30k|#line 3850 "bison_parser.cpp" 3850| 2.30k| break; 3851| | 3852| 2.82k| case 87: /* column_constraint: NULL */ ------------------ | Branch (3852:3): [True: 2.82k, False: 26.1M] ------------------ 3853| 2.82k|#line 619 "bison_parser.y" 3854| 2.82k| { (yyval.column_constraint_t) = ConstraintType::Null; } 3855| 2.82k|#line 3856 "bison_parser.cpp" 3856| 2.82k| break; 3857| | 3858| 1.82k| case 88: /* column_constraint: NOT NULL */ ------------------ | Branch (3858:3): [True: 1.82k, False: 26.1M] ------------------ 3859| 1.82k|#line 620 "bison_parser.y" 3860| 1.82k| { (yyval.column_constraint_t) = ConstraintType::NotNull; } 3861| 1.82k|#line 3862 "bison_parser.cpp" 3862| 1.82k| break; 3863| | 3864| 195| case 89: /* table_constraint: PRIMARY KEY '(' ident_commalist ')' */ ------------------ | Branch (3864:3): [True: 195, False: 26.1M] ------------------ 3865| 195|#line 622 "bison_parser.y" 3866| 195| { (yyval.table_constraint_t) = new TableConstraint(ConstraintType::PrimaryKey, (yyvsp[-1].str_vec)); } 3867| 195|#line 3868 "bison_parser.cpp" 3868| 195| break; 3869| | 3870| 144k| case 90: /* table_constraint: UNIQUE '(' ident_commalist ')' */ ------------------ | Branch (3870:3): [True: 144k, False: 25.9M] ------------------ 3871| 144k|#line 623 "bison_parser.y" 3872| 144k| { (yyval.table_constraint_t) = new TableConstraint(ConstraintType::Unique, (yyvsp[-1].str_vec)); } 3873| 144k|#line 3874 "bison_parser.cpp" 3874| 144k| break; 3875| | 3876| 769| case 91: /* drop_statement: DROP TABLE opt_exists table_name */ ------------------ | Branch (3876:3): [True: 769, False: 26.1M] ------------------ 3877| 769|#line 631 "bison_parser.y" 3878| 769| { 3879| 769| (yyval.drop_stmt) = new DropStatement(kDropTable); 3880| 769| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 3881| 769| (yyval.drop_stmt)->schema = (yyvsp[0].table_name).schema; 3882| 769| (yyval.drop_stmt)->name = (yyvsp[0].table_name).name; 3883| 769|} 3884| 769|#line 3885 "bison_parser.cpp" 3885| 769| break; 3886| | 3887| 1.51k| case 92: /* drop_statement: DROP VIEW opt_exists table_name */ ------------------ | Branch (3887:3): [True: 1.51k, False: 26.1M] ------------------ 3888| 1.51k|#line 637 "bison_parser.y" 3889| 1.51k| { 3890| 1.51k| (yyval.drop_stmt) = new DropStatement(kDropView); 3891| 1.51k| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 3892| 1.51k| (yyval.drop_stmt)->schema = (yyvsp[0].table_name).schema; 3893| 1.51k| (yyval.drop_stmt)->name = (yyvsp[0].table_name).name; 3894| 1.51k|} 3895| 1.51k|#line 3896 "bison_parser.cpp" 3896| 1.51k| break; 3897| | 3898| 861| case 93: /* drop_statement: DEALLOCATE PREPARE IDENTIFIER */ ------------------ | Branch (3898:3): [True: 861, False: 26.1M] ------------------ 3899| 861|#line 643 "bison_parser.y" 3900| 861| { 3901| 861| (yyval.drop_stmt) = new DropStatement(kDropPreparedStatement); 3902| 861| (yyval.drop_stmt)->ifExists = false; 3903| 861| (yyval.drop_stmt)->name = (yyvsp[0].sval); 3904| 861|} 3905| 861|#line 3906 "bison_parser.cpp" 3906| 861| break; 3907| | 3908| 708| case 94: /* drop_statement: DROP INDEX opt_exists IDENTIFIER */ ------------------ | Branch (3908:3): [True: 708, False: 26.1M] ------------------ 3909| 708|#line 649 "bison_parser.y" 3910| 708| { 3911| 708| (yyval.drop_stmt) = new DropStatement(kDropIndex); 3912| 708| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 3913| 708| (yyval.drop_stmt)->indexName = (yyvsp[0].sval); 3914| 708|} 3915| 708|#line 3916 "bison_parser.cpp" 3916| 708| break; 3917| | 3918| 311| case 95: /* opt_exists: IF EXISTS */ ------------------ | Branch (3918:3): [True: 311, False: 26.1M] ------------------ 3919| 311|#line 655 "bison_parser.y" 3920| 311| { (yyval.bval) = true; } 3921| 311|#line 3922 "bison_parser.cpp" 3922| 311| break; 3923| | 3924| 2.71k| case 96: /* opt_exists: %empty */ ------------------ | Branch (3924:3): [True: 2.71k, False: 26.1M] ------------------ 3925| 2.71k|#line 656 "bison_parser.y" 3926| 2.71k| { (yyval.bval) = false; } 3927| 2.71k|#line 3928 "bison_parser.cpp" 3928| 2.71k| break; 3929| | 3930| 0| case 97: /* alter_statement: ALTER TABLE opt_exists table_name alter_action */ ------------------ | Branch (3930:3): [True: 0, False: 26.1M] ------------------ 3931| 0|#line 663 "bison_parser.y" 3932| 0| { 3933| 0| (yyval.alter_stmt) = new AlterStatement((yyvsp[-1].table_name).name, (yyvsp[0].alter_action_t)); 3934| 0| (yyval.alter_stmt)->ifTableExists = (yyvsp[-2].bval); 3935| 0| (yyval.alter_stmt)->schema = (yyvsp[-1].table_name).schema; 3936| 0|} 3937| 0|#line 3938 "bison_parser.cpp" 3938| 0| break; 3939| | 3940| 0| case 98: /* alter_action: drop_action */ ------------------ | Branch (3940:3): [True: 0, False: 26.1M] ------------------ 3941| 0|#line 669 "bison_parser.y" 3942| 0| { (yyval.alter_action_t) = (yyvsp[0].drop_action_t); } 3943| 0|#line 3944 "bison_parser.cpp" 3944| 0| break; 3945| | 3946| 0| case 99: /* drop_action: DROP COLUMN opt_exists IDENTIFIER */ ------------------ | Branch (3946:3): [True: 0, False: 26.1M] ------------------ 3947| 0|#line 671 "bison_parser.y" 3948| 0| { 3949| 0| (yyval.drop_action_t) = new DropColumnAction((yyvsp[0].sval)); 3950| 0| (yyval.drop_action_t)->ifExists = (yyvsp[-1].bval); 3951| 0|} 3952| 0|#line 3953 "bison_parser.cpp" 3953| 0| break; 3954| | 3955| 1.28k| case 100: /* delete_statement: DELETE FROM table_name opt_where */ ------------------ | Branch (3955:3): [True: 1.28k, False: 26.1M] ------------------ 3956| 1.28k|#line 681 "bison_parser.y" 3957| 1.28k| { 3958| 1.28k| (yyval.delete_stmt) = new DeleteStatement(); 3959| 1.28k| (yyval.delete_stmt)->schema = (yyvsp[-1].table_name).schema; 3960| 1.28k| (yyval.delete_stmt)->tableName = (yyvsp[-1].table_name).name; 3961| 1.28k| (yyval.delete_stmt)->expr = (yyvsp[0].expr); 3962| 1.28k|} 3963| 1.28k|#line 3964 "bison_parser.cpp" 3964| 1.28k| break; 3965| | 3966| 581| case 101: /* truncate_statement: TRUNCATE table_name */ ------------------ | Branch (3966:3): [True: 581, False: 26.1M] ------------------ 3967| 581|#line 688 "bison_parser.y" 3968| 581| { 3969| 581| (yyval.delete_stmt) = new DeleteStatement(); 3970| 581| (yyval.delete_stmt)->schema = (yyvsp[0].table_name).schema; 3971| 581| (yyval.delete_stmt)->tableName = (yyvsp[0].table_name).name; 3972| 581|} 3973| 581|#line 3974 "bison_parser.cpp" 3974| 581| break; 3975| | 3976| 816| case 102: /* insert_statement: INSERT INTO table_name opt_column_list VALUES '(' literal_list ')' */ ------------------ | Branch (3976:3): [True: 816, False: 26.1M] ------------------ 3977| 816|#line 699 "bison_parser.y" 3978| 816| { 3979| 816| (yyval.insert_stmt) = new InsertStatement(kInsertValues); 3980| 816| (yyval.insert_stmt)->schema = (yyvsp[-5].table_name).schema; 3981| 816| (yyval.insert_stmt)->tableName = (yyvsp[-5].table_name).name; 3982| 816| (yyval.insert_stmt)->columns = (yyvsp[-4].str_vec); 3983| 816| (yyval.insert_stmt)->values = (yyvsp[-1].expr_vec); 3984| 816|} 3985| 816|#line 3986 "bison_parser.cpp" 3986| 816| break; 3987| | 3988| 1.66k| case 103: /* insert_statement: INSERT INTO table_name opt_column_list select_no_paren */ ------------------ | Branch (3988:3): [True: 1.66k, False: 26.1M] ------------------ 3989| 1.66k|#line 706 "bison_parser.y" 3990| 1.66k| { 3991| 1.66k| (yyval.insert_stmt) = new InsertStatement(kInsertSelect); 3992| 1.66k| (yyval.insert_stmt)->schema = (yyvsp[-2].table_name).schema; 3993| 1.66k| (yyval.insert_stmt)->tableName = (yyvsp[-2].table_name).name; 3994| 1.66k| (yyval.insert_stmt)->columns = (yyvsp[-1].str_vec); 3995| 1.66k| (yyval.insert_stmt)->select = (yyvsp[0].select_stmt); 3996| 1.66k|} 3997| 1.66k|#line 3998 "bison_parser.cpp" 3998| 1.66k| break; 3999| | 4000| 647| case 104: /* opt_column_list: '(' ident_commalist ')' */ ------------------ | Branch (4000:3): [True: 647, False: 26.1M] ------------------ 4001| 647|#line 714 "bison_parser.y" 4002| 647| { (yyval.str_vec) = (yyvsp[-1].str_vec); } 4003| 647|#line 4004 "bison_parser.cpp" 4004| 647| break; 4005| | 4006| 2.21k| case 105: /* opt_column_list: %empty */ ------------------ | Branch (4006:3): [True: 2.21k, False: 26.1M] ------------------ 4007| 2.21k|#line 715 "bison_parser.y" 4008| 2.21k| { (yyval.str_vec) = nullptr; } 4009| 2.21k|#line 4010 "bison_parser.cpp" 4010| 2.21k| break; 4011| | 4012| 1.19k| case 106: /* update_statement: UPDATE table_ref_name_no_alias SET update_clause_commalist opt_where */ ------------------ | Branch (4012:3): [True: 1.19k, False: 26.1M] ------------------ 4013| 1.19k|#line 722 "bison_parser.y" 4014| 1.19k| { 4015| 1.19k| (yyval.update_stmt) = new UpdateStatement(); 4016| 1.19k| (yyval.update_stmt)->table = (yyvsp[-3].table); 4017| 1.19k| (yyval.update_stmt)->updates = (yyvsp[-1].update_vec); 4018| 1.19k| (yyval.update_stmt)->where = (yyvsp[0].expr); 4019| 1.19k|} 4020| 1.19k|#line 4021 "bison_parser.cpp" 4021| 1.19k| break; 4022| | 4023| 1.21k| case 107: /* update_clause_commalist: update_clause */ ------------------ | Branch (4023:3): [True: 1.21k, False: 26.1M] ------------------ 4024| 1.21k|#line 729 "bison_parser.y" 4025| 1.21k| { 4026| 1.21k| (yyval.update_vec) = new std::vector(); 4027| 1.21k| (yyval.update_vec)->push_back((yyvsp[0].update_t)); 4028| 1.21k|} 4029| 1.21k|#line 4030 "bison_parser.cpp" 4030| 1.21k| break; 4031| | 4032| 266k| case 108: /* update_clause_commalist: update_clause_commalist ',' update_clause */ ------------------ | Branch (4032:3): [True: 266k, False: 25.8M] ------------------ 4033| 266k|#line 733 "bison_parser.y" 4034| 266k| { 4035| 266k| (yyvsp[-2].update_vec)->push_back((yyvsp[0].update_t)); 4036| 266k| (yyval.update_vec) = (yyvsp[-2].update_vec); 4037| 266k|} 4038| 266k|#line 4039 "bison_parser.cpp" 4039| 266k| break; 4040| | 4041| 267k| case 109: /* update_clause: IDENTIFIER '=' expr */ ------------------ | Branch (4041:3): [True: 267k, False: 25.8M] ------------------ 4042| 267k|#line 738 "bison_parser.y" 4043| 267k| { 4044| 267k| (yyval.update_t) = new UpdateClause(); 4045| 267k| (yyval.update_t)->column = (yyvsp[-2].sval); 4046| 267k| (yyval.update_t)->value = (yyvsp[0].expr); 4047| 267k|} 4048| 267k|#line 4049 "bison_parser.cpp" 4049| 267k| break; 4050| | 4051| 207| case 110: /* select_statement: opt_with_clause select_with_paren */ ------------------ | Branch (4051:3): [True: 207, False: 26.1M] ------------------ 4052| 207|#line 748 "bison_parser.y" 4053| 207| { 4054| 207| (yyval.select_stmt) = (yyvsp[0].select_stmt); 4055| 207| (yyval.select_stmt)->withDescriptions = (yyvsp[-1].with_description_vec); 4056| 207|} 4057| 207|#line 4058 "bison_parser.cpp" 4058| 207| break; 4059| | 4060| 12.0k| case 111: /* select_statement: opt_with_clause select_no_paren */ ------------------ | Branch (4060:3): [True: 12.0k, False: 26.0M] ------------------ 4061| 12.0k|#line 752 "bison_parser.y" 4062| 12.0k| { 4063| 12.0k| (yyval.select_stmt) = (yyvsp[0].select_stmt); 4064| 12.0k| (yyval.select_stmt)->withDescriptions = (yyvsp[-1].with_description_vec); 4065| 12.0k|} 4066| 12.0k|#line 4067 "bison_parser.cpp" 4067| 12.0k| break; 4068| | 4069| 458| case 112: /* select_statement: opt_with_clause select_with_paren set_operator select_within_set_operation opt_order opt_limit */ ------------------ | Branch (4069:3): [True: 458, False: 26.1M] ------------------ 4070| 458|#line 756 "bison_parser.y" 4071| 458| { 4072| 458| (yyval.select_stmt) = (yyvsp[-4].select_stmt); 4073| 458| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4073:7): [True: 194, False: 264] ------------------ 4074| 194| (yyval.select_stmt)->setOperations = new std::vector(); 4075| 194| } 4076| 458| (yyval.select_stmt)->setOperations->push_back((yyvsp[-3].set_operator_t)); 4077| 458| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[-2].select_stmt); 4078| 458| (yyval.select_stmt)->setOperations->back()->resultOrder = (yyvsp[-1].order_vec); 4079| 458| (yyval.select_stmt)->setOperations->back()->resultLimit = (yyvsp[0].limit); 4080| 458| (yyval.select_stmt)->withDescriptions = (yyvsp[-5].with_description_vec); 4081| 458|} 4082| 458|#line 4083 "bison_parser.cpp" 4083| 458| break; 4084| | 4085| 1.61k| case 115: /* select_within_set_operation_no_parentheses: select_clause */ ------------------ | Branch (4085:3): [True: 1.61k, False: 26.1M] ------------------ 4086| 1.61k|#line 770 "bison_parser.y" 4087| 1.61k| { (yyval.select_stmt) = (yyvsp[0].select_stmt); } 4088| 1.61k|#line 4089 "bison_parser.cpp" 4089| 1.61k| break; 4090| | 4091| 1.54k| case 116: /* select_within_set_operation_no_parentheses: select_clause set_operator select_within_set_operation */ ------------------ | Branch (4091:3): [True: 1.54k, False: 26.1M] ------------------ 4092| 1.54k|#line 771 "bison_parser.y" 4093| 1.54k| { 4094| 1.54k| (yyval.select_stmt) = (yyvsp[-2].select_stmt); 4095| 1.54k| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4095:7): [True: 1.54k, False: 0] ------------------ 4096| 1.54k| (yyval.select_stmt)->setOperations = new std::vector(); 4097| 1.54k| } 4098| 1.54k| (yyval.select_stmt)->setOperations->push_back((yyvsp[-1].set_operator_t)); 4099| 1.54k| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[0].select_stmt); 4100| 1.54k|} 4101| 1.54k|#line 4102 "bison_parser.cpp" 4102| 1.54k| break; 4103| | 4104| 37.1k| case 117: /* select_with_paren: '(' select_no_paren ')' */ ------------------ | Branch (4104:3): [True: 37.1k, False: 26.0M] ------------------ 4105| 37.1k|#line 780 "bison_parser.y" 4106| 37.1k| { (yyval.select_stmt) = (yyvsp[-1].select_stmt); } 4107| 37.1k|#line 4108 "bison_parser.cpp" 4108| 37.1k| break; 4109| | 4110| 194| case 118: /* select_with_paren: '(' select_with_paren ')' */ ------------------ | Branch (4110:3): [True: 194, False: 26.1M] ------------------ 4111| 194|#line 781 "bison_parser.y" 4112| 194| { (yyval.select_stmt) = (yyvsp[-1].select_stmt); } 4113| 194|#line 4114 "bison_parser.cpp" 4114| 194| break; 4115| | 4116| 51.6k| case 119: /* select_no_paren: select_clause opt_order opt_limit opt_locking_clause */ ------------------ | Branch (4116:3): [True: 51.6k, False: 26.0M] ------------------ 4117| 51.6k|#line 783 "bison_parser.y" 4118| 51.6k| { 4119| 51.6k| (yyval.select_stmt) = (yyvsp[-3].select_stmt); 4120| 51.6k| (yyval.select_stmt)->order = (yyvsp[-2].order_vec); 4121| | 4122| | // Limit could have been set by TOP. 4123| 51.6k| if ((yyvsp[-1].limit)) { ------------------ | Branch (4123:7): [True: 2.54k, False: 49.1k] ------------------ 4124| 2.54k| delete (yyval.select_stmt)->limit; 4125| 2.54k| (yyval.select_stmt)->limit = (yyvsp[-1].limit); 4126| 2.54k| } 4127| | 4128| 51.6k| if ((yyvsp[0].locking_clause_vec)) { ------------------ | Branch (4128:7): [True: 441, False: 51.2k] ------------------ 4129| 441| (yyval.select_stmt)->lockings = (yyvsp[0].locking_clause_vec); 4130| 441| } 4131| 51.6k|} 4132| 51.6k|#line 4133 "bison_parser.cpp" 4133| 51.6k| break; 4134| | 4135| 1.13k| case 120: /* select_no_paren: select_clause set_operator select_within_set_operation opt_order opt_limit opt_locking_clause */ ------------------ | Branch (4135:3): [True: 1.13k, False: 26.1M] ------------------ 4136| 1.13k|#line 797 "bison_parser.y" 4137| 1.13k| { 4138| 1.13k| (yyval.select_stmt) = (yyvsp[-5].select_stmt); 4139| 1.13k| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4139:7): [True: 1.13k, False: 0] ------------------ 4140| 1.13k| (yyval.select_stmt)->setOperations = new std::vector(); 4141| 1.13k| } 4142| 1.13k| (yyval.select_stmt)->setOperations->push_back((yyvsp[-4].set_operator_t)); 4143| 1.13k| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[-3].select_stmt); 4144| 1.13k| (yyval.select_stmt)->setOperations->back()->resultOrder = (yyvsp[-2].order_vec); 4145| 1.13k| (yyval.select_stmt)->setOperations->back()->resultLimit = (yyvsp[-1].limit); 4146| 1.13k| (yyval.select_stmt)->lockings = (yyvsp[0].locking_clause_vec); 4147| 1.13k|} 4148| 1.13k|#line 4149 "bison_parser.cpp" 4149| 1.13k| break; 4150| | 4151| 4.38k| case 121: /* set_operator: set_type opt_all */ ------------------ | Branch (4151:3): [True: 4.38k, False: 26.1M] ------------------ 4152| 4.38k|#line 809 "bison_parser.y" 4153| 4.38k| { 4154| 4.38k| (yyval.set_operator_t) = (yyvsp[-1].set_operator_t); 4155| 4.38k| (yyval.set_operator_t)->isAll = (yyvsp[0].bval); 4156| 4.38k|} 4157| 4.38k|#line 4158 "bison_parser.cpp" 4158| 4.38k| break; 4159| | 4160| 2.73k| case 122: /* set_type: UNION */ ------------------ | Branch (4160:3): [True: 2.73k, False: 26.1M] ------------------ 4161| 2.73k|#line 814 "bison_parser.y" 4162| 2.73k| { 4163| 2.73k| (yyval.set_operator_t) = new SetOperation(); 4164| 2.73k| (yyval.set_operator_t)->setType = SetType::kSetUnion; 4165| 2.73k|} 4166| 2.73k|#line 4167 "bison_parser.cpp" 4167| 2.73k| break; 4168| | 4169| 710| case 123: /* set_type: INTERSECT */ ------------------ | Branch (4169:3): [True: 710, False: 26.1M] ------------------ 4170| 710|#line 818 "bison_parser.y" 4171| 710| { 4172| 710| (yyval.set_operator_t) = new SetOperation(); 4173| 710| (yyval.set_operator_t)->setType = SetType::kSetIntersect; 4174| 710|} 4175| 710|#line 4176 "bison_parser.cpp" 4176| 710| break; 4177| | 4178| 942| case 124: /* set_type: EXCEPT */ ------------------ | Branch (4178:3): [True: 942, False: 26.1M] ------------------ 4179| 942|#line 822 "bison_parser.y" 4180| 942| { 4181| 942| (yyval.set_operator_t) = new SetOperation(); 4182| 942| (yyval.set_operator_t)->setType = SetType::kSetExcept; 4183| 942|} 4184| 942|#line 4185 "bison_parser.cpp" 4185| 942| break; 4186| | 4187| 232| case 125: /* opt_all: ALL */ ------------------ | Branch (4187:3): [True: 232, False: 26.1M] ------------------ 4188| 232|#line 827 "bison_parser.y" 4189| 232| { (yyval.bval) = true; } 4190| 232|#line 4191 "bison_parser.cpp" 4191| 232| break; 4192| | 4193| 4.15k| case 126: /* opt_all: %empty */ ------------------ | Branch (4193:3): [True: 4.15k, False: 26.1M] ------------------ 4194| 4.15k|#line 828 "bison_parser.y" 4195| 4.15k| { (yyval.bval) = false; } 4196| 4.15k|#line 4197 "bison_parser.cpp" 4197| 4.15k| break; 4198| | 4199| 57.8k| case 127: /* select_clause: SELECT opt_top opt_distinct select_list opt_from_clause opt_where opt_group */ ------------------ | Branch (4199:3): [True: 57.8k, False: 26.0M] ------------------ 4200| 57.8k|#line 830 "bison_parser.y" 4201| 57.8k| { 4202| 57.8k| (yyval.select_stmt) = new SelectStatement(); 4203| 57.8k| (yyval.select_stmt)->limit = (yyvsp[-5].limit); 4204| 57.8k| (yyval.select_stmt)->selectDistinct = (yyvsp[-4].bval); 4205| 57.8k| (yyval.select_stmt)->selectList = (yyvsp[-3].expr_vec); 4206| 57.8k| (yyval.select_stmt)->fromTable = (yyvsp[-2].table); 4207| 57.8k| (yyval.select_stmt)->whereClause = (yyvsp[-1].expr); 4208| 57.8k| (yyval.select_stmt)->groupBy = (yyvsp[0].group_t); 4209| 57.8k|} 4210| 57.8k|#line 4211 "bison_parser.cpp" 4211| 57.8k| break; 4212| | 4213| 590| case 128: /* opt_distinct: DISTINCT */ ------------------ | Branch (4213:3): [True: 590, False: 26.1M] ------------------ 4214| 590|#line 840 "bison_parser.y" 4215| 590| { (yyval.bval) = true; } 4216| 590|#line 4217 "bison_parser.cpp" 4217| 590| break; 4218| | 4219| 62.1k| case 129: /* opt_distinct: %empty */ ------------------ | Branch (4219:3): [True: 62.1k, False: 26.0M] ------------------ 4220| 62.1k|#line 841 "bison_parser.y" 4221| 62.1k| { (yyval.bval) = false; } 4222| 62.1k|#line 4223 "bison_parser.cpp" 4223| 62.1k| break; 4224| | 4225| 990| case 131: /* opt_from_clause: from_clause */ ------------------ | Branch (4225:3): [True: 990, False: 26.1M] ------------------ 4226| 990|#line 845 "bison_parser.y" 4227| 990| { (yyval.table) = (yyvsp[0].table); } 4228| 990|#line 4229 "bison_parser.cpp" 4229| 990| break; 4230| | 4231| 57.1k| case 132: /* opt_from_clause: %empty */ ------------------ | Branch (4231:3): [True: 57.1k, False: 26.0M] ------------------ 4232| 57.1k|#line 846 "bison_parser.y" 4233| 57.1k| { (yyval.table) = nullptr; } 4234| 57.1k|#line 4235 "bison_parser.cpp" 4235| 57.1k| break; 4236| | 4237| 990| case 133: /* from_clause: FROM table_ref */ ------------------ | Branch (4237:3): [True: 990, False: 26.1M] ------------------ 4238| 990|#line 848 "bison_parser.y" 4239| 990| { (yyval.table) = (yyvsp[0].table); } 4240| 990|#line 4241 "bison_parser.cpp" 4241| 990| break; 4242| | 4243| 1.28k| case 134: /* opt_where: WHERE expr */ ------------------ | Branch (4243:3): [True: 1.28k, False: 26.1M] ------------------ 4244| 1.28k|#line 850 "bison_parser.y" 4245| 1.28k| { (yyval.expr) = (yyvsp[0].expr); } 4246| 1.28k|#line 4247 "bison_parser.cpp" 4247| 1.28k| break; 4248| | 4249| 59.7k| case 135: /* opt_where: %empty */ ------------------ | Branch (4249:3): [True: 59.7k, False: 26.0M] ------------------ 4250| 59.7k|#line 851 "bison_parser.y" 4251| 59.7k| { (yyval.expr) = nullptr; } 4252| 59.7k|#line 4253 "bison_parser.cpp" 4253| 59.7k| break; 4254| | 4255| 1.51k| case 136: /* opt_group: GROUP BY expr_list opt_having */ ------------------ | Branch (4255:3): [True: 1.51k, False: 26.1M] ------------------ 4256| 1.51k|#line 853 "bison_parser.y" 4257| 1.51k| { 4258| 1.51k| (yyval.group_t) = new GroupByDescription(); 4259| 1.51k| (yyval.group_t)->columns = (yyvsp[-1].expr_vec); 4260| 1.51k| (yyval.group_t)->having = (yyvsp[0].expr); 4261| 1.51k|} 4262| 1.51k|#line 4263 "bison_parser.cpp" 4263| 1.51k| break; 4264| | 4265| 56.3k| case 137: /* opt_group: %empty */ ------------------ | Branch (4265:3): [True: 56.3k, False: 26.0M] ------------------ 4266| 56.3k|#line 858 "bison_parser.y" 4267| 56.3k| { (yyval.group_t) = nullptr; } 4268| 56.3k|#line 4269 "bison_parser.cpp" 4269| 56.3k| break; 4270| | 4271| 747| case 138: /* opt_having: HAVING expr */ ------------------ | Branch (4271:3): [True: 747, False: 26.1M] ------------------ 4272| 747|#line 860 "bison_parser.y" 4273| 747| { (yyval.expr) = (yyvsp[0].expr); } 4274| 747|#line 4275 "bison_parser.cpp" 4275| 747| break; 4276| | 4277| 765| case 139: /* opt_having: %empty */ ------------------ | Branch (4277:3): [True: 765, False: 26.1M] ------------------ 4278| 765|#line 861 "bison_parser.y" 4279| 765| { (yyval.expr) = nullptr; } 4280| 765|#line 4281 "bison_parser.cpp" 4281| 765| break; 4282| | 4283| 1.52k| case 140: /* opt_order: ORDER BY order_list */ ------------------ | Branch (4283:3): [True: 1.52k, False: 26.1M] ------------------ 4284| 1.52k|#line 863 "bison_parser.y" 4285| 1.52k| { (yyval.order_vec) = (yyvsp[0].order_vec); } 4286| 1.52k|#line 4287 "bison_parser.cpp" 4287| 1.52k| break; 4288| | 4289| 52.1k| case 141: /* opt_order: %empty */ ------------------ | Branch (4289:3): [True: 52.1k, False: 26.0M] ------------------ 4290| 52.1k|#line 864 "bison_parser.y" 4291| 52.1k| { (yyval.order_vec) = nullptr; } 4292| 52.1k|#line 4293 "bison_parser.cpp" 4293| 52.1k| break; 4294| | 4295| 1.62k| case 142: /* order_list: order_desc */ ------------------ | Branch (4295:3): [True: 1.62k, False: 26.1M] ------------------ 4296| 1.62k|#line 866 "bison_parser.y" 4297| 1.62k| { 4298| 1.62k| (yyval.order_vec) = new std::vector(); 4299| 1.62k| (yyval.order_vec)->push_back((yyvsp[0].order)); 4300| 1.62k|} 4301| 1.62k|#line 4302 "bison_parser.cpp" 4302| 1.62k| break; 4303| | 4304| 555k| case 143: /* order_list: order_list ',' order_desc */ ------------------ | Branch (4304:3): [True: 555k, False: 25.5M] ------------------ 4305| 555k|#line 870 "bison_parser.y" 4306| 555k| { 4307| 555k| (yyvsp[-2].order_vec)->push_back((yyvsp[0].order)); 4308| 555k| (yyval.order_vec) = (yyvsp[-2].order_vec); 4309| 555k|} 4310| 555k|#line 4311 "bison_parser.cpp" 4311| 555k| break; 4312| | 4313| 557k| case 144: /* order_desc: expr opt_order_type */ ------------------ | Branch (4313:3): [True: 557k, False: 25.5M] ------------------ 4314| 557k|#line 875 "bison_parser.y" 4315| 557k| { (yyval.order) = new OrderDescription((yyvsp[0].order_type), (yyvsp[-1].expr)); } 4316| 557k|#line 4317 "bison_parser.cpp" 4317| 557k| break; 4318| | 4319| 601| case 145: /* opt_order_type: ASC */ ------------------ | Branch (4319:3): [True: 601, False: 26.1M] ------------------ 4320| 601|#line 877 "bison_parser.y" 4321| 601| { (yyval.order_type) = kOrderAsc; } 4322| 601|#line 4323 "bison_parser.cpp" 4323| 601| break; 4324| | 4325| 521| case 146: /* opt_order_type: DESC */ ------------------ | Branch (4325:3): [True: 521, False: 26.1M] ------------------ 4326| 521|#line 878 "bison_parser.y" 4327| 521| { (yyval.order_type) = kOrderDesc; } 4328| 521|#line 4329 "bison_parser.cpp" 4329| 521| break; 4330| | 4331| 556k| case 147: /* opt_order_type: %empty */ ------------------ | Branch (4331:3): [True: 556k, False: 25.5M] ------------------ 4332| 556k|#line 879 "bison_parser.y" 4333| 556k| { (yyval.order_type) = kOrderAsc; } 4334| 556k|#line 4335 "bison_parser.cpp" 4335| 556k| break; 4336| | 4337| 856| case 148: /* opt_top: TOP int_literal */ ------------------ | Branch (4337:3): [True: 856, False: 26.1M] ------------------ 4338| 856|#line 883 "bison_parser.y" 4339| 856| { (yyval.limit) = new LimitDescription((yyvsp[0].expr), nullptr); } 4340| 856|#line 4341 "bison_parser.cpp" 4341| 856| break; 4342| | 4343| 59.1k| case 149: /* opt_top: %empty */ ------------------ | Branch (4343:3): [True: 59.1k, False: 26.0M] ------------------ 4344| 59.1k|#line 884 "bison_parser.y" 4345| 59.1k| { (yyval.limit) = nullptr; } 4346| 59.1k|#line 4347 "bison_parser.cpp" 4347| 59.1k| break; 4348| | 4349| 1.25k| case 150: /* opt_limit: LIMIT expr */ ------------------ | Branch (4349:3): [True: 1.25k, False: 26.1M] ------------------ 4350| 1.25k|#line 886 "bison_parser.y" 4351| 1.25k| { (yyval.limit) = new LimitDescription((yyvsp[0].expr), nullptr); } 4352| 1.25k|#line 4353 "bison_parser.cpp" 4353| 1.25k| break; 4354| | 4355| 495| case 151: /* opt_limit: OFFSET expr */ ------------------ | Branch (4355:3): [True: 495, False: 26.1M] ------------------ 4356| 495|#line 887 "bison_parser.y" 4357| 495| { (yyval.limit) = new LimitDescription(nullptr, (yyvsp[0].expr)); } 4358| 495|#line 4359 "bison_parser.cpp" 4359| 495| break; 4360| | 4361| 197| case 152: /* opt_limit: LIMIT expr OFFSET expr */ ------------------ | Branch (4361:3): [True: 197, False: 26.1M] ------------------ 4362| 197|#line 888 "bison_parser.y" 4363| 197| { (yyval.limit) = new LimitDescription((yyvsp[-2].expr), (yyvsp[0].expr)); } 4364| 197|#line 4365 "bison_parser.cpp" 4365| 197| break; 4366| | 4367| 563| case 153: /* opt_limit: LIMIT ALL */ ------------------ | Branch (4367:3): [True: 563, False: 26.1M] ------------------ 4368| 563|#line 889 "bison_parser.y" 4369| 563| { (yyval.limit) = new LimitDescription(nullptr, nullptr); } 4370| 563|#line 4371 "bison_parser.cpp" 4371| 563| break; 4372| | 4373| 387| case 154: /* opt_limit: LIMIT ALL OFFSET expr */ ------------------ | Branch (4373:3): [True: 387, False: 26.1M] ------------------ 4374| 387|#line 890 "bison_parser.y" 4375| 387| { (yyval.limit) = new LimitDescription(nullptr, (yyvsp[0].expr)); } 4376| 387|#line 4377 "bison_parser.cpp" 4377| 387| break; 4378| | 4379| 50.4k| case 155: /* opt_limit: %empty */ ------------------ | Branch (4379:3): [True: 50.4k, False: 26.0M] ------------------ 4380| 50.4k|#line 891 "bison_parser.y" 4381| 50.4k| { (yyval.limit) = nullptr; } 4382| 50.4k|#line 4383 "bison_parser.cpp" 4383| 50.4k| break; 4384| | 4385| 63.2k| case 156: /* expr_list: expr_alias */ ------------------ | Branch (4385:3): [True: 63.2k, False: 26.0M] ------------------ 4386| 63.2k|#line 896 "bison_parser.y" 4387| 63.2k| { 4388| 63.2k| (yyval.expr_vec) = new std::vector(); 4389| 63.2k| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 4390| 63.2k|} 4391| 63.2k|#line 4392 "bison_parser.cpp" 4392| 63.2k| break; 4393| | 4394| 550k| case 157: /* expr_list: expr_list ',' expr_alias */ ------------------ | Branch (4394:3): [True: 550k, False: 25.5M] ------------------ 4395| 550k|#line 900 "bison_parser.y" 4396| 550k| { 4397| 550k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 4398| 550k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 4399| 550k|} 4400| 550k|#line 4401 "bison_parser.cpp" 4401| 550k| break; 4402| | 4403| 320| case 158: /* opt_literal_list: literal_list */ ------------------ | Branch (4403:3): [True: 320, False: 26.1M] ------------------ 4404| 320|#line 905 "bison_parser.y" 4405| 320| { (yyval.expr_vec) = (yyvsp[0].expr_vec); } 4406| 320|#line 4407 "bison_parser.cpp" 4407| 320| break; 4408| | 4409| 479| case 159: /* opt_literal_list: %empty */ ------------------ | Branch (4409:3): [True: 479, False: 26.1M] ------------------ 4410| 479|#line 906 "bison_parser.y" 4411| 479| { (yyval.expr_vec) = nullptr; } 4412| 479|#line 4413 "bison_parser.cpp" 4413| 479| break; 4414| | 4415| 1.44k| case 160: /* literal_list: literal */ ------------------ | Branch (4415:3): [True: 1.44k, False: 26.1M] ------------------ 4416| 1.44k|#line 908 "bison_parser.y" 4417| 1.44k| { 4418| 1.44k| (yyval.expr_vec) = new std::vector(); 4419| 1.44k| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 4420| 1.44k|} 4421| 1.44k|#line 4422 "bison_parser.cpp" 4422| 1.44k| break; 4423| | 4424| 1.85k| case 161: /* literal_list: literal_list ',' literal */ ------------------ | Branch (4424:3): [True: 1.85k, False: 26.1M] ------------------ 4425| 1.85k|#line 912 "bison_parser.y" 4426| 1.85k| { 4427| 1.85k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 4428| 1.85k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 4429| 1.85k|} 4430| 1.85k|#line 4431 "bison_parser.cpp" 4431| 1.85k| break; 4432| | 4433| 613k| case 162: /* expr_alias: expr opt_alias */ ------------------ | Branch (4433:3): [True: 613k, False: 25.4M] ------------------ 4434| 613k|#line 917 "bison_parser.y" 4435| 613k| { 4436| 613k| (yyval.expr) = (yyvsp[-1].expr); 4437| 613k| if ((yyvsp[0].alias_t)) { ------------------ | Branch (4437:7): [True: 2.84k, False: 610k] ------------------ 4438| 2.84k| (yyval.expr)->alias = strdup((yyvsp[0].alias_t)->name); 4439| 2.84k| delete (yyvsp[0].alias_t); 4440| 2.84k| } 4441| 613k|} 4442| 613k|#line 4443 "bison_parser.cpp" 4443| 613k| break; 4444| | 4445| 1.29k| case 168: /* operand: '(' expr ')' */ ------------------ | Branch (4445:3): [True: 1.29k, False: 26.1M] ------------------ 4446| 1.29k|#line 927 "bison_parser.y" 4447| 1.29k| { (yyval.expr) = (yyvsp[-1].expr); } 4448| 1.29k|#line 4449 "bison_parser.cpp" 4449| 1.29k| break; 4450| | 4451| 579| case 178: /* operand: '(' select_no_paren ')' */ ------------------ | Branch (4451:3): [True: 579, False: 26.1M] ------------------ 4452| 579|#line 929 "bison_parser.y" 4453| 579| { 4454| 579| (yyval.expr) = Expr::makeSelect((yyvsp[-1].select_stmt)); 4455| 579|} 4456| 579|#line 4457 "bison_parser.cpp" 4457| 579| break; 4458| | 4459| 7.13k| case 181: /* unary_expr: '-' operand */ ------------------ | Branch (4459:3): [True: 7.13k, False: 26.1M] ------------------ 4460| 7.13k|#line 935 "bison_parser.y" 4461| 7.13k| { (yyval.expr) = Expr::makeOpUnary(kOpUnaryMinus, (yyvsp[0].expr)); } 4462| 7.13k|#line 4463 "bison_parser.cpp" 4463| 7.13k| break; 4464| | 4465| 531| case 182: /* unary_expr: NOT operand */ ------------------ | Branch (4465:3): [True: 531, False: 26.1M] ------------------ 4466| 531|#line 936 "bison_parser.y" 4467| 531| { (yyval.expr) = Expr::makeOpUnary(kOpNot, (yyvsp[0].expr)); } 4468| 531|#line 4469 "bison_parser.cpp" 4469| 531| break; 4470| | 4471| 759| case 183: /* unary_expr: operand ISNULL */ ------------------ | Branch (4471:3): [True: 759, False: 26.1M] ------------------ 4472| 759|#line 937 "bison_parser.y" 4473| 759| { (yyval.expr) = Expr::makeOpUnary(kOpIsNull, (yyvsp[-1].expr)); } 4474| 759|#line 4475 "bison_parser.cpp" 4475| 759| break; 4476| | 4477| 409| case 184: /* unary_expr: operand IS NULL */ ------------------ | Branch (4477:3): [True: 409, False: 26.1M] ------------------ 4478| 409|#line 938 "bison_parser.y" 4479| 409| { (yyval.expr) = Expr::makeOpUnary(kOpIsNull, (yyvsp[-2].expr)); } 4480| 409|#line 4481 "bison_parser.cpp" 4481| 409| break; 4482| | 4483| 196| case 185: /* unary_expr: operand IS NOT NULL */ ------------------ | Branch (4483:3): [True: 196, False: 26.1M] ------------------ 4484| 196|#line 939 "bison_parser.y" 4485| 196| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeOpUnary(kOpIsNull, (yyvsp[-3].expr))); } 4486| 196|#line 4487 "bison_parser.cpp" 4487| 196| break; 4488| | 4489| 14.2k| case 187: /* binary_expr: operand '-' operand */ ------------------ | Branch (4489:3): [True: 14.2k, False: 26.0M] ------------------ 4490| 14.2k|#line 941 "bison_parser.y" 4491| 14.2k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpMinus, (yyvsp[0].expr)); } 4492| 14.2k|#line 4493 "bison_parser.cpp" 4493| 14.2k| break; 4494| | 4495| 210k| case 188: /* binary_expr: operand '+' operand */ ------------------ | Branch (4495:3): [True: 210k, False: 25.8M] ------------------ 4496| 210k|#line 942 "bison_parser.y" 4497| 210k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpPlus, (yyvsp[0].expr)); } 4498| 210k|#line 4499 "bison_parser.cpp" 4499| 210k| break; 4500| | 4501| 15.1k| case 189: /* binary_expr: operand '/' operand */ ------------------ | Branch (4501:3): [True: 15.1k, False: 26.0M] ------------------ 4502| 15.1k|#line 943 "bison_parser.y" 4503| 15.1k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpSlash, (yyvsp[0].expr)); } 4504| 15.1k|#line 4505 "bison_parser.cpp" 4505| 15.1k| break; 4506| | 4507| 980k| case 190: /* binary_expr: operand '*' operand */ ------------------ | Branch (4507:3): [True: 980k, False: 25.1M] ------------------ 4508| 980k|#line 944 "bison_parser.y" 4509| 980k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpAsterisk, (yyvsp[0].expr)); } 4510| 980k|#line 4511 "bison_parser.cpp" 4511| 980k| break; 4512| | 4513| 1.29k| case 191: /* binary_expr: operand '%' operand */ ------------------ | Branch (4513:3): [True: 1.29k, False: 26.1M] ------------------ 4514| 1.29k|#line 945 "bison_parser.y" 4515| 1.29k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpPercentage, (yyvsp[0].expr)); } 4516| 1.29k|#line 4517 "bison_parser.cpp" 4517| 1.29k| break; 4518| | 4519| 6.63k| case 192: /* binary_expr: operand '^' operand */ ------------------ | Branch (4519:3): [True: 6.63k, False: 26.1M] ------------------ 4520| 6.63k|#line 946 "bison_parser.y" 4521| 6.63k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpCaret, (yyvsp[0].expr)); } 4522| 6.63k|#line 4523 "bison_parser.cpp" 4523| 6.63k| break; 4524| | 4525| 451| case 193: /* binary_expr: operand LIKE operand */ ------------------ | Branch (4525:3): [True: 451, False: 26.1M] ------------------ 4526| 451|#line 947 "bison_parser.y" 4527| 451| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLike, (yyvsp[0].expr)); } 4528| 451|#line 4529 "bison_parser.cpp" 4529| 451| break; 4530| | 4531| 194| case 194: /* binary_expr: operand NOT LIKE operand */ ------------------ | Branch (4531:3): [True: 194, False: 26.1M] ------------------ 4532| 194|#line 948 "bison_parser.y" 4533| 194| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-3].expr), kOpNotLike, (yyvsp[0].expr)); } 4534| 194|#line 4535 "bison_parser.cpp" 4535| 194| break; 4536| | 4537| 888| case 195: /* binary_expr: operand ILIKE operand */ ------------------ | Branch (4537:3): [True: 888, False: 26.1M] ------------------ 4538| 888|#line 949 "bison_parser.y" 4539| 888| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpILike, (yyvsp[0].expr)); } 4540| 888|#line 4541 "bison_parser.cpp" 4541| 888| break; 4542| | 4543| 439| case 196: /* binary_expr: operand CONCAT operand */ ------------------ | Branch (4543:3): [True: 439, False: 26.1M] ------------------ 4544| 439|#line 950 "bison_parser.y" 4545| 439| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpConcat, (yyvsp[0].expr)); } 4546| 439|#line 4547 "bison_parser.cpp" 4547| 439| break; 4548| | 4549| 663| case 197: /* logic_expr: expr AND expr */ ------------------ | Branch (4549:3): [True: 663, False: 26.1M] ------------------ 4550| 663|#line 952 "bison_parser.y" 4551| 663| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpAnd, (yyvsp[0].expr)); } 4552| 663|#line 4553 "bison_parser.cpp" 4553| 663| break; 4554| | 4555| 455| case 198: /* logic_expr: expr OR expr */ ------------------ | Branch (4555:3): [True: 455, False: 26.1M] ------------------ 4556| 455|#line 953 "bison_parser.y" 4557| 455| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpOr, (yyvsp[0].expr)); } 4558| 455|#line 4559 "bison_parser.cpp" 4559| 455| break; 4560| | 4561| 358| case 199: /* in_expr: operand IN '(' expr_list ')' */ ------------------ | Branch (4561:3): [True: 358, False: 26.1M] ------------------ 4562| 358|#line 955 "bison_parser.y" 4563| 358| { (yyval.expr) = Expr::makeInOperator((yyvsp[-4].expr), (yyvsp[-1].expr_vec)); } 4564| 358|#line 4565 "bison_parser.cpp" 4565| 358| break; 4566| | 4567| 203| case 200: /* in_expr: operand NOT IN '(' expr_list ')' */ ------------------ | Branch (4567:3): [True: 203, False: 26.1M] ------------------ 4568| 203|#line 956 "bison_parser.y" 4569| 203| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeInOperator((yyvsp[-5].expr), (yyvsp[-1].expr_vec))); } 4570| 203|#line 4571 "bison_parser.cpp" 4571| 203| break; 4572| | 4573| 195| case 201: /* in_expr: operand IN '(' select_no_paren ')' */ ------------------ | Branch (4573:3): [True: 195, False: 26.1M] ------------------ 4574| 195|#line 957 "bison_parser.y" 4575| 195| { (yyval.expr) = Expr::makeInOperator((yyvsp[-4].expr), (yyvsp[-1].select_stmt)); } 4576| 195|#line 4577 "bison_parser.cpp" 4577| 195| break; 4578| | 4579| 194| case 202: /* in_expr: operand NOT IN '(' select_no_paren ')' */ ------------------ | Branch (4579:3): [True: 194, False: 26.1M] ------------------ 4580| 194|#line 958 "bison_parser.y" 4581| 194| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeInOperator((yyvsp[-5].expr), (yyvsp[-1].select_stmt))); } 4582| 194|#line 4583 "bison_parser.cpp" 4583| 194| break; 4584| | 4585| 435| case 203: /* case_expr: CASE expr case_list END */ ------------------ | Branch (4585:3): [True: 435, False: 26.1M] ------------------ 4586| 435|#line 962 "bison_parser.y" 4587| 435| { (yyval.expr) = Expr::makeCase((yyvsp[-2].expr), (yyvsp[-1].expr), nullptr); } 4588| 435|#line 4589 "bison_parser.cpp" 4589| 435| break; 4590| | 4591| 205| case 204: /* case_expr: CASE expr case_list ELSE expr END */ ------------------ | Branch (4591:3): [True: 205, False: 26.1M] ------------------ 4592| 205|#line 963 "bison_parser.y" 4593| 205| { (yyval.expr) = Expr::makeCase((yyvsp[-4].expr), (yyvsp[-3].expr), (yyvsp[-1].expr)); } 4594| 205|#line 4595 "bison_parser.cpp" 4595| 205| break; 4596| | 4597| 690| case 205: /* case_expr: CASE case_list END */ ------------------ | Branch (4597:3): [True: 690, False: 26.1M] ------------------ 4598| 690|#line 964 "bison_parser.y" 4599| 690| { (yyval.expr) = Expr::makeCase(nullptr, (yyvsp[-1].expr), nullptr); } 4600| 690|#line 4601 "bison_parser.cpp" 4601| 690| break; 4602| | 4603| 522| case 206: /* case_expr: CASE case_list ELSE expr END */ ------------------ | Branch (4603:3): [True: 522, False: 26.1M] ------------------ 4604| 522|#line 965 "bison_parser.y" 4605| 522| { (yyval.expr) = Expr::makeCase(nullptr, (yyvsp[-3].expr), (yyvsp[-1].expr)); } 4606| 522|#line 4607 "bison_parser.cpp" 4607| 522| break; 4608| | 4609| 2.12k| case 207: /* case_list: WHEN expr THEN expr */ ------------------ | Branch (4609:3): [True: 2.12k, False: 26.1M] ------------------ 4610| 2.12k|#line 967 "bison_parser.y" 4611| 2.12k| { (yyval.expr) = Expr::makeCaseList(Expr::makeCaseListElement((yyvsp[-2].expr), (yyvsp[0].expr))); } 4612| 2.12k|#line 4613 "bison_parser.cpp" 4613| 2.12k| break; 4614| | 4615| 1.44k| case 208: /* case_list: case_list WHEN expr THEN expr */ ------------------ | Branch (4615:3): [True: 1.44k, False: 26.1M] ------------------ 4616| 1.44k|#line 968 "bison_parser.y" 4617| 1.44k| { (yyval.expr) = Expr::caseListAppend((yyvsp[-4].expr), Expr::makeCaseListElement((yyvsp[-2].expr), (yyvsp[0].expr))); } 4618| 1.44k|#line 4619 "bison_parser.cpp" 4619| 1.44k| break; 4620| | 4621| 752| case 209: /* exists_expr: EXISTS '(' select_no_paren ')' */ ------------------ | Branch (4621:3): [True: 752, False: 26.1M] ------------------ 4622| 752|#line 970 "bison_parser.y" 4623| 752| { (yyval.expr) = Expr::makeExists((yyvsp[-1].select_stmt)); } 4624| 752|#line 4625 "bison_parser.cpp" 4625| 752| break; 4626| | 4627| 194| case 210: /* exists_expr: NOT EXISTS '(' select_no_paren ')' */ ------------------ | Branch (4627:3): [True: 194, False: 26.1M] ------------------ 4628| 194|#line 971 "bison_parser.y" 4629| 194| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeExists((yyvsp[-1].select_stmt))); } 4630| 194|#line 4631 "bison_parser.cpp" 4631| 194| break; 4632| | 4633| 3.76k| case 211: /* comp_expr: operand '=' operand */ ------------------ | Branch (4633:3): [True: 3.76k, False: 26.1M] ------------------ 4634| 3.76k|#line 973 "bison_parser.y" 4635| 3.76k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpEquals, (yyvsp[0].expr)); } 4636| 3.76k|#line 4637 "bison_parser.cpp" 4637| 3.76k| break; 4638| | 4639| 2.04k| case 212: /* comp_expr: operand EQUALS operand */ ------------------ | Branch (4639:3): [True: 2.04k, False: 26.1M] ------------------ 4640| 2.04k|#line 974 "bison_parser.y" 4641| 2.04k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpEquals, (yyvsp[0].expr)); } 4642| 2.04k|#line 4643 "bison_parser.cpp" 4643| 2.04k| break; 4644| | 4645| 330| case 213: /* comp_expr: operand NOTEQUALS operand */ ------------------ | Branch (4645:3): [True: 330, False: 26.1M] ------------------ 4646| 330|#line 975 "bison_parser.y" 4647| 330| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpNotEquals, (yyvsp[0].expr)); } 4648| 330|#line 4649 "bison_parser.cpp" 4649| 330| break; 4650| | 4651| 1.86k| case 214: /* comp_expr: operand '<' operand */ ------------------ | Branch (4651:3): [True: 1.86k, False: 26.1M] ------------------ 4652| 1.86k|#line 976 "bison_parser.y" 4653| 1.86k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLess, (yyvsp[0].expr)); } 4654| 1.86k|#line 4655 "bison_parser.cpp" 4655| 1.86k| break; 4656| | 4657| 1.57k| case 215: /* comp_expr: operand '>' operand */ ------------------ | Branch (4657:3): [True: 1.57k, False: 26.1M] ------------------ 4658| 1.57k|#line 977 "bison_parser.y" 4659| 1.57k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpGreater, (yyvsp[0].expr)); } 4660| 1.57k|#line 4661 "bison_parser.cpp" 4661| 1.57k| break; 4662| | 4663| 321| case 216: /* comp_expr: operand LESSEQ operand */ ------------------ | Branch (4663:3): [True: 321, False: 26.1M] ------------------ 4664| 321|#line 978 "bison_parser.y" 4665| 321| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLessEq, (yyvsp[0].expr)); } 4666| 321|#line 4667 "bison_parser.cpp" 4667| 321| break; 4668| | 4669| 195| case 217: /* comp_expr: operand GREATEREQ operand */ ------------------ | Branch (4669:3): [True: 195, False: 26.1M] ------------------ 4670| 195|#line 979 "bison_parser.y" 4671| 195| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpGreaterEq, (yyvsp[0].expr)); } 4672| 195|#line 4673 "bison_parser.cpp" 4673| 195| break; 4674| | 4675| 326| case 218: /* function_expr: IDENTIFIER '(' ')' */ ------------------ | Branch (4675:3): [True: 326, False: 26.1M] ------------------ 4676| 326|#line 981 "bison_parser.y" 4677| 326| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-2].sval), new std::vector(), false); } 4678| 326|#line 4679 "bison_parser.cpp" 4679| 326| break; 4680| | 4681| 1.68k| case 219: /* function_expr: IDENTIFIER '(' opt_distinct expr_list ')' */ ------------------ | Branch (4681:3): [True: 1.68k, False: 26.1M] ------------------ 4682| 1.68k|#line 982 "bison_parser.y" 4683| 1.68k| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-4].sval), (yyvsp[-1].expr_vec), (yyvsp[-2].bval)); } 4684| 1.68k|#line 4685 "bison_parser.cpp" 4685| 1.68k| break; 4686| | 4687| 466| case 220: /* extract_expr: EXTRACT '(' datetime_field FROM expr ')' */ ------------------ | Branch (4687:3): [True: 466, False: 26.1M] ------------------ 4688| 466|#line 984 "bison_parser.y" 4689| 466| { (yyval.expr) = Expr::makeExtract((yyvsp[-3].datetime_field), (yyvsp[-1].expr)); } 4690| 466|#line 4691 "bison_parser.cpp" 4691| 466| break; 4692| | 4693| 373| case 221: /* cast_expr: CAST '(' expr AS column_type ')' */ ------------------ | Branch (4693:3): [True: 373, False: 26.1M] ------------------ 4694| 373|#line 986 "bison_parser.y" 4695| 373| { (yyval.expr) = Expr::makeCast((yyvsp[-3].expr), (yyvsp[-1].column_type_t)); } 4696| 373|#line 4697 "bison_parser.cpp" 4697| 373| break; 4698| | 4699| 782| case 222: /* datetime_field: SECOND */ ------------------ | Branch (4699:3): [True: 782, False: 26.1M] ------------------ 4700| 782|#line 988 "bison_parser.y" 4701| 782| { (yyval.datetime_field) = kDatetimeSecond; } 4702| 782|#line 4703 "bison_parser.cpp" 4703| 782| break; 4704| | 4705| 776| case 223: /* datetime_field: MINUTE */ ------------------ | Branch (4705:3): [True: 776, False: 26.1M] ------------------ 4706| 776|#line 989 "bison_parser.y" 4707| 776| { (yyval.datetime_field) = kDatetimeMinute; } 4708| 776|#line 4709 "bison_parser.cpp" 4709| 776| break; 4710| | 4711| 1.04k| case 224: /* datetime_field: HOUR */ ------------------ | Branch (4711:3): [True: 1.04k, False: 26.1M] ------------------ 4712| 1.04k|#line 990 "bison_parser.y" 4713| 1.04k| { (yyval.datetime_field) = kDatetimeHour; } 4714| 1.04k|#line 4715 "bison_parser.cpp" 4715| 1.04k| break; 4716| | 4717| 1.46k| case 225: /* datetime_field: DAY */ ------------------ | Branch (4717:3): [True: 1.46k, False: 26.1M] ------------------ 4718| 1.46k|#line 991 "bison_parser.y" 4719| 1.46k| { (yyval.datetime_field) = kDatetimeDay; } 4720| 1.46k|#line 4721 "bison_parser.cpp" 4721| 1.46k| break; 4722| | 4723| 701| case 226: /* datetime_field: MONTH */ ------------------ | Branch (4723:3): [True: 701, False: 26.1M] ------------------ 4724| 701|#line 992 "bison_parser.y" 4725| 701| { (yyval.datetime_field) = kDatetimeMonth; } 4726| 701|#line 4727 "bison_parser.cpp" 4727| 701| break; 4728| | 4729| 524| case 227: /* datetime_field: YEAR */ ------------------ | Branch (4729:3): [True: 524, False: 26.1M] ------------------ 4730| 524|#line 993 "bison_parser.y" 4731| 524| { (yyval.datetime_field) = kDatetimeYear; } 4732| 524|#line 4733 "bison_parser.cpp" 4733| 524| break; 4734| | 4735| 715| case 228: /* datetime_field_plural: SECONDS */ ------------------ | Branch (4735:3): [True: 715, False: 26.1M] ------------------ 4736| 715|#line 995 "bison_parser.y" 4737| 715| { (yyval.datetime_field) = kDatetimeSecond; } 4738| 715|#line 4739 "bison_parser.cpp" 4739| 715| break; 4740| | 4741| 750| case 229: /* datetime_field_plural: MINUTES */ ------------------ | Branch (4741:3): [True: 750, False: 26.1M] ------------------ 4742| 750|#line 996 "bison_parser.y" 4743| 750| { (yyval.datetime_field) = kDatetimeMinute; } 4744| 750|#line 4745 "bison_parser.cpp" 4745| 750| break; 4746| | 4747| 857| case 230: /* datetime_field_plural: HOURS */ ------------------ | Branch (4747:3): [True: 857, False: 26.1M] ------------------ 4748| 857|#line 997 "bison_parser.y" 4749| 857| { (yyval.datetime_field) = kDatetimeHour; } 4750| 857|#line 4751 "bison_parser.cpp" 4751| 857| break; 4752| | 4753| 521| case 231: /* datetime_field_plural: DAYS */ ------------------ | Branch (4753:3): [True: 521, False: 26.1M] ------------------ 4754| 521|#line 998 "bison_parser.y" 4755| 521| { (yyval.datetime_field) = kDatetimeDay; } 4756| 521|#line 4757 "bison_parser.cpp" 4757| 521| break; 4758| | 4759| 786| case 232: /* datetime_field_plural: MONTHS */ ------------------ | Branch (4759:3): [True: 786, False: 26.1M] ------------------ 4760| 786|#line 999 "bison_parser.y" 4761| 786| { (yyval.datetime_field) = kDatetimeMonth; } 4762| 786|#line 4763 "bison_parser.cpp" 4763| 786| break; 4764| | 4765| 694| case 233: /* datetime_field_plural: YEARS */ ------------------ | Branch (4765:3): [True: 694, False: 26.1M] ------------------ 4766| 694|#line 1000 "bison_parser.y" 4767| 694| { (yyval.datetime_field) = kDatetimeYear; } 4768| 694|#line 4769 "bison_parser.cpp" 4769| 694| break; 4770| | 4771| 435| case 236: /* array_expr: ARRAY '[' expr_list ']' */ ------------------ | Branch (4771:3): [True: 435, False: 26.1M] ------------------ 4772| 435|#line 1004 "bison_parser.y" 4773| 435| { (yyval.expr) = Expr::makeArray((yyvsp[-1].expr_vec)); } 4774| 435|#line 4775 "bison_parser.cpp" 4775| 435| break; 4776| | 4777| 194| case 237: /* array_index: operand '[' int_literal ']' */ ------------------ | Branch (4777:3): [True: 194, False: 26.1M] ------------------ 4778| 194|#line 1006 "bison_parser.y" 4779| 194| { (yyval.expr) = Expr::makeArrayIndex((yyvsp[-3].expr), (yyvsp[-1].expr)->ival); } 4780| 194|#line 4781 "bison_parser.cpp" 4781| 194| break; 4782| | 4783| 814| case 238: /* between_expr: operand BETWEEN operand AND operand */ ------------------ | Branch (4783:3): [True: 814, False: 26.1M] ------------------ 4784| 814|#line 1008 "bison_parser.y" 4785| 814| { (yyval.expr) = Expr::makeBetween((yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); } 4786| 814|#line 4787 "bison_parser.cpp" 4787| 814| break; 4788| | 4789| 1.28M| case 239: /* column_name: IDENTIFIER */ ------------------ | Branch (4789:3): [True: 1.28M, False: 24.8M] ------------------ 4790| 1.28M|#line 1010 "bison_parser.y" 4791| 1.28M| { (yyval.expr) = Expr::makeColumnRef((yyvsp[0].sval)); } 4792| 1.28M|#line 4793 "bison_parser.cpp" 4793| 1.28M| break; 4794| | 4795| 1.83k| case 240: /* column_name: IDENTIFIER '.' IDENTIFIER */ ------------------ | Branch (4795:3): [True: 1.83k, False: 26.1M] ------------------ 4796| 1.83k|#line 1011 "bison_parser.y" 4797| 1.83k| { (yyval.expr) = Expr::makeColumnRef((yyvsp[-2].sval), (yyvsp[0].sval)); } 4798| 1.83k|#line 4799 "bison_parser.cpp" 4799| 1.83k| break; 4800| | 4801| 1.14M| case 241: /* column_name: '*' */ ------------------ | Branch (4801:3): [True: 1.14M, False: 24.9M] ------------------ 4802| 1.14M|#line 1012 "bison_parser.y" 4803| 1.14M| { (yyval.expr) = Expr::makeStar(); } 4804| 1.14M|#line 4805 "bison_parser.cpp" 4805| 1.14M| break; 4806| | 4807| 195| case 242: /* column_name: IDENTIFIER '.' '*' */ ------------------ | Branch (4807:3): [True: 195, False: 26.1M] ------------------ 4808| 195|#line 1013 "bison_parser.y" 4809| 195| { (yyval.expr) = Expr::makeStar((yyvsp[-2].sval)); } 4810| 195|#line 4811 "bison_parser.cpp" 4811| 195| break; 4812| | 4813| 2.85k| case 250: /* string_literal: STRING */ ------------------ | Branch (4813:3): [True: 2.85k, False: 26.1M] ------------------ 4814| 2.85k|#line 1017 "bison_parser.y" 4815| 2.85k| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].sval)); } 4816| 2.85k|#line 4817 "bison_parser.cpp" 4817| 2.85k| break; 4818| | 4819| 597| case 251: /* bool_literal: TRUE */ ------------------ | Branch (4819:3): [True: 597, False: 26.1M] ------------------ 4820| 597|#line 1019 "bison_parser.y" 4821| 597| { (yyval.expr) = Expr::makeLiteral(true); } 4822| 597|#line 4823 "bison_parser.cpp" 4823| 597| break; 4824| | 4825| 706| case 252: /* bool_literal: FALSE */ ------------------ | Branch (4825:3): [True: 706, False: 26.1M] ------------------ 4826| 706|#line 1020 "bison_parser.y" 4827| 706| { (yyval.expr) = Expr::makeLiteral(false); } 4828| 706|#line 4829 "bison_parser.cpp" 4829| 706| break; 4830| | 4831| 401| case 253: /* num_literal: FLOATVAL */ ------------------ | Branch (4831:3): [True: 401, False: 26.1M] ------------------ 4832| 401|#line 1022 "bison_parser.y" 4833| 401| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].fval)); } 4834| 401|#line 4835 "bison_parser.cpp" 4835| 401| break; 4836| | 4837| 15.1k| case 255: /* int_literal: INTVAL */ ------------------ | Branch (4837:3): [True: 15.1k, False: 26.0M] ------------------ 4838| 15.1k|#line 1025 "bison_parser.y" 4839| 15.1k| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].ival)); } 4840| 15.1k|#line 4841 "bison_parser.cpp" 4841| 15.1k| break; 4842| | 4843| 342| case 256: /* null_literal: NULL */ ------------------ | Branch (4843:3): [True: 342, False: 26.1M] ------------------ 4844| 342|#line 1027 "bison_parser.y" 4845| 342| { (yyval.expr) = Expr::makeNullLiteral(); } 4846| 342|#line 4847 "bison_parser.cpp" 4847| 342| break; 4848| | 4849| 642| case 257: /* date_literal: DATE STRING */ ------------------ | Branch (4849:3): [True: 642, False: 26.1M] ------------------ 4850| 642|#line 1029 "bison_parser.y" 4851| 642| { 4852| 642| int day{0}, month{0}, year{0}, chars_parsed{0}; 4853| | // If the whole string is parsed, chars_parsed points to the terminating null byte after the last character 4854| 642| if (sscanf((yyvsp[0].sval), "%4d-%2d-%2d%n", &day, &month, &year, &chars_parsed) != 3 || (yyvsp[0].sval)[chars_parsed] != 0) { ------------------ | Branch (4854:7): [True: 5, False: 637] | Branch (4854:92): [True: 4, False: 633] ------------------ 4855| 9| free((yyvsp[0].sval)); 4856| 9| yyerror(&yyloc, result, scanner, "Found incorrect date format. Expected format: YYYY-MM-DD"); ------------------ | | 72| 9|#define yyerror hsql_error ------------------ 4857| 9| YYERROR; ------------------ | | 1480| 9|#define YYERROR goto yyerrorlab ------------------ 4858| 9| } 4859| 633| (yyval.expr) = Expr::makeDateLiteral((yyvsp[0].sval)); 4860| 633|} 4861| 0|#line 4862 "bison_parser.cpp" 4862| 0| break; 4863| | 4864| 8.63k| case 258: /* interval_literal: int_literal duration_field */ ------------------ | Branch (4864:3): [True: 8.63k, False: 26.0M] ------------------ 4865| 8.63k|#line 1040 "bison_parser.y" 4866| 8.63k| { 4867| 8.63k| (yyval.expr) = Expr::makeIntervalLiteral((yyvsp[-1].expr)->ival, (yyvsp[0].datetime_field)); 4868| 8.63k| delete (yyvsp[-1].expr); 4869| 8.63k|} 4870| 8.63k|#line 4871 "bison_parser.cpp" 4871| 8.63k| break; 4872| | 4873| 306| case 259: /* interval_literal: INTERVAL STRING datetime_field */ ------------------ | Branch (4873:3): [True: 306, False: 26.1M] ------------------ 4874| 306|#line 1044 "bison_parser.y" 4875| 306| { 4876| 306| int duration{0}, chars_parsed{0}; 4877| | // If the whole string is parsed, chars_parsed points to the terminating null byte after the last character 4878| 306| if (sscanf((yyvsp[-1].sval), "%d%n", &duration, &chars_parsed) != 1 || (yyvsp[-1].sval)[chars_parsed] != 0) { ------------------ | Branch (4878:7): [True: 2, False: 304] | Branch (4878:74): [True: 7, False: 297] ------------------ 4879| 9| free((yyvsp[-1].sval)); 4880| 9| yyerror(&yyloc, result, scanner, "Found incorrect interval format. Expected format: INTEGER"); ------------------ | | 72| 9|#define yyerror hsql_error ------------------ 4881| 9| YYERROR; ------------------ | | 1480| 9|#define YYERROR goto yyerrorlab ------------------ 4882| 9| } 4883| 297| free((yyvsp[-1].sval)); 4884| 297| (yyval.expr) = Expr::makeIntervalLiteral(duration, (yyvsp[0].datetime_field)); 4885| 297|} 4886| 0|#line 4887 "bison_parser.cpp" 4887| 0| break; 4888| | 4889| 3.40k| case 260: /* interval_literal: INTERVAL STRING */ ------------------ | Branch (4889:3): [True: 3.40k, False: 26.1M] ------------------ 4890| 3.40k|#line 1055 "bison_parser.y" 4891| 3.40k| { 4892| 3.40k| int duration{0}, chars_parsed{0}; 4893| | // 'seconds' and 'minutes' are the longest accepted interval qualifiers (7 chars) + null byte 4894| 3.40k| char unit_string[8]; 4895| | // If the whole string is parsed, chars_parsed points to the terminating null byte after the last character 4896| 3.40k| if (sscanf((yyvsp[0].sval), "%d %7s%n", &duration, unit_string, &chars_parsed) != 2 || (yyvsp[0].sval)[chars_parsed] != 0) { ------------------ | Branch (4896:7): [True: 11, False: 3.39k] | Branch (4896:90): [True: 9, False: 3.38k] ------------------ 4897| 20| free((yyvsp[0].sval)); 4898| 20| yyerror(&yyloc, result, scanner, "Found incorrect interval format. Expected format: INTEGER INTERVAL_QUALIIFIER"); ------------------ | | 72| 20|#define yyerror hsql_error ------------------ 4899| 20| YYERROR; ------------------ | | 1480| 20|#define YYERROR goto yyerrorlab ------------------ 4900| 20| } 4901| 3.38k| free((yyvsp[0].sval)); 4902| | 4903| 3.38k| DatetimeField unit; 4904| 3.38k| if (strcasecmp(unit_string, "second") == 0 || strcasecmp(unit_string, "seconds") == 0) { ------------------ | Branch (4904:7): [True: 265, False: 3.12k] | Branch (4904:49): [True: 195, False: 2.92k] ------------------ 4905| 460| unit = kDatetimeSecond; 4906| 2.92k| } else if (strcasecmp(unit_string, "minute") == 0 || strcasecmp(unit_string, "minutes") == 0) { ------------------ | Branch (4906:14): [True: 221, False: 2.70k] | Branch (4906:56): [True: 194, False: 2.51k] ------------------ 4907| 415| unit = kDatetimeMinute; 4908| 2.51k| } else if (strcasecmp(unit_string, "hour") == 0 || strcasecmp(unit_string, "hours") == 0) { ------------------ | Branch (4908:14): [True: 235, False: 2.27k] | Branch (4908:54): [True: 194, False: 2.08k] ------------------ 4909| 429| unit = kDatetimeHour; 4910| 2.08k| } else if (strcasecmp(unit_string, "day") == 0 || strcasecmp(unit_string, "days") == 0) { ------------------ | Branch (4910:14): [True: 729, False: 1.35k] | Branch (4910:53): [True: 215, False: 1.13k] ------------------ 4911| 944| unit = kDatetimeDay; 4912| 1.13k| } else if (strcasecmp(unit_string, "month") == 0 || strcasecmp(unit_string, "months") == 0) { ------------------ | Branch (4912:14): [True: 194, False: 943] | Branch (4912:55): [True: 194, False: 749] ------------------ 4913| 388| unit = kDatetimeMonth; 4914| 749| } else if (strcasecmp(unit_string, "year") == 0 || strcasecmp(unit_string, "years") == 0) { ------------------ | Branch (4914:14): [True: 236, False: 513] | Branch (4914:54): [True: 217, False: 296] ------------------ 4915| 453| unit = kDatetimeYear; 4916| 453| } else { 4917| 296| yyerror(&yyloc, result, scanner, "Interval qualifier is unknown."); ------------------ | | 72| 296|#define yyerror hsql_error ------------------ 4918| 296| YYERROR; ------------------ | | 1480| 296|#define YYERROR goto yyerrorlab ------------------ 4919| 296| } 4920| 3.08k| (yyval.expr) = Expr::makeIntervalLiteral(duration, unit); 4921| 3.08k|} 4922| 0|#line 4923 "bison_parser.cpp" 4923| 0| break; 4924| | 4925| 353k| case 261: /* param_expr: '?' */ ------------------ | Branch (4925:3): [True: 353k, False: 25.7M] ------------------ 4926| 353k|#line 1087 "bison_parser.y" 4927| 353k| { 4928| 353k| (yyval.expr) = Expr::makeParameter(yylloc.total_column); 4929| 353k| (yyval.expr)->ival2 = yyloc.param_list.size(); 4930| 353k| yyloc.param_list.push_back((yyval.expr)); 4931| 353k|} 4932| 353k|#line 4933 "bison_parser.cpp" 4933| 353k| break; 4934| | 4935| 835| case 263: /* table_ref: table_ref_commalist ',' table_ref_atomic */ ------------------ | Branch (4935:3): [True: 835, False: 26.1M] ------------------ 4936| 835|#line 1096 "bison_parser.y" 4937| 835| { 4938| 835| (yyvsp[-2].table_vec)->push_back((yyvsp[0].table)); 4939| 835| auto tbl = new TableRef(kTableCrossProduct); 4940| 835| tbl->list = (yyvsp[-2].table_vec); 4941| 835| (yyval.table) = tbl; 4942| 835|} 4943| 835|#line 4944 "bison_parser.cpp" 4944| 835| break; 4945| | 4946| 242| case 267: /* nonjoin_table_ref_atomic: '(' select_statement ')' opt_table_alias */ ------------------ | Branch (4946:3): [True: 242, False: 26.1M] ------------------ 4947| 242|#line 1105 "bison_parser.y" 4948| 242| { 4949| 242| auto tbl = new TableRef(kTableSelect); 4950| 242| tbl->select = (yyvsp[-2].select_stmt); 4951| 242| tbl->alias = (yyvsp[0].alias_t); 4952| 242| (yyval.table) = tbl; 4953| 242|} 4954| 242|#line 4955 "bison_parser.cpp" 4955| 242| break; 4956| | 4957| 924| case 268: /* table_ref_commalist: table_ref_atomic */ ------------------ | Branch (4957:3): [True: 924, False: 26.1M] ------------------ 4958| 924|#line 1112 "bison_parser.y" 4959| 924| { 4960| 924| (yyval.table_vec) = new std::vector(); 4961| 924| (yyval.table_vec)->push_back((yyvsp[0].table)); 4962| 924|} 4963| 924|#line 4964 "bison_parser.cpp" 4964| 924| break; 4965| | 4966| 530k| case 269: /* table_ref_commalist: table_ref_commalist ',' table_ref_atomic */ ------------------ | Branch (4966:3): [True: 530k, False: 25.5M] ------------------ 4967| 530k|#line 1116 "bison_parser.y" 4968| 530k| { 4969| 530k| (yyvsp[-2].table_vec)->push_back((yyvsp[0].table)); 4970| 530k| (yyval.table_vec) = (yyvsp[-2].table_vec); 4971| 530k|} 4972| 530k|#line 4973 "bison_parser.cpp" 4973| 530k| break; 4974| | 4975| 646k| case 270: /* table_ref_name: table_name opt_table_alias */ ------------------ | Branch (4975:3): [True: 646k, False: 25.4M] ------------------ 4976| 646k|#line 1121 "bison_parser.y" 4977| 646k| { 4978| 646k| auto tbl = new TableRef(kTableName); 4979| 646k| tbl->schema = (yyvsp[-1].table_name).schema; 4980| 646k| tbl->name = (yyvsp[-1].table_name).name; 4981| 646k| tbl->alias = (yyvsp[0].alias_t); 4982| 646k| (yyval.table) = tbl; 4983| 646k|} 4984| 646k|#line 4985 "bison_parser.cpp" 4985| 646k| break; 4986| | 4987| 1.23k| case 271: /* table_ref_name_no_alias: table_name */ ------------------ | Branch (4987:3): [True: 1.23k, False: 26.1M] ------------------ 4988| 1.23k|#line 1129 "bison_parser.y" 4989| 1.23k| { 4990| 1.23k| (yyval.table) = new TableRef(kTableName); 4991| 1.23k| (yyval.table)->schema = (yyvsp[0].table_name).schema; 4992| 1.23k| (yyval.table)->name = (yyvsp[0].table_name).name; 4993| 1.23k|} 4994| 1.23k|#line 4995 "bison_parser.cpp" 4995| 1.23k| break; 4996| | 4997| 660k| case 272: /* table_name: IDENTIFIER */ ------------------ | Branch (4997:3): [True: 660k, False: 25.4M] ------------------ 4998| 660k|#line 1135 "bison_parser.y" 4999| 660k| { 5000| 660k| (yyval.table_name).schema = nullptr; 5001| 660k| (yyval.table_name).name = (yyvsp[0].sval); 5002| 660k|} 5003| 660k|#line 5004 "bison_parser.cpp" 5004| 660k| break; 5005| | 5006| 328| case 273: /* table_name: IDENTIFIER '.' IDENTIFIER */ ------------------ | Branch (5006:3): [True: 328, False: 26.1M] ------------------ 5007| 328|#line 1139 "bison_parser.y" 5008| 328| { 5009| 328| (yyval.table_name).schema = (yyvsp[-2].sval); 5010| 328| (yyval.table_name).name = (yyvsp[0].sval); 5011| 328|} 5012| 328|#line 5013 "bison_parser.cpp" 5013| 328| break; 5014| | 5015| 199| case 274: /* opt_index_name: IDENTIFIER */ ------------------ | Branch (5015:3): [True: 199, False: 26.1M] ------------------ 5016| 199|#line 1144 "bison_parser.y" 5017| 199| { (yyval.sval) = (yyvsp[0].sval); } 5018| 199|#line 5019 "bison_parser.cpp" 5019| 199| break; 5020| | 5021| 1.23k| case 275: /* opt_index_name: %empty */ ------------------ | Branch (5021:3): [True: 1.23k, False: 26.1M] ------------------ 5022| 1.23k|#line 1145 "bison_parser.y" 5023| 1.23k| { (yyval.sval) = nullptr; } 5024| 1.23k|#line 5025 "bison_parser.cpp" 5025| 1.23k| break; 5026| | 5027| 314| case 277: /* table_alias: AS IDENTIFIER '(' ident_commalist ')' */ ------------------ | Branch (5027:3): [True: 314, False: 26.1M] ------------------ 5028| 314|#line 1147 "bison_parser.y" 5029| 314| { (yyval.alias_t) = new Alias((yyvsp[-3].sval), (yyvsp[-1].str_vec)); } 5030| 314|#line 5031 "bison_parser.cpp" 5031| 314| break; 5032| | 5033| 642k| case 279: /* opt_table_alias: %empty */ ------------------ | Branch (5033:3): [True: 642k, False: 25.4M] ------------------ 5034| 642k|#line 1149 "bison_parser.y" 5035| 642k| { (yyval.alias_t) = nullptr; } 5036| 642k|#line 5037 "bison_parser.cpp" 5037| 642k| break; 5038| | 5039| 266| case 280: /* alias: AS IDENTIFIER */ ------------------ | Branch (5039:3): [True: 266, False: 26.1M] ------------------ 5040| 266|#line 1151 "bison_parser.y" 5041| 266| { (yyval.alias_t) = new Alias((yyvsp[0].sval)); } 5042| 266|#line 5043 "bison_parser.cpp" 5043| 266| break; 5044| | 5045| 6.88k| case 281: /* alias: IDENTIFIER */ ------------------ | Branch (5045:3): [True: 6.88k, False: 26.1M] ------------------ 5046| 6.88k|#line 1152 "bison_parser.y" 5047| 6.88k| { (yyval.alias_t) = new Alias((yyvsp[0].sval)); } 5048| 6.88k|#line 5049 "bison_parser.cpp" 5049| 6.88k| break; 5050| | 5051| 610k| case 283: /* opt_alias: %empty */ ------------------ | Branch (5051:3): [True: 610k, False: 25.4M] ------------------ 5052| 610k|#line 1154 "bison_parser.y" 5053| 610k| { (yyval.alias_t) = nullptr; } 5054| 610k|#line 5055 "bison_parser.cpp" 5055| 610k| break; 5056| | 5057| 443| case 284: /* opt_locking_clause: opt_locking_clause_list */ ------------------ | Branch (5057:3): [True: 443, False: 26.1M] ------------------ 5058| 443|#line 1160 "bison_parser.y" 5059| 443| { (yyval.locking_clause_vec) = (yyvsp[0].locking_clause_vec); } 5060| 443|#line 5061 "bison_parser.cpp" 5061| 443| break; 5062| | 5063| 52.3k| case 285: /* opt_locking_clause: %empty */ ------------------ | Branch (5063:3): [True: 52.3k, False: 26.0M] ------------------ 5064| 52.3k|#line 1161 "bison_parser.y" 5065| 52.3k| { (yyval.locking_clause_vec) = nullptr; } 5066| 52.3k|#line 5067 "bison_parser.cpp" 5067| 52.3k| break; 5068| | 5069| 468| case 286: /* opt_locking_clause_list: locking_clause */ ------------------ | Branch (5069:3): [True: 468, False: 26.1M] ------------------ 5070| 468|#line 1163 "bison_parser.y" 5071| 468| { 5072| 468| (yyval.locking_clause_vec) = new std::vector(); 5073| 468| (yyval.locking_clause_vec)->push_back((yyvsp[0].locking_t)); 5074| 468|} 5075| 468|#line 5076 "bison_parser.cpp" 5076| 468| break; 5077| | 5078| 3.63k| case 287: /* opt_locking_clause_list: opt_locking_clause_list locking_clause */ ------------------ | Branch (5078:3): [True: 3.63k, False: 26.1M] ------------------ 5079| 3.63k|#line 1167 "bison_parser.y" 5080| 3.63k| { 5081| 3.63k| (yyvsp[-1].locking_clause_vec)->push_back((yyvsp[0].locking_t)); 5082| 3.63k| (yyval.locking_clause_vec) = (yyvsp[-1].locking_clause_vec); 5083| 3.63k|} 5084| 3.63k|#line 5085 "bison_parser.cpp" 5085| 3.63k| break; 5086| | 5087| 3.81k| case 288: /* locking_clause: FOR row_lock_mode opt_row_lock_policy */ ------------------ | Branch (5087:3): [True: 3.81k, False: 26.1M] ------------------ 5088| 3.81k|#line 1172 "bison_parser.y" 5089| 3.81k| { 5090| 3.81k| (yyval.locking_t) = new LockingClause(); 5091| 3.81k| (yyval.locking_t)->rowLockMode = (yyvsp[-1].lock_mode_t); 5092| 3.81k| (yyval.locking_t)->rowLockWaitPolicy = (yyvsp[0].lock_wait_policy_t); 5093| 3.81k| (yyval.locking_t)->tables = nullptr; 5094| 3.81k|} 5095| 3.81k|#line 5096 "bison_parser.cpp" 5096| 3.81k| break; 5097| | 5098| 288| case 289: /* locking_clause: FOR row_lock_mode OF ident_commalist opt_row_lock_policy */ ------------------ | Branch (5098:3): [True: 288, False: 26.1M] ------------------ 5099| 288|#line 1178 "bison_parser.y" 5100| 288| { 5101| 288| (yyval.locking_t) = new LockingClause(); 5102| 288| (yyval.locking_t)->rowLockMode = (yyvsp[-3].lock_mode_t); 5103| 288| (yyval.locking_t)->tables = (yyvsp[-1].str_vec); 5104| 288| (yyval.locking_t)->rowLockWaitPolicy = (yyvsp[0].lock_wait_policy_t); 5105| 288|} 5106| 288|#line 5107 "bison_parser.cpp" 5107| 288| break; 5108| | 5109| 768| case 290: /* row_lock_mode: UPDATE */ ------------------ | Branch (5109:3): [True: 768, False: 26.1M] ------------------ 5110| 768|#line 1185 "bison_parser.y" 5111| 768| { (yyval.lock_mode_t) = RowLockMode::ForUpdate; } 5112| 768|#line 5113 "bison_parser.cpp" 5113| 768| break; 5114| | 5115| 0| case 291: /* row_lock_mode: NO KEY UPDATE */ ------------------ | Branch (5115:3): [True: 0, False: 26.1M] ------------------ 5116| 0|#line 1186 "bison_parser.y" 5117| 0| { (yyval.lock_mode_t) = RowLockMode::ForNoKeyUpdate; } 5118| 0|#line 5119 "bison_parser.cpp" 5119| 0| break; 5120| | 5121| 3.13k| case 292: /* row_lock_mode: SHARE */ ------------------ | Branch (5121:3): [True: 3.13k, False: 26.1M] ------------------ 5122| 3.13k|#line 1187 "bison_parser.y" 5123| 3.13k| { (yyval.lock_mode_t) = RowLockMode::ForShare; } 5124| 3.13k|#line 5125 "bison_parser.cpp" 5125| 3.13k| break; 5126| | 5127| 207| case 293: /* row_lock_mode: KEY SHARE */ ------------------ | Branch (5127:3): [True: 207, False: 26.1M] ------------------ 5128| 207|#line 1188 "bison_parser.y" 5129| 207| { (yyval.lock_mode_t) = RowLockMode::ForKeyShare; } 5130| 207|#line 5131 "bison_parser.cpp" 5131| 207| break; 5132| | 5133| 0| case 294: /* opt_row_lock_policy: SKIP LOCKED */ ------------------ | Branch (5133:3): [True: 0, False: 26.1M] ------------------ 5134| 0|#line 1190 "bison_parser.y" 5135| 0| { (yyval.lock_wait_policy_t) = RowLockWaitPolicy::SkipLocked; } 5136| 0|#line 5137 "bison_parser.cpp" 5137| 0| break; 5138| | 5139| 611| case 295: /* opt_row_lock_policy: NOWAIT */ ------------------ | Branch (5139:3): [True: 611, False: 26.1M] ------------------ 5140| 611|#line 1191 "bison_parser.y" 5141| 611| { (yyval.lock_wait_policy_t) = RowLockWaitPolicy::NoWait; } 5142| 611|#line 5143 "bison_parser.cpp" 5143| 611| break; 5144| | 5145| 3.49k| case 296: /* opt_row_lock_policy: %empty */ ------------------ | Branch (5145:3): [True: 3.49k, False: 26.1M] ------------------ 5146| 3.49k|#line 1192 "bison_parser.y" 5147| 3.49k| { (yyval.lock_wait_policy_t) = RowLockWaitPolicy::None; } 5148| 3.49k|#line 5149 "bison_parser.cpp" 5149| 3.49k| break; 5150| | 5151| 14.8k| case 298: /* opt_with_clause: %empty */ ------------------ | Branch (5151:3): [True: 14.8k, False: 26.0M] ------------------ 5152| 14.8k|#line 1198 "bison_parser.y" 5153| 14.8k| { (yyval.with_description_vec) = nullptr; } 5154| 14.8k|#line 5155 "bison_parser.cpp" 5155| 14.8k| break; 5156| | 5157| 496| case 299: /* with_clause: WITH with_description_list */ ------------------ | Branch (5157:3): [True: 496, False: 26.1M] ------------------ 5158| 496|#line 1200 "bison_parser.y" 5159| 496| { (yyval.with_description_vec) = (yyvsp[0].with_description_vec); } 5160| 496|#line 5161 "bison_parser.cpp" 5161| 496| break; 5162| | 5163| 538| case 300: /* with_description_list: with_description */ ------------------ | Branch (5163:3): [True: 538, False: 26.1M] ------------------ 5164| 538|#line 1202 "bison_parser.y" 5165| 538| { 5166| 538| (yyval.with_description_vec) = new std::vector(); 5167| 538| (yyval.with_description_vec)->push_back((yyvsp[0].with_description_t)); 5168| 538|} 5169| 538|#line 5170 "bison_parser.cpp" 5170| 538| break; 5171| | 5172| 35.6k| case 301: /* with_description_list: with_description_list ',' with_description */ ------------------ | Branch (5172:3): [True: 35.6k, False: 26.0M] ------------------ 5173| 35.6k|#line 1206 "bison_parser.y" 5174| 35.6k| { 5175| 35.6k| (yyvsp[-2].with_description_vec)->push_back((yyvsp[0].with_description_t)); 5176| 35.6k| (yyval.with_description_vec) = (yyvsp[-2].with_description_vec); 5177| 35.6k|} 5178| 35.6k|#line 5179 "bison_parser.cpp" 5179| 35.6k| break; 5180| | 5181| 36.1k| case 302: /* with_description: IDENTIFIER AS select_with_paren */ ------------------ | Branch (5181:3): [True: 36.1k, False: 26.0M] ------------------ 5182| 36.1k|#line 1211 "bison_parser.y" 5183| 36.1k| { 5184| 36.1k| (yyval.with_description_t) = new WithDescription(); 5185| 36.1k| (yyval.with_description_t)->alias = (yyvsp[-2].sval); 5186| 36.1k| (yyval.with_description_t)->select = (yyvsp[0].select_stmt); 5187| 36.1k|} 5188| 36.1k|#line 5189 "bison_parser.cpp" 5189| 36.1k| break; 5190| | 5191| 791| case 303: /* join_clause: table_ref_atomic NATURAL JOIN nonjoin_table_ref_atomic */ ------------------ | Branch (5191:3): [True: 791, False: 26.1M] ------------------ 5192| 791|#line 1221 "bison_parser.y" 5193| 791| { 5194| 791| (yyval.table) = new TableRef(kTableJoin); 5195| 791| (yyval.table)->join = new JoinDefinition(); 5196| 791| (yyval.table)->join->type = kJoinNatural; 5197| 791| (yyval.table)->join->left = (yyvsp[-3].table); 5198| 791| (yyval.table)->join->right = (yyvsp[0].table); 5199| 791|} 5200| 791|#line 5201 "bison_parser.cpp" 5201| 791| break; 5202| | 5203| 108k| case 304: /* join_clause: table_ref_atomic opt_join_type JOIN table_ref_atomic ON join_condition */ ------------------ | Branch (5203:3): [True: 108k, False: 25.9M] ------------------ 5204| 108k|#line 1228 "bison_parser.y" 5205| 108k| { 5206| 108k| (yyval.table) = new TableRef(kTableJoin); 5207| 108k| (yyval.table)->join = new JoinDefinition(); 5208| 108k| (yyval.table)->join->type = (JoinType)(yyvsp[-4].join_type); 5209| 108k| (yyval.table)->join->left = (yyvsp[-5].table); 5210| 108k| (yyval.table)->join->right = (yyvsp[-2].table); 5211| 108k| (yyval.table)->join->condition = (yyvsp[0].expr); 5212| 108k|} 5213| 108k|#line 5214 "bison_parser.cpp" 5214| 108k| break; 5215| | 5216| 1.53k| case 305: /* join_clause: table_ref_atomic opt_join_type JOIN table_ref_atomic USING '(' column_name ')' */ ------------------ | Branch (5216:3): [True: 1.53k, False: 26.1M] ------------------ 5217| 1.53k|#line 1236 "bison_parser.y" 5218| 1.53k| { 5219| 1.53k| (yyval.table) = new TableRef(kTableJoin); 5220| 1.53k| (yyval.table)->join = new JoinDefinition(); 5221| 1.53k| (yyval.table)->join->type = (JoinType)(yyvsp[-6].join_type); 5222| 1.53k| (yyval.table)->join->left = (yyvsp[-7].table); 5223| 1.53k| (yyval.table)->join->right = (yyvsp[-4].table); 5224| 1.53k| auto left_col = Expr::makeColumnRef(strdup((yyvsp[-1].expr)->name)); 5225| 1.53k| if ((yyvsp[-1].expr)->alias) { ------------------ | Branch (5225:7): [True: 0, False: 1.53k] ------------------ 5226| 0| left_col->alias = strdup((yyvsp[-1].expr)->alias); 5227| 0| } 5228| 1.53k| if ((yyvsp[-7].table)->getName()) { ------------------ | Branch (5228:7): [True: 469, False: 1.06k] ------------------ 5229| 469| left_col->table = strdup((yyvsp[-7].table)->getName()); 5230| 469| } 5231| 1.53k| auto right_col = Expr::makeColumnRef(strdup((yyvsp[-1].expr)->name)); 5232| 1.53k| if ((yyvsp[-1].expr)->alias) { ------------------ | Branch (5232:7): [True: 0, False: 1.53k] ------------------ 5233| 0| right_col->alias = strdup((yyvsp[-1].expr)->alias); 5234| 0| } 5235| 1.53k| if ((yyvsp[-4].table)->getName()) { ------------------ | Branch (5235:7): [True: 1.16k, False: 366] ------------------ 5236| 1.16k| right_col->table = strdup((yyvsp[-4].table)->getName()); 5237| 1.16k| } 5238| 1.53k| (yyval.table)->join->condition = Expr::makeOpBinary(left_col, kOpEquals, right_col); 5239| 1.53k| delete (yyvsp[-1].expr); 5240| 1.53k|} 5241| 1.53k|#line 5242 "bison_parser.cpp" 5242| 1.53k| break; 5243| | 5244| 715| case 306: /* opt_join_type: INNER */ ------------------ | Branch (5244:3): [True: 715, False: 26.1M] ------------------ 5245| 715|#line 1260 "bison_parser.y" 5246| 715| { (yyval.join_type) = kJoinInner; } 5247| 715|#line 5248 "bison_parser.cpp" 5248| 715| break; 5249| | 5250| 66| case 307: /* opt_join_type: LEFT OUTER */ ------------------ | Branch (5250:3): [True: 66, False: 26.1M] ------------------ 5251| 66|#line 1261 "bison_parser.y" 5252| 66| { (yyval.join_type) = kJoinLeft; } 5253| 66|#line 5254 "bison_parser.cpp" 5254| 66| break; 5255| | 5256| 571| case 308: /* opt_join_type: LEFT */ ------------------ | Branch (5256:3): [True: 571, False: 26.1M] ------------------ 5257| 571|#line 1262 "bison_parser.y" 5258| 571| { (yyval.join_type) = kJoinLeft; } 5259| 571|#line 5260 "bison_parser.cpp" 5260| 571| break; 5261| | 5262| 66| case 309: /* opt_join_type: RIGHT OUTER */ ------------------ | Branch (5262:3): [True: 66, False: 26.1M] ------------------ 5263| 66|#line 1263 "bison_parser.y" 5264| 66| { (yyval.join_type) = kJoinRight; } 5265| 66|#line 5266 "bison_parser.cpp" 5266| 66| break; 5267| | 5268| 731| case 310: /* opt_join_type: RIGHT */ ------------------ | Branch (5268:3): [True: 731, False: 26.1M] ------------------ 5269| 731|#line 1264 "bison_parser.y" 5270| 731| { (yyval.join_type) = kJoinRight; } 5271| 731|#line 5272 "bison_parser.cpp" 5272| 731| break; 5273| | 5274| 66| case 311: /* opt_join_type: FULL OUTER */ ------------------ | Branch (5274:3): [True: 66, False: 26.1M] ------------------ 5275| 66|#line 1265 "bison_parser.y" 5276| 66| { (yyval.join_type) = kJoinFull; } 5277| 66|#line 5278 "bison_parser.cpp" 5278| 66| break; 5279| | 5280| 715| case 312: /* opt_join_type: OUTER */ ------------------ | Branch (5280:3): [True: 715, False: 26.1M] ------------------ 5281| 715|#line 1266 "bison_parser.y" 5282| 715| { (yyval.join_type) = kJoinFull; } 5283| 715|#line 5284 "bison_parser.cpp" 5284| 715| break; 5285| | 5286| 567| case 313: /* opt_join_type: FULL */ ------------------ | Branch (5286:3): [True: 567, False: 26.1M] ------------------ 5287| 567|#line 1267 "bison_parser.y" 5288| 567| { (yyval.join_type) = kJoinFull; } 5289| 567|#line 5290 "bison_parser.cpp" 5290| 567| break; 5291| | 5292| 342| case 314: /* opt_join_type: CROSS */ ------------------ | Branch (5292:3): [True: 342, False: 26.1M] ------------------ 5293| 342|#line 1268 "bison_parser.y" 5294| 342| { (yyval.join_type) = kJoinCross; } 5295| 342|#line 5296 "bison_parser.cpp" 5296| 342| break; 5297| | 5298| 109k| case 315: /* opt_join_type: %empty */ ------------------ | Branch (5298:3): [True: 109k, False: 25.9M] ------------------ 5299| 109k|#line 1269 "bison_parser.y" 5300| 109k| { (yyval.join_type) = kJoinInner; } 5301| 109k|#line 5302 "bison_parser.cpp" 5302| 109k| break; 5303| | 5304| 146k| case 319: /* ident_commalist: IDENTIFIER */ ------------------ | Branch (5304:3): [True: 146k, False: 25.9M] ------------------ 5305| 146k|#line 1280 "bison_parser.y" 5306| 146k| { 5307| 146k| (yyval.str_vec) = new std::vector(); 5308| 146k| (yyval.str_vec)->push_back((yyvsp[0].sval)); 5309| 146k|} 5310| 146k|#line 5311 "bison_parser.cpp" 5311| 146k| break; 5312| | 5313| 553k| case 320: /* ident_commalist: ident_commalist ',' IDENTIFIER */ ------------------ | Branch (5313:3): [True: 553k, False: 25.5M] ------------------ 5314| 553k|#line 1284 "bison_parser.y" 5315| 553k| { 5316| 553k| (yyvsp[-2].str_vec)->push_back((yyvsp[0].sval)); 5317| 553k| (yyval.str_vec) = (yyvsp[-2].str_vec); 5318| 553k|} 5319| 553k|#line 5320 "bison_parser.cpp" 5320| 553k| break; 5321| | 5322| | 5323| 0|#line 5324 "bison_parser.cpp" 5324| | 5325| 10.6M| default: break; ------------------ | Branch (5325:7): [True: 10.6M, False: 15.4M] ------------------ 5326| 26.1M| } 5327| | /* User semantic actions sometimes alter yychar, and that requires 5328| | that yytoken be updated with the new translation. We take the 5329| | approach of translating immediately before every use of yytoken. 5330| | One alternative is translating here after every semantic action, 5331| | but that translation would be missed if the semantic action invokes 5332| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 5333| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 5334| | incorrect destructor might then be invoked immediately. In the 5335| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 5336| | to an incorrect destructor call or verbose syntax error message 5337| | before the lookahead is translated. */ 5338| 26.1M| YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 5339| | 5340| 26.1M| YYPOPSTACK (yylen); ------------------ | | 2965| 26.1M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5341| 26.1M| yylen = 0; 5342| | 5343| 26.1M| *++yyvsp = yyval; 5344| 26.1M| *++yylsp = yyloc; 5345| | 5346| | /* Now 'shift' the result of the reduction. Determine what state 5347| | that goes to, based on the state we popped back to and the rule 5348| | number reduced by. */ 5349| 26.1M| { 5350| 26.1M| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 780| 26.1M|#define YYNTOKENS 187 ------------------ 5351| 26.1M| const int yyi = yypgoto[yylhs] + *yyssp; 5352| 26.1M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 777| 43.3M|#define YYLAST 883 ------------------ | Branch (5352:16): [True: 17.2M, False: 8.85M] | Branch (5352:28): [True: 17.2M, False: 0] | Branch (5352:45): [True: 6.87M, False: 10.3M] ------------------ 5353| 26.1M| ? yytable[yyi] 5354| 26.1M| : yydefgoto[yylhs]); 5355| 26.1M| } 5356| | 5357| 26.1M| goto yynewstate; 5358| | 5359| | 5360| |/*--------------------------------------. 5361| || yyerrlab -- here on detecting error. | 5362| |`--------------------------------------*/ 5363| 3.44k|yyerrlab: 5364| | /* Make sure we have latest lookahead translation. See comments at 5365| | user semantic actions for why this is necessary. */ 5366| 3.44k| yytoken = yychar == SQL_HSQL_EMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 795| 6.88k| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 789| 3.44k|#define YYMAXUTOK 424 | | ------------------ | | | Branch (795:4): [True: 3.44k, False: 0] | | | Branch (795:18): [True: 3.44k, False: 0] | | ------------------ | | 796| 6.88k| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 111| 3.44k|# define YY_CAST(Type, Val) static_cast (Val) | | ------------------ | | 797| 6.88k| : YYSYMBOL_YYUNDEF) ------------------ | Branch (5366:13): [True: 0, False: 3.44k] ------------------ 5367| | /* If not already recovering from an error, report this error. */ 5368| 3.44k| if (!yyerrstatus) ------------------ | Branch (5368:7): [True: 3.44k, False: 0] ------------------ 5369| 3.44k| { 5370| 3.44k| ++yynerrs; ------------------ | | 74| 3.44k|#define yynerrs hsql_nerrs ------------------ 5371| 3.44k| { 5372| 3.44k| yypcontext_t yyctx 5373| 3.44k| = {yyssp, yytoken, &yylloc}; 5374| 3.44k| char const *yymsgp = YY_("syntax error"); ------------------ | | 576| 3.44k|# define YY_(Msgid) Msgid ------------------ 5375| 3.44k| int yysyntax_error_status; 5376| 3.44k| yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); 5377| 3.44k| if (yysyntax_error_status == 0) ------------------ | Branch (5377:13): [True: 3.44k, False: 0] ------------------ 5378| 3.44k| yymsgp = yymsg; 5379| 0| else if (yysyntax_error_status == -1) ------------------ | Branch (5379:18): [True: 0, False: 0] ------------------ 5380| 0| { 5381| 0| if (yymsg != yymsgbuf) ------------------ | Branch (5381:17): [True: 0, False: 0] ------------------ 5382| 0| YYSTACK_FREE (yymsg); ------------------ | | 684| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 703| 0|# define YYFREE free | | ------------------ ------------------ 5383| 0| yymsg = YY_CAST (char *, ------------------ | | 111| 0|# define YY_CAST(Type, Val) static_cast (Val) ------------------ 5384| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); 5385| 0| if (yymsg) ------------------ | Branch (5385:17): [True: 0, False: 0] ------------------ 5386| 0| { 5387| 0| yysyntax_error_status 5388| 0| = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); 5389| 0| yymsgp = yymsg; 5390| 0| } 5391| 0| else 5392| 0| { 5393| 0| yymsg = yymsgbuf; 5394| 0| yymsg_alloc = sizeof yymsgbuf; 5395| 0| yysyntax_error_status = YYENOMEM; 5396| 0| } 5397| 0| } 5398| 3.44k| yyerror (&yylloc, result, scanner, yymsgp); ------------------ | | 72| 3.44k|#define yyerror hsql_error ------------------ 5399| 3.44k| if (yysyntax_error_status == YYENOMEM) ------------------ | Branch (5399:13): [True: 0, False: 3.44k] ------------------ 5400| 0| YYNOMEM; ------------------ | | 1481| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 5401| 3.44k| } 5402| 3.44k| } 5403| | 5404| 3.44k| yyerror_range[1] = yylloc; 5405| 3.44k| if (yyerrstatus == 3) ------------------ | Branch (5405:7): [True: 0, False: 3.44k] ------------------ 5406| 0| { 5407| | /* If just tried and failed to reuse lookahead token after an 5408| | error, discard it. */ 5409| | 5410| 0| if (yychar <= SQL_YYEOF) ------------------ | Branch (5410:11): [True: 0, False: 0] ------------------ 5411| 0| { 5412| | /* Return failure if at end of input. */ 5413| 0| if (yychar == SQL_YYEOF) ------------------ | Branch (5413:15): [True: 0, False: 0] ------------------ 5414| 0| YYABORT; ------------------ | | 1479| 0|#define YYABORT goto yyabortlab ------------------ 5415| 0| } 5416| 0| else 5417| 0| { 5418| 0| yydestruct ("Error: discarding", 5419| 0| yytoken, &yylval, &yylloc, result, scanner); 5420| 0| yychar = SQL_HSQL_EMPTY; 5421| 0| } 5422| 0| } 5423| | 5424| | /* Else will try to reuse lookahead token after shifting the error 5425| | token. */ 5426| 3.44k| goto yyerrlab1; 5427| | 5428| | 5429| |/*---------------------------------------------------. 5430| || yyerrorlab -- error raised explicitly by YYERROR. | 5431| |`---------------------------------------------------*/ 5432| 3.44k|yyerrorlab: 5433| | /* Pacify compilers when the user code never invokes YYERROR and the 5434| | label yyerrorlab therefore never appears in user code. */ 5435| 447| if (0) ------------------ | Branch (5435:7): [Folded - Ignored] ------------------ 5436| 0| YYERROR; ------------------ | | 1480| 0|#define YYERROR goto yyerrorlab ------------------ 5437| 447| ++yynerrs; ------------------ | | 74| 447|#define yynerrs hsql_nerrs ------------------ 5438| | 5439| | /* Do not reclaim the symbols of the rule whose action triggered 5440| | this YYERROR. */ 5441| 447| YYPOPSTACK (yylen); ------------------ | | 2965| 447|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5442| 447| yylen = 0; 5443| 447| YY_STACK_PRINT (yyss, yyssp); 5444| 447| yystate = *yyssp; 5445| 447| goto yyerrlab1; 5446| | 5447| | 5448| |/*-------------------------------------------------------------. 5449| || yyerrlab1 -- common code for both syntax error and YYERROR. | 5450| |`-------------------------------------------------------------*/ 5451| 3.88k|yyerrlab1: 5452| 3.88k| yyerrstatus = 3; /* Each real token shifted decrements this. */ 5453| | 5454| | /* Pop stack until we find a state that shifts the error token. */ 5455| 3.88k| for (;;) 5456| 48.5k| { 5457| 48.5k| yyn = yypact[yystate]; 5458| 48.5k| if (!yypact_value_is_default (yyn)) ------------------ | | 971| 48.5k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 968| 48.5k|#define YYPACT_NINF (-337) | | ------------------ ------------------ | Branch (5458:11): [True: 48.5k, False: 0] ------------------ 5459| 48.5k| { 5460| 48.5k| yyn += YYSYMBOL_YYerror; 5461| 48.5k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) ------------------ | | 777| 89.9k|#define YYLAST 883 ------------------ | Branch (5461:15): [True: 41.3k, False: 7.17k] | Branch (5461:27): [True: 41.3k, False: 0] | Branch (5461:44): [True: 0, False: 41.3k] ------------------ 5462| 0| { 5463| 0| yyn = yytable[yyn]; 5464| 0| if (0 < yyn) ------------------ | Branch (5464:19): [True: 0, False: 0] ------------------ 5465| 0| break; 5466| 0| } 5467| 48.5k| } 5468| | 5469| | /* Pop the current state because it cannot handle the error token. */ 5470| 48.5k| if (yyssp == yyss) ------------------ | Branch (5470:11): [True: 3.88k, False: 44.6k] ------------------ 5471| 3.88k| YYABORT; ------------------ | | 1479| 3.88k|#define YYABORT goto yyabortlab ------------------ 5472| | 5473| 44.6k| yyerror_range[1] = *yylsp; 5474| 44.6k| yydestruct ("Error: popping", 5475| 44.6k| YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp, result, scanner); ------------------ | | 889| 44.6k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 111| 44.6k|# define YY_CAST(Type, Val) static_cast (Val) | | ------------------ ------------------ 5476| 44.6k| YYPOPSTACK (1); ------------------ | | 2965| 44.6k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5477| 44.6k| yystate = *yyssp; 5478| 44.6k| YY_STACK_PRINT (yyss, yyssp); 5479| 44.6k| } 5480| | 5481| 0| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 5482| 0| *++yyvsp = yylval; 5483| 0| YY_IGNORE_MAYBE_UNINITIALIZED_END 5484| | 5485| 0| yyerror_range[2] = yylloc; 5486| 0| ++yylsp; 5487| 0| YYLLOC_DEFAULT (*yylsp, yyerror_range, 2); ------------------ | | 1513| 0| do \ | | 1514| 0| if (N) \ | | ------------------ | | | Branch (1514:11): [Folded - Ignored] | | ------------------ | | 1515| 0| { \ | | 1516| 0| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ | | ------------------ | | | | 1531| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1517| 0| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ | | ------------------ | | | | 1531| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1518| 0| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ | | ------------------ | | | | 1531| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1519| 0| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ | | ------------------ | | | | 1531| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1520| 0| } \ | | 1521| 0| else \ | | 1522| 0| { \ | | 1523| 0| (Current).first_line = (Current).last_line = \ | | 1524| 0| YYRHSLOC (Rhs, 0).last_line; \ | | ------------------ | | | | 1531| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1525| 0| (Current).first_column = (Current).last_column = \ | | 1526| 0| YYRHSLOC (Rhs, 0).last_column; \ | | ------------------ | | | | 1531| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1527| 0| } \ | | 1528| 0| while (0) | | ------------------ | | | Branch (1528:12): [Folded - Ignored] | | ------------------ ------------------ 5488| | 5489| | /* Shift the error token. */ 5490| 0| YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 5491| | 5492| 0| yystate = yyn; 5493| 0| goto yynewstate; 5494| | 5495| | 5496| |/*-------------------------------------. 5497| || yyacceptlab -- YYACCEPT comes here. | 5498| |`-------------------------------------*/ 5499| 1.69k|yyacceptlab: 5500| 1.69k| yyresult = 0; 5501| 1.69k| goto yyreturnlab; 5502| | 5503| | 5504| |/*-----------------------------------. 5505| || yyabortlab -- YYABORT comes here. | 5506| |`-----------------------------------*/ 5507| 3.88k|yyabortlab: 5508| 3.88k| yyresult = 1; 5509| 3.88k| goto yyreturnlab; 5510| | 5511| | 5512| |/*-----------------------------------------------------------. 5513| || yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | 5514| |`-----------------------------------------------------------*/ 5515| 16|yyexhaustedlab: 5516| 16| yyerror (&yylloc, result, scanner, YY_("memory exhausted")); ------------------ | | 72| 16|#define yyerror hsql_error ------------------ yyerror (&yylloc, result, scanner, YY_("memory exhausted")); ------------------ | | 576| 16|# define YY_(Msgid) Msgid ------------------ 5517| 16| yyresult = 2; 5518| 16| goto yyreturnlab; 5519| | 5520| | 5521| |/*----------------------------------------------------------. 5522| || yyreturnlab -- parsing is finished, clean up and return. | 5523| |`----------------------------------------------------------*/ 5524| 5.59k|yyreturnlab: 5525| 5.59k| if (yychar != SQL_HSQL_EMPTY) ------------------ | Branch (5525:7): [True: 3.76k, False: 1.82k] ------------------ 5526| 3.76k| { 5527| | /* Make sure we have latest lookahead translation. See comments at 5528| | user semantic actions for why this is necessary. */ 5529| 3.76k| yytoken = YYTRANSLATE (yychar); ------------------ | | 795| 3.76k| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 789| 3.76k|#define YYMAXUTOK 424 | | ------------------ | | | Branch (795:4): [True: 3.76k, False: 0] | | | Branch (795:18): [True: 3.76k, False: 0] | | ------------------ | | 796| 3.76k| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 111| 3.76k|# define YY_CAST(Type, Val) static_cast (Val) | | ------------------ | | 797| 3.76k| : YYSYMBOL_YYUNDEF) ------------------ 5530| 3.76k| yydestruct ("Cleanup: discarding lookahead", 5531| 3.76k| yytoken, &yylval, &yylloc, result, scanner); 5532| 3.76k| } 5533| | /* Do not reclaim the symbols of the rule whose action triggered 5534| | this YYABORT or YYACCEPT. */ 5535| 5.59k| YYPOPSTACK (yylen); ------------------ | | 2965| 5.59k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5536| 5.59k| YY_STACK_PRINT (yyss, yyssp); 5537| 12.1k| while (yyssp != yyss) ------------------ | Branch (5537:10): [True: 6.56k, False: 5.59k] ------------------ 5538| 6.56k| { 5539| 6.56k| yydestruct ("Cleanup: popping", 5540| 6.56k| YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp, result, scanner); ------------------ | | 889| 6.56k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 111| 6.56k|# define YY_CAST(Type, Val) static_cast (Val) | | ------------------ ------------------ 5541| 6.56k| YYPOPSTACK (1); ------------------ | | 2965| 6.56k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5542| 6.56k| } 5543| 5.59k|#ifndef yyoverflow 5544| 5.59k| if (yyss != yyssa) ------------------ | Branch (5544:7): [True: 0, False: 5.59k] ------------------ 5545| 0| YYSTACK_FREE (yyss); ------------------ | | 684| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 703| 0|# define YYFREE free | | ------------------ ------------------ 5546| 5.59k|#endif 5547| 5.59k| if (yymsg != yymsgbuf) ------------------ | Branch (5547:7): [True: 0, False: 5.59k] ------------------ 5548| 0| YYSTACK_FREE (yymsg); ------------------ | | 684| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 703| 0|# define YYFREE free | | ------------------ ------------------ 5549| 5.59k| return yyresult; 5550| 3.88k|} bison_parser.cpp:_ZL14yysyntax_errorPlPPcPK12yypcontext_t: 1935| 3.44k|{ 1936| 3.44k| enum { YYARGS_MAX = 5 }; 1937| | /* Internationalized format string. */ 1938| 3.44k| const char *yyformat = YY_NULLPTR; ------------------ | | 121| 3.44k|# define YY_NULLPTR nullptr ------------------ 1939| | /* Arguments of yyformat: reported tokens (one for the "unexpected", 1940| | one per "expected"). */ 1941| 3.44k| yysymbol_kind_t yyarg[YYARGS_MAX]; 1942| | /* Cumulated lengths of YYARG. */ 1943| 3.44k| YYPTRDIFF_T yysize = 0; ------------------ | | 526| 3.44k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1944| | 1945| | /* Actual size of YYARG. */ 1946| 3.44k| int yycount = yy_syntax_error_arguments (yyctx, yyarg, YYARGS_MAX); 1947| 3.44k| if (yycount == YYENOMEM) ------------------ | Branch (1947:7): [True: 0, False: 3.44k] ------------------ 1948| 0| return YYENOMEM; 1949| | 1950| 3.44k| switch (yycount) 1951| 3.44k| { 1952| 0|#define YYCASE_(N, S) \ 1953| 0| case N: \ 1954| 0| yyformat = S; \ 1955| 0| break 1956| 0| default: /* Avoid compiler warnings. */ ------------------ | Branch (1956:5): [True: 0, False: 3.44k] ------------------ 1957| 0| YYCASE_(0, YY_("syntax error")); ------------------ | | 1953| 0| case N: \ | | ------------------ | | | Branch (1953:7): [True: 0, False: 3.44k] | | ------------------ | | 1954| 0| yyformat = S; \ | | 1955| 0| break ------------------ 1958| 579| YYCASE_(1, YY_("syntax error, unexpected %s")); ------------------ | | 1953| 579| case N: \ | | ------------------ | | | Branch (1953:7): [True: 579, False: 2.86k] | | ------------------ | | 1954| 579| yyformat = S; \ | | 1955| 579| break ------------------ 1959| 984| YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); ------------------ | | 1953| 984| case N: \ | | ------------------ | | | Branch (1953:7): [True: 984, False: 2.45k] | | ------------------ | | 1954| 984| yyformat = S; \ | | 1955| 984| break ------------------ 1960| 1.58k| YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); ------------------ | | 1953| 1.58k| case N: \ | | ------------------ | | | Branch (1953:7): [True: 1.58k, False: 1.85k] | | ------------------ | | 1954| 1.58k| yyformat = S; \ | | 1955| 1.58k| break ------------------ 1961| 250| YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); ------------------ | | 1953| 250| case N: \ | | ------------------ | | | Branch (1953:7): [True: 250, False: 3.19k] | | ------------------ | | 1954| 250| yyformat = S; \ | | 1955| 250| break ------------------ 1962| 3.44k| YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); ------------------ | | 1953| 43| case N: \ | | ------------------ | | | Branch (1953:7): [True: 43, False: 3.39k] | | ------------------ | | 1954| 43| yyformat = S; \ | | 1955| 43| break ------------------ 1963| 3.44k|#undef YYCASE_ 1964| 3.44k| } 1965| | 1966| | /* Compute error message size. Don't count the "%s"s, but reserve 1967| | room for the terminator. */ 1968| 3.44k| yysize = yystrlen (yyformat) - 2 * yycount + 1; ------------------ | | 1794| 3.44k|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 111| 3.44k|# define YY_CAST(Type, Val) static_cast (Val) | | ------------------ ------------------ 1969| 3.44k| { 1970| 3.44k| int yyi; 1971| 11.9k| for (yyi = 0; yyi < yycount; ++yyi) ------------------ | Branch (1971:19): [True: 8.52k, False: 3.44k] ------------------ 1972| 8.52k| { 1973| 8.52k| YYPTRDIFF_T yysize1 ------------------ | | 526| 8.52k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1974| 8.52k| = yysize + yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]]); ------------------ | | 121| 8.52k|# define YY_NULLPTR nullptr ------------------ 1975| 8.52k| if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) ------------------ | | 686| 8.52k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 554| 8.52k| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 111| 17.0k|# define YY_CAST(Type, Val) static_cast (Val) | | | | | | ------------------ | | | | | | | Branch (111:50): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1975:13): [True: 8.52k, False: 0] | Branch (1975:34): [True: 8.52k, False: 0] ------------------ 1976| 8.52k| yysize = yysize1; 1977| 0| else 1978| 0| return YYENOMEM; 1979| 8.52k| } 1980| 3.44k| } 1981| | 1982| 3.44k| if (*yymsg_alloc < yysize) ------------------ | Branch (1982:7): [True: 0, False: 3.44k] ------------------ 1983| 0| { 1984| 0| *yymsg_alloc = 2 * yysize; 1985| 0| if (! (yysize <= *yymsg_alloc ------------------ | Branch (1985:14): [True: 0, False: 0] ------------------ 1986| 0| && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) ------------------ | | 686| 0|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 554| 0| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 111| 0|# define YY_CAST(Type, Val) static_cast (Val) | | | | | | ------------------ | | | | | | | Branch (111:50): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1986:17): [True: 0, False: 0] ------------------ 1987| 0| *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; ------------------ | | 686| 0|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 554| 0| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 111| 0|# define YY_CAST(Type, Val) static_cast (Val) | | | | | | ------------------ | | | | | | | Branch (111:50): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1988| 0| return -1; 1989| 0| } 1990| | 1991| | /* Avoid sprintf, as that infringes on the user's name space. 1992| | Don't have undefined behavior even if the translation 1993| | produced a string with the wrong number of "%s"s. */ 1994| 3.44k| { 1995| 3.44k| char *yyp = *yymsg; 1996| 3.44k| int yyi = 0; 1997| 141k| while ((*yyp = *yyformat) != '\0') ------------------ | Branch (1997:12): [True: 137k, False: 3.44k] ------------------ 1998| 137k| if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) ------------------ | Branch (1998:11): [True: 8.52k, False: 129k] | Branch (1998:26): [True: 8.52k, False: 0] | Branch (1998:48): [True: 8.52k, False: 0] ------------------ 1999| 8.52k| { 2000| 8.52k| yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]); 2001| 8.52k| yyformat += 2; 2002| 8.52k| } 2003| 129k| else 2004| 129k| { 2005| 129k| ++yyp; 2006| 129k| ++yyformat; 2007| 129k| } 2008| 3.44k| } 2009| 3.44k| return 0; 2010| 3.44k|} bison_parser.cpp:_ZL25yy_syntax_error_argumentsPK12yypcontext_tP15yysymbol_kind_ti: 1882| 3.44k|{ 1883| | /* Actual size of YYARG. */ 1884| 3.44k| int yycount = 0; 1885| | /* There are many possibilities here to consider: 1886| | - If this state is a consistent state with a default action, then 1887| | the only way this function was invoked is if the default action 1888| | is an error action. In that case, don't check for expected 1889| | tokens because there are none. 1890| | - The only way there can be no lookahead present (in yychar) is if 1891| | this state is a consistent state with a default action. Thus, 1892| | detecting the absence of a lookahead is sufficient to determine 1893| | that there is no unexpected or expected token to report. In that 1894| | case, just report a simple "syntax error". 1895| | - Don't assume there isn't a lookahead just because this state is a 1896| | consistent state with a default action. There might have been a 1897| | previous inconsistent state, consistent state with a non-default 1898| | action, or user semantic action that manipulated yychar. 1899| | - Of course, the expected token list depends on states to have 1900| | correct lookahead information, and it depends on the parser not 1901| | to perform extra reductions after fetching a lookahead from the 1902| | scanner and before detecting a syntax error. Thus, state merging 1903| | (from LALR or IELR) and default reductions corrupt the expected 1904| | token list. However, the list is correct for canonical LR with 1905| | one exception: it will still contain any token that will not be 1906| | accepted due to an error action in a later state. 1907| | */ 1908| 3.44k| if (yyctx->yytoken != YYSYMBOL_YYEMPTY) ------------------ | Branch (1908:7): [True: 3.44k, False: 0] ------------------ 1909| 3.44k| { 1910| 3.44k| int yyn; 1911| 3.44k| if (yyarg) ------------------ | Branch (1911:11): [True: 3.44k, False: 0] ------------------ 1912| 3.44k| yyarg[yycount] = yyctx->yytoken; 1913| 3.44k| ++yycount; 1914| 3.44k| yyn = yypcontext_expected_tokens (yyctx, 1915| 3.44k| yyarg ? yyarg + 1 : yyarg, yyargn - 1); ------------------ | Branch (1915:41): [True: 3.44k, False: 0] ------------------ 1916| 3.44k| if (yyn == YYENOMEM) ------------------ | Branch (1916:11): [True: 0, False: 3.44k] ------------------ 1917| 0| return YYENOMEM; 1918| 3.44k| else 1919| 3.44k| yycount += yyn; 1920| 3.44k| } 1921| 3.44k| return yycount; 1922| 3.44k|} bison_parser.cpp:_ZL26yypcontext_expected_tokensPK12yypcontext_tP15yysymbol_kind_ti: 1758| 3.44k|{ 1759| | /* Actual size of YYARG. */ 1760| 3.44k| int yycount = 0; 1761| 3.44k| int yyn = yypact[+*yyctx->yyssp]; 1762| 3.44k| if (!yypact_value_is_default (yyn)) ------------------ | | 971| 3.44k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 968| 3.44k|#define YYPACT_NINF (-337) | | ------------------ ------------------ | Branch (1762:7): [True: 3.44k, False: 0] ------------------ 1763| 3.44k| { 1764| | /* Start YYX at -YYN if negative to avoid negative indexes in 1765| | YYCHECK. In other words, skip the first -YYN actions for 1766| | this state because they are default actions. */ 1767| 3.44k| int yyxbegin = yyn < 0 ? -yyn : 0; ------------------ | Branch (1767:22): [True: 1.11k, False: 2.32k] ------------------ 1768| | /* Stay within bounds of both yycheck and yytname. */ 1769| 3.44k| int yychecklim = YYLAST - yyn + 1; ------------------ | | 777| 3.44k|#define YYLAST 883 ------------------ 1770| 3.44k| int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 780| 3.44k|#define YYNTOKENS 187 ------------------ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 780| 3.44k|#define YYNTOKENS 187 ------------------ | Branch (1770:20): [True: 0, False: 3.44k] ------------------ 1771| 3.44k| int yyx; 1772| 535k| for (yyx = yyxbegin; yyx < yyxend; ++yyx) ------------------ | Branch (1772:28): [True: 532k, False: 2.86k] ------------------ 1773| 532k| if (yycheck[yyx + yyn] == yyx && yyx != YYSYMBOL_YYerror ------------------ | Branch (1773:13): [True: 8.05k, False: 524k] | Branch (1773:42): [True: 8.05k, False: 0] ------------------ 1774| 532k| && !yytable_value_is_error (yytable[yyx + yyn])) ------------------ | | 976| 8.05k| ((Yyn) == YYTABLE_NINF) | | ------------------ | | | | 973| 8.05k|#define YYTABLE_NINF (-318) | | ------------------ ------------------ | Branch (1774:16): [True: 7.97k, False: 78] ------------------ 1775| 7.97k| { 1776| 7.97k| if (!yyarg) ------------------ | Branch (1776:17): [True: 0, False: 7.97k] ------------------ 1777| 0| ++yycount; 1778| 7.97k| else if (yycount == yyargn) ------------------ | Branch (1778:22): [True: 579, False: 7.39k] ------------------ 1779| 579| return 0; 1780| 7.39k| else 1781| 7.39k| yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx); ------------------ | | 111| 7.39k|# define YY_CAST(Type, Val) static_cast (Val) ------------------ 1782| 7.97k| } 1783| 3.44k| } 1784| 2.86k| if (yyarg && yycount == 0 && 0 < yyargn) ------------------ | Branch (1784:7): [True: 2.86k, False: 0] | Branch (1784:16): [True: 0, False: 2.86k] | Branch (1784:32): [True: 0, False: 0] ------------------ 1785| 0| yyarg[0] = YYSYMBOL_YYEMPTY; 1786| 2.86k| return yycount; 1787| 3.44k|} bison_parser.cpp:_ZL9yytnamerrPcPKc: 1838| 17.0k|{ 1839| 17.0k| if (*yystr == '"') ------------------ | Branch (1839:7): [True: 3.77k, False: 13.2k] ------------------ 1840| 3.77k| { 1841| 3.77k| YYPTRDIFF_T yyn = 0; ------------------ | | 526| 3.77k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1842| 3.77k| char const *yyp = yystr; 1843| 3.77k| for (;;) 1844| 45.3k| switch (*++yyp) 1845| 45.3k| { 1846| 0| case '\'': ------------------ | Branch (1846:11): [True: 0, False: 45.3k] ------------------ 1847| 0| case ',': ------------------ | Branch (1847:11): [True: 0, False: 45.3k] ------------------ 1848| 0| goto do_not_strip_quotes; 1849| | 1850| 0| case '\\': ------------------ | Branch (1850:11): [True: 0, False: 45.3k] ------------------ 1851| 0| if (*++yyp != '\\') ------------------ | Branch (1851:17): [True: 0, False: 0] ------------------ 1852| 0| goto do_not_strip_quotes; 1853| 0| else 1854| 0| goto append; 1855| | 1856| 0| append: 1857| 41.5k| default: ------------------ | Branch (1857:11): [True: 41.5k, False: 3.77k] ------------------ 1858| 41.5k| if (yyres) ------------------ | Branch (1858:17): [True: 20.7k, False: 20.7k] ------------------ 1859| 20.7k| yyres[yyn] = *yyp; 1860| 41.5k| yyn++; 1861| 41.5k| break; 1862| | 1863| 3.77k| case '"': ------------------ | Branch (1863:11): [True: 3.77k, False: 41.5k] ------------------ 1864| 3.77k| if (yyres) ------------------ | Branch (1864:17): [True: 1.88k, False: 1.88k] ------------------ 1865| 1.88k| yyres[yyn] = '\0'; 1866| 3.77k| return yyn; 1867| 45.3k| } 1868| 0| do_not_strip_quotes: ; 1869| 0| } 1870| | 1871| 13.2k| if (yyres) ------------------ | Branch (1871:7): [True: 6.63k, False: 6.63k] ------------------ 1872| 6.63k| return yystpcpy (yyres, yystr) - yyres; ------------------ | | 1810| 6.63k|# define yystpcpy stpcpy ------------------ 1873| 6.63k| else 1874| 6.63k| return yystrlen (yystr); ------------------ | | 1794| 6.63k|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 111| 6.63k|# define YY_CAST(Type, Val) static_cast (Val) | | ------------------ ------------------ 1875| 13.2k|} bison_parser.cpp:_ZL10yydestructPKc15yysymbol_kind_tP10HSQL_STYPEP15HSQL_CUST_LTYPEPN4hsql15SQLParserResultEPv: 2020| 54.9k|{ 2021| 54.9k| YY_USE (yyvaluep); ------------------ | | 599| 54.9k|# define YY_USE(E) ((void) (E)) ------------------ 2022| 54.9k| YY_USE (yylocationp); ------------------ | | 599| 54.9k|# define YY_USE(E) ((void) (E)) ------------------ 2023| 54.9k| YY_USE (result); ------------------ | | 599| 54.9k|# define YY_USE(E) ((void) (E)) ------------------ 2024| 54.9k| YY_USE (scanner); ------------------ | | 599| 54.9k|# define YY_USE(E) ((void) (E)) ------------------ 2025| 54.9k| if (!yymsg) ------------------ | Branch (2025:7): [True: 0, False: 54.9k] ------------------ 2026| 0| yymsg = "Deleting"; 2027| 54.9k| YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 2028| | 2029| 54.9k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2030| 54.9k| switch (yykind) 2031| 54.9k| { 2032| 1.60k| case YYSYMBOL_IDENTIFIER: /* IDENTIFIER */ ------------------ | Branch (2032:5): [True: 1.60k, False: 53.3k] ------------------ 2033| 1.60k|#line 177 "bison_parser.y" 2034| 1.60k| { free( (((*yyvaluep).sval)) ); } 2035| 1.60k|#line 2036 "bison_parser.cpp" 2036| 1.60k| break; 2037| | 2038| 61| case YYSYMBOL_STRING: /* STRING */ ------------------ | Branch (2038:5): [True: 61, False: 54.9k] ------------------ 2039| 61|#line 177 "bison_parser.y" 2040| 61| { free( (((*yyvaluep).sval)) ); } 2041| 61|#line 2042 "bison_parser.cpp" 2042| 61| break; 2043| | 2044| 24| case YYSYMBOL_FLOATVAL: /* FLOATVAL */ ------------------ | Branch (2044:5): [True: 24, False: 54.9k] ------------------ 2045| 24|#line 164 "bison_parser.y" 2046| 24| { } 2047| 24|#line 2048 "bison_parser.cpp" 2048| 24| break; 2049| | 2050| 35| case YYSYMBOL_INTVAL: /* INTVAL */ ------------------ | Branch (2050:5): [True: 35, False: 54.9k] ------------------ 2051| 35|#line 164 "bison_parser.y" 2052| 35| { } 2053| 35|#line 2054 "bison_parser.cpp" 2054| 35| break; 2055| | 2056| 479| case YYSYMBOL_statement_list: /* statement_list */ ------------------ | Branch (2056:5): [True: 479, False: 54.5k] ------------------ 2057| 479|#line 178 "bison_parser.y" 2058| 479| { 2059| 479| if (((*yyvaluep).stmt_vec)) { ------------------ | Branch (2059:11): [True: 479, False: 0] ------------------ 2060| 227k| for (auto ptr : *(((*yyvaluep).stmt_vec))) { ------------------ | Branch (2060:23): [True: 227k, False: 479] ------------------ 2061| 227k| delete ptr; 2062| 227k| } 2063| 479| } 2064| 479| delete (((*yyvaluep).stmt_vec)); 2065| 479| } 2066| 479|#line 2067 "bison_parser.cpp" 2067| 479| break; 2068| | 2069| 0| case YYSYMBOL_statement: /* statement */ ------------------ | Branch (2069:5): [True: 0, False: 54.9k] ------------------ 2070| 0|#line 186 "bison_parser.y" 2071| 0| { delete (((*yyvaluep).statement)); } 2072| 0|#line 2073 "bison_parser.cpp" 2073| 0| break; 2074| | 2075| 54| case YYSYMBOL_preparable_statement: /* preparable_statement */ ------------------ | Branch (2075:5): [True: 54, False: 54.9k] ------------------ 2076| 54|#line 186 "bison_parser.y" 2077| 54| { delete (((*yyvaluep).statement)); } 2078| 54|#line 2079 "bison_parser.cpp" 2079| 54| break; 2080| | 2081| 0| case YYSYMBOL_opt_hints: /* opt_hints */ ------------------ | Branch (2081:5): [True: 0, False: 54.9k] ------------------ 2082| 0|#line 178 "bison_parser.y" 2083| 0| { 2084| 0| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2084:11): [True: 0, False: 0] ------------------ 2085| 0| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2085:23): [True: 0, False: 0] ------------------ 2086| 0| delete ptr; 2087| 0| } 2088| 0| } 2089| 0| delete (((*yyvaluep).expr_vec)); 2090| 0| } 2091| 0|#line 2092 "bison_parser.cpp" 2092| 0| break; 2093| | 2094| 38| case YYSYMBOL_hint_list: /* hint_list */ ------------------ | Branch (2094:5): [True: 38, False: 54.9k] ------------------ 2095| 38|#line 178 "bison_parser.y" 2096| 38| { 2097| 38| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2097:11): [True: 38, False: 0] ------------------ 2098| 803| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2098:23): [True: 803, False: 38] ------------------ 2099| 803| delete ptr; 2100| 803| } 2101| 38| } 2102| 38| delete (((*yyvaluep).expr_vec)); 2103| 38| } 2104| 38|#line 2105 "bison_parser.cpp" 2105| 38| break; 2106| | 2107| 0| case YYSYMBOL_hint: /* hint */ ------------------ | Branch (2107:5): [True: 0, False: 54.9k] ------------------ 2108| 0|#line 186 "bison_parser.y" 2109| 0| { delete (((*yyvaluep).expr)); } 2110| 0|#line 2111 "bison_parser.cpp" 2111| 0| break; 2112| | 2113| 0| case YYSYMBOL_transaction_statement: /* transaction_statement */ ------------------ | Branch (2113:5): [True: 0, False: 54.9k] ------------------ 2114| 0|#line 186 "bison_parser.y" 2115| 0| { delete (((*yyvaluep).transaction_stmt)); } 2116| 0|#line 2117 "bison_parser.cpp" 2117| 0| break; 2118| | 2119| 1| case YYSYMBOL_prepare_statement: /* prepare_statement */ ------------------ | Branch (2119:5): [True: 1, False: 54.9k] ------------------ 2120| 1|#line 186 "bison_parser.y" 2121| 1| { delete (((*yyvaluep).prep_stmt)); } 2122| 1|#line 2123 "bison_parser.cpp" 2123| 1| break; 2124| | 2125| 0| case YYSYMBOL_prepare_target_query: /* prepare_target_query */ ------------------ | Branch (2125:5): [True: 0, False: 54.9k] ------------------ 2126| 0|#line 177 "bison_parser.y" 2127| 0| { free( (((*yyvaluep).sval)) ); } 2128| 0|#line 2129 "bison_parser.cpp" 2129| 0| break; 2130| | 2131| 0| case YYSYMBOL_execute_statement: /* execute_statement */ ------------------ | Branch (2131:5): [True: 0, False: 54.9k] ------------------ 2132| 0|#line 186 "bison_parser.y" 2133| 0| { delete (((*yyvaluep).exec_stmt)); } 2134| 0|#line 2135 "bison_parser.cpp" 2135| 0| break; 2136| | 2137| 0| case YYSYMBOL_import_statement: /* import_statement */ ------------------ | Branch (2137:5): [True: 0, False: 54.9k] ------------------ 2138| 0|#line 186 "bison_parser.y" 2139| 0| { delete (((*yyvaluep).import_stmt)); } 2140| 0|#line 2141 "bison_parser.cpp" 2141| 0| break; 2142| | 2143| 4| case YYSYMBOL_file_type: /* file_type */ ------------------ | Branch (2143:5): [True: 4, False: 54.9k] ------------------ 2144| 4|#line 164 "bison_parser.y" 2145| 4| { } 2146| 4|#line 2147 "bison_parser.cpp" 2147| 4| break; 2148| | 2149| 1| case YYSYMBOL_file_path: /* file_path */ ------------------ | Branch (2149:5): [True: 1, False: 54.9k] ------------------ 2150| 1|#line 177 "bison_parser.y" 2151| 1| { free( (((*yyvaluep).sval)) ); } 2152| 1|#line 2153 "bison_parser.cpp" 2153| 1| break; 2154| | 2155| 0| case YYSYMBOL_opt_file_type: /* opt_file_type */ ------------------ | Branch (2155:5): [True: 0, False: 54.9k] ------------------ 2156| 0|#line 164 "bison_parser.y" 2157| 0| { } 2158| 0|#line 2159 "bison_parser.cpp" 2159| 0| break; 2160| | 2161| 0| case YYSYMBOL_export_statement: /* export_statement */ ------------------ | Branch (2161:5): [True: 0, False: 54.9k] ------------------ 2162| 0|#line 186 "bison_parser.y" 2163| 0| { delete (((*yyvaluep).export_stmt)); } 2164| 0|#line 2165 "bison_parser.cpp" 2165| 0| break; 2166| | 2167| 0| case YYSYMBOL_show_statement: /* show_statement */ ------------------ | Branch (2167:5): [True: 0, False: 54.9k] ------------------ 2168| 0|#line 186 "bison_parser.y" 2169| 0| { delete (((*yyvaluep).show_stmt)); } 2170| 0|#line 2171 "bison_parser.cpp" 2171| 0| break; 2172| | 2173| 0| case YYSYMBOL_create_statement: /* create_statement */ ------------------ | Branch (2173:5): [True: 0, False: 54.9k] ------------------ 2174| 0|#line 186 "bison_parser.y" 2175| 0| { delete (((*yyvaluep).create_stmt)); } 2176| 0|#line 2177 "bison_parser.cpp" 2177| 0| break; 2178| | 2179| 640| case YYSYMBOL_opt_not_exists: /* opt_not_exists */ ------------------ | Branch (2179:5): [True: 640, False: 54.3k] ------------------ 2180| 640|#line 164 "bison_parser.y" 2181| 640| { } 2182| 640|#line 2183 "bison_parser.cpp" 2183| 640| break; 2184| | 2185| 590| case YYSYMBOL_table_elem_commalist: /* table_elem_commalist */ ------------------ | Branch (2185:5): [True: 590, False: 54.3k] ------------------ 2186| 590|#line 178 "bison_parser.y" 2187| 590| { 2188| 590| if (((*yyvaluep).table_element_vec)) { ------------------ | Branch (2188:11): [True: 590, False: 0] ------------------ 2189| 119k| for (auto ptr : *(((*yyvaluep).table_element_vec))) { ------------------ | Branch (2189:23): [True: 119k, False: 590] ------------------ 2190| 119k| delete ptr; 2191| 119k| } 2192| 590| } 2193| 590| delete (((*yyvaluep).table_element_vec)); 2194| 590| } 2195| 590|#line 2196 "bison_parser.cpp" 2196| 590| break; 2197| | 2198| 0| case YYSYMBOL_table_elem: /* table_elem */ ------------------ | Branch (2198:5): [True: 0, False: 54.9k] ------------------ 2199| 0|#line 186 "bison_parser.y" 2200| 0| { delete (((*yyvaluep).table_element_t)); } 2201| 0|#line 2202 "bison_parser.cpp" 2202| 0| break; 2203| | 2204| 0| case YYSYMBOL_column_def: /* column_def */ ------------------ | Branch (2204:5): [True: 0, False: 54.9k] ------------------ 2205| 0|#line 186 "bison_parser.y" 2206| 0| { delete (((*yyvaluep).column_t)); } 2207| 0|#line 2208 "bison_parser.cpp" 2208| 0| break; 2209| | 2210| 24| case YYSYMBOL_column_type: /* column_type */ ------------------ | Branch (2210:5): [True: 24, False: 54.9k] ------------------ 2211| 24|#line 164 "bison_parser.y" 2212| 24| { } 2213| 24|#line 2214 "bison_parser.cpp" 2214| 24| break; 2215| | 2216| 0| case YYSYMBOL_opt_time_precision: /* opt_time_precision */ ------------------ | Branch (2216:5): [True: 0, False: 54.9k] ------------------ 2217| 0|#line 164 "bison_parser.y" 2218| 0| { } 2219| 0|#line 2220 "bison_parser.cpp" 2220| 0| break; 2221| | 2222| 0| case YYSYMBOL_opt_decimal_specification: /* opt_decimal_specification */ ------------------ | Branch (2222:5): [True: 0, False: 54.9k] ------------------ 2223| 0|#line 186 "bison_parser.y" 2224| 0| { delete (((*yyvaluep).ival_pair)); } 2225| 0|#line 2226 "bison_parser.cpp" 2226| 0| break; 2227| | 2228| 0| case YYSYMBOL_opt_column_constraints: /* opt_column_constraints */ ------------------ | Branch (2228:5): [True: 0, False: 54.9k] ------------------ 2229| 0|#line 164 "bison_parser.y" 2230| 0| { } 2231| 0|#line 2232 "bison_parser.cpp" 2232| 0| break; 2233| | 2234| 13| case YYSYMBOL_column_constraint_set: /* column_constraint_set */ ------------------ | Branch (2234:5): [True: 13, False: 54.9k] ------------------ 2235| 13|#line 164 "bison_parser.y" 2236| 13| { } 2237| 13|#line 2238 "bison_parser.cpp" 2238| 13| break; 2239| | 2240| 0| case YYSYMBOL_column_constraint: /* column_constraint */ ------------------ | Branch (2240:5): [True: 0, False: 54.9k] ------------------ 2241| 0|#line 164 "bison_parser.y" 2242| 0| { } 2243| 0|#line 2244 "bison_parser.cpp" 2244| 0| break; 2245| | 2246| 0| case YYSYMBOL_table_constraint: /* table_constraint */ ------------------ | Branch (2246:5): [True: 0, False: 54.9k] ------------------ 2247| 0|#line 186 "bison_parser.y" 2248| 0| { delete (((*yyvaluep).table_constraint_t)); } 2249| 0|#line 2250 "bison_parser.cpp" 2250| 0| break; 2251| | 2252| 0| case YYSYMBOL_drop_statement: /* drop_statement */ ------------------ | Branch (2252:5): [True: 0, False: 54.9k] ------------------ 2253| 0|#line 186 "bison_parser.y" 2254| 0| { delete (((*yyvaluep).drop_stmt)); } 2255| 0|#line 2256 "bison_parser.cpp" 2256| 0| break; 2257| | 2258| 35| case YYSYMBOL_opt_exists: /* opt_exists */ ------------------ | Branch (2258:5): [True: 35, False: 54.9k] ------------------ 2259| 35|#line 164 "bison_parser.y" 2260| 35| { } 2261| 35|#line 2262 "bison_parser.cpp" 2262| 35| break; 2263| | 2264| 0| case YYSYMBOL_alter_statement: /* alter_statement */ ------------------ | Branch (2264:5): [True: 0, False: 54.9k] ------------------ 2265| 0|#line 186 "bison_parser.y" 2266| 0| { delete (((*yyvaluep).alter_stmt)); } 2267| 0|#line 2268 "bison_parser.cpp" 2268| 0| break; 2269| | 2270| 0| case YYSYMBOL_alter_action: /* alter_action */ ------------------ | Branch (2270:5): [True: 0, False: 54.9k] ------------------ 2271| 0|#line 186 "bison_parser.y" 2272| 0| { delete (((*yyvaluep).alter_action_t)); } 2273| 0|#line 2274 "bison_parser.cpp" 2274| 0| break; 2275| | 2276| 0| case YYSYMBOL_drop_action: /* drop_action */ ------------------ | Branch (2276:5): [True: 0, False: 54.9k] ------------------ 2277| 0|#line 186 "bison_parser.y" 2278| 0| { delete (((*yyvaluep).drop_action_t)); } 2279| 0|#line 2280 "bison_parser.cpp" 2280| 0| break; 2281| | 2282| 0| case YYSYMBOL_delete_statement: /* delete_statement */ ------------------ | Branch (2282:5): [True: 0, False: 54.9k] ------------------ 2283| 0|#line 186 "bison_parser.y" 2284| 0| { delete (((*yyvaluep).delete_stmt)); } 2285| 0|#line 2286 "bison_parser.cpp" 2286| 0| break; 2287| | 2288| 0| case YYSYMBOL_truncate_statement: /* truncate_statement */ ------------------ | Branch (2288:5): [True: 0, False: 54.9k] ------------------ 2289| 0|#line 186 "bison_parser.y" 2290| 0| { delete (((*yyvaluep).delete_stmt)); } 2291| 0|#line 2292 "bison_parser.cpp" 2292| 0| break; 2293| | 2294| 0| case YYSYMBOL_insert_statement: /* insert_statement */ ------------------ | Branch (2294:5): [True: 0, False: 54.9k] ------------------ 2295| 0|#line 186 "bison_parser.y" 2296| 0| { delete (((*yyvaluep).insert_stmt)); } 2297| 0|#line 2298 "bison_parser.cpp" 2298| 0| break; 2299| | 2300| 54| case YYSYMBOL_opt_column_list: /* opt_column_list */ ------------------ | Branch (2300:5): [True: 54, False: 54.9k] ------------------ 2301| 54|#line 169 "bison_parser.y" 2302| 54| { 2303| 54| if (((*yyvaluep).str_vec)) { ------------------ | Branch (2303:11): [True: 28, False: 26] ------------------ 2304| 814| for (auto ptr : *(((*yyvaluep).str_vec))) { ------------------ | Branch (2304:23): [True: 814, False: 28] ------------------ 2305| 814| free(ptr); 2306| 814| } 2307| 28| } 2308| 54| delete (((*yyvaluep).str_vec)); 2309| 54| } 2310| 54|#line 2311 "bison_parser.cpp" 2311| 54| break; 2312| | 2313| 0| case YYSYMBOL_update_statement: /* update_statement */ ------------------ | Branch (2313:5): [True: 0, False: 54.9k] ------------------ 2314| 0|#line 186 "bison_parser.y" 2315| 0| { delete (((*yyvaluep).update_stmt)); } 2316| 0|#line 2317 "bison_parser.cpp" 2317| 0| break; 2318| | 2319| 18| case YYSYMBOL_update_clause_commalist: /* update_clause_commalist */ ------------------ | Branch (2319:5): [True: 18, False: 54.9k] ------------------ 2320| 18|#line 178 "bison_parser.y" 2321| 18| { 2322| 18| if (((*yyvaluep).update_vec)) { ------------------ | Branch (2322:11): [True: 18, False: 0] ------------------ 2323| 110k| for (auto ptr : *(((*yyvaluep).update_vec))) { ------------------ | Branch (2323:23): [True: 110k, False: 18] ------------------ 2324| 110k| delete ptr; 2325| 110k| } 2326| 18| } 2327| 18| delete (((*yyvaluep).update_vec)); 2328| 18| } 2329| 18|#line 2330 "bison_parser.cpp" 2330| 18| break; 2331| | 2332| 0| case YYSYMBOL_update_clause: /* update_clause */ ------------------ | Branch (2332:5): [True: 0, False: 54.9k] ------------------ 2333| 0|#line 186 "bison_parser.y" 2334| 0| { delete (((*yyvaluep).update_t)); } 2335| 0|#line 2336 "bison_parser.cpp" 2336| 0| break; 2337| | 2338| 2| case YYSYMBOL_select_statement: /* select_statement */ ------------------ | Branch (2338:5): [True: 2, False: 54.9k] ------------------ 2339| 2|#line 186 "bison_parser.y" 2340| 2| { delete (((*yyvaluep).select_stmt)); } 2341| 2|#line 2342 "bison_parser.cpp" 2342| 2| break; 2343| | 2344| 72| case YYSYMBOL_select_within_set_operation: /* select_within_set_operation */ ------------------ | Branch (2344:5): [True: 72, False: 54.9k] ------------------ 2345| 72|#line 186 "bison_parser.y" 2346| 72| { delete (((*yyvaluep).select_stmt)); } 2347| 72|#line 2348 "bison_parser.cpp" 2348| 72| break; 2349| | 2350| 0| case YYSYMBOL_select_within_set_operation_no_parentheses: /* select_within_set_operation_no_parentheses */ ------------------ | Branch (2350:5): [True: 0, False: 54.9k] ------------------ 2351| 0|#line 186 "bison_parser.y" 2352| 0| { delete (((*yyvaluep).select_stmt)); } 2353| 0|#line 2354 "bison_parser.cpp" 2354| 0| break; 2355| | 2356| 35| case YYSYMBOL_select_with_paren: /* select_with_paren */ ------------------ | Branch (2356:5): [True: 35, False: 54.9k] ------------------ 2357| 35|#line 186 "bison_parser.y" 2358| 35| { delete (((*yyvaluep).select_stmt)); } 2359| 35|#line 2360 "bison_parser.cpp" 2360| 35| break; 2361| | 2362| 127| case YYSYMBOL_select_no_paren: /* select_no_paren */ ------------------ | Branch (2362:5): [True: 127, False: 54.8k] ------------------ 2363| 127|#line 186 "bison_parser.y" 2364| 127| { delete (((*yyvaluep).select_stmt)); } 2365| 127|#line 2366 "bison_parser.cpp" 2366| 127| break; 2367| | 2368| 1.25k| case YYSYMBOL_set_operator: /* set_operator */ ------------------ | Branch (2368:5): [True: 1.25k, False: 53.7k] ------------------ 2369| 1.25k|#line 186 "bison_parser.y" 2370| 1.25k| { delete (((*yyvaluep).set_operator_t)); } 2371| 1.25k|#line 2372 "bison_parser.cpp" 2372| 1.25k| break; 2373| | 2374| 0| case YYSYMBOL_set_type: /* set_type */ ------------------ | Branch (2374:5): [True: 0, False: 54.9k] ------------------ 2375| 0|#line 186 "bison_parser.y" 2376| 0| { delete (((*yyvaluep).set_operator_t)); } 2377| 0|#line 2378 "bison_parser.cpp" 2378| 0| break; 2379| | 2380| 0| case YYSYMBOL_opt_all: /* opt_all */ ------------------ | Branch (2380:5): [True: 0, False: 54.9k] ------------------ 2381| 0|#line 164 "bison_parser.y" 2382| 0| { } 2383| 0|#line 2384 "bison_parser.cpp" 2384| 0| break; 2385| | 2386| 1.85k| case YYSYMBOL_select_clause: /* select_clause */ ------------------ | Branch (2386:5): [True: 1.85k, False: 53.1k] ------------------ 2387| 1.85k|#line 186 "bison_parser.y" 2388| 1.85k| { delete (((*yyvaluep).select_stmt)); } 2389| 1.85k|#line 2390 "bison_parser.cpp" 2390| 1.85k| break; 2391| | 2392| 3.19k| case YYSYMBOL_opt_distinct: /* opt_distinct */ ------------------ | Branch (2392:5): [True: 3.19k, False: 51.7k] ------------------ 2393| 3.19k|#line 164 "bison_parser.y" 2394| 3.19k| { } 2395| 3.19k|#line 2396 "bison_parser.cpp" 2396| 3.19k| break; 2397| | 2398| 750| case YYSYMBOL_select_list: /* select_list */ ------------------ | Branch (2398:5): [True: 750, False: 54.2k] ------------------ 2399| 750|#line 178 "bison_parser.y" 2400| 750| { 2401| 750| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2401:11): [True: 750, False: 0] ------------------ 2402| 1.14k| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2402:23): [True: 1.14k, False: 750] ------------------ 2403| 1.14k| delete ptr; 2404| 1.14k| } 2405| 750| } 2406| 750| delete (((*yyvaluep).expr_vec)); 2407| 750| } 2408| 750|#line 2409 "bison_parser.cpp" 2409| 750| break; 2410| | 2411| 271| case YYSYMBOL_opt_from_clause: /* opt_from_clause */ ------------------ | Branch (2411:5): [True: 271, False: 54.7k] ------------------ 2412| 271|#line 186 "bison_parser.y" 2413| 271| { delete (((*yyvaluep).table)); } 2414| 271|#line 2415 "bison_parser.cpp" 2415| 271| break; 2416| | 2417| 0| case YYSYMBOL_from_clause: /* from_clause */ ------------------ | Branch (2417:5): [True: 0, False: 54.9k] ------------------ 2418| 0|#line 186 "bison_parser.y" 2419| 0| { delete (((*yyvaluep).table)); } 2420| 0|#line 2421 "bison_parser.cpp" 2421| 0| break; 2422| | 2423| 148| case YYSYMBOL_opt_where: /* opt_where */ ------------------ | Branch (2423:5): [True: 148, False: 54.8k] ------------------ 2424| 148|#line 186 "bison_parser.y" 2425| 148| { delete (((*yyvaluep).expr)); } 2426| 148|#line 2427 "bison_parser.cpp" 2427| 148| break; 2428| | 2429| 1| case YYSYMBOL_opt_group: /* opt_group */ ------------------ | Branch (2429:5): [True: 1, False: 54.9k] ------------------ 2430| 1|#line 186 "bison_parser.y" 2431| 1| { delete (((*yyvaluep).group_t)); } 2432| 1|#line 2433 "bison_parser.cpp" 2433| 1| break; 2434| | 2435| 0| case YYSYMBOL_opt_having: /* opt_having */ ------------------ | Branch (2435:5): [True: 0, False: 54.9k] ------------------ 2436| 0|#line 186 "bison_parser.y" 2437| 0| { delete (((*yyvaluep).expr)); } 2438| 0|#line 2439 "bison_parser.cpp" 2439| 0| break; 2440| | 2441| 458| case YYSYMBOL_opt_order: /* opt_order */ ------------------ | Branch (2441:5): [True: 458, False: 54.5k] ------------------ 2442| 458|#line 178 "bison_parser.y" 2443| 458| { 2444| 458| if (((*yyvaluep).order_vec)) { ------------------ | Branch (2444:11): [True: 80, False: 378] ------------------ 2445| 1.73k| for (auto ptr : *(((*yyvaluep).order_vec))) { ------------------ | Branch (2445:23): [True: 1.73k, False: 80] ------------------ 2446| 1.73k| delete ptr; 2447| 1.73k| } 2448| 80| } 2449| 458| delete (((*yyvaluep).order_vec)); 2450| 458| } 2451| 458|#line 2452 "bison_parser.cpp" 2452| 458| break; 2453| | 2454| 98| case YYSYMBOL_order_list: /* order_list */ ------------------ | Branch (2454:5): [True: 98, False: 54.8k] ------------------ 2455| 98|#line 178 "bison_parser.y" 2456| 98| { 2457| 98| if (((*yyvaluep).order_vec)) { ------------------ | Branch (2457:11): [True: 98, False: 0] ------------------ 2458| 500k| for (auto ptr : *(((*yyvaluep).order_vec))) { ------------------ | Branch (2458:23): [True: 500k, False: 98] ------------------ 2459| 500k| delete ptr; 2460| 500k| } 2461| 98| } 2462| 98| delete (((*yyvaluep).order_vec)); 2463| 98| } 2464| 98|#line 2465 "bison_parser.cpp" 2465| 98| break; 2466| | 2467| 0| case YYSYMBOL_order_desc: /* order_desc */ ------------------ | Branch (2467:5): [True: 0, False: 54.9k] ------------------ 2468| 0|#line 186 "bison_parser.y" 2469| 0| { delete (((*yyvaluep).order)); } 2470| 0|#line 2471 "bison_parser.cpp" 2471| 0| break; 2472| | 2473| 0| case YYSYMBOL_opt_order_type: /* opt_order_type */ ------------------ | Branch (2473:5): [True: 0, False: 54.9k] ------------------ 2474| 0|#line 164 "bison_parser.y" 2475| 0| { } 2476| 0|#line 2477 "bison_parser.cpp" 2477| 0| break; 2478| | 2479| 2.22k| case YYSYMBOL_opt_top: /* opt_top */ ------------------ | Branch (2479:5): [True: 2.22k, False: 52.7k] ------------------ 2480| 2.22k|#line 186 "bison_parser.y" 2481| 2.22k| { delete (((*yyvaluep).limit)); } 2482| 2.22k|#line 2483 "bison_parser.cpp" 2483| 2.22k| break; 2484| | 2485| 57| case YYSYMBOL_opt_limit: /* opt_limit */ ------------------ | Branch (2485:5): [True: 57, False: 54.9k] ------------------ 2486| 57|#line 186 "bison_parser.y" 2487| 57| { delete (((*yyvaluep).limit)); } 2488| 57|#line 2489 "bison_parser.cpp" 2489| 57| break; 2490| | 2491| 446| case YYSYMBOL_expr_list: /* expr_list */ ------------------ | Branch (2491:5): [True: 446, False: 54.5k] ------------------ 2492| 446|#line 178 "bison_parser.y" 2493| 446| { 2494| 446| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2494:11): [True: 446, False: 0] ------------------ 2495| 468k| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2495:23): [True: 468k, False: 446] ------------------ 2496| 468k| delete ptr; 2497| 468k| } 2498| 446| } 2499| 446| delete (((*yyvaluep).expr_vec)); 2500| 446| } 2501| 446|#line 2502 "bison_parser.cpp" 2502| 446| break; 2503| | 2504| 28| case YYSYMBOL_opt_literal_list: /* opt_literal_list */ ------------------ | Branch (2504:5): [True: 28, False: 54.9k] ------------------ 2505| 28|#line 178 "bison_parser.y" 2506| 28| { 2507| 28| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2507:11): [True: 23, False: 5] ------------------ 2508| 488| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2508:23): [True: 488, False: 23] ------------------ 2509| 488| delete ptr; 2510| 488| } 2511| 23| } 2512| 28| delete (((*yyvaluep).expr_vec)); 2513| 28| } 2514| 28|#line 2515 "bison_parser.cpp" 2515| 28| break; 2516| | 2517| 24| case YYSYMBOL_literal_list: /* literal_list */ ------------------ | Branch (2517:5): [True: 24, False: 54.9k] ------------------ 2518| 24|#line 178 "bison_parser.y" 2519| 24| { 2520| 24| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2520:11): [True: 24, False: 0] ------------------ 2521| 406| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2521:23): [True: 406, False: 24] ------------------ 2522| 406| delete ptr; 2523| 406| } 2524| 24| } 2525| 24| delete (((*yyvaluep).expr_vec)); 2526| 24| } 2527| 24|#line 2528 "bison_parser.cpp" 2528| 24| break; 2529| | 2530| 0| case YYSYMBOL_expr_alias: /* expr_alias */ ------------------ | Branch (2530:5): [True: 0, False: 54.9k] ------------------ 2531| 0|#line 186 "bison_parser.y" 2532| 0| { delete (((*yyvaluep).expr)); } 2533| 0|#line 2534 "bison_parser.cpp" 2534| 0| break; 2535| | 2536| 304| case YYSYMBOL_expr: /* expr */ ------------------ | Branch (2536:5): [True: 304, False: 54.6k] ------------------ 2537| 304|#line 186 "bison_parser.y" 2538| 304| { delete (((*yyvaluep).expr)); } 2539| 304|#line 2540 "bison_parser.cpp" 2540| 304| break; 2541| | 2542| 1.69k| case YYSYMBOL_operand: /* operand */ ------------------ | Branch (2542:5): [True: 1.69k, False: 53.2k] ------------------ 2543| 1.69k|#line 186 "bison_parser.y" 2544| 1.69k| { delete (((*yyvaluep).expr)); } 2545| 1.69k|#line 2546 "bison_parser.cpp" 2546| 1.69k| break; 2547| | 2548| 0| case YYSYMBOL_scalar_expr: /* scalar_expr */ ------------------ | Branch (2548:5): [True: 0, False: 54.9k] ------------------ 2549| 0|#line 186 "bison_parser.y" 2550| 0| { delete (((*yyvaluep).expr)); } 2551| 0|#line 2552 "bison_parser.cpp" 2552| 0| break; 2553| | 2554| 0| case YYSYMBOL_unary_expr: /* unary_expr */ ------------------ | Branch (2554:5): [True: 0, False: 54.9k] ------------------ 2555| 0|#line 186 "bison_parser.y" 2556| 0| { delete (((*yyvaluep).expr)); } 2557| 0|#line 2558 "bison_parser.cpp" 2558| 0| break; 2559| | 2560| 0| case YYSYMBOL_binary_expr: /* binary_expr */ ------------------ | Branch (2560:5): [True: 0, False: 54.9k] ------------------ 2561| 0|#line 186 "bison_parser.y" 2562| 0| { delete (((*yyvaluep).expr)); } 2563| 0|#line 2564 "bison_parser.cpp" 2564| 0| break; 2565| | 2566| 0| case YYSYMBOL_logic_expr: /* logic_expr */ ------------------ | Branch (2566:5): [True: 0, False: 54.9k] ------------------ 2567| 0|#line 186 "bison_parser.y" 2568| 0| { delete (((*yyvaluep).expr)); } 2569| 0|#line 2570 "bison_parser.cpp" 2570| 0| break; 2571| | 2572| 0| case YYSYMBOL_in_expr: /* in_expr */ ------------------ | Branch (2572:5): [True: 0, False: 54.9k] ------------------ 2573| 0|#line 186 "bison_parser.y" 2574| 0| { delete (((*yyvaluep).expr)); } 2575| 0|#line 2576 "bison_parser.cpp" 2576| 0| break; 2577| | 2578| 0| case YYSYMBOL_case_expr: /* case_expr */ ------------------ | Branch (2578:5): [True: 0, False: 54.9k] ------------------ 2579| 0|#line 186 "bison_parser.y" 2580| 0| { delete (((*yyvaluep).expr)); } 2581| 0|#line 2582 "bison_parser.cpp" 2582| 0| break; 2583| | 2584| 268| case YYSYMBOL_case_list: /* case_list */ ------------------ | Branch (2584:5): [True: 268, False: 54.7k] ------------------ 2585| 268|#line 186 "bison_parser.y" 2586| 268| { delete (((*yyvaluep).expr)); } 2587| 268|#line 2588 "bison_parser.cpp" 2588| 268| break; 2589| | 2590| 0| case YYSYMBOL_exists_expr: /* exists_expr */ ------------------ | Branch (2590:5): [True: 0, False: 54.9k] ------------------ 2591| 0|#line 186 "bison_parser.y" 2592| 0| { delete (((*yyvaluep).expr)); } 2593| 0|#line 2594 "bison_parser.cpp" 2594| 0| break; 2595| | 2596| 0| case YYSYMBOL_comp_expr: /* comp_expr */ ------------------ | Branch (2596:5): [True: 0, False: 54.9k] ------------------ 2597| 0|#line 186 "bison_parser.y" 2598| 0| { delete (((*yyvaluep).expr)); } 2599| 0|#line 2600 "bison_parser.cpp" 2600| 0| break; 2601| | 2602| 0| case YYSYMBOL_function_expr: /* function_expr */ ------------------ | Branch (2602:5): [True: 0, False: 54.9k] ------------------ 2603| 0|#line 186 "bison_parser.y" 2604| 0| { delete (((*yyvaluep).expr)); } 2605| 0|#line 2606 "bison_parser.cpp" 2606| 0| break; 2607| | 2608| 0| case YYSYMBOL_extract_expr: /* extract_expr */ ------------------ | Branch (2608:5): [True: 0, False: 54.9k] ------------------ 2609| 0|#line 186 "bison_parser.y" 2610| 0| { delete (((*yyvaluep).expr)); } 2611| 0|#line 2612 "bison_parser.cpp" 2612| 0| break; 2613| | 2614| 0| case YYSYMBOL_cast_expr: /* cast_expr */ ------------------ | Branch (2614:5): [True: 0, False: 54.9k] ------------------ 2615| 0|#line 186 "bison_parser.y" 2616| 0| { delete (((*yyvaluep).expr)); } 2617| 0|#line 2618 "bison_parser.cpp" 2618| 0| break; 2619| | 2620| 205| case YYSYMBOL_datetime_field: /* datetime_field */ ------------------ | Branch (2620:5): [True: 205, False: 54.7k] ------------------ 2621| 205|#line 164 "bison_parser.y" 2622| 205| { } 2623| 205|#line 2624 "bison_parser.cpp" 2624| 205| break; 2625| | 2626| 0| case YYSYMBOL_datetime_field_plural: /* datetime_field_plural */ ------------------ | Branch (2626:5): [True: 0, False: 54.9k] ------------------ 2627| 0|#line 164 "bison_parser.y" 2628| 0| { } 2629| 0|#line 2630 "bison_parser.cpp" 2630| 0| break; 2631| | 2632| 0| case YYSYMBOL_duration_field: /* duration_field */ ------------------ | Branch (2632:5): [True: 0, False: 54.9k] ------------------ 2633| 0|#line 164 "bison_parser.y" 2634| 0| { } 2635| 0|#line 2636 "bison_parser.cpp" 2636| 0| break; 2637| | 2638| 0| case YYSYMBOL_array_expr: /* array_expr */ ------------------ | Branch (2638:5): [True: 0, False: 54.9k] ------------------ 2639| 0|#line 186 "bison_parser.y" 2640| 0| { delete (((*yyvaluep).expr)); } 2641| 0|#line 2642 "bison_parser.cpp" 2642| 0| break; 2643| | 2644| 0| case YYSYMBOL_array_index: /* array_index */ ------------------ | Branch (2644:5): [True: 0, False: 54.9k] ------------------ 2645| 0|#line 186 "bison_parser.y" 2646| 0| { delete (((*yyvaluep).expr)); } 2647| 0|#line 2648 "bison_parser.cpp" 2648| 0| break; 2649| | 2650| 0| case YYSYMBOL_between_expr: /* between_expr */ ------------------ | Branch (2650:5): [True: 0, False: 54.9k] ------------------ 2651| 0|#line 186 "bison_parser.y" 2652| 0| { delete (((*yyvaluep).expr)); } 2653| 0|#line 2654 "bison_parser.cpp" 2654| 0| break; 2655| | 2656| 1| case YYSYMBOL_column_name: /* column_name */ ------------------ | Branch (2656:5): [True: 1, False: 54.9k] ------------------ 2657| 1|#line 186 "bison_parser.y" 2658| 1| { delete (((*yyvaluep).expr)); } 2659| 1|#line 2660 "bison_parser.cpp" 2660| 1| break; 2661| | 2662| 0| case YYSYMBOL_literal: /* literal */ ------------------ | Branch (2662:5): [True: 0, False: 54.9k] ------------------ 2663| 0|#line 186 "bison_parser.y" 2664| 0| { delete (((*yyvaluep).expr)); } 2665| 0|#line 2666 "bison_parser.cpp" 2666| 0| break; 2667| | 2668| 0| case YYSYMBOL_string_literal: /* string_literal */ ------------------ | Branch (2668:5): [True: 0, False: 54.9k] ------------------ 2669| 0|#line 186 "bison_parser.y" 2670| 0| { delete (((*yyvaluep).expr)); } 2671| 0|#line 2672 "bison_parser.cpp" 2672| 0| break; 2673| | 2674| 0| case YYSYMBOL_bool_literal: /* bool_literal */ ------------------ | Branch (2674:5): [True: 0, False: 54.9k] ------------------ 2675| 0|#line 186 "bison_parser.y" 2676| 0| { delete (((*yyvaluep).expr)); } 2677| 0|#line 2678 "bison_parser.cpp" 2678| 0| break; 2679| | 2680| 0| case YYSYMBOL_num_literal: /* num_literal */ ------------------ | Branch (2680:5): [True: 0, False: 54.9k] ------------------ 2681| 0|#line 186 "bison_parser.y" 2682| 0| { delete (((*yyvaluep).expr)); } 2683| 0|#line 2684 "bison_parser.cpp" 2684| 0| break; 2685| | 2686| 3| case YYSYMBOL_int_literal: /* int_literal */ ------------------ | Branch (2686:5): [True: 3, False: 54.9k] ------------------ 2687| 3|#line 186 "bison_parser.y" 2688| 3| { delete (((*yyvaluep).expr)); } 2689| 3|#line 2690 "bison_parser.cpp" 2690| 3| break; 2691| | 2692| 0| case YYSYMBOL_null_literal: /* null_literal */ ------------------ | Branch (2692:5): [True: 0, False: 54.9k] ------------------ 2693| 0|#line 186 "bison_parser.y" 2694| 0| { delete (((*yyvaluep).expr)); } 2695| 0|#line 2696 "bison_parser.cpp" 2696| 0| break; 2697| | 2698| 0| case YYSYMBOL_date_literal: /* date_literal */ ------------------ | Branch (2698:5): [True: 0, False: 54.9k] ------------------ 2699| 0|#line 186 "bison_parser.y" 2700| 0| { delete (((*yyvaluep).expr)); } 2701| 0|#line 2702 "bison_parser.cpp" 2702| 0| break; 2703| | 2704| 0| case YYSYMBOL_interval_literal: /* interval_literal */ ------------------ | Branch (2704:5): [True: 0, False: 54.9k] ------------------ 2705| 0|#line 186 "bison_parser.y" 2706| 0| { delete (((*yyvaluep).expr)); } 2707| 0|#line 2708 "bison_parser.cpp" 2708| 0| break; 2709| | 2710| 0| case YYSYMBOL_param_expr: /* param_expr */ ------------------ | Branch (2710:5): [True: 0, False: 54.9k] ------------------ 2711| 0|#line 186 "bison_parser.y" 2712| 0| { delete (((*yyvaluep).expr)); } 2713| 0|#line 2714 "bison_parser.cpp" 2714| 0| break; 2715| | 2716| 0| case YYSYMBOL_table_ref: /* table_ref */ ------------------ | Branch (2716:5): [True: 0, False: 54.9k] ------------------ 2717| 0|#line 186 "bison_parser.y" 2718| 0| { delete (((*yyvaluep).table)); } 2719| 0|#line 2720 "bison_parser.cpp" 2720| 0| break; 2721| | 2722| 2.54k| case YYSYMBOL_table_ref_atomic: /* table_ref_atomic */ ------------------ | Branch (2722:5): [True: 2.54k, False: 52.4k] ------------------ 2723| 2.54k|#line 186 "bison_parser.y" 2724| 2.54k| { delete (((*yyvaluep).table)); } 2725| 2.54k|#line 2726 "bison_parser.cpp" 2726| 2.54k| break; 2727| | 2728| 0| case YYSYMBOL_nonjoin_table_ref_atomic: /* nonjoin_table_ref_atomic */ ------------------ | Branch (2728:5): [True: 0, False: 54.9k] ------------------ 2729| 0|#line 186 "bison_parser.y" 2730| 0| { delete (((*yyvaluep).table)); } 2731| 0|#line 2732 "bison_parser.cpp" 2732| 0| break; 2733| | 2734| 89| case YYSYMBOL_table_ref_commalist: /* table_ref_commalist */ ------------------ | Branch (2734:5): [True: 89, False: 54.8k] ------------------ 2735| 89|#line 178 "bison_parser.y" 2736| 89| { 2737| 89| if (((*yyvaluep).table_vec)) { ------------------ | Branch (2737:11): [True: 89, False: 0] ------------------ 2738| 344k| for (auto ptr : *(((*yyvaluep).table_vec))) { ------------------ | Branch (2738:23): [True: 344k, False: 89] ------------------ 2739| 344k| delete ptr; 2740| 344k| } 2741| 89| } 2742| 89| delete (((*yyvaluep).table_vec)); 2743| 89| } 2744| 89|#line 2745 "bison_parser.cpp" 2745| 89| break; 2746| | 2747| 0| case YYSYMBOL_table_ref_name: /* table_ref_name */ ------------------ | Branch (2747:5): [True: 0, False: 54.9k] ------------------ 2748| 0|#line 186 "bison_parser.y" 2749| 0| { delete (((*yyvaluep).table)); } 2750| 0|#line 2751 "bison_parser.cpp" 2751| 0| break; 2752| | 2753| 36| case YYSYMBOL_table_ref_name_no_alias: /* table_ref_name_no_alias */ ------------------ | Branch (2753:5): [True: 36, False: 54.9k] ------------------ 2754| 36|#line 186 "bison_parser.y" 2755| 36| { delete (((*yyvaluep).table)); } 2756| 36|#line 2757 "bison_parser.cpp" 2757| 36| break; 2758| | 2759| 718| case YYSYMBOL_table_name: /* table_name */ ------------------ | Branch (2759:5): [True: 718, False: 54.2k] ------------------ 2760| 718|#line 165 "bison_parser.y" 2761| 718| { 2762| 718| free( (((*yyvaluep).table_name).name) ); 2763| 718| free( (((*yyvaluep).table_name).schema) ); 2764| 718| } 2765| 718|#line 2766 "bison_parser.cpp" 2766| 718| break; 2767| | 2768| 16| case YYSYMBOL_opt_index_name: /* opt_index_name */ ------------------ | Branch (2768:5): [True: 16, False: 54.9k] ------------------ 2769| 16|#line 177 "bison_parser.y" 2770| 16| { free( (((*yyvaluep).sval)) ); } 2771| 16|#line 2772 "bison_parser.cpp" 2772| 16| break; 2773| | 2774| 0| case YYSYMBOL_table_alias: /* table_alias */ ------------------ | Branch (2774:5): [True: 0, False: 54.9k] ------------------ 2775| 0|#line 186 "bison_parser.y" 2776| 0| { delete (((*yyvaluep).alias_t)); } 2777| 0|#line 2778 "bison_parser.cpp" 2778| 0| break; 2779| | 2780| 2| case YYSYMBOL_opt_table_alias: /* opt_table_alias */ ------------------ | Branch (2780:5): [True: 2, False: 54.9k] ------------------ 2781| 2|#line 186 "bison_parser.y" 2782| 2| { delete (((*yyvaluep).alias_t)); } 2783| 2|#line 2784 "bison_parser.cpp" 2784| 2| break; 2785| | 2786| 0| case YYSYMBOL_alias: /* alias */ ------------------ | Branch (2786:5): [True: 0, False: 54.9k] ------------------ 2787| 0|#line 186 "bison_parser.y" 2788| 0| { delete (((*yyvaluep).alias_t)); } 2789| 0|#line 2790 "bison_parser.cpp" 2790| 0| break; 2791| | 2792| 3| case YYSYMBOL_opt_alias: /* opt_alias */ ------------------ | Branch (2792:5): [True: 3, False: 54.9k] ------------------ 2793| 3|#line 186 "bison_parser.y" 2794| 3| { delete (((*yyvaluep).alias_t)); } 2795| 3|#line 2796 "bison_parser.cpp" 2796| 3| break; 2797| | 2798| 0| case YYSYMBOL_opt_locking_clause: /* opt_locking_clause */ ------------------ | Branch (2798:5): [True: 0, False: 54.9k] ------------------ 2799| 0|#line 186 "bison_parser.y" 2800| 0| { delete (((*yyvaluep).locking_clause_vec)); } 2801| 0|#line 2802 "bison_parser.cpp" 2802| 0| break; 2803| | 2804| 25| case YYSYMBOL_opt_locking_clause_list: /* opt_locking_clause_list */ ------------------ | Branch (2804:5): [True: 25, False: 54.9k] ------------------ 2805| 25|#line 186 "bison_parser.y" 2806| 25| { delete (((*yyvaluep).locking_clause_vec)); } 2807| 25|#line 2808 "bison_parser.cpp" 2808| 25| break; 2809| | 2810| 0| case YYSYMBOL_locking_clause: /* locking_clause */ ------------------ | Branch (2810:5): [True: 0, False: 54.9k] ------------------ 2811| 0|#line 186 "bison_parser.y" 2812| 0| { delete (((*yyvaluep).locking_t)); } 2813| 0|#line 2814 "bison_parser.cpp" 2814| 0| break; 2815| | 2816| 8| case YYSYMBOL_row_lock_mode: /* row_lock_mode */ ------------------ | Branch (2816:5): [True: 8, False: 54.9k] ------------------ 2817| 8|#line 164 "bison_parser.y" 2818| 8| { } 2819| 8|#line 2820 "bison_parser.cpp" 2820| 8| break; 2821| | 2822| 1| case YYSYMBOL_opt_row_lock_policy: /* opt_row_lock_policy */ ------------------ | Branch (2822:5): [True: 1, False: 54.9k] ------------------ 2823| 1|#line 164 "bison_parser.y" 2824| 1| { } 2825| 1|#line 2826 "bison_parser.cpp" 2826| 1| break; 2827| | 2828| 2.63k| case YYSYMBOL_opt_with_clause: /* opt_with_clause */ ------------------ | Branch (2828:5): [True: 2.63k, False: 52.3k] ------------------ 2829| 2.63k|#line 186 "bison_parser.y" 2830| 2.63k| { delete (((*yyvaluep).with_description_vec)); } 2831| 2.63k|#line 2832 "bison_parser.cpp" 2832| 2.63k| break; 2833| | 2834| 0| case YYSYMBOL_with_clause: /* with_clause */ ------------------ | Branch (2834:5): [True: 0, False: 54.9k] ------------------ 2835| 0|#line 186 "bison_parser.y" 2836| 0| { delete (((*yyvaluep).with_description_vec)); } 2837| 0|#line 2838 "bison_parser.cpp" 2838| 0| break; 2839| | 2840| 42| case YYSYMBOL_with_description_list: /* with_description_list */ ------------------ | Branch (2840:5): [True: 42, False: 54.9k] ------------------ 2841| 42|#line 186 "bison_parser.y" 2842| 42| { delete (((*yyvaluep).with_description_vec)); } 2843| 42|#line 2844 "bison_parser.cpp" 2844| 42| break; 2845| | 2846| 0| case YYSYMBOL_with_description: /* with_description */ ------------------ | Branch (2846:5): [True: 0, False: 54.9k] ------------------ 2847| 0|#line 186 "bison_parser.y" 2848| 0| { delete (((*yyvaluep).with_description_t)); } 2849| 0|#line 2850 "bison_parser.cpp" 2850| 0| break; 2851| | 2852| 0| case YYSYMBOL_join_clause: /* join_clause */ ------------------ | Branch (2852:5): [True: 0, False: 54.9k] ------------------ 2853| 0|#line 186 "bison_parser.y" 2854| 0| { delete (((*yyvaluep).table)); } 2855| 0|#line 2856 "bison_parser.cpp" 2856| 0| break; 2857| | 2858| 2.52k| case YYSYMBOL_opt_join_type: /* opt_join_type */ ------------------ | Branch (2858:5): [True: 2.52k, False: 52.4k] ------------------ 2859| 2.52k|#line 164 "bison_parser.y" 2860| 2.52k| { } 2861| 2.52k|#line 2862 "bison_parser.cpp" 2862| 2.52k| break; 2863| | 2864| 0| case YYSYMBOL_join_condition: /* join_condition */ ------------------ | Branch (2864:5): [True: 0, False: 54.9k] ------------------ 2865| 0|#line 186 "bison_parser.y" 2866| 0| { delete (((*yyvaluep).expr)); } 2867| 0|#line 2868 "bison_parser.cpp" 2868| 0| break; 2869| | 2870| 34| case YYSYMBOL_ident_commalist: /* ident_commalist */ ------------------ | Branch (2870:5): [True: 34, False: 54.9k] ------------------ 2871| 34|#line 169 "bison_parser.y" 2872| 34| { 2873| 34| if (((*yyvaluep).str_vec)) { ------------------ | Branch (2873:11): [True: 34, False: 0] ------------------ 2874| 433k| for (auto ptr : *(((*yyvaluep).str_vec))) { ------------------ | Branch (2874:23): [True: 433k, False: 34] ------------------ 2875| 433k| free(ptr); 2876| 433k| } 2877| 34| } 2878| 34| delete (((*yyvaluep).str_vec)); 2879| 34| } 2880| 34|#line 2881 "bison_parser.cpp" 2881| 34| break; 2882| | 2883| 29.1k| default: ------------------ | Branch (2883:7): [True: 29.1k, False: 25.8k] ------------------ 2884| 29.1k| break; 2885| 54.9k| } 2886| 54.9k| YY_IGNORE_MAYBE_UNINITIALIZED_END 2887| 54.9k|} _Z8hsql_lexP10HSQL_STYPEP15HSQL_CUST_LTYPEPv: 3174| 10.8M|{ 3175| 10.8M| yy_state_type yy_current_state; 3176| 10.8M| char *yy_cp, *yy_bp; 3177| 10.8M| int yy_act; 3178| 10.8M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3179| | 3180| 10.8M| yylval = yylval_param; ------------------ | | 2987| 10.8M| # define yylval yyg->yylval_r ------------------ 3181| | 3182| 10.8M| yylloc = yylloc_param; ------------------ | | 2989| 10.8M| # define yylloc yyg->yylloc_r ------------------ 3183| | 3184| 10.8M| if ( !yyg->yy_init ) ------------------ | Branch (3184:7): [True: 5.59k, False: 10.8M] ------------------ 3185| 5.59k| { 3186| 5.59k| yyg->yy_init = 1; 3187| | 3188| |#ifdef YY_USER_INIT 3189| | YY_USER_INIT; 3190| |#endif 3191| | 3192| 5.59k| if ( ! yyg->yy_start ) ------------------ | Branch (3192:8): [True: 5.59k, False: 0] ------------------ 3193| 5.59k| yyg->yy_start = 1; /* first start state */ 3194| | 3195| 5.59k| if ( ! yyin ) ------------------ | | 356| 5.59k|#define yyin yyg->yyin_r ------------------ | Branch (3195:8): [True: 5.59k, False: 0] ------------------ 3196| 5.59k| yyin = stdin; ------------------ | | 356| 5.59k|#define yyin yyg->yyin_r ------------------ 3197| | 3198| 5.59k| if ( ! yyout ) ------------------ | | 357| 5.59k|#define yyout yyg->yyout_r ------------------ | Branch (3198:8): [True: 5.59k, False: 0] ------------------ 3199| 5.59k| yyout = stdout; ------------------ | | 357| 5.59k|#define yyout yyg->yyout_r ------------------ 3200| | 3201| 5.59k| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 502| 5.59k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:29): [True: 5.59k, False: 0] | | ------------------ | | 503| 5.59k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 5.59k| : NULL) ------------------ | Branch (3201:8): [True: 0, False: 5.59k] ------------------ 3202| 0| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 0|#define yyensure_buffer_stack hsql_ensure_buffer_stack ------------------ 3203| 0| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 3204| 0| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 20| 0|#define yy_create_buffer hsql__create_buffer ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 356| 0|#define yyin yyg->yyin_r ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 391| 0|#define YY_BUF_SIZE 16384 ------------------ 3205| 0| } 3206| | 3207| 5.59k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 5.59k|#define yy_load_buffer_state hsql__load_buffer_state ------------------ 3208| 5.59k| } 3209| | 3210| 10.8M| { 3211| 10.8M|#line 57 "flex_lexer.l" 3212| | 3213| | 3214| 10.8M|#line 3214 "flex_lexer.cpp" 3215| | 3216| 11.4M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (3216:23): [Folded - Ignored] ------------------ 3217| 11.4M| { 3218| 11.4M| yy_cp = yyg->yy_c_buf_p; 3219| | 3220| | /* Support of yytext. */ 3221| 11.4M| *yy_cp = yyg->yy_hold_char; 3222| | 3223| | /* yy_bp points to the position in yy_ch_buf of the start of 3224| | * the current run. 3225| | */ 3226| 11.4M| yy_bp = yy_cp; 3227| | 3228| 11.4M| yy_current_state = yyg->yy_start; 3229| 11.4M|yy_match: 3230| 11.4M| do 3231| 41.7M| { 3232| 41.7M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 346| 41.7M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 3233| 41.7M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (3233:9): [True: 30.2M, False: 11.5M] ------------------ 3234| 30.2M| { 3235| 30.2M| yyg->yy_last_accepting_state = yy_current_state; 3236| 30.2M| yyg->yy_last_accepting_cpos = yy_cp; 3237| 30.2M| } 3238| 72.0M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (3238:12): [True: 30.3M, False: 41.7M] ------------------ 3239| 30.3M| { 3240| 30.3M| yy_current_state = (int) yy_def[yy_current_state]; 3241| 30.3M| if ( yy_current_state >= 1240 ) ------------------ | Branch (3241:10): [True: 18.8M, False: 11.4M] ------------------ 3242| 18.8M| yy_c = yy_meta[yy_c]; 3243| 30.3M| } 3244| 41.7M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 3245| 41.7M| ++yy_cp; 3246| 41.7M| } 3247| 41.7M| while ( yy_current_state != 1239 ); ------------------ | Branch (3247:11): [True: 30.2M, False: 11.4M] ------------------ 3248| 11.4M| yy_cp = yyg->yy_last_accepting_cpos; 3249| 11.4M| yy_current_state = yyg->yy_last_accepting_state; 3250| | 3251| 11.4M|yy_find_action: 3252| 11.4M| yy_act = yy_accept[yy_current_state]; 3253| | 3254| 11.4M| YY_DO_BEFORE_ACTION; ------------------ | | 571| 11.4M| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 560| 11.4M|#define yytext_ptr yytext_r | | ------------------ | | 572| 11.4M| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 359| 11.4M|#define yyleng yyg->yyleng_r | | ------------------ | | 573| 11.4M| yyg->yy_hold_char = *yy_cp; \ | | 574| 11.4M| *yy_cp = '\0'; \ | | 575| 11.4M| yyg->yy_c_buf_p = yy_cp; ------------------ 3255| | 3256| 11.4M|do_action: /* This label is used only to access EOF actions. */ 3257| | 3258| 11.4M| switch ( yy_act ) 3259| 11.4M| { /* beginning of action switch */ 3260| 16| case 0: /* must back up */ ------------------ | Branch (3260:4): [True: 16, False: 11.4M] ------------------ 3261| | /* undo the effects of YY_DO_BEFORE_ACTION */ 3262| 16| *yy_cp = yyg->yy_hold_char; 3263| 16| yy_cp = yyg->yy_last_accepting_cpos; 3264| 16| yy_current_state = yyg->yy_last_accepting_state; 3265| 16| goto yy_find_action; 3266| | 3267| 1.35k|case 1: ------------------ | Branch (3267:1): [True: 1.35k, False: 11.4M] ------------------ 3268| 1.35k|YY_RULE_SETUP ------------------ | | 3169| 1.35k| YY_USER_ACTION | | ------------------ | | | | 66| 1.35k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.35k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.07k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.07k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.71k, False: 1.35k] | | | | ------------------ | | | | 69| 2.71k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 2.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.71k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 2.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.71k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.71k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.71k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.71k| } else { \ | | | | 75| 2.71k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 2.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.71k| } \ | | | | 77| 2.71k| } | | ------------------ ------------------ 3269| 1.35k|#line 59 "flex_lexer.l" 3270| 1.35k|BEGIN(COMMENT); ------------------ | | 369| 1.35k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(COMMENT); ------------------ | | 2931| 1.35k|#define COMMENT 2 ------------------ 3271| 1.35k| YY_BREAK ------------------ | | 3165| 1.35k|#define YY_BREAK /*LINTED*/break; ------------------ 3272| 721|case 2: ------------------ | Branch (3272:1): [True: 721, False: 11.4M] ------------------ 3273| 721|YY_RULE_SETUP ------------------ | | 3169| 721| YY_USER_ACTION | | ------------------ | | | | 66| 721| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 721| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 721| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 721| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 721| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 721| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 38.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 38.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 38.0k, False: 721] | | | | ------------------ | | | | 69| 38.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 38.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 38.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 38.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 38.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 38.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 38.0k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 38.0k| } else { \ | | | | 75| 38.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 38.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 38.0k| } \ | | | | 77| 38.0k| } | | ------------------ ------------------ 3274| 721|#line 60 "flex_lexer.l" 3275| 721|/* skipping comment content until a end of line is read */; 3276| 721| YY_BREAK ------------------ | | 3165| 721|#define YY_BREAK /*LINTED*/break; ------------------ 3277| 1.02k|case 3: ------------------ | Branch (3277:1): [True: 1.02k, False: 11.4M] ------------------ 3278| |/* rule 3 can match eol */ 3279| 1.02k|YY_RULE_SETUP ------------------ | | 3169| 1.02k| YY_USER_ACTION | | ------------------ | | | | 66| 1.02k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.02k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.05k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.05k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 1.02k, False: 1.02k] | | | | ------------------ | | | | 69| 1.02k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 1.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 1.02k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 1.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.02k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 1.02k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 1.02k, False: 0] | | | | ------------------ | | | | 72| 1.02k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 1.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 1.02k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 1.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 1.02k| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 1.02k| } | | ------------------ ------------------ 3280| 1.02k|#line 61 "flex_lexer.l" 3281| 1.02k|BEGIN(INITIAL); ------------------ | | 369| 1.02k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 2929| 1.02k|#define INITIAL 0 ------------------ 3282| 1.02k| YY_BREAK ------------------ | | 3165| 1.02k|#define YY_BREAK /*LINTED*/break; ------------------ 3283| 583k|case 4: ------------------ | Branch (3283:1): [True: 583k, False: 10.9M] ------------------ 3284| |/* rule 4 can match eol */ 3285| 583k|YY_RULE_SETUP ------------------ | | 3169| 583k| YY_USER_ACTION | | ------------------ | | | | 66| 583k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 583k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 583k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 583k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 583k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 583k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.17M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.17M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 590k, False: 583k] | | | | ------------------ | | | | 69| 590k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 590k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 590k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 590k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 590k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 590k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 195k, False: 395k] | | | | ------------------ | | | | 72| 195k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 195k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 195k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 195k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 395k| } else { \ | | | | 75| 395k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 395k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 395k| } \ | | | | 77| 590k| } | | ------------------ ------------------ 3286| 583k|#line 63 "flex_lexer.l" 3287| 583k|/* skip whitespace */; 3288| 583k| YY_BREAK ------------------ | | 3165| 583k|#define YY_BREAK /*LINTED*/break; ------------------ 3289| 2|case 5: ------------------ | Branch (3289:1): [True: 2, False: 11.4M] ------------------ 3290| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6, False: 2] | | | | ------------------ | | | | 69| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6| } else { \ | | | | 75| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6| } \ | | | | 77| 6| } | | ------------------ ------------------ 3291| 2|#line 65 "flex_lexer.l" 3292| 2|TOKEN(ADD) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3293| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3294| 2|case 6: ------------------ | Branch (3294:1): [True: 2, False: 11.4M] ------------------ 3295| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 12| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 10, False: 2] | | | | ------------------ | | | | 69| 10| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 10| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 10] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 10| } else { \ | | | | 75| 10| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 10| } \ | | | | 77| 10| } | | ------------------ ------------------ 3296| 2|#line 66 "flex_lexer.l" 3297| 2|TOKEN(AFTER) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3298| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3299| 1.19k|case 7: ------------------ | Branch (3299:1): [True: 1.19k, False: 11.4M] ------------------ 3300| 1.19k|YY_RULE_SETUP ------------------ | | 3169| 1.19k| YY_USER_ACTION | | ------------------ | | | | 66| 1.19k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.19k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.77k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.77k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.57k, False: 1.19k] | | | | ------------------ | | | | 69| 3.57k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 3.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.57k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 3.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.57k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.57k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.57k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.57k| } else { \ | | | | 75| 3.57k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 3.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.57k| } \ | | | | 77| 3.57k| } | | ------------------ ------------------ 3301| 1.19k|#line 67 "flex_lexer.l" 3302| 1.19k|TOKEN(ALL) ------------------ | | 2909| 1.19k|#define TOKEN(name) { return SQL_##name; } ------------------ 3303| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3304| 3|case 8: ------------------ | Branch (3304:1): [True: 3, False: 11.4M] ------------------ 3305| 3|YY_RULE_SETUP ------------------ | | 3169| 3| YY_USER_ACTION | | ------------------ | | | | 66| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 18| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 18|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 15, False: 3] | | | | ------------------ | | | | 69| 15| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 15| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 15| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 15| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 15| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 15|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 15] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 15| } else { \ | | | | 75| 15| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 15| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 15| } \ | | | | 77| 15| } | | ------------------ ------------------ 3306| 3|#line 68 "flex_lexer.l" 3307| 3|TOKEN(ALTER) ------------------ | | 2909| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3308| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3309| 2|case 9: ------------------ | Branch (3309:1): [True: 2, False: 11.4M] ------------------ 3310| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 16| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 16|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 14, False: 2] | | | | ------------------ | | | | 69| 14| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 14| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 14] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 14| } else { \ | | | | 75| 14| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 14| } \ | | | | 77| 14| } | | ------------------ ------------------ 3311| 2|#line 69 "flex_lexer.l" 3312| 2|TOKEN(ANALYZE) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3313| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3314| 1.53k|case 10: ------------------ | Branch (3314:1): [True: 1.53k, False: 11.4M] ------------------ 3315| 1.53k|YY_RULE_SETUP ------------------ | | 3169| 1.53k| YY_USER_ACTION | | ------------------ | | | | 66| 1.53k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.53k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6.12k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.59k, False: 1.53k] | | | | ------------------ | | | | 69| 4.59k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.59k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.59k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.59k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.59k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.59k| } else { \ | | | | 75| 4.59k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.59k| } \ | | | | 77| 4.59k| } | | ------------------ ------------------ 3316| 1.53k|#line 70 "flex_lexer.l" 3317| 1.53k|TOKEN(AND) ------------------ | | 2909| 1.53k|#define TOKEN(name) { return SQL_##name; } ------------------ 3318| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3319| 884|case 11: ------------------ | Branch (3319:1): [True: 884, False: 11.4M] ------------------ 3320| 884|YY_RULE_SETUP ------------------ | | 3169| 884| YY_USER_ACTION | | ------------------ | | | | 66| 884| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 884| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 884| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 884| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 884| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 884| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.30k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.30k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.42k, False: 884] | | | | ------------------ | | | | 69| 4.42k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.42k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.42k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.42k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.42k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.42k| } else { \ | | | | 75| 4.42k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.42k| } \ | | | | 77| 4.42k| } | | ------------------ ------------------ 3321| 884|#line 71 "flex_lexer.l" 3322| 884|TOKEN(ARRAY) ------------------ | | 2909| 884|#define TOKEN(name) { return SQL_##name; } ------------------ 3323| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3324| 37.7k|case 12: ------------------ | Branch (3324:1): [True: 37.7k, False: 11.4M] ------------------ 3325| 37.7k|YY_RULE_SETUP ------------------ | | 3169| 37.7k| YY_USER_ACTION | | ------------------ | | | | 66| 37.7k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 37.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 37.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 37.7k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 37.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 37.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 113k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 113k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 75.4k, False: 37.7k] | | | | ------------------ | | | | 69| 75.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 75.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 75.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 75.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 75.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 75.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 75.4k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 75.4k| } else { \ | | | | 75| 75.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 75.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 75.4k| } \ | | | | 77| 75.4k| } | | ------------------ ------------------ 3326| 37.7k|#line 72 "flex_lexer.l" 3327| 37.7k|TOKEN(AS) ------------------ | | 2909| 37.7k|#define TOKEN(name) { return SQL_##name; } ------------------ 3328| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3329| 610|case 13: ------------------ | Branch (3329:1): [True: 610, False: 11.4M] ------------------ 3330| 610|YY_RULE_SETUP ------------------ | | 3169| 610| YY_USER_ACTION | | ------------------ | | | | 66| 610| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 610| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 610| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 610| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 610| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 610| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.44k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.44k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 1.83k, False: 610] | | | | ------------------ | | | | 69| 1.83k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 1.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 1.83k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 1.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.83k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 1.83k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 1.83k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 1.83k| } else { \ | | | | 75| 1.83k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 1.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 1.83k| } \ | | | | 77| 1.83k| } | | ------------------ ------------------ 3331| 610|#line 73 "flex_lexer.l" 3332| 610|TOKEN(ASC) ------------------ | | 2909| 610|#define TOKEN(name) { return SQL_##name; } ------------------ 3333| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3334| 2|case 14: ------------------ | Branch (3334:1): [True: 2, False: 11.4M] ------------------ 3335| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 2] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 3336| 2|#line 74 "flex_lexer.l" 3337| 2|TOKEN(BEFORE) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3338| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3339| 266k|case 15: ------------------ | Branch (3339:1): [True: 266k, False: 11.2M] ------------------ 3340| 266k|YY_RULE_SETUP ------------------ | | 3169| 266k| YY_USER_ACTION | | ------------------ | | | | 66| 266k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 266k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 266k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 266k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 266k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 266k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.59M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.59M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 1.33M, False: 266k] | | | | ------------------ | | | | 69| 1.33M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 1.33M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 1.33M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 1.33M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.33M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 1.33M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 1.33M] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 1.33M| } else { \ | | | | 75| 1.33M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 1.33M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 1.33M| } \ | | | | 77| 1.33M| } | | ------------------ ------------------ 3341| 266k|#line 75 "flex_lexer.l" 3342| 266k|TOKEN(BEGIN) ------------------ | | 2909| 266k|#define TOKEN(name) { return SQL_##name; } ------------------ 3343| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3344| 1.01k|case 16: ------------------ | Branch (3344:1): [True: 1.01k, False: 11.4M] ------------------ 3345| 1.01k|YY_RULE_SETUP ------------------ | | 3169| 1.01k| YY_USER_ACTION | | ------------------ | | | | 66| 1.01k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.01k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8.12k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7.11k, False: 1.01k] | | | | ------------------ | | | | 69| 7.11k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 7.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7.11k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 7.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.11k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7.11k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7.11k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7.11k| } else { \ | | | | 75| 7.11k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 7.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7.11k| } \ | | | | 77| 7.11k| } | | ------------------ ------------------ 3346| 1.01k|#line 76 "flex_lexer.l" 3347| 1.01k|TOKEN(BETWEEN) ------------------ | | 2909| 1.01k|#define TOKEN(name) { return SQL_##name; } ------------------ 3348| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3349| 827|case 17: ------------------ | Branch (3349:1): [True: 827, False: 11.4M] ------------------ 3350| 827|YY_RULE_SETUP ------------------ | | 3169| 827| YY_USER_ACTION | | ------------------ | | | | 66| 827| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 827| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 827| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 827| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 827| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 827| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.78k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.78k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.96k, False: 827] | | | | ------------------ | | | | 69| 4.96k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.96k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.96k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.96k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.96k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.96k| } else { \ | | | | 75| 4.96k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.96k| } \ | | | | 77| 4.96k| } | | ------------------ ------------------ 3351| 827|#line 77 "flex_lexer.l" 3352| 827|TOKEN(BIGINT) ------------------ | | 2909| 827|#define TOKEN(name) { return SQL_##name; } ------------------ 3353| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3354| 629|case 18: ------------------ | Branch (3354:1): [True: 629, False: 11.4M] ------------------ 3355| 629|YY_RULE_SETUP ------------------ | | 3169| 629| YY_USER_ACTION | | ------------------ | | | | 66| 629| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 629| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 629| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 629| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 629| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 629| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.03k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.03k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.40k, False: 629] | | | | ------------------ | | | | 69| 4.40k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.40k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.40k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.40k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.40k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.40k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.40k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.40k| } else { \ | | | | 75| 4.40k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.40k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.40k| } \ | | | | 77| 4.40k| } | | ------------------ ------------------ 3356| 629|#line 78 "flex_lexer.l" 3357| 629|TOKEN(BOOLEAN) ------------------ | | 2909| 629|#define TOKEN(name) { return SQL_##name; } ------------------ 3358| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3359| 3.41k|case 19: ------------------ | Branch (3359:1): [True: 3.41k, False: 11.4M] ------------------ 3360| 3.41k|YY_RULE_SETUP ------------------ | | 3169| 3.41k| YY_USER_ACTION | | ------------------ | | | | 66| 3.41k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3.41k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 10.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 10.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6.83k, False: 3.41k] | | | | ------------------ | | | | 69| 6.83k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 6.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6.83k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 6.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.83k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6.83k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6.83k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6.83k| } else { \ | | | | 75| 6.83k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 6.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6.83k| } \ | | | | 77| 6.83k| } | | ------------------ ------------------ 3361| 3.41k|#line 79 "flex_lexer.l" 3362| 3.41k|TOKEN(BY) ------------------ | | 2909| 3.41k|#define TOKEN(name) { return SQL_##name; } ------------------ 3363| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3364| 1|case 20: ------------------ | Branch (3364:1): [True: 1, False: 11.4M] ------------------ 3365| 1|YY_RULE_SETUP ------------------ | | 3169| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4, False: 1] | | | | ------------------ | | | | 69| 4| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4| } else { \ | | | | 75| 4| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4| } \ | | | | 77| 4| } | | ------------------ ------------------ 3366| 1|#line 80 "flex_lexer.l" 3367| 1|TOKEN(CALL) ------------------ | | 2909| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3368| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3369| 2|case 21: ------------------ | Branch (3369:1): [True: 2, False: 11.4M] ------------------ 3370| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 16| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 16|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 14, False: 2] | | | | ------------------ | | | | 69| 14| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 14| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 14] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 14| } else { \ | | | | 75| 14| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 14| } \ | | | | 77| 14| } | | ------------------ ------------------ 3371| 2|#line 81 "flex_lexer.l" 3372| 2|TOKEN(CASCADE) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3373| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3374| 2.66k|case 22: ------------------ | Branch (3374:1): [True: 2.66k, False: 11.4M] ------------------ 3375| 2.66k|YY_RULE_SETUP ------------------ | | 3169| 2.66k| YY_USER_ACTION | | ------------------ | | | | 66| 2.66k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.66k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 13.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 13.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 10.6k, False: 2.66k] | | | | ------------------ | | | | 69| 10.6k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 10.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 10.6k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 10.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.6k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 10.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 10.6k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 10.6k| } else { \ | | | | 75| 10.6k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 10.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 10.6k| } \ | | | | 77| 10.6k| } | | ------------------ ------------------ 3376| 2.66k|#line 82 "flex_lexer.l" 3377| 2.66k|TOKEN(CASE) ------------------ | | 2909| 2.66k|#define TOKEN(name) { return SQL_##name; } ------------------ 3378| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3379| 787|case 23: ------------------ | Branch (3379:1): [True: 787, False: 11.4M] ------------------ 3380| 787|YY_RULE_SETUP ------------------ | | 3169| 787| YY_USER_ACTION | | ------------------ | | | | 66| 787| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 787| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 787| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 787| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 787| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 787| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.93k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.93k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.14k, False: 787] | | | | ------------------ | | | | 69| 3.14k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 3.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.14k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 3.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.14k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.14k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.14k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.14k| } else { \ | | | | 75| 3.14k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 3.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.14k| } \ | | | | 77| 3.14k| } | | ------------------ ------------------ 3381| 787|#line 83 "flex_lexer.l" 3382| 787|TOKEN(CAST) ------------------ | | 2909| 787|#define TOKEN(name) { return SQL_##name; } ------------------ 3383| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3384| 578|case 24: ------------------ | Branch (3384:1): [True: 578, False: 11.4M] ------------------ 3385| 578|YY_RULE_SETUP ------------------ | | 3169| 578| YY_USER_ACTION | | ------------------ | | | | 66| 578| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 578| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 578| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 578| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 578| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 578| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.89k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.89k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.31k, False: 578] | | | | ------------------ | | | | 69| 2.31k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 2.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.31k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 2.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.31k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.31k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.31k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.31k| } else { \ | | | | 75| 2.31k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 2.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.31k| } \ | | | | 77| 2.31k| } | | ------------------ ------------------ 3386| 578|#line 84 "flex_lexer.l" 3387| 578|TOKEN(CHAR) ------------------ | | 2909| 578|#define TOKEN(name) { return SQL_##name; } ------------------ 3388| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3389| 2|case 25: ------------------ | Branch (3389:1): [True: 2, False: 11.4M] ------------------ 3390| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 2] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 3391| 2|#line 85 "flex_lexer.l" 3392| 2|TOKEN(COLUMN) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3393| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3394| 817|case 26: ------------------ | Branch (3394:1): [True: 817, False: 11.4M] ------------------ 3395| 817|YY_RULE_SETUP ------------------ | | 3169| 817| YY_USER_ACTION | | ------------------ | | | | 66| 817| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 817| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 817| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 817| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 817| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 817| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6.53k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6.53k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.71k, False: 817] | | | | ------------------ | | | | 69| 5.71k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 5.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.71k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 5.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.71k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.71k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.71k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.71k| } else { \ | | | | 75| 5.71k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 5.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.71k| } \ | | | | 77| 5.71k| } | | ------------------ ------------------ 3396| 817|#line 86 "flex_lexer.l" 3397| 817|TOKEN(COLUMNS) ------------------ | | 2909| 817|#define TOKEN(name) { return SQL_##name; } ------------------ 3398| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3399| 762|case 27: ------------------ | Branch (3399:1): [True: 762, False: 11.4M] ------------------ 3400| 762|YY_RULE_SETUP ------------------ | | 3169| 762| YY_USER_ACTION | | ------------------ | | | | 66| 762| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 762| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 762| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 762| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 762| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 762| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.33k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.33k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.57k, False: 762] | | | | ------------------ | | | | 69| 4.57k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.57k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.57k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.57k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.57k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.57k| } else { \ | | | | 75| 4.57k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.57k| } \ | | | | 77| 4.57k| } | | ------------------ ------------------ 3401| 762|#line 87 "flex_lexer.l" 3402| 762|TOKEN(COMMIT) ------------------ | | 2909| 762|#define TOKEN(name) { return SQL_##name; } ------------------ 3403| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3404| 3|case 28: ------------------ | Branch (3404:1): [True: 3, False: 11.4M] ------------------ 3405| 3|YY_RULE_SETUP ------------------ | | 3169| 3| YY_USER_ACTION | | ------------------ | | | | 66| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 24| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 24|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 21, False: 3] | | | | ------------------ | | | | 69| 21| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 21| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 21| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 21| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 21| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 21|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 21] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 21| } else { \ | | | | 75| 21| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 21| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 21| } \ | | | | 77| 21| } | | ------------------ ------------------ 3406| 3|#line 88 "flex_lexer.l" 3407| 3|TOKEN(CONTROL) ------------------ | | 2909| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3408| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3409| 1.47k|case 29: ------------------ | Branch (3409:1): [True: 1.47k, False: 11.4M] ------------------ 3410| 1.47k|YY_RULE_SETUP ------------------ | | 3169| 1.47k| YY_USER_ACTION | | ------------------ | | | | 66| 1.47k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.47k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 7.35k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 7.35k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.88k, False: 1.47k] | | | | ------------------ | | | | 69| 5.88k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 5.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.88k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 5.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.88k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.88k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.88k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.88k| } else { \ | | | | 75| 5.88k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 5.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.88k| } \ | | | | 77| 5.88k| } | | ------------------ ------------------ 3411| 1.47k|#line 89 "flex_lexer.l" 3412| 1.47k|TOKEN(COPY) ------------------ | | 2909| 1.47k|#define TOKEN(name) { return SQL_##name; } ------------------ 3413| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3414| 3.94k|case 30: ------------------ | Branch (3414:1): [True: 3.94k, False: 11.4M] ------------------ 3415| 3.94k|YY_RULE_SETUP ------------------ | | 3169| 3.94k| YY_USER_ACTION | | ------------------ | | | | 66| 3.94k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3.94k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 27.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 27.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 23.6k, False: 3.94k] | | | | ------------------ | | | | 69| 23.6k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 23.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 23.6k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 23.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 23.6k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 23.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 23.6k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 23.6k| } else { \ | | | | 75| 23.6k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 23.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 23.6k| } \ | | | | 77| 23.6k| } | | ------------------ ------------------ 3416| 3.94k|#line 90 "flex_lexer.l" 3417| 3.94k|TOKEN(CREATE) ------------------ | | 2909| 3.94k|#define TOKEN(name) { return SQL_##name; } ------------------ 3418| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3419| 350|case 31: ------------------ | Branch (3419:1): [True: 350, False: 11.4M] ------------------ 3420| 350|YY_RULE_SETUP ------------------ | | 3169| 350| YY_USER_ACTION | | ------------------ | | | | 66| 350| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 350| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 350| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 350| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 350| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 350| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.10k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.10k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 1.75k, False: 350] | | | | ------------------ | | | | 69| 1.75k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 1.75k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.75k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 1.75k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 1.75k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 1.75k| } else { \ | | | | 75| 1.75k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 1.75k| } \ | | | | 77| 1.75k| } | | ------------------ ------------------ 3421| 350|#line 91 "flex_lexer.l" 3422| 350|TOKEN(CROSS) ------------------ | | 2909| 350|#define TOKEN(name) { return SQL_##name; } ------------------ 3423| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3424| 1.18k|case 32: ------------------ | Branch (3424:1): [True: 1.18k, False: 11.4M] ------------------ 3425| 1.18k|YY_RULE_SETUP ------------------ | | 3169| 1.18k| YY_USER_ACTION | | ------------------ | | | | 66| 1.18k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.18k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.94k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.94k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.75k, False: 1.18k] | | | | ------------------ | | | | 69| 4.75k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.75k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.75k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.75k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.75k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.75k| } else { \ | | | | 75| 4.75k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.75k| } \ | | | | 77| 4.75k| } | | ------------------ ------------------ 3426| 1.18k|#line 92 "flex_lexer.l" 3427| 1.18k|TOKEN(DATE) ------------------ | | 2909| 1.18k|#define TOKEN(name) { return SQL_##name; } ------------------ 3428| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3429| 566|case 33: ------------------ | Branch (3429:1): [True: 566, False: 11.4M] ------------------ 3430| 566|YY_RULE_SETUP ------------------ | | 3169| 566| YY_USER_ACTION | | ------------------ | | | | 66| 566| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 566| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 566| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 566| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 566| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 566| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.09k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.09k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.52k, False: 566] | | | | ------------------ | | | | 69| 4.52k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.52k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.52k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.52k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.52k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.52k| } else { \ | | | | 75| 4.52k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.52k| } \ | | | | 77| 4.52k| } | | ------------------ ------------------ 3431| 566|#line 93 "flex_lexer.l" 3432| 566|TOKEN(DATETIME) ------------------ | | 2909| 566|#define TOKEN(name) { return SQL_##name; } ------------------ 3433| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3434| 1.47k|case 34: ------------------ | Branch (3434:1): [True: 1.47k, False: 11.4M] ------------------ 3435| 1.47k|YY_RULE_SETUP ------------------ | | 3169| 1.47k| YY_USER_ACTION | | ------------------ | | | | 66| 1.47k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.47k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.90k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.90k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.43k, False: 1.47k] | | | | ------------------ | | | | 69| 4.43k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.43k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.43k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.43k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.43k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.43k| } else { \ | | | | 75| 4.43k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.43k| } \ | | | | 77| 4.43k| } | | ------------------ ------------------ 3436| 1.47k|#line 94 "flex_lexer.l" 3437| 1.47k|TOKEN(DAY) ------------------ | | 2909| 1.47k|#define TOKEN(name) { return SQL_##name; } ------------------ 3438| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3439| 529|case 35: ------------------ | Branch (3439:1): [True: 529, False: 11.4M] ------------------ 3440| 529|YY_RULE_SETUP ------------------ | | 3169| 529| YY_USER_ACTION | | ------------------ | | | | 66| 529| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 529| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 529| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 529| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 529| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 529| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.64k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.64k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.11k, False: 529] | | | | ------------------ | | | | 69| 2.11k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 2.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.11k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 2.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.11k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.11k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.11k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.11k| } else { \ | | | | 75| 2.11k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 2.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.11k| } \ | | | | 77| 2.11k| } | | ------------------ ------------------ 3441| 529|#line 95 "flex_lexer.l" 3442| 529|TOKEN(DAYS) ------------------ | | 2909| 529|#define TOKEN(name) { return SQL_##name; } ------------------ 3443| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3444| 892|case 36: ------------------ | Branch (3444:1): [True: 892, False: 11.4M] ------------------ 3445| 892|YY_RULE_SETUP ------------------ | | 3169| 892| YY_USER_ACTION | | ------------------ | | | | 66| 892| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 892| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 892| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 892| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 892| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 892| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 9.81k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 9.81k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8.92k, False: 892] | | | | ------------------ | | | | 69| 8.92k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 8.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8.92k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 8.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.92k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8.92k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8.92k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8.92k| } else { \ | | | | 75| 8.92k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 8.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8.92k| } \ | | | | 77| 8.92k| } | | ------------------ ------------------ 3446| 892|#line 96 "flex_lexer.l" 3447| 892|TOKEN(DEALLOCATE) ------------------ | | 2909| 892|#define TOKEN(name) { return SQL_##name; } ------------------ 3448| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3449| 1.04k|case 37: ------------------ | Branch (3449:1): [True: 1.04k, False: 11.4M] ------------------ 3450| 1.04k|YY_RULE_SETUP ------------------ | | 3169| 1.04k| YY_USER_ACTION | | ------------------ | | | | 66| 1.04k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.04k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8.33k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8.33k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7.29k, False: 1.04k] | | | | ------------------ | | | | 69| 7.29k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 7.29k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7.29k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 7.29k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.29k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7.29k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7.29k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7.29k| } else { \ | | | | 75| 7.29k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 7.29k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7.29k| } \ | | | | 77| 7.29k| } | | ------------------ ------------------ 3451| 1.04k|#line 97 "flex_lexer.l" 3452| 1.04k|TOKEN(DECIMAL) ------------------ | | 2909| 1.04k|#define TOKEN(name) { return SQL_##name; } ------------------ 3453| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3454| 2|case 38: ------------------ | Branch (3454:1): [True: 2, False: 11.4M] ------------------ 3455| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 16| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 16|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 14, False: 2] | | | | ------------------ | | | | 69| 14| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 14| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 14] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 14| } else { \ | | | | 75| 14| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 14| } \ | | | | 77| 14| } | | ------------------ ------------------ 3456| 2|#line 98 "flex_lexer.l" 3457| 2|TOKEN(DEFAULT) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3458| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3459| 1.31k|case 39: ------------------ | Branch (3459:1): [True: 1.31k, False: 11.4M] ------------------ 3460| 1.31k|YY_RULE_SETUP ------------------ | | 3169| 1.31k| YY_USER_ACTION | | ------------------ | | | | 66| 1.31k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.31k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 9.19k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 9.19k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7.88k, False: 1.31k] | | | | ------------------ | | | | 69| 7.88k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 7.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7.88k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 7.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.88k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7.88k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7.88k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7.88k| } else { \ | | | | 75| 7.88k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 7.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7.88k| } \ | | | | 77| 7.88k| } | | ------------------ ------------------ 3461| 1.31k|#line 99 "flex_lexer.l" 3462| 1.31k|TOKEN(DELETE) ------------------ | | 2909| 1.31k|#define TOKEN(name) { return SQL_##name; } ------------------ 3463| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3464| 1|case 40: ------------------ | Branch (3464:1): [True: 1, False: 11.4M] ------------------ 3465| 1|YY_RULE_SETUP ------------------ | | 3169| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5, False: 1] | | | | ------------------ | | | | 69| 5| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5| } else { \ | | | | 75| 5| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5| } \ | | | | 77| 5| } | | ------------------ ------------------ 3466| 1|#line 100 "flex_lexer.l" 3467| 1|TOKEN(DELTA) ------------------ | | 2909| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3468| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3469| 530|case 41: ------------------ | Branch (3469:1): [True: 530, False: 11.4M] ------------------ 3470| 530|YY_RULE_SETUP ------------------ | | 3169| 530| YY_USER_ACTION | | ------------------ | | | | 66| 530| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 530| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.65k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.65k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.12k, False: 530] | | | | ------------------ | | | | 69| 2.12k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.12k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.12k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.12k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.12k| } else { \ | | | | 75| 2.12k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.12k| } \ | | | | 77| 2.12k| } | | ------------------ ------------------ 3471| 530|#line 101 "flex_lexer.l" 3472| 530|TOKEN(DESC) ------------------ | | 2909| 530|#define TOKEN(name) { return SQL_##name; } ------------------ 3473| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3474| 633|case 42: ------------------ | Branch (3474:1): [True: 633, False: 11.4M] ------------------ 3475| 633|YY_RULE_SETUP ------------------ | | 3169| 633| YY_USER_ACTION | | ------------------ | | | | 66| 633| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 633| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 633| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 633| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 633| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 633| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.69k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.69k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.06k, False: 633] | | | | ------------------ | | | | 69| 5.06k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 5.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.06k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 5.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.06k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.06k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.06k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.06k| } else { \ | | | | 75| 5.06k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 5.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.06k| } \ | | | | 77| 5.06k| } | | ------------------ ------------------ 3476| 633|#line 102 "flex_lexer.l" 3477| 633|TOKEN(DESCRIBE) ------------------ | | 2909| 633|#define TOKEN(name) { return SQL_##name; } ------------------ 3478| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3479| 1|case 43: ------------------ | Branch (3479:1): [True: 1, False: 11.4M] ------------------ 3480| 1|YY_RULE_SETUP ------------------ | | 3169| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 7| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6, False: 1] | | | | ------------------ | | | | 69| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6| } else { \ | | | | 75| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6| } \ | | | | 77| 6| } | | ------------------ ------------------ 3481| 1|#line 103 "flex_lexer.l" 3482| 1|TOKEN(DIRECT) ------------------ | | 2909| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3483| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3484| 599|case 44: ------------------ | Branch (3484:1): [True: 599, False: 11.4M] ------------------ 3485| 599|YY_RULE_SETUP ------------------ | | 3169| 599| YY_USER_ACTION | | ------------------ | | | | 66| 599| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 599| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 599| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 599| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 599| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 599| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.39k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.39k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.79k, False: 599] | | | | ------------------ | | | | 69| 4.79k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.79k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.79k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.79k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.79k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.79k| } else { \ | | | | 75| 4.79k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.79k| } \ | | | | 77| 4.79k| } | | ------------------ ------------------ 3486| 599|#line 104 "flex_lexer.l" 3487| 599|TOKEN(DISTINCT) ------------------ | | 2909| 599|#define TOKEN(name) { return SQL_##name; } ------------------ 3488| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3489| 779|case 45: ------------------ | Branch (3489:1): [True: 779, False: 11.4M] ------------------ 3490| 779|YY_RULE_SETUP ------------------ | | 3169| 779| YY_USER_ACTION | | ------------------ | | | | 66| 779| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 779| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 779| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 779| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 779| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 779| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.45k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.45k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.67k, False: 779] | | | | ------------------ | | | | 69| 4.67k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.67k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.67k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.67k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.67k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.67k| } else { \ | | | | 75| 4.67k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.67k| } \ | | | | 77| 4.67k| } | | ------------------ ------------------ 3491| 779|#line 105 "flex_lexer.l" 3492| 779|TOKEN(DOUBLE) ------------------ | | 2909| 779|#define TOKEN(name) { return SQL_##name; } ------------------ 3493| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3494| 3.06k|case 46: ------------------ | Branch (3494:1): [True: 3.06k, False: 11.4M] ------------------ 3495| 3.06k|YY_RULE_SETUP ------------------ | | 3169| 3.06k| YY_USER_ACTION | | ------------------ | | | | 66| 3.06k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3.06k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 15.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 15.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12.2k, False: 3.06k] | | | | ------------------ | | | | 69| 12.2k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 12.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12.2k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 12.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12.2k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12.2k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12.2k| } else { \ | | | | 75| 12.2k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 12.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12.2k| } \ | | | | 77| 12.2k| } | | ------------------ ------------------ 3496| 3.06k|#line 106 "flex_lexer.l" 3497| 3.06k|TOKEN(DROP) ------------------ | | 2909| 3.06k|#define TOKEN(name) { return SQL_##name; } ------------------ 3498| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3499| 909|case 47: ------------------ | Branch (3499:1): [True: 909, False: 11.4M] ------------------ 3500| 909|YY_RULE_SETUP ------------------ | | 3169| 909| YY_USER_ACTION | | ------------------ | | | | 66| 909| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 909| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 909| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 909| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 909| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 909| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.54k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.54k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.63k, False: 909] | | | | ------------------ | | | | 69| 3.63k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.63k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.63k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.63k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.63k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.63k| } else { \ | | | | 75| 3.63k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.63k| } \ | | | | 77| 3.63k| } | | ------------------ ------------------ 3501| 909|#line 107 "flex_lexer.l" 3502| 909|TOKEN(ELSE) ------------------ | | 2909| 909|#define TOKEN(name) { return SQL_##name; } ------------------ 3503| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3504| 1.86k|case 48: ------------------ | Branch (3504:1): [True: 1.86k, False: 11.4M] ------------------ 3505| 1.86k|YY_RULE_SETUP ------------------ | | 3169| 1.86k| YY_USER_ACTION | | ------------------ | | | | 66| 1.86k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.86k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.86k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.86k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.86k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.86k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 7.46k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 7.46k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.59k, False: 1.86k] | | | | ------------------ | | | | 69| 5.59k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 5.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.59k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 5.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.59k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.59k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.59k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.59k| } else { \ | | | | 75| 5.59k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 5.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.59k| } \ | | | | 77| 5.59k| } | | ------------------ ------------------ 3506| 1.86k|#line 108 "flex_lexer.l" 3507| 1.86k|TOKEN(END) ------------------ | | 2909| 1.86k|#define TOKEN(name) { return SQL_##name; } ------------------ 3508| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3509| 1|case 49: ------------------ | Branch (3509:1): [True: 1, False: 11.4M] ------------------ 3510| 1|YY_RULE_SETUP ------------------ | | 3169| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 7| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6, False: 1] | | | | ------------------ | | | | 69| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6| } else { \ | | | | 75| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6| } \ | | | | 77| 6| } | | ------------------ ------------------ 3511| 1|#line 109 "flex_lexer.l" 3512| 1|TOKEN(ESCAPE) ------------------ | | 2909| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3513| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3514| 955|case 50: ------------------ | Branch (3514:1): [True: 955, False: 11.4M] ------------------ 3515| 955|YY_RULE_SETUP ------------------ | | 3169| 955| YY_USER_ACTION | | ------------------ | | | | 66| 955| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 955| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 955| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 955| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 955| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 955| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6.68k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6.68k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.73k, False: 955] | | | | ------------------ | | | | 69| 5.73k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 5.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.73k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 5.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.73k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.73k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.73k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.73k| } else { \ | | | | 75| 5.73k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 5.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.73k| } \ | | | | 77| 5.73k| } | | ------------------ ------------------ 3516| 955|#line 110 "flex_lexer.l" 3517| 955|TOKEN(EXCEPT) ------------------ | | 2909| 955|#define TOKEN(name) { return SQL_##name; } ------------------ 3518| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3519| 1.63k|case 51: ------------------ | Branch (3519:1): [True: 1.63k, False: 11.4M] ------------------ 3520| 1.63k|YY_RULE_SETUP ------------------ | | 3169| 1.63k| YY_USER_ACTION | | ------------------ | | | | 66| 1.63k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.63k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 13.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 13.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 11.4k, False: 1.63k] | | | | ------------------ | | | | 69| 11.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 11.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 11.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 11.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 11.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 11.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 11.4k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 11.4k| } else { \ | | | | 75| 11.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 11.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 11.4k| } \ | | | | 77| 11.4k| } | | ------------------ ------------------ 3521| 1.63k|#line 111 "flex_lexer.l" 3522| 1.63k|TOKEN(EXECUTE) ------------------ | | 2909| 1.63k|#define TOKEN(name) { return SQL_##name; } ------------------ 3523| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3524| 1.66k|case 52: ------------------ | Branch (3524:1): [True: 1.66k, False: 11.4M] ------------------ 3525| 1.66k|YY_RULE_SETUP ------------------ | | 3169| 1.66k| YY_USER_ACTION | | ------------------ | | | | 66| 1.66k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.66k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 11.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 11.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 9.97k, False: 1.66k] | | | | ------------------ | | | | 69| 9.97k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 9.97k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 9.97k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 9.97k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.97k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 9.97k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 9.97k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 9.97k| } else { \ | | | | 75| 9.97k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 9.97k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 9.97k| } \ | | | | 77| 9.97k| } | | ------------------ ------------------ 3526| 1.66k|#line 112 "flex_lexer.l" 3527| 1.66k|TOKEN(EXISTS) ------------------ | | 2909| 1.66k|#define TOKEN(name) { return SQL_##name; } ------------------ 3528| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3529| 1|case 53: ------------------ | Branch (3529:1): [True: 1, False: 11.4M] ------------------ 3530| 1|YY_RULE_SETUP ------------------ | | 3169| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7, False: 1] | | | | ------------------ | | | | 69| 7| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7| } else { \ | | | | 75| 7| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7| } \ | | | | 77| 7| } | | ------------------ ------------------ 3531| 1|#line 113 "flex_lexer.l" 3532| 1|TOKEN(EXPLAIN) ------------------ | | 2909| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3533| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3534| 692|case 54: ------------------ | Branch (3534:1): [True: 692, False: 11.4M] ------------------ 3535| 692|YY_RULE_SETUP ------------------ | | 3169| 692| YY_USER_ACTION | | ------------------ | | | | 66| 692| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 692| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 692| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 692| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 692| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 692| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.53k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.53k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.84k, False: 692] | | | | ------------------ | | | | 69| 4.84k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.84k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.84k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.84k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.84k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.84k| } else { \ | | | | 75| 4.84k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.84k| } \ | | | | 77| 4.84k| } | | ------------------ ------------------ 3536| 692|#line 114 "flex_lexer.l" 3537| 692|TOKEN(EXTRACT) ------------------ | | 2909| 692|#define TOKEN(name) { return SQL_##name; } ------------------ 3538| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3539| 709|case 55: ------------------ | Branch (3539:1): [True: 709, False: 11.4M] ------------------ 3540| 709|YY_RULE_SETUP ------------------ | | 3169| 709| YY_USER_ACTION | | ------------------ | | | | 66| 709| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 709| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 709| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 709| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 709| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 709| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.25k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.25k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.54k, False: 709] | | | | ------------------ | | | | 69| 3.54k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 3.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.54k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 3.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.54k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.54k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.54k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.54k| } else { \ | | | | 75| 3.54k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 3.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.54k| } \ | | | | 77| 3.54k| } | | ------------------ ------------------ 3541| 709|#line 115 "flex_lexer.l" 3542| 709|TOKEN(FALSE) ------------------ | | 2909| 709|#define TOKEN(name) { return SQL_##name; } ------------------ 3543| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3544| 3|case 56: ------------------ | Branch (3544:1): [True: 3, False: 11.4M] ------------------ 3545| 3|YY_RULE_SETUP ------------------ | | 3169| 3| YY_USER_ACTION | | ------------------ | | | | 66| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 15| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 15|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 3] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 3546| 3|#line 116 "flex_lexer.l" 3547| 3|TOKEN(FILE) ------------------ | | 2909| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3548| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3549| 724|case 57: ------------------ | Branch (3549:1): [True: 724, False: 11.4M] ------------------ 3550| 724|YY_RULE_SETUP ------------------ | | 3169| 724| YY_USER_ACTION | | ------------------ | | | | 66| 724| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 724| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 724| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 724| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 724| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 724| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.34k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.34k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.62k, False: 724] | | | | ------------------ | | | | 69| 3.62k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 3.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.62k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 3.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.62k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.62k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.62k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.62k| } else { \ | | | | 75| 3.62k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 3.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.62k| } \ | | | | 77| 3.62k| } | | ------------------ ------------------ 3551| 724|#line 117 "flex_lexer.l" 3552| 724|TOKEN(FLOAT) ------------------ | | 2909| 724|#define TOKEN(name) { return SQL_##name; } ------------------ 3553| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3554| 4.17k|case 58: ------------------ | Branch (3554:1): [True: 4.17k, False: 11.4M] ------------------ 3555| 4.17k|YY_RULE_SETUP ------------------ | | 3169| 4.17k| YY_USER_ACTION | | ------------------ | | | | 66| 4.17k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 4.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 4.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 4.17k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 4.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 4.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 16.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 16.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12.5k, False: 4.17k] | | | | ------------------ | | | | 69| 12.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 12.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 12.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12.5k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12.5k| } else { \ | | | | 75| 12.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 12.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12.5k| } \ | | | | 77| 12.5k| } | | ------------------ ------------------ 3556| 4.17k|#line 118 "flex_lexer.l" 3557| 4.17k|TOKEN(FOR) ------------------ | | 2909| 4.17k|#define TOKEN(name) { return SQL_##name; } ------------------ 3558| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3559| 2|case 59: ------------------ | Branch (3559:1): [True: 2, False: 11.4M] ------------------ 3560| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 2] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 3561| 2|#line 119 "flex_lexer.l" 3562| 2|TOKEN(FORMAT) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3563| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3564| 4.93k|case 60: ------------------ | Branch (3564:1): [True: 4.93k, False: 11.4M] ------------------ 3565| 4.93k|YY_RULE_SETUP ------------------ | | 3169| 4.93k| YY_USER_ACTION | | ------------------ | | | | 66| 4.93k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 4.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 4.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 4.93k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 4.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 4.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 24.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 24.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 19.7k, False: 4.93k] | | | | ------------------ | | | | 69| 19.7k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 19.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 19.7k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 19.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 19.7k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 19.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 19.7k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 19.7k| } else { \ | | | | 75| 19.7k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 19.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 19.7k| } \ | | | | 77| 19.7k| } | | ------------------ ------------------ 3566| 4.93k|#line 120 "flex_lexer.l" 3567| 4.93k|TOKEN(FROM) ------------------ | | 2909| 4.93k|#define TOKEN(name) { return SQL_##name; } ------------------ 3568| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3569| 644|case 61: ------------------ | Branch (3569:1): [True: 644, False: 11.4M] ------------------ 3570| 644|YY_RULE_SETUP ------------------ | | 3169| 644| YY_USER_ACTION | | ------------------ | | | | 66| 644| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 644| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 644| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 644| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 644| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 644| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.22k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.22k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.57k, False: 644] | | | | ------------------ | | | | 69| 2.57k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 2.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.57k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 2.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.57k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.57k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.57k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.57k| } else { \ | | | | 75| 2.57k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 2.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.57k| } \ | | | | 77| 2.57k| } | | ------------------ ------------------ 3571| 644|#line 121 "flex_lexer.l" 3572| 644|TOKEN(FULL) ------------------ | | 2909| 644|#define TOKEN(name) { return SQL_##name; } ------------------ 3573| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3574| 1|case 62: ------------------ | Branch (3574:1): [True: 1, False: 11.4M] ------------------ 3575| 1|YY_RULE_SETUP ------------------ | | 3169| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 7| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6, False: 1] | | | | ------------------ | | | | 69| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6| } else { \ | | | | 75| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6| } \ | | | | 77| 6| } | | ------------------ ------------------ 3576| 1|#line 122 "flex_lexer.l" 3577| 1|TOKEN(GLOBAL) ------------------ | | 2909| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3578| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3579| 1.66k|case 63: ------------------ | Branch (3579:1): [True: 1.66k, False: 11.4M] ------------------ 3580| 1.66k|YY_RULE_SETUP ------------------ | | 3169| 1.66k| YY_USER_ACTION | | ------------------ | | | | 66| 1.66k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.66k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 9.99k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 9.99k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8.33k, False: 1.66k] | | | | ------------------ | | | | 69| 8.33k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 8.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8.33k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 8.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.33k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8.33k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8.33k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8.33k| } else { \ | | | | 75| 8.33k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 8.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8.33k| } \ | | | | 77| 8.33k| } | | ------------------ ------------------ 3581| 1.66k|#line 123 "flex_lexer.l" 3582| 1.66k|TOKEN(GROUP) ------------------ | | 2909| 1.66k|#define TOKEN(name) { return SQL_##name; } ------------------ 3583| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3584| 2|case 64: ------------------ | Branch (3584:1): [True: 2, False: 11.4M] ------------------ 3585| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 10| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8, False: 2] | | | | ------------------ | | | | 69| 8| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8| } else { \ | | | | 75| 8| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8| } \ | | | | 77| 8| } | | ------------------ ------------------ 3586| 2|#line 124 "flex_lexer.l" 3587| 2|TOKEN(HASH) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3588| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3589| 794|case 65: ------------------ | Branch (3589:1): [True: 794, False: 11.4M] ------------------ 3590| 794|YY_RULE_SETUP ------------------ | | 3169| 794| YY_USER_ACTION | | ------------------ | | | | 66| 794| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 794| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 794| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 794| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 794| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 794| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.55k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.55k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.76k, False: 794] | | | | ------------------ | | | | 69| 4.76k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.76k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.76k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.76k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.76k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.76k| } else { \ | | | | 75| 4.76k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.76k| } \ | | | | 77| 4.76k| } | | ------------------ ------------------ 3591| 794|#line 125 "flex_lexer.l" 3592| 794|TOKEN(HAVING) ------------------ | | 2909| 794|#define TOKEN(name) { return SQL_##name; } ------------------ 3593| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3594| 1.33k|case 66: ------------------ | Branch (3594:1): [True: 1.33k, False: 11.4M] ------------------ 3595| 1.33k|YY_RULE_SETUP ------------------ | | 3169| 1.33k| YY_USER_ACTION | | ------------------ | | | | 66| 1.33k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.33k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6.66k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.32k, False: 1.33k] | | | | ------------------ | | | | 69| 5.32k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 5.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.32k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 5.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.32k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.32k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.32k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.32k| } else { \ | | | | 75| 5.32k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 5.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.32k| } \ | | | | 77| 5.32k| } | | ------------------ ------------------ 3596| 1.33k|#line 126 "flex_lexer.l" 3597| 1.33k|TOKEN(HINT) ------------------ | | 2909| 1.33k|#define TOKEN(name) { return SQL_##name; } ------------------ 3598| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3599| 1.05k|case 67: ------------------ | Branch (3599:1): [True: 1.05k, False: 11.4M] ------------------ 3600| 1.05k|YY_RULE_SETUP ------------------ | | 3169| 1.05k| YY_USER_ACTION | | ------------------ | | | | 66| 1.05k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.05k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.26k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.26k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.21k, False: 1.05k] | | | | ------------------ | | | | 69| 4.21k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.21k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.21k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.21k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.21k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.21k| } else { \ | | | | 75| 4.21k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.21k| } \ | | | | 77| 4.21k| } | | ------------------ ------------------ 3601| 1.05k|#line 127 "flex_lexer.l" 3602| 1.05k|TOKEN(HOUR) ------------------ | | 2909| 1.05k|#define TOKEN(name) { return SQL_##name; } ------------------ 3603| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3604| 868|case 68: ------------------ | Branch (3604:1): [True: 868, False: 11.4M] ------------------ 3605| 868|YY_RULE_SETUP ------------------ | | 3169| 868| YY_USER_ACTION | | ------------------ | | | | 66| 868| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 868| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 868| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 868| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 868| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 868| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.20k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.20k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.34k, False: 868] | | | | ------------------ | | | | 69| 4.34k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.34k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.34k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.34k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.34k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.34k| } else { \ | | | | 75| 4.34k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.34k| } \ | | | | 77| 4.34k| } | | ------------------ ------------------ 3606| 868|#line 128 "flex_lexer.l" 3607| 868|TOKEN(HOURS) ------------------ | | 2909| 868|#define TOKEN(name) { return SQL_##name; } ------------------ 3608| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3609| 522|case 69: ------------------ | Branch (3609:1): [True: 522, False: 11.4M] ------------------ 3610| 522|YY_RULE_SETUP ------------------ | | 3169| 522| YY_USER_ACTION | | ------------------ | | | | 66| 522| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 522| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 522| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 522| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 522| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 522| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.56k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.56k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 1.04k, False: 522] | | | | ------------------ | | | | 69| 1.04k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 1.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 1.04k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 1.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.04k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 1.04k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 1.04k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 1.04k| } else { \ | | | | 75| 1.04k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 1.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 1.04k| } \ | | | | 77| 1.04k| } | | ------------------ ------------------ 3611| 522|#line 129 "flex_lexer.l" 3612| 522|TOKEN(IF) ------------------ | | 2909| 522|#define TOKEN(name) { return SQL_##name; } ------------------ 3613| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3614| 916|case 70: ------------------ | Branch (3614:1): [True: 916, False: 11.4M] ------------------ 3615| 916|YY_RULE_SETUP ------------------ | | 3169| 916| YY_USER_ACTION | | ------------------ | | | | 66| 916| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 916| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 916| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 916| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 916| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 916| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.49k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.49k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.58k, False: 916] | | | | ------------------ | | | | 69| 4.58k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.58k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.58k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.58k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.58k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.58k| } else { \ | | | | 75| 4.58k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.58k| } \ | | | | 77| 4.58k| } | | ------------------ ------------------ 3616| 916|#line 130 "flex_lexer.l" 3617| 916|TOKEN(ILIKE) ------------------ | | 2909| 916|#define TOKEN(name) { return SQL_##name; } ------------------ 3618| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3619| 120|case 71: ------------------ | Branch (3619:1): [True: 120, False: 11.4M] ------------------ 3620| 120|YY_RULE_SETUP ------------------ | | 3169| 120| YY_USER_ACTION | | ------------------ | | | | 66| 120| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 120| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 120| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 120| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 120| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 120| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 840| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 840|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 720, False: 120] | | | | ------------------ | | | | 69| 720| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 720| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 720| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 720| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 720| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 720|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 720] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 720| } else { \ | | | | 75| 720| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 720| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 720| } \ | | | | 77| 720| } | | ------------------ ------------------ 3621| 120|#line 131 "flex_lexer.l" 3622| 120|TOKEN(IMPORT) ------------------ | | 2909| 120|#define TOKEN(name) { return SQL_##name; } ------------------ 3623| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3624| 1.17k|case 72: ------------------ | Branch (3624:1): [True: 1.17k, False: 11.4M] ------------------ 3625| 1.17k|YY_RULE_SETUP ------------------ | | 3169| 1.17k| YY_USER_ACTION | | ------------------ | | | | 66| 1.17k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.17k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.52k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.52k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.35k, False: 1.17k] | | | | ------------------ | | | | 69| 2.35k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 2.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.35k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 2.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.35k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.35k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.35k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.35k| } else { \ | | | | 75| 2.35k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 2.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.35k| } \ | | | | 77| 2.35k| } | | ------------------ ------------------ 3626| 1.17k|#line 132 "flex_lexer.l" 3627| 1.17k|TOKEN(IN) ------------------ | | 2909| 1.17k|#define TOKEN(name) { return SQL_##name; } ------------------ 3628| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3629| 2.16k|case 73: ------------------ | Branch (3629:1): [True: 2.16k, False: 11.4M] ------------------ 3630| 2.16k|YY_RULE_SETUP ------------------ | | 3169| 2.16k| YY_USER_ACTION | | ------------------ | | | | 66| 2.16k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.16k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 12.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 12.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 10.8k, False: 2.16k] | | | | ------------------ | | | | 69| 10.8k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 10.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 10.8k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 10.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.8k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 10.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 10.8k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 10.8k| } else { \ | | | | 75| 10.8k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 10.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 10.8k| } \ | | | | 77| 10.8k| } | | ------------------ ------------------ 3631| 2.16k|#line 133 "flex_lexer.l" 3632| 2.16k|TOKEN(INDEX) ------------------ | | 2909| 2.16k|#define TOKEN(name) { return SQL_##name; } ------------------ 3633| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3634| 725|case 74: ------------------ | Branch (3634:1): [True: 725, False: 11.4M] ------------------ 3635| 725|YY_RULE_SETUP ------------------ | | 3169| 725| YY_USER_ACTION | | ------------------ | | | | 66| 725| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 725| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 725| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 725| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 725| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 725| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.35k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.35k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.62k, False: 725] | | | | ------------------ | | | | 69| 3.62k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 3.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.62k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 3.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.62k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.62k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.62k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.62k| } else { \ | | | | 75| 3.62k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 3.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.62k| } \ | | | | 77| 3.62k| } | | ------------------ ------------------ 3636| 725|#line 134 "flex_lexer.l" 3637| 725|TOKEN(INNER) ------------------ | | 2909| 725|#define TOKEN(name) { return SQL_##name; } ------------------ 3638| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3639| 2.57k|case 75: ------------------ | Branch (3639:1): [True: 2.57k, False: 11.4M] ------------------ 3640| 2.57k|YY_RULE_SETUP ------------------ | | 3169| 2.57k| YY_USER_ACTION | | ------------------ | | | | 66| 2.57k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.57k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 18.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 18.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 15.4k, False: 2.57k] | | | | ------------------ | | | | 69| 15.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 15.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 15.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 15.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 15.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 15.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 15.4k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 15.4k| } else { \ | | | | 75| 15.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 15.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 15.4k| } \ | | | | 77| 15.4k| } | | ------------------ ------------------ 3641| 2.57k|#line 135 "flex_lexer.l" 3642| 2.57k|TOKEN(INSERT) ------------------ | | 2909| 2.57k|#define TOKEN(name) { return SQL_##name; } ------------------ 3643| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3644| 39.6k|case 76: ------------------ | Branch (3644:1): [True: 39.6k, False: 11.4M] ------------------ 3645| 39.6k|YY_RULE_SETUP ------------------ | | 3169| 39.6k| YY_USER_ACTION | | ------------------ | | | | 66| 39.6k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 39.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 39.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 39.6k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 39.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 39.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 158k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 158k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 118k, False: 39.6k] | | | | ------------------ | | | | 69| 118k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 118k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 118k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 118k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 118k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 118k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 118k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 118k| } else { \ | | | | 75| 118k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 118k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 118k| } \ | | | | 77| 118k| } | | ------------------ ------------------ 3646| 39.6k|#line 136 "flex_lexer.l" 3647| 39.6k|TOKEN(INT) ------------------ | | 2909| 39.6k|#define TOKEN(name) { return SQL_##name; } ------------------ 3648| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3649| 678|case 77: ------------------ | Branch (3649:1): [True: 678, False: 11.4M] ------------------ 3650| 678|YY_RULE_SETUP ------------------ | | 3169| 678| YY_USER_ACTION | | ------------------ | | | | 66| 678| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 678| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 678| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 678| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 678| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 678| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.42k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.42k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.74k, False: 678] | | | | ------------------ | | | | 69| 4.74k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.74k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.74k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.74k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.74k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.74k| } else { \ | | | | 75| 4.74k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.74k| } \ | | | | 77| 4.74k| } | | ------------------ ------------------ 3651| 678|#line 137 "flex_lexer.l" 3652| 678|TOKEN(INTEGER) ------------------ | | 2909| 678|#define TOKEN(name) { return SQL_##name; } ------------------ 3653| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3654| 714|case 78: ------------------ | Branch (3654:1): [True: 714, False: 11.4M] ------------------ 3655| 714|YY_RULE_SETUP ------------------ | | 3169| 714| YY_USER_ACTION | | ------------------ | | | | 66| 714| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 714| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 714| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 714| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 714| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 714| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 7.14k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 7.14k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6.42k, False: 714] | | | | ------------------ | | | | 69| 6.42k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 6.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6.42k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 6.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.42k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6.42k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6.42k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6.42k| } else { \ | | | | 75| 6.42k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 6.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6.42k| } \ | | | | 77| 6.42k| } | | ------------------ ------------------ 3656| 714|#line 138 "flex_lexer.l" 3657| 714|TOKEN(INTERSECT) ------------------ | | 2909| 714|#define TOKEN(name) { return SQL_##name; } ------------------ 3658| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3659| 3.72k|case 79: ------------------ | Branch (3659:1): [True: 3.72k, False: 11.4M] ------------------ 3660| 3.72k|YY_RULE_SETUP ------------------ | | 3169| 3.72k| YY_USER_ACTION | | ------------------ | | | | 66| 3.72k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3.72k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 33.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 33.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 29.7k, False: 3.72k] | | | | ------------------ | | | | 69| 29.7k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 29.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 29.7k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 29.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 29.7k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 29.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 29.7k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 29.7k| } else { \ | | | | 75| 29.7k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 29.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 29.7k| } \ | | | | 77| 29.7k| } | | ------------------ ------------------ 3661| 3.72k|#line 139 "flex_lexer.l" 3662| 3.72k|TOKEN(INTERVAL) ------------------ | | 2909| 3.72k|#define TOKEN(name) { return SQL_##name; } ------------------ 3663| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3664| 2.57k|case 80: ------------------ | Branch (3664:1): [True: 2.57k, False: 11.4M] ------------------ 3665| 2.57k|YY_RULE_SETUP ------------------ | | 3169| 2.57k| YY_USER_ACTION | | ------------------ | | | | 66| 2.57k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.57k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 12.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 12.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 10.2k, False: 2.57k] | | | | ------------------ | | | | 69| 10.2k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 10.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 10.2k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 10.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.2k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 10.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 10.2k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 10.2k| } else { \ | | | | 75| 10.2k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 10.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 10.2k| } \ | | | | 77| 10.2k| } | | ------------------ ------------------ 3666| 2.57k|#line 140 "flex_lexer.l" 3667| 2.57k|TOKEN(INTO) ------------------ | | 2909| 2.57k|#define TOKEN(name) { return SQL_##name; } ------------------ 3668| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3669| 627|case 81: ------------------ | Branch (3669:1): [True: 627, False: 11.4M] ------------------ 3670| 627|YY_RULE_SETUP ------------------ | | 3169| 627| YY_USER_ACTION | | ------------------ | | | | 66| 627| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 627| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 627| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 627| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 627| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 627| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.88k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.88k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 1.25k, False: 627] | | | | ------------------ | | | | 69| 1.25k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 1.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 1.25k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 1.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.25k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 1.25k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 1.25k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 1.25k| } else { \ | | | | 75| 1.25k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 1.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 1.25k| } \ | | | | 77| 1.25k| } | | ------------------ ------------------ 3671| 627|#line 141 "flex_lexer.l" 3672| 627|TOKEN(IS) ------------------ | | 2909| 627|#define TOKEN(name) { return SQL_##name; } ------------------ 3673| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3674| 763|case 82: ------------------ | Branch (3674:1): [True: 763, False: 11.4M] ------------------ 3675| 763|YY_RULE_SETUP ------------------ | | 3169| 763| YY_USER_ACTION | | ------------------ | | | | 66| 763| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 763| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 763| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 763| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 763| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 763| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.34k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.34k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.57k, False: 763] | | | | ------------------ | | | | 69| 4.57k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.57k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.57k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.57k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.57k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.57k| } else { \ | | | | 75| 4.57k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.57k| } \ | | | | 77| 4.57k| } | | ------------------ ------------------ 3676| 763|#line 142 "flex_lexer.l" 3677| 763|TOKEN(ISNULL) ------------------ | | 2909| 763|#define TOKEN(name) { return SQL_##name; } ------------------ 3678| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3679| 113k|case 83: ------------------ | Branch (3679:1): [True: 113k, False: 11.3M] ------------------ 3680| 113k|YY_RULE_SETUP ------------------ | | 3169| 113k| YY_USER_ACTION | | ------------------ | | | | 66| 113k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 113k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 113k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 113k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 113k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 113k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 568k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 568k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 454k, False: 113k] | | | | ------------------ | | | | 69| 454k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 454k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 454k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 454k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 454k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 454k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 454k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 454k| } else { \ | | | | 75| 454k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 454k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 454k| } \ | | | | 77| 454k| } | | ------------------ ------------------ 3681| 113k|#line 143 "flex_lexer.l" 3682| 113k|TOKEN(JOIN) ------------------ | | 2909| 113k|#define TOKEN(name) { return SQL_##name; } ------------------ 3683| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3684| 2.76k|case 84: ------------------ | Branch (3684:1): [True: 2.76k, False: 11.4M] ------------------ 3685| 2.76k|YY_RULE_SETUP ------------------ | | 3169| 2.76k| YY_USER_ACTION | | ------------------ | | | | 66| 2.76k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.76k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 11.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 11.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8.28k, False: 2.76k] | | | | ------------------ | | | | 69| 8.28k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 8.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8.28k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 8.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.28k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8.28k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8.28k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8.28k| } else { \ | | | | 75| 8.28k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 8.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8.28k| } \ | | | | 77| 8.28k| } | | ------------------ ------------------ 3686| 2.76k|#line 144 "flex_lexer.l" 3687| 2.76k|TOKEN(KEY) ------------------ | | 2909| 2.76k|#define TOKEN(name) { return SQL_##name; } ------------------ 3688| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3689| 647|case 85: ------------------ | Branch (3689:1): [True: 647, False: 11.4M] ------------------ 3690| 647|YY_RULE_SETUP ------------------ | | 3169| 647| YY_USER_ACTION | | ------------------ | | | | 66| 647| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 647| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 647| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 647| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 647| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 647| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.23k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.23k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.58k, False: 647] | | | | ------------------ | | | | 69| 2.58k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 2.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.58k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 2.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.58k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.58k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.58k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.58k| } else { \ | | | | 75| 2.58k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 2.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.58k| } \ | | | | 77| 2.58k| } | | ------------------ ------------------ 3691| 647|#line 145 "flex_lexer.l" 3692| 647|TOKEN(LEFT) ------------------ | | 2909| 647|#define TOKEN(name) { return SQL_##name; } ------------------ 3693| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3694| 773|case 86: ------------------ | Branch (3694:1): [True: 773, False: 11.4M] ------------------ 3695| 773|YY_RULE_SETUP ------------------ | | 3169| 773| YY_USER_ACTION | | ------------------ | | | | 66| 773| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 773| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 773| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 773| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 773| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 773| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.86k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.86k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.09k, False: 773] | | | | ------------------ | | | | 69| 3.09k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 3.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.09k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 3.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.09k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.09k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.09k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.09k| } else { \ | | | | 75| 3.09k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 3.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.09k| } \ | | | | 77| 3.09k| } | | ------------------ ------------------ 3696| 773|#line 146 "flex_lexer.l" 3697| 773|TOKEN(LIKE) ------------------ | | 2909| 773|#define TOKEN(name) { return SQL_##name; } ------------------ 3698| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3699| 2.65k|case 87: ------------------ | Branch (3699:1): [True: 2.65k, False: 11.4M] ------------------ 3700| 2.65k|YY_RULE_SETUP ------------------ | | 3169| 2.65k| YY_USER_ACTION | | ------------------ | | | | 66| 2.65k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.65k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 15.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 15.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 13.2k, False: 2.65k] | | | | ------------------ | | | | 69| 13.2k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 13.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 13.2k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 13.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 13.2k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 13.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 13.2k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 13.2k| } else { \ | | | | 75| 13.2k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 13.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 13.2k| } \ | | | | 77| 13.2k| } | | ------------------ ------------------ 3701| 2.65k|#line 147 "flex_lexer.l" 3702| 2.65k|TOKEN(LIMIT) ------------------ | | 2909| 2.65k|#define TOKEN(name) { return SQL_##name; } ------------------ 3703| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3704| 3|case 88: ------------------ | Branch (3704:1): [True: 3, False: 11.4M] ------------------ 3705| 3|YY_RULE_SETUP ------------------ | | 3169| 3| YY_USER_ACTION | | ------------------ | | | | 66| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 15| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 15|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 3] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 3706| 3|#line 148 "flex_lexer.l" 3707| 3|TOKEN(LOAD) ------------------ | | 2909| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3708| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3709| 2|case 89: ------------------ | Branch (3709:1): [True: 2, False: 11.4M] ------------------ 3710| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 12| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 10, False: 2] | | | | ------------------ | | | | 69| 10| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 10| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 10] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 10| } else { \ | | | | 75| 10| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 10| } \ | | | | 77| 10| } | | ------------------ ------------------ 3711| 2|#line 149 "flex_lexer.l" 3712| 2|TOKEN(LOCAL) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3713| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3714| 2|case 90: ------------------ | Branch (3714:1): [True: 2, False: 11.4M] ------------------ 3715| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 2] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 3716| 2|#line 150 "flex_lexer.l" 3717| 2|TOKEN(LOCKED) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3718| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3719| 530|case 91: ------------------ | Branch (3719:1): [True: 530, False: 11.4M] ------------------ 3720| 530|YY_RULE_SETUP ------------------ | | 3169| 530| YY_USER_ACTION | | ------------------ | | | | 66| 530| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 530| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.65k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.65k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.12k, False: 530] | | | | ------------------ | | | | 69| 2.12k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.12k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.12k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.12k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.12k| } else { \ | | | | 75| 2.12k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.12k| } \ | | | | 77| 2.12k| } | | ------------------ ------------------ 3721| 530|#line 151 "flex_lexer.l" 3722| 530|TOKEN(LONG) ------------------ | | 2909| 530|#define TOKEN(name) { return SQL_##name; } ------------------ 3723| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3724| 1|case 92: ------------------ | Branch (3724:1): [True: 1, False: 11.4M] ------------------ 3725| 1|YY_RULE_SETUP ------------------ | | 3169| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5, False: 1] | | | | ------------------ | | | | 69| 5| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5| } else { \ | | | | 75| 5| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5| } \ | | | | 77| 5| } | | ------------------ ------------------ 3726| 1|#line 152 "flex_lexer.l" 3727| 1|TOKEN(MERGE) ------------------ | | 2909| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3728| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3729| 2|case 93: ------------------ | Branch (3729:1): [True: 2, False: 11.4M] ------------------ 3730| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 12| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 10, False: 2] | | | | ------------------ | | | | 69| 10| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 10| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 10] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 10| } else { \ | | | | 75| 10| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 10| } \ | | | | 77| 10| } | | ------------------ ------------------ 3731| 2|#line 153 "flex_lexer.l" 3732| 2|TOKEN(MINUS) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3733| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3734| 787|case 94: ------------------ | Branch (3734:1): [True: 787, False: 11.4M] ------------------ 3735| 787|YY_RULE_SETUP ------------------ | | 3169| 787| YY_USER_ACTION | | ------------------ | | | | 66| 787| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 787| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 787| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 787| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 787| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 787| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.50k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.50k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.72k, False: 787] | | | | ------------------ | | | | 69| 4.72k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.72k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.72k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.72k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.72k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.72k| } else { \ | | | | 75| 4.72k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.72k| } \ | | | | 77| 4.72k| } | | ------------------ ------------------ 3736| 787|#line 154 "flex_lexer.l" 3737| 787|TOKEN(MINUTE) ------------------ | | 2909| 787|#define TOKEN(name) { return SQL_##name; } ------------------ 3738| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3739| 759|case 95: ------------------ | Branch (3739:1): [True: 759, False: 11.4M] ------------------ 3740| 759|YY_RULE_SETUP ------------------ | | 3169| 759| YY_USER_ACTION | | ------------------ | | | | 66| 759| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 759| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 759| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 759| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 759| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 759| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6.07k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6.07k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.31k, False: 759] | | | | ------------------ | | | | 69| 5.31k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 5.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.31k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 5.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.31k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.31k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.31k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.31k| } else { \ | | | | 75| 5.31k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 5.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.31k| } \ | | | | 77| 5.31k| } | | ------------------ ------------------ 3741| 759|#line 155 "flex_lexer.l" 3742| 759|TOKEN(MINUTES) ------------------ | | 2909| 759|#define TOKEN(name) { return SQL_##name; } ------------------ 3743| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3744| 707|case 96: ------------------ | Branch (3744:1): [True: 707, False: 11.4M] ------------------ 3745| 707|YY_RULE_SETUP ------------------ | | 3169| 707| YY_USER_ACTION | | ------------------ | | | | 66| 707| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 707| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 707| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 707| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 707| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 707| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.24k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.24k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.53k, False: 707] | | | | ------------------ | | | | 69| 3.53k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 3.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.53k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 3.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.53k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.53k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.53k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.53k| } else { \ | | | | 75| 3.53k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 3.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.53k| } \ | | | | 77| 3.53k| } | | ------------------ ------------------ 3746| 707|#line 156 "flex_lexer.l" 3747| 707|TOKEN(MONTH) ------------------ | | 2909| 707|#define TOKEN(name) { return SQL_##name; } ------------------ 3748| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3749| 795|case 97: ------------------ | Branch (3749:1): [True: 795, False: 11.4M] ------------------ 3750| 795|YY_RULE_SETUP ------------------ | | 3169| 795| YY_USER_ACTION | | ------------------ | | | | 66| 795| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 795| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 795| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 795| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 795| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 795| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.56k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.56k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.77k, False: 795] | | | | ------------------ | | | | 69| 4.77k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.77k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.77k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.77k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.77k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.77k| } else { \ | | | | 75| 4.77k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.77k| } \ | | | | 77| 4.77k| } | | ------------------ ------------------ 3751| 795|#line 157 "flex_lexer.l" 3752| 795|TOKEN(MONTHS) ------------------ | | 2909| 795|#define TOKEN(name) { return SQL_##name; } ------------------ 3753| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3754| 815|case 98: ------------------ | Branch (3754:1): [True: 815, False: 11.4M] ------------------ 3755| 815|YY_RULE_SETUP ------------------ | | 3169| 815| YY_USER_ACTION | | ------------------ | | | | 66| 815| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 815| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 815| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 815| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 815| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 815| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6.52k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6.52k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.70k, False: 815] | | | | ------------------ | | | | 69| 5.70k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 5.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.70k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 5.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.70k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.70k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.70k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.70k| } else { \ | | | | 75| 5.70k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 5.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.70k| } \ | | | | 77| 5.70k| } | | ------------------ ------------------ 3756| 815|#line 158 "flex_lexer.l" 3757| 815|TOKEN(NATURAL) ------------------ | | 2909| 815|#define TOKEN(name) { return SQL_##name; } ------------------ 3758| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3759| 5|case 99: ------------------ | Branch (3759:1): [True: 5, False: 11.4M] ------------------ 3760| 5|YY_RULE_SETUP ------------------ | | 3169| 5| YY_USER_ACTION | | ------------------ | | | | 66| 5| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 5| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 15| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 15|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 10, False: 5] | | | | ------------------ | | | | 69| 10| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 10| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 10] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 10| } else { \ | | | | 75| 10| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 10| } \ | | | | 77| 10| } | | ------------------ ------------------ 3761| 5|#line 159 "flex_lexer.l" 3762| 5|TOKEN(NO) ------------------ | | 2909| 5|#define TOKEN(name) { return SQL_##name; } ------------------ 3763| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3764| 3.65k|case 100: ------------------ | Branch (3764:1): [True: 3.65k, False: 11.4M] ------------------ 3765| 3.65k|YY_RULE_SETUP ------------------ | | 3169| 3.65k| YY_USER_ACTION | | ------------------ | | | | 66| 3.65k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3.65k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 14.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 14.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 10.9k, False: 3.65k] | | | | ------------------ | | | | 69| 10.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 10.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 10.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 10.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 10.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 10.9k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 10.9k| } else { \ | | | | 75| 10.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 10.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 10.9k| } \ | | | | 77| 10.9k| } | | ------------------ ------------------ 3766| 3.65k|#line 160 "flex_lexer.l" 3767| 3.65k|TOKEN(NOT) ------------------ | | 2909| 3.65k|#define TOKEN(name) { return SQL_##name; } ------------------ 3768| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3769| 623|case 101: ------------------ | Branch (3769:1): [True: 623, False: 11.4M] ------------------ 3770| 623|YY_RULE_SETUP ------------------ | | 3169| 623| YY_USER_ACTION | | ------------------ | | | | 66| 623| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 623| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 623| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 623| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 623| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 623| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.36k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.36k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.73k, False: 623] | | | | ------------------ | | | | 69| 3.73k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 3.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.73k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 3.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.73k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.73k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.73k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.73k| } else { \ | | | | 75| 3.73k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 3.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.73k| } \ | | | | 77| 3.73k| } | | ------------------ ------------------ 3771| 623|#line 161 "flex_lexer.l" 3772| 623|TOKEN(NOWAIT) ------------------ | | 2909| 623|#define TOKEN(name) { return SQL_##name; } ------------------ 3773| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3774| 5.60k|case 102: ------------------ | Branch (3774:1): [True: 5.60k, False: 11.4M] ------------------ 3775| 5.60k|YY_RULE_SETUP ------------------ | | 3169| 5.60k| YY_USER_ACTION | | ------------------ | | | | 66| 5.60k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 5.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 5.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 5.60k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 5.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 5.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 28.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 28.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 22.4k, False: 5.60k] | | | | ------------------ | | | | 69| 22.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 22.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 22.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 22.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 22.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 22.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 22.4k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 22.4k| } else { \ | | | | 75| 22.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 22.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 22.4k| } \ | | | | 77| 22.4k| } | | ------------------ ------------------ 3776| 5.60k|#line 162 "flex_lexer.l" 3777| 5.60k|TOKEN(NULL) ------------------ | | 2909| 5.60k|#define TOKEN(name) { return SQL_##name; } ------------------ 3778| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3779| 2|case 103: ------------------ | Branch (3779:1): [True: 2, False: 11.4M] ------------------ 3780| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 18| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 18|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 16, False: 2] | | | | ------------------ | | | | 69| 16| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 16| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 16| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 16|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 16] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 16| } else { \ | | | | 75| 16| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 16| } \ | | | | 77| 16| } | | ------------------ ------------------ 3781| 2|#line 163 "flex_lexer.l" 3782| 2|TOKEN(NVARCHAR) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3783| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3784| 303|case 104: ------------------ | Branch (3784:1): [True: 303, False: 11.4M] ------------------ 3785| 303|YY_RULE_SETUP ------------------ | | 3169| 303| YY_USER_ACTION | | ------------------ | | | | 66| 303| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 303| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 303| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 303| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 303| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 303| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 909| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 909|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 606, False: 303] | | | | ------------------ | | | | 69| 606| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 606| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 606| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 606| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 606| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 606|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 606] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 606| } else { \ | | | | 75| 606| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 606| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 606| } \ | | | | 77| 606| } | | ------------------ ------------------ 3786| 303|#line 164 "flex_lexer.l" 3787| 303|TOKEN(OF) ------------------ | | 2909| 303|#define TOKEN(name) { return SQL_##name; } ------------------ 3788| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3789| 2|case 105: ------------------ | Branch (3789:1): [True: 2, False: 11.4M] ------------------ 3790| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6, False: 2] | | | | ------------------ | | | | 69| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6| } else { \ | | | | 75| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6| } \ | | | | 77| 6| } | | ------------------ ------------------ 3791| 2|#line 165 "flex_lexer.l" 3792| 2|TOKEN(OFF) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3793| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3794| 1.24k|case 106: ------------------ | Branch (3794:1): [True: 1.24k, False: 11.4M] ------------------ 3795| 1.24k|YY_RULE_SETUP ------------------ | | 3169| 1.24k| YY_USER_ACTION | | ------------------ | | | | 66| 1.24k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.24k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8.74k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8.74k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7.49k, False: 1.24k] | | | | ------------------ | | | | 69| 7.49k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 7.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7.49k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 7.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.49k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7.49k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7.49k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7.49k| } else { \ | | | | 75| 7.49k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 7.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7.49k| } \ | | | | 77| 7.49k| } | | ------------------ ------------------ 3796| 1.24k|#line 166 "flex_lexer.l" 3797| 1.24k|TOKEN(OFFSET) ------------------ | | 2909| 1.24k|#define TOKEN(name) { return SQL_##name; } ------------------ 3798| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3799| 110k|case 107: ------------------ | Branch (3799:1): [True: 110k, False: 11.3M] ------------------ 3800| 110k|YY_RULE_SETUP ------------------ | | 3169| 110k| YY_USER_ACTION | | ------------------ | | | | 66| 110k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 110k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 110k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 110k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 110k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 110k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 331k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 331k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 220k, False: 110k] | | | | ------------------ | | | | 69| 220k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 220k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 220k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 220k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 220k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 220k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 220k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 220k| } else { \ | | | | 75| 220k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 220k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 220k| } \ | | | | 77| 220k| } | | ------------------ ------------------ 3801| 110k|#line 167 "flex_lexer.l" 3802| 110k|TOKEN(ON) ------------------ | | 2909| 110k|#define TOKEN(name) { return SQL_##name; } ------------------ 3803| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3804| 530|case 108: ------------------ | Branch (3804:1): [True: 530, False: 11.4M] ------------------ 3805| 530|YY_RULE_SETUP ------------------ | | 3169| 530| YY_USER_ACTION | | ------------------ | | | | 66| 530| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 530| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.59k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.59k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 1.06k, False: 530] | | | | ------------------ | | | | 69| 1.06k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 1.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 1.06k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 1.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.06k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 1.06k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 1.06k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 1.06k| } else { \ | | | | 75| 1.06k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 1.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 1.06k| } \ | | | | 77| 1.06k| } | | ------------------ ------------------ 3806| 530|#line 168 "flex_lexer.l" 3807| 530|TOKEN(OR) ------------------ | | 2909| 530|#define TOKEN(name) { return SQL_##name; } ------------------ 3808| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3809| 1.78k|case 109: ------------------ | Branch (3809:1): [True: 1.78k, False: 11.4M] ------------------ 3810| 1.78k|YY_RULE_SETUP ------------------ | | 3169| 1.78k| YY_USER_ACTION | | ------------------ | | | | 66| 1.78k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.78k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.78k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.78k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.78k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.78k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 10.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 10.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8.93k, False: 1.78k] | | | | ------------------ | | | | 69| 8.93k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 8.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8.93k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 8.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.93k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8.93k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8.93k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8.93k| } else { \ | | | | 75| 8.93k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 8.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8.93k| } \ | | | | 77| 8.93k| } | | ------------------ ------------------ 3811| 1.78k|#line 169 "flex_lexer.l" 3812| 1.78k|TOKEN(ORDER) ------------------ | | 2909| 1.78k|#define TOKEN(name) { return SQL_##name; } ------------------ 3813| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3814| 922|case 110: ------------------ | Branch (3814:1): [True: 922, False: 11.4M] ------------------ 3815| 922|YY_RULE_SETUP ------------------ | | 3169| 922| YY_USER_ACTION | | ------------------ | | | | 66| 922| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 922| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 922| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 922| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 922| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 922| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.53k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.53k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.61k, False: 922] | | | | ------------------ | | | | 69| 4.61k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.61k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.61k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.61k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.61k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.61k| } else { \ | | | | 75| 4.61k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.61k| } \ | | | | 77| 4.61k| } | | ------------------ ------------------ 3816| 922|#line 170 "flex_lexer.l" 3817| 922|TOKEN(OUTER) ------------------ | | 2909| 922|#define TOKEN(name) { return SQL_##name; } ------------------ 3818| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3819| 0|case 111: ------------------ | Branch (3819:1): [True: 0, False: 11.4M] ------------------ 3820| 0|YY_RULE_SETUP ------------------ | | 3169| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 3821| 0|#line 171 "flex_lexer.l" 3822| 0|TOKEN(PARAMETERS) ------------------ | | 2909| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 3823| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3824| 1|case 112: ------------------ | Branch (3824:1): [True: 1, False: 11.4M] ------------------ 3825| 1|YY_RULE_SETUP ------------------ | | 3169| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4, False: 1] | | | | ------------------ | | | | 69| 4| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4| } else { \ | | | | 75| 4| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4| } \ | | | | 77| 4| } | | ------------------ ------------------ 3826| 1|#line 172 "flex_lexer.l" 3827| 1|TOKEN(PLAN) ------------------ | | 2909| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3828| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3829| 1.70k|case 113: ------------------ | Branch (3829:1): [True: 1.70k, False: 11.4M] ------------------ 3830| 1.70k|YY_RULE_SETUP ------------------ | | 3169| 1.70k| YY_USER_ACTION | | ------------------ | | | | 66| 1.70k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.70k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 13.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 13.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 11.9k, False: 1.70k] | | | | ------------------ | | | | 69| 11.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 11.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 11.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 11.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 11.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 11.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 11.9k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 11.9k| } else { \ | | | | 75| 11.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 11.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 11.9k| } \ | | | | 77| 11.9k| } | | ------------------ ------------------ 3831| 1.70k|#line 173 "flex_lexer.l" 3832| 1.70k|TOKEN(PREPARE) ------------------ | | 2909| 1.70k|#define TOKEN(name) { return SQL_##name; } ------------------ 3833| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3834| 2.56k|case 114: ------------------ | Branch (3834:1): [True: 2.56k, False: 11.4M] ------------------ 3835| 2.56k|YY_RULE_SETUP ------------------ | | 3169| 2.56k| YY_USER_ACTION | | ------------------ | | | | 66| 2.56k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.56k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 20.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 20.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 17.9k, False: 2.56k] | | | | ------------------ | | | | 69| 17.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 17.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 17.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 17.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 17.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 17.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 17.9k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 17.9k| } else { \ | | | | 75| 17.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 17.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 17.9k| } \ | | | | 77| 17.9k| } | | ------------------ ------------------ 3836| 2.56k|#line 174 "flex_lexer.l" 3837| 2.56k|TOKEN(PRIMARY) ------------------ | | 2909| 2.56k|#define TOKEN(name) { return SQL_##name; } ------------------ 3838| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3839| 562|case 115: ------------------ | Branch (3839:1): [True: 562, False: 11.4M] ------------------ 3840| 562|YY_RULE_SETUP ------------------ | | 3169| 562| YY_USER_ACTION | | ------------------ | | | | 66| 562| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 562| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 562| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 562| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 562| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 562| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.81k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.81k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.24k, False: 562] | | | | ------------------ | | | | 69| 2.24k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 2.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.24k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 2.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.24k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.24k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.24k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.24k| } else { \ | | | | 75| 2.24k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 2.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.24k| } \ | | | | 77| 2.24k| } | | ------------------ ------------------ 3841| 562|#line 175 "flex_lexer.l" 3842| 562|TOKEN(REAL) ------------------ | | 2909| 562|#define TOKEN(name) { return SQL_##name; } ------------------ 3843| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3844| 2|case 116: ------------------ | Branch (3844:1): [True: 2, False: 11.4M] ------------------ 3845| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 2] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 3846| 2|#line 176 "flex_lexer.l" 3847| 2|TOKEN(RENAME) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3848| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3849| 1|case 117: ------------------ | Branch (3849:1): [True: 1, False: 11.4M] ------------------ 3850| 1|YY_RULE_SETUP ------------------ | | 3169| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 9| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 9|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8, False: 1] | | | | ------------------ | | | | 69| 8| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8| } else { \ | | | | 75| 8| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8| } \ | | | | 77| 8| } | | ------------------ ------------------ 3851| 1|#line 177 "flex_lexer.l" 3852| 1|TOKEN(RESTRICT) ------------------ | | 2909| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3853| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3854| 806|case 118: ------------------ | Branch (3854:1): [True: 806, False: 11.4M] ------------------ 3855| 806|YY_RULE_SETUP ------------------ | | 3169| 806| YY_USER_ACTION | | ------------------ | | | | 66| 806| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 806| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 806| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 806| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 806| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 806| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.83k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.83k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.03k, False: 806] | | | | ------------------ | | | | 69| 4.03k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.03k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.03k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.03k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.03k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.03k| } else { \ | | | | 75| 4.03k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.03k| } \ | | | | 77| 4.03k| } | | ------------------ ------------------ 3856| 806|#line 178 "flex_lexer.l" 3857| 806|TOKEN(RIGHT) ------------------ | | 2909| 806|#define TOKEN(name) { return SQL_##name; } ------------------ 3858| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3859| 678|case 119: ------------------ | Branch (3859:1): [True: 678, False: 11.4M] ------------------ 3860| 678|YY_RULE_SETUP ------------------ | | 3169| 678| YY_USER_ACTION | | ------------------ | | | | 66| 678| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 678| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 678| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 678| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 678| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 678| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6.10k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6.10k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.42k, False: 678] | | | | ------------------ | | | | 69| 5.42k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 5.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.42k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 5.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.42k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.42k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.42k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.42k| } else { \ | | | | 75| 5.42k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 5.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.42k| } \ | | | | 77| 5.42k| } | | ------------------ ------------------ 3861| 678|#line 179 "flex_lexer.l" 3862| 678|TOKEN(ROLLBACK) ------------------ | | 2909| 678|#define TOKEN(name) { return SQL_##name; } ------------------ 3863| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3864| 1|case 120: ------------------ | Branch (3864:1): [True: 1, False: 11.4M] ------------------ 3865| 1|YY_RULE_SETUP ------------------ | | 3169| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 7| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6, False: 1] | | | | ------------------ | | | | 69| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6| } else { \ | | | | 75| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6| } \ | | | | 77| 6| } | | ------------------ ------------------ 3866| 1|#line 180 "flex_lexer.l" 3867| 1|TOKEN(SCHEMA) ------------------ | | 2909| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3868| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3869| 2|case 121: ------------------ | Branch (3869:1): [True: 2, False: 11.4M] ------------------ 3870| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 16| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 16|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 14, False: 2] | | | | ------------------ | | | | 69| 14| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 14| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 14] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 14| } else { \ | | | | 75| 14| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 14| } \ | | | | 77| 14| } | | ------------------ ------------------ 3871| 2|#line 181 "flex_lexer.l" 3872| 2|TOKEN(SCHEMAS) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3873| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3874| 789|case 122: ------------------ | Branch (3874:1): [True: 789, False: 11.4M] ------------------ 3875| 789|YY_RULE_SETUP ------------------ | | 3169| 789| YY_USER_ACTION | | ------------------ | | | | 66| 789| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 789| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 789| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 789| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 789| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 789| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.52k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.52k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.73k, False: 789] | | | | ------------------ | | | | 69| 4.73k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.73k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.73k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.73k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.73k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.73k| } else { \ | | | | 75| 4.73k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.73k| } \ | | | | 77| 4.73k| } | | ------------------ ------------------ 3876| 789|#line 182 "flex_lexer.l" 3877| 789|TOKEN(SECOND) ------------------ | | 2909| 789|#define TOKEN(name) { return SQL_##name; } ------------------ 3878| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3879| 726|case 123: ------------------ | Branch (3879:1): [True: 726, False: 11.4M] ------------------ 3880| 726|YY_RULE_SETUP ------------------ | | 3169| 726| YY_USER_ACTION | | ------------------ | | | | 66| 726| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 726| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 726| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 726| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 726| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 726| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.80k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.80k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.08k, False: 726] | | | | ------------------ | | | | 69| 5.08k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 5.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.08k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 5.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.08k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.08k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.08k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.08k| } else { \ | | | | 75| 5.08k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 5.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.08k| } \ | | | | 77| 5.08k| } | | ------------------ ------------------ 3881| 726|#line 183 "flex_lexer.l" 3882| 726|TOKEN(SECONDS) ------------------ | | 2909| 726|#define TOKEN(name) { return SQL_##name; } ------------------ 3883| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3884| 60.0k|case 124: ------------------ | Branch (3884:1): [True: 60.0k, False: 11.4M] ------------------ 3885| 60.0k|YY_RULE_SETUP ------------------ | | 3169| 60.0k| YY_USER_ACTION | | ------------------ | | | | 66| 60.0k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 60.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 60.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 60.0k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 60.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 60.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 420k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 420k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 360k, False: 60.0k] | | | | ------------------ | | | | 69| 360k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 360k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 360k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 360k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 360k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 360k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 360k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 360k| } else { \ | | | | 75| 360k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 360k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 360k| } \ | | | | 77| 360k| } | | ------------------ ------------------ 3886| 60.0k|#line 184 "flex_lexer.l" 3887| 60.0k|TOKEN(SELECT) ------------------ | | 2909| 60.0k|#define TOKEN(name) { return SQL_##name; } ------------------ 3888| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3889| 1.24k|case 125: ------------------ | Branch (3889:1): [True: 1.24k, False: 11.4M] ------------------ 3890| 1.24k|YY_RULE_SETUP ------------------ | | 3169| 1.24k| YY_USER_ACTION | | ------------------ | | | | 66| 1.24k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.24k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.96k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.96k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.72k, False: 1.24k] | | | | ------------------ | | | | 69| 3.72k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 3.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.72k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 3.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.72k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.72k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.72k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.72k| } else { \ | | | | 75| 3.72k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 3.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.72k| } \ | | | | 77| 3.72k| } | | ------------------ ------------------ 3891| 1.24k|#line 185 "flex_lexer.l" 3892| 1.24k|TOKEN(SET) ------------------ | | 2909| 1.24k|#define TOKEN(name) { return SQL_##name; } ------------------ 3893| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3894| 3.35k|case 126: ------------------ | Branch (3894:1): [True: 3.35k, False: 11.4M] ------------------ 3895| 3.35k|YY_RULE_SETUP ------------------ | | 3169| 3.35k| YY_USER_ACTION | | ------------------ | | | | 66| 3.35k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3.35k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 20.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 20.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 16.7k, False: 3.35k] | | | | ------------------ | | | | 69| 16.7k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 16.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 16.7k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 16.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 16.7k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 16.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 16.7k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 16.7k| } else { \ | | | | 75| 16.7k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 16.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 16.7k| } \ | | | | 77| 16.7k| } | | ------------------ ------------------ 3896| 3.35k|#line 186 "flex_lexer.l" 3897| 3.35k|TOKEN(SHARE) ------------------ | | 2909| 3.35k|#define TOKEN(name) { return SQL_##name; } ------------------ 3898| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3899| 2.23k|case 127: ------------------ | Branch (3899:1): [True: 2.23k, False: 11.4M] ------------------ 3900| 2.23k|YY_RULE_SETUP ------------------ | | 3169| 2.23k| YY_USER_ACTION | | ------------------ | | | | 66| 2.23k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.23k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 11.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 11.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8.94k, False: 2.23k] | | | | ------------------ | | | | 69| 8.94k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 8.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8.94k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 8.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.94k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8.94k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8.94k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8.94k| } else { \ | | | | 75| 8.94k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 8.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8.94k| } \ | | | | 77| 8.94k| } | | ------------------ ------------------ 3901| 2.23k|#line 187 "flex_lexer.l" 3902| 2.23k|TOKEN(SHOW) ------------------ | | 2909| 2.23k|#define TOKEN(name) { return SQL_##name; } ------------------ 3903| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3904| 2|case 128: ------------------ | Branch (3904:1): [True: 2, False: 11.4M] ------------------ 3905| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 10| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8, False: 2] | | | | ------------------ | | | | 69| 8| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8| } else { \ | | | | 75| 8| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8| } \ | | | | 77| 8| } | | ------------------ ------------------ 3906| 2|#line 188 "flex_lexer.l" 3907| 2|TOKEN(SKIP) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3908| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3909| 558|case 129: ------------------ | Branch (3909:1): [True: 558, False: 11.4M] ------------------ 3910| 558|YY_RULE_SETUP ------------------ | | 3169| 558| YY_USER_ACTION | | ------------------ | | | | 66| 558| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 558| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 558| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 558| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 558| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 558| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.02k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.02k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.46k, False: 558] | | | | ------------------ | | | | 69| 4.46k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.46k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.46k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.46k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.46k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.46k| } else { \ | | | | 75| 4.46k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.46k| } \ | | | | 77| 4.46k| } | | ------------------ ------------------ 3911| 558|#line 189 "flex_lexer.l" 3912| 558|TOKEN(SMALLINT) ------------------ | | 2909| 558|#define TOKEN(name) { return SQL_##name; } ------------------ 3913| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3914| 2|case 130: ------------------ | Branch (3914:1): [True: 2, False: 11.4M] ------------------ 3915| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 2] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 3916| 2|#line 190 "flex_lexer.l" 3917| 2|TOKEN(SORTED) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3918| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3919| 2|case 131: ------------------ | Branch (3919:1): [True: 2, False: 11.4M] ------------------ 3920| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 16| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 16|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 14, False: 2] | | | | ------------------ | | | | 69| 14| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 14| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 14] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 14| } else { \ | | | | 75| 14| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 14| } \ | | | | 77| 14| } | | ------------------ ------------------ 3921| 2|#line 191 "flex_lexer.l" 3922| 2|TOKEN(SPATIAL) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3923| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3924| 2.92k|case 132: ------------------ | Branch (3924:1): [True: 2.92k, False: 11.4M] ------------------ 3925| 2.92k|YY_RULE_SETUP ------------------ | | 3169| 2.92k| YY_USER_ACTION | | ------------------ | | | | 66| 2.92k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.92k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 17.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 17.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 14.6k, False: 2.92k] | | | | ------------------ | | | | 69| 14.6k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 14.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 14.6k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 14.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14.6k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 14.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 14.6k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 14.6k| } else { \ | | | | 75| 14.6k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 14.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 14.6k| } \ | | | | 77| 14.6k| } | | ------------------ ------------------ 3926| 2.92k|#line 192 "flex_lexer.l" 3927| 2.92k|TOKEN(TABLE) ------------------ | | 2909| 2.92k|#define TOKEN(name) { return SQL_##name; } ------------------ 3928| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3929| 1.41k|case 133: ------------------ | Branch (3929:1): [True: 1.41k, False: 11.4M] ------------------ 3930| 1.41k|YY_RULE_SETUP ------------------ | | 3169| 1.41k| YY_USER_ACTION | | ------------------ | | | | 66| 1.41k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.41k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 9.93k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 9.93k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8.51k, False: 1.41k] | | | | ------------------ | | | | 69| 8.51k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 8.51k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8.51k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 8.51k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.51k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8.51k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8.51k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8.51k| } else { \ | | | | 75| 8.51k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 8.51k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8.51k| } \ | | | | 77| 8.51k| } | | ------------------ ------------------ 3931| 1.41k|#line 193 "flex_lexer.l" 3932| 1.41k|TOKEN(TABLES) ------------------ | | 2909| 1.41k|#define TOKEN(name) { return SQL_##name; } ------------------ 3933| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3934| 1|case 134: ------------------ | Branch (3934:1): [True: 1, False: 11.4M] ------------------ 3935| 1|YY_RULE_SETUP ------------------ | | 3169| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 10| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 9, False: 1] | | | | ------------------ | | | | 69| 9| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 9| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 9| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 9| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 9|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 9] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 9| } else { \ | | | | 75| 9| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 9| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 9| } \ | | | | 77| 9| } | | ------------------ ------------------ 3936| 1|#line 194 "flex_lexer.l" 3937| 1|TOKEN(TEMPORARY) ------------------ | | 2909| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3938| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3939| 580|case 135: ------------------ | Branch (3939:1): [True: 580, False: 11.4M] ------------------ 3940| 580|YY_RULE_SETUP ------------------ | | 3169| 580| YY_USER_ACTION | | ------------------ | | | | 66| 580| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 580| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 580| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 580| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 580| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 580| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.90k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.90k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.32k, False: 580] | | | | ------------------ | | | | 69| 2.32k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 2.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.32k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 2.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.32k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.32k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.32k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.32k| } else { \ | | | | 75| 2.32k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 2.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.32k| } \ | | | | 77| 2.32k| } | | ------------------ ------------------ 3941| 580|#line 195 "flex_lexer.l" 3942| 580|TOKEN(TEXT) ------------------ | | 2909| 580|#define TOKEN(name) { return SQL_##name; } ------------------ 3943| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3944| 3.58k|case 136: ------------------ | Branch (3944:1): [True: 3.58k, False: 11.4M] ------------------ 3945| 3.58k|YY_RULE_SETUP ------------------ | | 3169| 3.58k| YY_USER_ACTION | | ------------------ | | | | 66| 3.58k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3.58k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 17.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 17.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 14.3k, False: 3.58k] | | | | ------------------ | | | | 69| 14.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 14.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 14.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 14.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 14.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 14.3k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 14.3k| } else { \ | | | | 75| 14.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 14.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 14.3k| } \ | | | | 77| 14.3k| } | | ------------------ ------------------ 3946| 3.58k|#line 196 "flex_lexer.l" 3947| 3.58k|TOKEN(THEN) ------------------ | | 2909| 3.58k|#define TOKEN(name) { return SQL_##name; } ------------------ 3948| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3949| 109k|case 137: ------------------ | Branch (3949:1): [True: 109k, False: 11.3M] ------------------ 3950| 109k|YY_RULE_SETUP ------------------ | | 3169| 109k| YY_USER_ACTION | | ------------------ | | | | 66| 109k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 109k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 109k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 109k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 109k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 109k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 546k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 546k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 437k, False: 109k] | | | | ------------------ | | | | 69| 437k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 437k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 437k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 437k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 437k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 437k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 437k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 437k| } else { \ | | | | 75| 437k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 437k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 437k| } \ | | | | 77| 437k| } | | ------------------ ------------------ 3951| 109k|#line 197 "flex_lexer.l" 3952| 109k|TOKEN(TIME) ------------------ | | 2909| 109k|#define TOKEN(name) { return SQL_##name; } ------------------ 3953| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3954| 56.7k|case 138: ------------------ | Branch (3954:1): [True: 56.7k, False: 11.4M] ------------------ 3955| 56.7k|YY_RULE_SETUP ------------------ | | 3169| 56.7k| YY_USER_ACTION | | ------------------ | | | | 66| 56.7k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 56.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 56.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 56.7k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 56.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 56.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 567k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 567k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 511k, False: 56.7k] | | | | ------------------ | | | | 69| 511k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 511k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 511k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 511k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 511k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 511k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 511k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 511k| } else { \ | | | | 75| 511k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 511k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 511k| } \ | | | | 77| 511k| } | | ------------------ ------------------ 3956| 56.7k|#line 198 "flex_lexer.l" 3957| 56.7k|TOKEN(TIMESTAMP) ------------------ | | 2909| 56.7k|#define TOKEN(name) { return SQL_##name; } ------------------ 3958| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3959| 889|case 139: ------------------ | Branch (3959:1): [True: 889, False: 11.4M] ------------------ 3960| 889|YY_RULE_SETUP ------------------ | | 3169| 889| YY_USER_ACTION | | ------------------ | | | | 66| 889| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 889| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 889| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 889| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 889| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 889| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.66k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 1.77k, False: 889] | | | | ------------------ | | | | 69| 1.77k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 1.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 1.77k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 1.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.77k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 1.77k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 1.77k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 1.77k| } else { \ | | | | 75| 1.77k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 1.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 1.77k| } \ | | | | 77| 1.77k| } | | ------------------ ------------------ 3961| 889|#line 199 "flex_lexer.l" 3962| 889|TOKEN(TO) ------------------ | | 2909| 889|#define TOKEN(name) { return SQL_##name; } ------------------ 3963| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3964| 875|case 140: ------------------ | Branch (3964:1): [True: 875, False: 11.4M] ------------------ 3965| 875|YY_RULE_SETUP ------------------ | | 3169| 875| YY_USER_ACTION | | ------------------ | | | | 66| 875| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 875| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 875| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 875| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 875| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 875| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.50k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.50k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.62k, False: 875] | | | | ------------------ | | | | 69| 2.62k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 2.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.62k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 2.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.62k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.62k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.62k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.62k| } else { \ | | | | 75| 2.62k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 2.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.62k| } \ | | | | 77| 2.62k| } | | ------------------ ------------------ 3966| 875|#line 200 "flex_lexer.l" 3967| 875|TOKEN(TOP) ------------------ | | 2909| 875|#define TOKEN(name) { return SQL_##name; } ------------------ 3968| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3969| 0|case 141: ------------------ | Branch (3969:1): [True: 0, False: 11.4M] ------------------ 3970| 0|YY_RULE_SETUP ------------------ | | 3169| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 3971| 0|#line 201 "flex_lexer.l" 3972| 0|TOKEN(TRANSACTION) ------------------ | | 2909| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 3973| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3974| 599|case 142: ------------------ | Branch (3974:1): [True: 599, False: 11.4M] ------------------ 3975| 599|YY_RULE_SETUP ------------------ | | 3169| 599| YY_USER_ACTION | | ------------------ | | | | 66| 599| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 599| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 599| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 599| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 599| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 599| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.99k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.99k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.39k, False: 599] | | | | ------------------ | | | | 69| 2.39k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 2.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.39k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 2.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.39k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.39k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.39k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.39k| } else { \ | | | | 75| 2.39k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 2.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.39k| } \ | | | | 77| 2.39k| } | | ------------------ ------------------ 3976| 599|#line 202 "flex_lexer.l" 3977| 599|TOKEN(TRUE) ------------------ | | 2909| 599|#define TOKEN(name) { return SQL_##name; } ------------------ 3978| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3979| 598|case 143: ------------------ | Branch (3979:1): [True: 598, False: 11.4M] ------------------ 3980| 598|YY_RULE_SETUP ------------------ | | 3169| 598| YY_USER_ACTION | | ------------------ | | | | 66| 598| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 598| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 598| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 598| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 598| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 598| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.38k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.38k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.78k, False: 598] | | | | ------------------ | | | | 69| 4.78k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.78k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.78k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.78k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.78k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.78k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.78k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.78k| } else { \ | | | | 75| 4.78k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.78k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.78k| } \ | | | | 77| 4.78k| } | | ------------------ ------------------ 3981| 598|#line 203 "flex_lexer.l" 3982| 598|TOKEN(TRUNCATE) ------------------ | | 2909| 598|#define TOKEN(name) { return SQL_##name; } ------------------ 3983| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3984| 2.74k|case 144: ------------------ | Branch (3984:1): [True: 2.74k, False: 11.4M] ------------------ 3985| 2.74k|YY_RULE_SETUP ------------------ | | 3169| 2.74k| YY_USER_ACTION | | ------------------ | | | | 66| 2.74k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.74k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 16.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 16.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 13.7k, False: 2.74k] | | | | ------------------ | | | | 69| 13.7k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 13.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 13.7k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 13.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 13.7k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 13.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 13.7k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 13.7k| } else { \ | | | | 75| 13.7k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 13.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 13.7k| } \ | | | | 77| 13.7k| } | | ------------------ ------------------ 3986| 2.74k|#line 204 "flex_lexer.l" 3987| 2.74k|TOKEN(UNION) ------------------ | | 2909| 2.74k|#define TOKEN(name) { return SQL_##name; } ------------------ 3988| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3989| 146k|case 145: ------------------ | Branch (3989:1): [True: 146k, False: 11.3M] ------------------ 3990| 146k|YY_RULE_SETUP ------------------ | | 3169| 146k| YY_USER_ACTION | | ------------------ | | | | 66| 146k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 146k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 146k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 146k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 146k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 146k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.02M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.02M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 878k, False: 146k] | | | | ------------------ | | | | 69| 878k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 878k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 878k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 878k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 878k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 878k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 878k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 878k| } else { \ | | | | 75| 878k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 878k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 878k| } \ | | | | 77| 878k| } | | ------------------ ------------------ 3991| 146k|#line 205 "flex_lexer.l" 3992| 146k|TOKEN(UNIQUE) ------------------ | | 2909| 146k|#define TOKEN(name) { return SQL_##name; } ------------------ 3993| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3994| 2|case 146: ------------------ | Branch (3994:1): [True: 2, False: 11.4M] ------------------ 3995| 2|YY_RULE_SETUP ------------------ | | 3169| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 2] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 3996| 2|#line 206 "flex_lexer.l" 3997| 2|TOKEN(UNLOAD) ------------------ | | 2909| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3998| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3999| 2.01k|case 147: ------------------ | Branch (3999:1): [True: 2.01k, False: 11.4M] ------------------ 4000| 2.01k|YY_RULE_SETUP ------------------ | | 3169| 2.01k| YY_USER_ACTION | | ------------------ | | | | 66| 2.01k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.01k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 14.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 14.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12.0k, False: 2.01k] | | | | ------------------ | | | | 69| 12.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 12.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 12.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12.0k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12.0k| } else { \ | | | | 75| 12.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 12.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12.0k| } \ | | | | 77| 12.0k| } | | ------------------ ------------------ 4001| 2.01k|#line 207 "flex_lexer.l" 4002| 2.01k|TOKEN(UPDATE) ------------------ | | 2909| 2.01k|#define TOKEN(name) { return SQL_##name; } ------------------ 4003| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4004| 1.54k|case 148: ------------------ | Branch (4004:1): [True: 1.54k, False: 11.4M] ------------------ 4005| 1.54k|YY_RULE_SETUP ------------------ | | 3169| 1.54k| YY_USER_ACTION | | ------------------ | | | | 66| 1.54k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.54k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 9.29k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 9.29k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7.74k, False: 1.54k] | | | | ------------------ | | | | 69| 7.74k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 7.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7.74k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 7.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.74k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7.74k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7.74k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7.74k| } else { \ | | | | 75| 7.74k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 7.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7.74k| } \ | | | | 77| 7.74k| } | | ------------------ ------------------ 4006| 1.54k|#line 208 "flex_lexer.l" 4007| 1.54k|TOKEN(USING) ------------------ | | 2909| 1.54k|#define TOKEN(name) { return SQL_##name; } ------------------ 4008| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4009| 839|case 149: ------------------ | Branch (4009:1): [True: 839, False: 11.4M] ------------------ 4010| 839|YY_RULE_SETUP ------------------ | | 3169| 839| YY_USER_ACTION | | ------------------ | | | | 66| 839| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 839| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 839| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 839| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 839| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 839| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.87k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.87k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.03k, False: 839] | | | | ------------------ | | | | 69| 5.03k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 5.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.03k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 5.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.03k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.03k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.03k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.03k| } else { \ | | | | 75| 5.03k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 5.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.03k| } \ | | | | 77| 5.03k| } | | ------------------ ------------------ 4011| 839|#line 209 "flex_lexer.l" 4012| 839|TOKEN(VALUES) ------------------ | | 2909| 839|#define TOKEN(name) { return SQL_##name; } ------------------ 4013| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4014| 814|case 150: ------------------ | Branch (4014:1): [True: 814, False: 11.4M] ------------------ 4015| 814|YY_RULE_SETUP ------------------ | | 3169| 814| YY_USER_ACTION | | ------------------ | | | | 66| 814| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 814| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 814| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 814| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 814| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 814| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6.51k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6.51k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.69k, False: 814] | | | | ------------------ | | | | 69| 5.69k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 5.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.69k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 5.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.69k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.69k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.69k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.69k| } else { \ | | | | 75| 5.69k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 5.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.69k| } \ | | | | 77| 5.69k| } | | ------------------ ------------------ 4016| 814|#line 210 "flex_lexer.l" 4017| 814|TOKEN(VARCHAR) ------------------ | | 2909| 814|#define TOKEN(name) { return SQL_##name; } ------------------ 4018| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4019| 1.89k|case 151: ------------------ | Branch (4019:1): [True: 1.89k, False: 11.4M] ------------------ 4020| 1.89k|YY_RULE_SETUP ------------------ | | 3169| 1.89k| YY_USER_ACTION | | ------------------ | | | | 66| 1.89k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.89k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 9.47k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 9.47k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7.57k, False: 1.89k] | | | | ------------------ | | | | 69| 7.57k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 7.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7.57k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 7.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.57k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7.57k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7.57k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7.57k| } else { \ | | | | 75| 7.57k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 7.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7.57k| } \ | | | | 77| 7.57k| } | | ------------------ ------------------ 4021| 1.89k|#line 211 "flex_lexer.l" 4022| 1.89k|TOKEN(VIEW) ------------------ | | 2909| 1.89k|#define TOKEN(name) { return SQL_##name; } ------------------ 4023| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4024| 0|case 152: ------------------ | Branch (4024:1): [True: 0, False: 11.4M] ------------------ 4025| 0|YY_RULE_SETUP ------------------ | | 3169| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 4026| 0|#line 212 "flex_lexer.l" 4027| 0|TOKEN(VIRTUAL) ------------------ | | 2909| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 4028| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4029| 3.63k|case 153: ------------------ | Branch (4029:1): [True: 3.63k, False: 11.4M] ------------------ 4030| 3.63k|YY_RULE_SETUP ------------------ | | 3169| 3.63k| YY_USER_ACTION | | ------------------ | | | | 66| 3.63k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3.63k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 18.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 18.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 14.5k, False: 3.63k] | | | | ------------------ | | | | 69| 14.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 14.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 14.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 14.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 14.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 14.5k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 14.5k| } else { \ | | | | 75| 14.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 14.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 14.5k| } \ | | | | 77| 14.5k| } | | ------------------ ------------------ 4031| 3.63k|#line 213 "flex_lexer.l" 4032| 3.63k|TOKEN(WHEN) ------------------ | | 2909| 3.63k|#define TOKEN(name) { return SQL_##name; } ------------------ 4033| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4034| 1.41k|case 154: ------------------ | Branch (4034:1): [True: 1.41k, False: 11.4M] ------------------ 4035| 1.41k|YY_RULE_SETUP ------------------ | | 3169| 1.41k| YY_USER_ACTION | | ------------------ | | | | 66| 1.41k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.41k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8.51k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8.51k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7.09k, False: 1.41k] | | | | ------------------ | | | | 69| 7.09k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 7.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7.09k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 7.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.09k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7.09k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7.09k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7.09k| } else { \ | | | | 75| 7.09k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 7.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7.09k| } \ | | | | 77| 7.09k| } | | ------------------ ------------------ 4036| 1.41k|#line 214 "flex_lexer.l" 4037| 1.41k|TOKEN(WHERE) ------------------ | | 2909| 1.41k|#define TOKEN(name) { return SQL_##name; } ------------------ 4038| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4039| 1.90k|case 155: ------------------ | Branch (4039:1): [True: 1.90k, False: 11.4M] ------------------ 4040| 1.90k|YY_RULE_SETUP ------------------ | | 3169| 1.90k| YY_USER_ACTION | | ------------------ | | | | 66| 1.90k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 1.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.90k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 1.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 9.50k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 9.50k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7.60k, False: 1.90k] | | | | ------------------ | | | | 69| 7.60k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 7.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7.60k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 7.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.60k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7.60k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7.60k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7.60k| } else { \ | | | | 75| 7.60k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 7.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7.60k| } \ | | | | 77| 7.60k| } | | ------------------ ------------------ 4041| 1.90k|#line 215 "flex_lexer.l" 4042| 1.90k|TOKEN(WITH) ------------------ | | 2909| 1.90k|#define TOKEN(name) { return SQL_##name; } ------------------ 4043| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4044| 532|case 156: ------------------ | Branch (4044:1): [True: 532, False: 11.4M] ------------------ 4045| 532|YY_RULE_SETUP ------------------ | | 3169| 532| YY_USER_ACTION | | ------------------ | | | | 66| 532| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 532| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 532| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 532| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 532| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 532| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.66k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.12k, False: 532] | | | | ------------------ | | | | 69| 2.12k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.12k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.12k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.12k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.12k| } else { \ | | | | 75| 2.12k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.12k| } \ | | | | 77| 2.12k| } | | ------------------ ------------------ 4046| 532|#line 216 "flex_lexer.l" 4047| 532|TOKEN(YEAR) ------------------ | | 2909| 532|#define TOKEN(name) { return SQL_##name; } ------------------ 4048| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4049| 701|case 157: ------------------ | Branch (4049:1): [True: 701, False: 11.4M] ------------------ 4050| 701|YY_RULE_SETUP ------------------ | | 3169| 701| YY_USER_ACTION | | ------------------ | | | | 66| 701| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 701| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 701| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 701| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 701| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 701| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.20k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.20k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.50k, False: 701] | | | | ------------------ | | | | 69| 3.50k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 3.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.50k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 3.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.50k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.50k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.50k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.50k| } else { \ | | | | 75| 3.50k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 3.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.50k| } \ | | | | 77| 3.50k| } | | ------------------ ------------------ 4051| 701|#line 217 "flex_lexer.l" 4052| 701|TOKEN(YEARS) ------------------ | | 2909| 701|#define TOKEN(name) { return SQL_##name; } ------------------ 4053| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4054| 0|case 158: ------------------ | Branch (4054:1): [True: 0, False: 11.4M] ------------------ 4055| |/* rule 158 can match eol */ 4056| 0|YY_RULE_SETUP ------------------ | | 3169| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 4057| 0|#line 219 "flex_lexer.l" 4058| 0|TOKEN(CHARACTER_VARYING) ------------------ | | 2909| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 4059| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4060| |/* Allow =/== see https://sqlite.org/lang_expr.html#collateop */ 4061| 2.17k|case 159: ------------------ | Branch (4061:1): [True: 2.17k, False: 11.4M] ------------------ 4062| 2.17k|YY_RULE_SETUP ------------------ | | 3169| 2.17k| YY_USER_ACTION | | ------------------ | | | | 66| 2.17k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.17k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6.51k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6.51k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.34k, False: 2.17k] | | | | ------------------ | | | | 69| 4.34k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 4.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.34k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 4.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.34k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.34k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.34k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.34k| } else { \ | | | | 75| 4.34k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 4.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.34k| } \ | | | | 77| 4.34k| } | | ------------------ ------------------ 4063| 2.17k|#line 222 "flex_lexer.l" 4064| 2.17k|TOKEN(EQUALS) ------------------ | | 2909| 2.17k|#define TOKEN(name) { return SQL_##name; } ------------------ 4065| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4066| 310|case 160: ------------------ | Branch (4066:1): [True: 310, False: 11.4M] ------------------ 4067| 310|YY_RULE_SETUP ------------------ | | 3169| 310| YY_USER_ACTION | | ------------------ | | | | 66| 310| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 310| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 310| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 310| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 310| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 310| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 930| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 930|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 620, False: 310] | | | | ------------------ | | | | 69| 620| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 620| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 620| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 620| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 620| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 620|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 620] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 620| } else { \ | | | | 75| 620| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 620| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 620| } \ | | | | 77| 620| } | | ------------------ ------------------ 4068| 310|#line 223 "flex_lexer.l" 4069| 310|TOKEN(NOTEQUALS) ------------------ | | 2909| 310|#define TOKEN(name) { return SQL_##name; } ------------------ 4070| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4071| 345|case 161: ------------------ | Branch (4071:1): [True: 345, False: 11.4M] ------------------ 4072| 345|YY_RULE_SETUP ------------------ | | 3169| 345| YY_USER_ACTION | | ------------------ | | | | 66| 345| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 345| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 345| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 345| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 345| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 345| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.03k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.03k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 690, False: 345] | | | | ------------------ | | | | 69| 690| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 690| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 690| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 690| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 690| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 690|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 690] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 690| } else { \ | | | | 75| 690| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 690| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 690| } \ | | | | 77| 690| } | | ------------------ ------------------ 4073| 345|#line 224 "flex_lexer.l" 4074| 345|TOKEN(NOTEQUALS) ------------------ | | 2909| 345|#define TOKEN(name) { return SQL_##name; } ------------------ 4075| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4076| 453|case 162: ------------------ | Branch (4076:1): [True: 453, False: 11.4M] ------------------ 4077| 453|YY_RULE_SETUP ------------------ | | 3169| 453| YY_USER_ACTION | | ------------------ | | | | 66| 453| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 453| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 453| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 453| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 453| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 453| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.35k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.35k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 906, False: 453] | | | | ------------------ | | | | 69| 906| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 906| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 906| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 906| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 906| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 906|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 906] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 906| } else { \ | | | | 75| 906| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 906| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 906| } \ | | | | 77| 906| } | | ------------------ ------------------ 4078| 453|#line 225 "flex_lexer.l" 4079| 453|TOKEN(LESSEQ) ------------------ | | 2909| 453|#define TOKEN(name) { return SQL_##name; } ------------------ 4080| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4081| 326|case 163: ------------------ | Branch (4081:1): [True: 326, False: 11.4M] ------------------ 4082| 326|YY_RULE_SETUP ------------------ | | 3169| 326| YY_USER_ACTION | | ------------------ | | | | 66| 326| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 326| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 326| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 326| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 326| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 326| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 978| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 978|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 652, False: 326] | | | | ------------------ | | | | 69| 652| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 652| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 652| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 652| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 652| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 652|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 652] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 652| } else { \ | | | | 75| 652| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 652| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 652| } \ | | | | 77| 652| } | | ------------------ ------------------ 4083| 326|#line 226 "flex_lexer.l" 4084| 326|TOKEN(GREATEREQ) ------------------ | | 2909| 326|#define TOKEN(name) { return SQL_##name; } ------------------ 4085| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4086| 456|case 164: ------------------ | Branch (4086:1): [True: 456, False: 11.4M] ------------------ 4087| 456|YY_RULE_SETUP ------------------ | | 3169| 456| YY_USER_ACTION | | ------------------ | | | | 66| 456| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 456| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 456| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 456| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 456| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 456| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.36k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.36k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 912, False: 456] | | | | ------------------ | | | | 69| 912| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 912| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 912| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 912| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 912| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 912|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 912] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 912| } else { \ | | | | 75| 912| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 912| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 912| } \ | | | | 77| 912| } | | ------------------ ------------------ 4088| 456|#line 227 "flex_lexer.l" 4089| 456|TOKEN(CONCAT) ------------------ | | 2909| 456|#define TOKEN(name) { return SQL_##name; } ------------------ 4090| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4091| 6.56M|case 165: ------------------ | Branch (4091:1): [True: 6.56M, False: 4.91M] ------------------ 4092| 6.56M|YY_RULE_SETUP ------------------ | | 3169| 6.56M| YY_USER_ACTION | | ------------------ | | | | 66| 6.56M| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 6.56M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 6.56M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 6.56M| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 6.56M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 6.56M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 13.1M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 13.1M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6.56M, False: 6.56M] | | | | ------------------ | | | | 69| 6.56M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 6.56M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6.56M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 6.56M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.56M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6.56M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6.56M] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6.56M| } else { \ | | | | 75| 6.56M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 6.56M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6.56M| } \ | | | | 77| 6.56M| } | | ------------------ ------------------ 4093| 6.56M|#line 229 "flex_lexer.l" 4094| 6.56M|{ return yytext[0]; } ------------------ | | 360| 6.56M|#define yytext yyg->yytext_r ------------------ 4095| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4096| 207|case 166: ------------------ | Branch (4096:1): [True: 207, False: 11.4M] ------------------ 4097| 207|#line 232 "flex_lexer.l" 4098| 425|case 167: ------------------ | Branch (4098:1): [True: 218, False: 11.4M] ------------------ 4099| 425|YY_RULE_SETUP ------------------ | | 3169| 425| YY_USER_ACTION | | ------------------ | | | | 66| 425| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 425| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 425| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 425| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 425| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 425| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.92k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.92k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.49k, False: 425] | | | | ------------------ | | | | 69| 2.49k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 2.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.49k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 2.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.49k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.49k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.49k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.49k| } else { \ | | | | 75| 2.49k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 2.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.49k| } \ | | | | 77| 2.49k| } | | ------------------ ------------------ 4100| 425|#line 232 "flex_lexer.l" 4101| 425|{ 4102| 425| yylval->fval = atof(yytext); ------------------ | | 2987| 425| # define yylval yyg->yylval_r ------------------ yylval->fval = atof(yytext); ------------------ | | 360| 425|#define yytext yyg->yytext_r ------------------ 4103| 425| return SQL_FLOATVAL; 4104| 207|} 4105| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4106| |/* 4107| | * Regularly, negative literals are treated as . This does not work for LLONG_MIN, as it has no 4108| | * positive equivalent. We thus match for LLONG_MIN specifically. This is not an issue for floats, where 4109| | * numeric_limits::lowest() == -numeric_limits::max(); 4110| | */ 4111| 524|case 168: ------------------ | Branch (4111:1): [True: 524, False: 11.4M] ------------------ 4112| 524|YY_RULE_SETUP ------------------ | | 3169| 524| YY_USER_ACTION | | ------------------ | | | | 66| 524| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 524| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 524| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 524| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 524| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 524| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 11.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 11.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 10.4k, False: 524] | | | | ------------------ | | | | 69| 10.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 10.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 10.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 10.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 10.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 10.4k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 10.4k| } else { \ | | | | 75| 10.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 10.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 10.4k| } \ | | | | 77| 10.4k| } | | ------------------ ------------------ 4113| 524|#line 242 "flex_lexer.l" 4114| 524|{ 4115| 524| yylval->ival = LLONG_MIN; ------------------ | | 2987| 524| # define yylval yyg->yylval_r ------------------ 4116| 524| return SQL_INTVAL; 4117| 207|} 4118| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4119| 16.7k|case 169: ------------------ | Branch (4119:1): [True: 16.7k, False: 11.4M] ------------------ 4120| 16.7k|YY_RULE_SETUP ------------------ | | 3169| 16.7k| YY_USER_ACTION | | ------------------ | | | | 66| 16.7k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 16.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 16.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 16.7k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 16.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 16.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 34.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 34.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 17.6k, False: 16.7k] | | | | ------------------ | | | | 69| 17.6k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 17.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 17.6k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 17.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 17.6k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 17.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 17.6k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 17.6k| } else { \ | | | | 75| 17.6k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 17.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 17.6k| } \ | | | | 77| 17.6k| } | | ------------------ ------------------ 4121| 16.7k|#line 247 "flex_lexer.l" 4122| 16.7k|{ 4123| 16.7k| errno = 0; 4124| 16.7k| yylval->ival = strtoll(yytext, nullptr, 0); ------------------ | | 2987| 16.7k| # define yylval yyg->yylval_r ------------------ yylval->ival = strtoll(yytext, nullptr, 0); ------------------ | | 360| 16.7k|#define yytext yyg->yytext_r ------------------ 4125| 16.7k| if (errno) { 4126| 5| return fprintf(stderr, "[SQL-Lexer-Error] Integer cannot be parsed - is it out of range?"); 4127| 0| return 0; 4128| 5| } 4129| 16.7k| return SQL_INTVAL; 4130| 16.7k|} 4131| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4132| 2.11k|case 170: ------------------ | Branch (4132:1): [True: 2.11k, False: 11.4M] ------------------ 4133| 2.11k|YY_RULE_SETUP ------------------ | | 3169| 2.11k| YY_USER_ACTION | | ------------------ | | | | 66| 2.11k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 2.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.11k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 2.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 10.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 10.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8.38k, False: 2.11k] | | | | ------------------ | | | | 69| 8.38k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 8.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8.38k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 8.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.38k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8.38k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8.38k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8.38k| } else { \ | | | | 75| 8.38k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 8.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8.38k| } \ | | | | 77| 8.38k| } | | ------------------ ------------------ 4134| 2.11k|#line 257 "flex_lexer.l" 4135| 2.11k|{ 4136| | // Crop the leading and trailing quote char 4137| 2.11k| yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 2987| 2.11k| # define yylval yyg->yylval_r ------------------ yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 360| 2.11k|#define yytext yyg->yytext_r ------------------ yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 360| 2.11k|#define yytext yyg->yytext_r ------------------ 4138| 2.11k| return SQL_IDENTIFIER; 4139| 16.7k|} 4140| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4141| 3.18M|case 171: ------------------ | Branch (4141:1): [True: 3.18M, False: 8.29M] ------------------ 4142| 3.18M|YY_RULE_SETUP ------------------ | | 3169| 3.18M| YY_USER_ACTION | | ------------------ | | | | 66| 3.18M| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.18M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 3.18M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3.18M| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.18M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 3.18M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 9.28M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 9.28M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6.09M, False: 3.18M] | | | | ------------------ | | | | 69| 6.09M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 6.09M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6.09M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 6.09M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.09M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6.09M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6.09M] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6.09M| } else { \ | | | | 75| 6.09M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 6.09M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6.09M| } \ | | | | 77| 6.09M| } | | ------------------ ------------------ 4143| 3.18M|#line 263 "flex_lexer.l" 4144| 3.18M|{ 4145| 3.18M| yylval->sval = strdup(yytext); ------------------ | | 2987| 3.18M| # define yylval yyg->yylval_r ------------------ yylval->sval = strdup(yytext); ------------------ | | 360| 3.18M|#define yytext yyg->yytext_r ------------------ 4146| 3.18M| return SQL_IDENTIFIER; 4147| 16.7k|} 4148| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4149| 8.21k|case 172: ------------------ | Branch (4149:1): [True: 8.21k, False: 11.4M] ------------------ 4150| 8.21k|YY_RULE_SETUP ------------------ | | 3169| 8.21k| YY_USER_ACTION | | ------------------ | | | | 66| 8.21k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 8.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 8.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 8.21k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 8.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 8.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 16.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 16.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8.21k, False: 8.21k] | | | | ------------------ | | | | 69| 8.21k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 8.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8.21k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 8.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.21k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8.21k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8.21k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8.21k| } else { \ | | | | 75| 8.21k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 8.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8.21k| } \ | | | | 77| 8.21k| } | | ------------------ ------------------ 4151| 8.21k|#line 268 "flex_lexer.l" 4152| 8.21k|{ BEGIN singlequotedstring; strbuf.clear(); strbuf.str(""); } // Clear strbuf manually, see #170 ------------------ | | 369| 8.21k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN singlequotedstring; strbuf.clear(); strbuf.str(""); } // Clear strbuf manually, see #170 ------------------ | | 2930| 8.21k|#define singlequotedstring 1 ------------------ 4153| 8.21k| YY_BREAK ------------------ | | 3165| 8.21k|#define YY_BREAK /*LINTED*/break; ------------------ 4154| 681|case 173: ------------------ | Branch (4154:1): [True: 681, False: 11.4M] ------------------ 4155| 681|YY_RULE_SETUP ------------------ | | 3169| 681| YY_USER_ACTION | | ------------------ | | | | 66| 681| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 681| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 681| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 681| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 681| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 681| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.04k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.04k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 1.36k, False: 681] | | | | ------------------ | | | | 69| 1.36k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 1.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 1.36k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 1.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.36k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 1.36k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 1.36k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 1.36k| } else { \ | | | | 75| 1.36k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 1.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 1.36k| } \ | | | | 77| 1.36k| } | | ------------------ ------------------ 4156| 681|#line 269 "flex_lexer.l" 4157| 681|{ strbuf << '\''; } 4158| 681| YY_BREAK ------------------ | | 3165| 681|#define YY_BREAK /*LINTED*/break; ------------------ 4159| 5.64k|case 174: ------------------ | Branch (4159:1): [True: 5.64k, False: 11.4M] ------------------ 4160| |/* rule 174 can match eol */ 4161| 5.64k|YY_RULE_SETUP ------------------ | | 3169| 5.64k| YY_USER_ACTION | | ------------------ | | | | 66| 5.64k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 5.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 5.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 5.64k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 5.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 5.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 11.7M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 11.7M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 11.7M, False: 5.64k] | | | | ------------------ | | | | 69| 11.7M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 11.7M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 11.7M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 11.7M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 11.7M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 11.7M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 2.72k, False: 11.7M] | | | | ------------------ | | | | 72| 2.72k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 2.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 2.72k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 2.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 11.7M| } else { \ | | | | 75| 11.7M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 11.7M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 11.7M| } \ | | | | 77| 11.7M| } | | ------------------ ------------------ 4162| 5.64k|#line 270 "flex_lexer.l" 4163| 5.64k|{ strbuf << yytext; } ------------------ | | 360| 5.64k|#define yytext yyg->yytext_r ------------------ 4164| 5.64k| YY_BREAK ------------------ | | 3165| 5.64k|#define YY_BREAK /*LINTED*/break; ------------------ 4165| 8.08k|case 175: ------------------ | Branch (4165:1): [True: 8.08k, False: 11.4M] ------------------ 4166| 8.08k|YY_RULE_SETUP ------------------ | | 3169| 8.08k| YY_USER_ACTION | | ------------------ | | | | 66| 8.08k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 8.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 8.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 8.08k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 8.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 8.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 16.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 16.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8.08k, False: 8.08k] | | | | ------------------ | | | | 69| 8.08k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 8.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8.08k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 8.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.08k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8.08k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8.08k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8.08k| } else { \ | | | | 75| 8.08k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 8.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8.08k| } \ | | | | 77| 8.08k| } | | ------------------ ------------------ 4167| 8.08k|#line 271 "flex_lexer.l" 4168| 8.08k|{ BEGIN 0; yylval->sval = strdup(strbuf.str().c_str()); return SQL_STRING; } ------------------ | | 369| 8.08k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN 0; yylval->sval = strdup(strbuf.str().c_str()); return SQL_STRING; } ------------------ | | 2987| 8.08k| # define yylval yyg->yylval_r ------------------ 4169| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4170| 130|case YY_STATE_EOF(singlequotedstring): ------------------ | | 377| 130|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 130|#define YY_END_OF_BUFFER 178 | | ------------------ ------------------ | Branch (4170:1): [True: 130, False: 11.4M] ------------------ 4171| 130|#line 272 "flex_lexer.l" 4172| 130|{ fprintf(stderr, "[SQL-Lexer-Error] Unterminated string\n"); return 0; } 4173| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4174| 127|case 176: ------------------ | Branch (4174:1): [True: 127, False: 11.4M] ------------------ 4175| 127|YY_RULE_SETUP ------------------ | | 3169| 127| YY_USER_ACTION | | ------------------ | | | | 66| 127| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 127| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 127| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 127| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 127| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 127| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 254| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 254|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 127, False: 127] | | | | ------------------ | | | | 69| 127| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 127| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 127| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 127| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 127| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 127|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 127] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 127| } else { \ | | | | 75| 127| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 127| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 127| } \ | | | | 77| 127| } | | ------------------ ------------------ 4176| 127|#line 274 "flex_lexer.l" 4177| 127|{ fprintf(stderr, "[SQL-Lexer-Error] Unknown Character: %c\n", yytext[0]); return 0; } ------------------ | | 360| 127|#define yytext yyg->yytext_r ------------------ 4178| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4179| 0|case 177: ------------------ | Branch (4179:1): [True: 0, False: 11.4M] ------------------ 4180| 0|YY_RULE_SETUP ------------------ | | 3169| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2989| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 4181| 0|#line 276 "flex_lexer.l" 4182| 0|ECHO; ------------------ | | 3084| 0|#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 360| 0|#define yytext yyg->yytext_r | | ------------------ | | #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 359| 0|#define yyleng yyg->yyleng_r | | ------------------ | | #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 357| 0|#define yyout yyg->yyout_r | | ------------------ | | | Branch (3084:23): [True: 0, False: 0] | | | Branch (3084:80): [Folded - Ignored] | | ------------------ ------------------ 4183| 0| YY_BREAK ------------------ | | 3165| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4184| 0|#line 4184 "flex_lexer.cpp" 4185| 3.34k|case YY_STATE_EOF(INITIAL): ------------------ | | 377| 3.34k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 3.34k|#define YY_END_OF_BUFFER 178 | | ------------------ ------------------ | Branch (4185:1): [True: 3.34k, False: 11.4M] ------------------ 4186| 3.40k|case YY_STATE_EOF(COMMENT): ------------------ | | 377| 3.40k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 3.40k|#define YY_END_OF_BUFFER 178 | | ------------------ ------------------ | Branch (4186:1): [True: 65, False: 11.4M] ------------------ 4187| 3.40k| yyterminate(); ------------------ | | 3128| 3.40k|#define yyterminate() return YY_NULL | | ------------------ | | | | 341| 3.40k|#define YY_NULL 0 | | ------------------ ------------------ 4188| | 4189| 8.66k| case YY_END_OF_BUFFER: ------------------ | | 577| 8.66k|#define YY_END_OF_BUFFER 178 ------------------ | Branch (4189:2): [True: 8.66k, False: 11.4M] ------------------ 4190| 8.66k| { 4191| | /* Amount of text matched not including the EOB char. */ 4192| 8.66k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 560| 8.66k|#define yytext_ptr yytext_r ------------------ 4193| | 4194| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 4195| 8.66k| *yy_cp = yyg->yy_hold_char; 4196| 8.66k| YY_RESTORE_YY_MORE_OFFSET 4197| | 4198| 8.66k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 508| 8.66k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 479| 8.66k|#define YY_BUFFER_NEW 0 ------------------ | Branch (4198:8): [True: 5.12k, False: 3.54k] ------------------ 4199| 5.12k| { 4200| | /* We're scanning a new file or input source. It's 4201| | * possible that this happened because the user 4202| | * just pointed yyin at a new source and called 4203| | * yylex(). If so, then we have to assure 4204| | * consistency between YY_CURRENT_BUFFER and our 4205| | * globals. Here is the right place to do so, because 4206| | * this is the first action (other than possibly a 4207| | * back-up) that will match for the new input source. 4208| | */ 4209| 5.12k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 508| 5.12k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4210| 5.12k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 508| 5.12k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 356| 5.12k|#define yyin yyg->yyin_r ------------------ 4211| 5.12k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 508| 5.12k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 480| 5.12k|#define YY_BUFFER_NORMAL 1 ------------------ 4212| 5.12k| } 4213| | 4214| | /* Note that here we test for yy_c_buf_p "<=" to the position 4215| | * of the first EOB in the buffer, since yy_c_buf_p will 4216| | * already have been incremented past the NUL character 4217| | * (since all states make transitions on EOB to the 4218| | * end-of-buffer state). Contrast this with the test 4219| | * in input(). 4220| | */ 4221| 8.66k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 508| 8.66k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4221:8): [True: 0, False: 8.66k] ------------------ 4222| 0| { /* This was really a NUL. */ 4223| 0| yy_state_type yy_next_state; 4224| | 4225| 0| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ 4226| | 4227| 0| yy_current_state = yy_get_previous_state( yyscanner ); 4228| | 4229| | /* Okay, we're now positioned to make the NUL 4230| | * transition. We couldn't have 4231| | * yy_get_previous_state() go ahead and do it 4232| | * for us because it doesn't know how to deal 4233| | * with the possibility of jamming (and we don't 4234| | * want to build jamming into it because then it 4235| | * will run more slowly). 4236| | */ 4237| | 4238| 0| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); 4239| | 4240| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 2890| 0|#define YY_MORE_ADJ 0 ------------------ 4241| | 4242| 0| if ( yy_next_state ) ------------------ | Branch (4242:9): [True: 0, False: 0] ------------------ 4243| 0| { 4244| | /* Consume the NUL. */ 4245| 0| yy_cp = ++yyg->yy_c_buf_p; 4246| 0| yy_current_state = yy_next_state; 4247| 0| goto yy_match; 4248| 0| } 4249| | 4250| 0| else 4251| 0| { 4252| 0| yy_cp = yyg->yy_last_accepting_cpos; 4253| 0| yy_current_state = yyg->yy_last_accepting_state; 4254| 0| goto yy_find_action; 4255| 0| } 4256| 0| } 4257| | 4258| 8.66k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (4258:17): [True: 0, False: 8.66k] ------------------ 4259| 8.66k| { 4260| 3.53k| case EOB_ACT_END_OF_FILE: ------------------ | | 410| 3.53k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (4260:4): [True: 3.53k, False: 5.12k] ------------------ 4261| 3.53k| { 4262| 3.53k| yyg->yy_did_buffer_switch_on_eof = 0; 4263| | 4264| 3.53k| if ( yywrap( yyscanner ) ) ------------------ | | 206| 3.53k|#define yywrap hsql_wrap | | ------------------ | | | | 554| 3.53k|#define hsql_wrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (554:30): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 4265| 3.53k| { 4266| | /* Note: because we've taken care in 4267| | * yy_get_next_buffer() to have set up 4268| | * yytext, we can now set up 4269| | * yy_c_buf_p so that if some total 4270| | * hoser (like flex itself) wants to 4271| | * call the scanner after we return the 4272| | * YY_NULL, it'll still work - another 4273| | * YY_NULL will get returned. 4274| | */ 4275| 3.53k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 560| 3.53k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 2890| 3.53k|#define YY_MORE_ADJ 0 ------------------ 4276| | 4277| 3.53k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 377| 3.53k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 3.53k|#define YY_END_OF_BUFFER 178 | | ------------------ ------------------ 4278| 3.53k| goto do_action; 4279| 3.53k| } 4280| | 4281| 0| else 4282| 0| { 4283| 0| if ( ! yyg->yy_did_buffer_switch_on_eof ) ------------------ | Branch (4283:11): [True: 0, False: 0] ------------------ 4284| 0| YY_NEW_FILE; ------------------ | | 379| 0|#define YY_NEW_FILE yyrestart( yyin , yyscanner ) | | ------------------ | | | | 98| 0|#define yyrestart hsql_restart | | ------------------ | | #define YY_NEW_FILE yyrestart( yyin , yyscanner ) | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ ------------------ 4285| 0| } 4286| 0| break; 4287| 3.53k| } 4288| | 4289| 0| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 409| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (4289:4): [True: 0, False: 8.66k] ------------------ 4290| 0| yyg->yy_c_buf_p = 4291| 0| yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ 4292| | 4293| 0| yy_current_state = yy_get_previous_state( yyscanner ); 4294| | 4295| 0| yy_cp = yyg->yy_c_buf_p; 4296| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 2890| 0|#define YY_MORE_ADJ 0 ------------------ 4297| 0| goto yy_match; 4298| | 4299| 5.12k| case EOB_ACT_LAST_MATCH: ------------------ | | 411| 5.12k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (4299:4): [True: 5.12k, False: 3.53k] ------------------ 4300| 5.12k| yyg->yy_c_buf_p = 4301| 5.12k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 508| 5.12k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4302| | 4303| 5.12k| yy_current_state = yy_get_previous_state( yyscanner ); 4304| | 4305| 5.12k| yy_cp = yyg->yy_c_buf_p; 4306| 5.12k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 560| 5.12k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 2890| 5.12k|#define YY_MORE_ADJ 0 ------------------ 4307| 5.12k| goto yy_find_action; 4308| 8.66k| } 4309| 0| break; 4310| 8.66k| } 4311| | 4312| 0| default: ------------------ | Branch (4312:2): [True: 0, False: 11.4M] ------------------ 4313| 0| YY_FATAL_ERROR( ------------------ | | 3138| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4314| 11.4M| "fatal flex scanner internal error--no action found" ); 4315| 11.4M| } /* end of action switch */ 4316| 11.4M| } /* end of scanning one token */ 4317| 10.8M| } /* end of user's declarations */ 4318| 10.8M|} /* end of yylex */ _Z22hsql__switch_to_bufferP15yy_buffer_statePv: 4627| 5.59k|{ 4628| 5.59k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4629| | 4630| | /* TODO. We should be able to replace this entire function body 4631| | * with 4632| | * yypop_buffer_state(); 4633| | * yypush_buffer_state(new_buffer); 4634| | */ 4635| 5.59k| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 5.59k|#define yyensure_buffer_stack hsql_ensure_buffer_stack ------------------ 4636| 5.59k| if ( YY_CURRENT_BUFFER == new_buffer ) ------------------ | | 502| 5.59k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:29): [True: 5.59k, False: 0] | | ------------------ | | 503| 5.59k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 5.59k| : NULL) ------------------ | Branch (4636:7): [True: 0, False: 5.59k] ------------------ 4637| 0| return; 4638| | 4639| 5.59k| if ( YY_CURRENT_BUFFER ) ------------------ | | 502| 5.59k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:27): [True: 0, False: 5.59k] | | | Branch (502:29): [True: 5.59k, False: 0] | | ------------------ | | 503| 5.59k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 5.59k| : NULL) ------------------ 4640| 0| { 4641| | /* Flush out information for old buffer. */ 4642| 0| *yyg->yy_c_buf_p = yyg->yy_hold_char; 4643| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4644| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4645| 0| } 4646| | 4647| 5.59k| YY_CURRENT_BUFFER_LVALUE = new_buffer; ------------------ | | 508| 5.59k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4648| 5.59k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 5.59k|#define yy_load_buffer_state hsql__load_buffer_state ------------------ 4649| | 4650| | /* We don't actually know whether we did this switch during 4651| | * EOF (yywrap()) processing, but the only time this flag 4652| | * is looked at is after yywrap() is called, so it's safe 4653| | * to go ahead and always set it. 4654| | */ 4655| 5.59k| yyg->yy_did_buffer_switch_on_eof = 1; 4656| 5.59k|} _Z19hsql__delete_bufferP15yy_buffer_statePv: 4702| 5.59k|{ 4703| 5.59k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4704| | 4705| 5.59k| if ( ! b ) ------------------ | Branch (4705:7): [True: 0, False: 5.59k] ------------------ 4706| 0| return; 4707| | 4708| 5.59k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 502| 5.59k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:29): [True: 5.59k, False: 0] | | ------------------ | | 503| 5.59k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 5.59k| : NULL) ------------------ | Branch (4708:7): [True: 5.59k, False: 0] ------------------ 4709| 5.59k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 508| 5.59k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4710| | 4711| 5.59k| if ( b->yy_is_our_buffer ) ------------------ | Branch (4711:7): [True: 5.59k, False: 0] ------------------ 4712| 5.59k| yyfree( (void *) b->yy_ch_buf , yyscanner ); ------------------ | | 248| 5.59k|#define yyfree hsql_free ------------------ 4713| | 4714| 5.59k| yyfree( (void *) b , yyscanner ); ------------------ | | 248| 5.59k|#define yyfree hsql_free ------------------ 4715| 5.59k|} _Z17hsql__scan_bufferPcmPv: 4882| 5.59k|{ 4883| 5.59k| YY_BUFFER_STATE b; 4884| | 4885| 5.59k| if ( size < 2 || ------------------ | Branch (4885:7): [True: 0, False: 5.59k] ------------------ 4886| 5.59k| base[size-2] != YY_END_OF_BUFFER_CHAR || ------------------ | | 380| 11.1k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (4886:7): [True: 0, False: 5.59k] ------------------ 4887| 5.59k| base[size-1] != YY_END_OF_BUFFER_CHAR ) ------------------ | | 380| 5.59k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (4887:7): [True: 0, False: 5.59k] ------------------ 4888| | /* They forgot to leave room for the EOB's. */ 4889| 0| return NULL; 4890| | 4891| 5.59k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); ------------------ | | 236| 5.59k|#define yyalloc hsql_alloc ------------------ 4892| 5.59k| if ( ! b ) ------------------ | Branch (4892:7): [True: 0, False: 5.59k] ------------------ 4893| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); ------------------ | | 3138| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4894| | 4895| 5.59k| b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ 4896| 5.59k| b->yy_buf_pos = b->yy_ch_buf = base; 4897| 5.59k| b->yy_is_our_buffer = 0; 4898| 5.59k| b->yy_input_file = NULL; 4899| 5.59k| b->yy_n_chars = b->yy_buf_size; 4900| 5.59k| b->yy_is_interactive = 0; 4901| 5.59k| b->yy_at_bol = 1; 4902| 5.59k| b->yy_fill_buffer = 0; 4903| 5.59k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 479| 5.59k|#define YY_BUFFER_NEW 0 ------------------ 4904| | 4905| 5.59k| yy_switch_to_buffer( b , yyscanner ); ------------------ | | 68| 5.59k|#define yy_switch_to_buffer hsql__switch_to_buffer ------------------ 4906| | 4907| 5.59k| return b; 4908| 5.59k|} _Z17hsql__scan_stringPKcPv: 4919| 5.59k|{ 4920| | 4921| 5.59k| return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner); ------------------ | | 44| 5.59k|#define yy_scan_bytes hsql__scan_bytes ------------------ 4922| 5.59k|} _Z16hsql__scan_bytesPKciPv: 4932| 5.59k|{ 4933| 5.59k| YY_BUFFER_STATE b; 4934| 5.59k| char *buf; 4935| 5.59k| yy_size_t n; 4936| 5.59k| int i; 4937| | 4938| | /* Get memory for full buffer, including space for trailing EOB's. */ 4939| 5.59k| n = (yy_size_t) (_yybytes_len + 2); 4940| 5.59k| buf = (char *) yyalloc( n , yyscanner ); ------------------ | | 236| 5.59k|#define yyalloc hsql_alloc ------------------ 4941| 5.59k| if ( ! buf ) ------------------ | Branch (4941:7): [True: 0, False: 5.59k] ------------------ 4942| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); ------------------ | | 3138| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4943| | 4944| 34.4M| for ( i = 0; i < _yybytes_len; ++i ) ------------------ | Branch (4944:15): [True: 34.4M, False: 5.59k] ------------------ 4945| 34.4M| buf[i] = yybytes[i]; 4946| | 4947| 5.59k| buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 5.59k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 4948| | 4949| 5.59k| b = yy_scan_buffer( buf, n , yyscanner); ------------------ | | 32| 5.59k|#define yy_scan_buffer hsql__scan_buffer ------------------ 4950| 5.59k| if ( ! b ) ------------------ | Branch (4950:7): [True: 0, False: 5.59k] ------------------ 4951| 0| YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); ------------------ | | 3138| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4952| | 4953| | /* It's okay to grow etc. this buffer, and we should throw it 4954| | * away when we're done. 4955| | */ 4956| 5.59k| b->yy_is_our_buffer = 1; 4957| | 4958| 5.59k| return b; 4959| 5.59k|} _Z13hsql_lex_initPPv: 5167| 5.59k|{ 5168| 5.59k| if (ptr_yy_globals == NULL){ ------------------ | Branch (5168:9): [True: 0, False: 5.59k] ------------------ 5169| 0| errno = EINVAL; 5170| 0| return 1; 5171| 0| } 5172| | 5173| 5.59k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL ); ------------------ | | 236| 5.59k|#define yyalloc hsql_alloc ------------------ 5174| | 5175| 5.59k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (5175:9): [True: 0, False: 5.59k] ------------------ 5176| 0| errno = ENOMEM; 5177| 0| return 1; 5178| 0| } 5179| | 5180| | /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ 5181| 5.59k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 5182| | 5183| 5.59k| return yy_init_globals ( *ptr_yy_globals ); 5184| 5.59k|} _Z16hsql_lex_destroyPv: 5255| 5.59k|{ 5256| 5.59k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5257| | 5258| | /* Pop the buffer stack, destroying each element. */ 5259| 5.59k| while(YY_CURRENT_BUFFER){ ------------------ | | 502| 5.59k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:27): [True: 0, False: 5.59k] | | | Branch (502:29): [True: 5.59k, False: 0] | | ------------------ | | 503| 5.59k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 5.59k| : NULL) ------------------ 5260| 0| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 26| 0|#define yy_delete_buffer hsql__delete_buffer ------------------ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 502| 0|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:29): [True: 0, False: 0] | | ------------------ | | 503| 0| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 0| : NULL) ------------------ 5261| 0| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 5262| 0| yypop_buffer_state(yyscanner); ------------------ | | 80| 0|#define yypop_buffer_state hsql_pop_buffer_state ------------------ 5263| 0| } 5264| | 5265| | /* Destroy the stack itself. */ 5266| 5.59k| yyfree(yyg->yy_buffer_stack , yyscanner); ------------------ | | 248| 5.59k|#define yyfree hsql_free ------------------ 5267| 5.59k| yyg->yy_buffer_stack = NULL; 5268| | 5269| | /* Destroy the start condition stack. */ 5270| 5.59k| yyfree( yyg->yy_start_stack , yyscanner ); ------------------ | | 248| 5.59k|#define yyfree hsql_free ------------------ 5271| 5.59k| yyg->yy_start_stack = NULL; 5272| | 5273| | /* Reset the globals. This is important in a non-reentrant scanner so the next time 5274| | * yylex() is called, initialization will occur. */ 5275| 5.59k| yy_init_globals( yyscanner); 5276| | 5277| | /* Destroy the main struct (reentrant only). */ 5278| 5.59k| yyfree ( yyscanner , yyscanner ); ------------------ | | 248| 5.59k|#define yyfree hsql_free ------------------ 5279| 5.59k| yyscanner = NULL; 5280| 5.59k| return 0; 5281| 5.59k|} _Z10hsql_allocmPv: 5311| 22.3k|{ 5312| 22.3k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5313| 22.3k| (void)yyg; 5314| 22.3k| return malloc(size); 5315| 22.3k|} _Z9hsql_freePvS_: 5333| 27.9k|{ 5334| 27.9k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5335| 27.9k| (void)yyg; 5336| 27.9k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 5337| 27.9k|} flex_lexer.cpp:_ZL18yy_get_next_bufferPv: 4328| 8.66k|{ 4329| 8.66k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4330| 8.66k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 508| 8.66k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4331| 8.66k| char *source = yyg->yytext_ptr; ------------------ | | 560| 8.66k|#define yytext_ptr yytext_r ------------------ 4332| 8.66k| int number_to_move, i; 4333| 8.66k| int ret_val; 4334| | 4335| 8.66k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 508| 8.66k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4335:7): [True: 0, False: 8.66k] ------------------ 4336| 0| YY_FATAL_ERROR( ------------------ | | 3138| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4337| 8.66k| "fatal flex scanner internal error--end of buffer missed" ); 4338| | 4339| 8.66k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 508| 8.66k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4339:7): [True: 8.66k, False: 0] ------------------ 4340| 8.66k| { /* Don't try to fill the buffer, so this is an EOF. */ 4341| 8.66k| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 560| 8.66k|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 2890| 8.66k|#define YY_MORE_ADJ 0 ------------------ | Branch (4341:8): [True: 3.53k, False: 5.12k] ------------------ 4342| 3.53k| { 4343| | /* We matched a single character, the EOB, so 4344| | * treat this as a final EOF. 4345| | */ 4346| 3.53k| return EOB_ACT_END_OF_FILE; ------------------ | | 410| 3.53k|#define EOB_ACT_END_OF_FILE 1 ------------------ 4347| 3.53k| } 4348| | 4349| 5.12k| else 4350| 5.12k| { 4351| | /* We matched some text prior to the EOB, first 4352| | * process it. 4353| | */ 4354| 5.12k| return EOB_ACT_LAST_MATCH; ------------------ | | 411| 5.12k|#define EOB_ACT_LAST_MATCH 2 ------------------ 4355| 5.12k| } 4356| 8.66k| } 4357| | 4358| | /* Try to read more data. */ 4359| | 4360| | /* First move last chars to start of buffer. */ 4361| 0| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ 4362| | 4363| 0| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (4363:15): [True: 0, False: 0] ------------------ 4364| 0| *(dest++) = *(source++); 4365| | 4366| 0| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 491| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (4366:7): [True: 0, False: 0] ------------------ 4367| | /* don't do the read, it's not guaranteed to return an EOF, 4368| | * just force an EOF 4369| | */ 4370| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4371| | 4372| 0| else 4373| 0| { 4374| 0| int num_to_read = 4375| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4376| | 4377| 0| while ( num_to_read <= 0 ) ------------------ | Branch (4377:11): [True: 0, False: 0] ------------------ 4378| 0| { /* Not enough room in the buffer - grow it. */ 4379| | 4380| | /* just a shorter name for the current buffer */ 4381| 0| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4382| | 4383| 0| int yy_c_buf_p_offset = 4384| 0| (int) (yyg->yy_c_buf_p - b->yy_ch_buf); 4385| | 4386| 0| if ( b->yy_is_our_buffer ) ------------------ | Branch (4386:9): [True: 0, False: 0] ------------------ 4387| 0| { 4388| 0| int new_size = b->yy_buf_size * 2; 4389| | 4390| 0| if ( new_size <= 0 ) ------------------ | Branch (4390:10): [True: 0, False: 0] ------------------ 4391| 0| b->yy_buf_size += b->yy_buf_size / 8; 4392| 0| else 4393| 0| b->yy_buf_size *= 2; 4394| | 4395| 0| b->yy_ch_buf = (char *) 4396| | /* Include room in for 2 EOB chars. */ 4397| 0| yyrealloc( (void *) b->yy_ch_buf, ------------------ | | 242| 0|#define yyrealloc hsql_realloc ------------------ 4398| 0| (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); 4399| 0| } 4400| 0| else 4401| | /* Can't grow it, we don't own it. */ 4402| 0| b->yy_ch_buf = NULL; 4403| | 4404| 0| if ( ! b->yy_ch_buf ) ------------------ | Branch (4404:9): [True: 0, False: 0] ------------------ 4405| 0| YY_FATAL_ERROR( ------------------ | | 3138| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4406| 0| "fatal error - scanner input buffer overflow" ); 4407| | 4408| 0| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 4409| | 4410| 0| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4411| 0| number_to_move - 1; 4412| | 4413| 0| } 4414| | 4415| 0| if ( num_to_read > YY_READ_BUF_SIZE ) ------------------ | | 3075| 0|#define YY_READ_BUF_SIZE 8192 ------------------ | Branch (4415:8): [True: 0, False: 0] ------------------ 4416| 0| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 3075| 0|#define YY_READ_BUF_SIZE 8192 ------------------ 4417| | 4418| | /* Read in more data. */ 4419| 0| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ------------------ | | 3092| 0| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ | | ------------------ | | | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ | | | Branch (3092:7): [True: 0, False: 0] | | ------------------ | | 3093| 0| { \ | | 3094| 0| int c = '*'; \ | | 3095| 0| int n; \ | | 3096| 0| for ( n = 0; n < max_size && \ | | ------------------ | | | Branch (3096:16): [True: 0, False: 0] | | ------------------ | | 3097| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (3097:9): [True: 0, False: 0] | | | Branch (3097:38): [True: 0, False: 0] | | ------------------ | | 3098| 0| buf[n] = (char) c; \ | | 3099| 0| if ( c == '\n' ) \ | | ------------------ | | | Branch (3099:8): [True: 0, False: 0] | | ------------------ | | 3100| 0| buf[n++] = (char) c; \ | | 3101| 0| if ( c == EOF && ferror( yyin ) ) \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (3101:8): [True: 0, False: 0] | | | Branch (3101:20): [True: 0, False: 0] | | ------------------ | | 3102| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 3138| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) | | ------------------ | | 3103| 0| result = n; \ | | 3104| 0| } \ | | 3105| 0| else \ | | 3106| 0| { \ | | 3107| 0| errno=0; \ | | 3108| 0| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (3108:11): [True: 0, False: 0] | | | Branch (3108:78): [True: 0, False: 0] | | ------------------ | | 3109| 0| { \ | | 3110| 0| if( errno != EINTR) \ | | ------------------ | | | Branch (3110:8): [True: 0, False: 0] | | ------------------ | | 3111| 0| { \ | | 3112| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 3138| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) | | ------------------ | | 3113| 0| break; \ | | 3114| 0| } \ | | 3115| 0| errno=0; \ | | 3116| 0| clearerr(yyin); \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | 3117| 0| } \ | | 3118| 0| }\ ------------------ 4420| 0| yyg->yy_n_chars, num_to_read ); 4421| | 4422| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4423| 0| } 4424| | 4425| 0| if ( yyg->yy_n_chars == 0 ) ------------------ | Branch (4425:7): [True: 0, False: 0] ------------------ 4426| 0| { 4427| 0| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 2890| 0|#define YY_MORE_ADJ 0 ------------------ | Branch (4427:8): [True: 0, False: 0] ------------------ 4428| 0| { 4429| 0| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 410| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 4430| 0| yyrestart( yyin , yyscanner); ------------------ | | 98| 0|#define yyrestart hsql_restart ------------------ yyrestart( yyin , yyscanner); ------------------ | | 356| 0|#define yyin yyg->yyin_r ------------------ 4431| 0| } 4432| | 4433| 0| else 4434| 0| { 4435| 0| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 411| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 4436| 0| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4437| 0| YY_BUFFER_EOF_PENDING; ------------------ | | 491| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ 4438| 0| } 4439| 0| } 4440| | 4441| 0| else 4442| 0| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 409| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 4443| | 4444| 0| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4444:6): [True: 0, False: 0] ------------------ 4445| | /* Extend the array by 50%, plus the number we really need. */ 4446| 0| int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); 4447| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 242| 0|#define yyrealloc hsql_realloc ------------------ 4448| 0| (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner ); ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4449| 0| if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4449:8): [True: 0, False: 0] ------------------ 4450| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ------------------ | | 3138| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4451| | /* "- 2" to take care of EOB's */ 4452| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4453| 0| } 4454| | 4455| 0| yyg->yy_n_chars += number_to_move; 4456| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 0|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 4457| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 0|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 4458| | 4459| 0| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4460| | 4461| 0| return ret_val; 4462| 0|} flex_lexer.cpp:_ZL21yy_get_previous_statePv: 4467| 5.12k|{ 4468| 5.12k| yy_state_type yy_current_state; 4469| 5.12k| char *yy_cp; 4470| 5.12k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4471| | 4472| 5.12k| yy_current_state = yyg->yy_start; 4473| | 4474| 5.36M| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 560| 5.12k|#define yytext_ptr yytext_r ------------------ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 2890| 5.12k|#define YY_MORE_ADJ 0 ------------------ | Branch (4474:47): [True: 5.36M, False: 5.12k] ------------------ 4475| 5.36M| { 4476| 5.36M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 346| 5.36M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (4476:19): [True: 5.36M, False: 0] ------------------ 4477| 5.36M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (4477:8): [True: 5.29M, False: 66.9k] ------------------ 4478| 5.29M| { 4479| 5.29M| yyg->yy_last_accepting_state = yy_current_state; 4480| 5.29M| yyg->yy_last_accepting_cpos = yy_cp; 4481| 5.29M| } 4482| 10.7M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (4482:11): [True: 5.34M, False: 5.36M] ------------------ 4483| 5.34M| { 4484| 5.34M| yy_current_state = (int) yy_def[yy_current_state]; 4485| 5.34M| if ( yy_current_state >= 1240 ) ------------------ | Branch (4485:9): [True: 5.34M, False: 471] ------------------ 4486| 5.34M| yy_c = yy_meta[yy_c]; 4487| 5.34M| } 4488| 5.36M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 4489| 5.36M| } 4490| | 4491| 5.12k| return yy_current_state; 4492| 5.12k|} flex_lexer.cpp:_ZL23hsql__load_buffer_statePv: 4659| 11.1k|{ 4660| 11.1k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4661| 11.1k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 508| 11.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4662| 11.1k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 560| 11.1k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 508| 11.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4663| 11.1k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 356| 11.1k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 508| 11.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4664| 11.1k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 4665| 11.1k|} flex_lexer.cpp:_ZL24hsql_ensure_buffer_stackPv: 4832| 5.59k|{ 4833| 5.59k| yy_size_t num_to_alloc; 4834| 5.59k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4835| | 4836| 5.59k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (4836:6): [True: 5.59k, False: 0] ------------------ 4837| | 4838| | /* First allocation is just for 2 elements, since we don't know if this 4839| | * scanner will even need a stack. We use 2 instead of 1 to avoid an 4840| | * immediate realloc on the next call. 4841| | */ 4842| 5.59k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 4843| 5.59k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc ------------------ | | 236| 5.59k|#define yyalloc hsql_alloc ------------------ 4844| 5.59k| (num_to_alloc * sizeof(struct yy_buffer_state*) 4845| 5.59k| , yyscanner); 4846| 5.59k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (4846:8): [True: 0, False: 5.59k] ------------------ 4847| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 3138| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4848| | 4849| 5.59k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 4850| | 4851| 5.59k| yyg->yy_buffer_stack_max = num_to_alloc; 4852| 5.59k| yyg->yy_buffer_stack_top = 0; 4853| 5.59k| return; 4854| 5.59k| } 4855| | 4856| 0| if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ ------------------ | Branch (4856:6): [True: 0, False: 0] ------------------ 4857| | 4858| | /* Increase the buffer to prepare for a possible push. */ 4859| 0| yy_size_t grow_size = 8 /* arbitrary grow size */; 4860| | 4861| 0| num_to_alloc = yyg->yy_buffer_stack_max + grow_size; 4862| 0| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc ------------------ | | 242| 0|#define yyrealloc hsql_realloc ------------------ 4863| 0| (yyg->yy_buffer_stack, 4864| 0| num_to_alloc * sizeof(struct yy_buffer_state*) 4865| 0| , yyscanner); 4866| 0| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (4866:8): [True: 0, False: 0] ------------------ 4867| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 3138| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4868| | 4869| | /* zero only the new slots.*/ 4870| 0| memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); 4871| 0| yyg->yy_buffer_stack_max = num_to_alloc; 4872| 0| } 4873| 0|} flex_lexer.cpp:_ZL15yy_init_globalsPv: 5221| 11.1k|{ 5222| 11.1k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5223| | /* Initialization is the same as for the non-reentrant scanner. 5224| | * This function is called from yylex_destroy(), so don't allocate here. 5225| | */ 5226| | 5227| 11.1k| yyg->yy_buffer_stack = NULL; 5228| 11.1k| yyg->yy_buffer_stack_top = 0; 5229| 11.1k| yyg->yy_buffer_stack_max = 0; 5230| 11.1k| yyg->yy_c_buf_p = NULL; 5231| 11.1k| yyg->yy_init = 0; 5232| 11.1k| yyg->yy_start = 0; 5233| | 5234| 11.1k| yyg->yy_start_stack_ptr = 0; 5235| 11.1k| yyg->yy_start_stack_depth = 0; 5236| 11.1k| yyg->yy_start_stack = NULL; 5237| | 5238| |/* Defined in main.c */ 5239| |#ifdef YY_STDINIT 5240| | yyin = stdin; 5241| | yyout = stdout; 5242| |#else 5243| 11.1k| yyin = NULL; ------------------ | | 356| 11.1k|#define yyin yyg->yyin_r ------------------ 5244| 11.1k| yyout = NULL; ------------------ | | 357| 11.1k|#define yyout yyg->yyout_r ------------------ 5245| 11.1k|#endif 5246| | 5247| | /* For future reference: Set errno on error, since we are called by 5248| | * yylex_init() 5249| | */ 5250| 11.1k| return 0; 5251| 11.1k|} _ZN4hsql15CreateStatementC2ENS_10CreateTypeE: 19| 3.28k| select(nullptr) {} _ZN4hsql15CreateStatementD2Ev: 21| 3.28k|CreateStatement::~CreateStatement() { 22| 3.28k| free(filePath); 23| 3.28k| free(schema); 24| 3.28k| free(tableName); 25| 3.28k| free(indexName); 26| 3.28k| delete select; 27| | 28| 3.28k| if (columns) { ------------------ | Branch (28:7): [True: 1.33k, False: 1.94k] ------------------ 29| 143k| for (ColumnDefinition* def : *columns) { ------------------ | Branch (29:32): [True: 143k, False: 1.33k] ------------------ 30| 143k| delete def; 31| 143k| } 32| 1.33k| delete columns; 33| 1.33k| } 34| | 35| 3.28k| if (tableConstraints) { ------------------ | Branch (35:7): [True: 1.33k, False: 1.94k] ------------------ 36| 96.6k| for (TableConstraint* def : *tableConstraints) { ------------------ | Branch (36:31): [True: 96.6k, False: 1.33k] ------------------ 37| 96.6k| delete def; 38| 96.6k| } 39| 1.33k| delete tableConstraints; 40| 1.33k| } 41| | 42| 3.28k| if (indexColumns) { ------------------ | Branch (42:7): [True: 1.42k, False: 1.85k] ------------------ 43| 4.68k| for (char* column : *indexColumns) { ------------------ | Branch (43:23): [True: 4.68k, False: 1.42k] ------------------ 44| 4.68k| free(column); 45| 4.68k| } 46| 1.42k| delete indexColumns; 47| 1.42k| } 48| | 49| 3.28k| if (viewColumns) { ------------------ | Branch (49:7): [True: 74, False: 3.20k] ------------------ 50| 268| for (char* column : *viewColumns) { ------------------ | Branch (50:23): [True: 268, False: 74] ------------------ 51| 268| free(column); 52| 268| } 53| 74| delete viewColumns; 54| 74| } 55| 3.28k|} _ZN4hsql15CreateStatement27setColumnDefsAndConstraintsEPNSt3__16vectorIPNS_12TableElementENS1_9allocatorIS4_EEEE: 57| 1.33k|void CreateStatement::setColumnDefsAndConstraints(std::vector* tableElements) { 58| 1.33k| columns = new std::vector(); 59| 1.33k| tableConstraints = new std::vector(); 60| | 61| 239k| for (auto tableElem : *tableElements) { ------------------ | Branch (61:23): [True: 239k, False: 1.33k] ------------------ 62| 239k| if (auto* colDef = dynamic_cast(tableElem)) { ------------------ | Branch (62:15): [True: 143k, False: 96.6k] ------------------ 63| 143k| columns->emplace_back(colDef); 64| 143k| } else if (auto* tableConstraint = dynamic_cast(tableElem)) { ------------------ | Branch (64:22): [True: 96.6k, False: 0] ------------------ 65| 96.6k| tableConstraints->emplace_back(tableConstraint); 66| 96.6k| } 67| 239k| } 68| 1.33k|} _ZN4hsql12TableElementD2Ev: 18| 358k| virtual ~TableElement() {} _ZN4hsql16ColumnDefinition22trySetNullableExplicitEv: 39| 214k| bool trySetNullableExplicit() { 40| 214k| if (column_constraints->count(ConstraintType::NotNull) || column_constraints->count(ConstraintType::PrimaryKey)) { ------------------ | Branch (40:9): [True: 1.56k, False: 213k] | Branch (40:9): [True: 2.77k, False: 211k] | Branch (40:63): [True: 1.21k, False: 211k] ------------------ 41| 2.77k| if (column_constraints->count(ConstraintType::Null)) { ------------------ | Branch (41:11): [True: 1.25k, False: 1.51k] ------------------ 42| 1.25k| return false; 43| 1.25k| } 44| 1.51k| nullable = false; 45| 1.51k| } 46| | 47| 213k| return true; 48| 214k| } _ZN4hsql4ExprC2ENS_8ExprTypeE: 24| 4.08M| distinct(false) {} _ZN4hsql4ExprD2Ev: 26| 3.93M|Expr::~Expr() { 27| 3.93M| delete expr; 28| 3.93M| delete expr2; 29| 3.93M| delete select; 30| 3.93M| free(name); 31| 3.93M| free(table); 32| 3.93M| free(alias); 33| | 34| 3.93M| if (exprList) { ------------------ | Branch (34:7): [True: 6.22k, False: 3.93M] ------------------ 35| 9.35k| for (Expr* e : *exprList) { ------------------ | Branch (35:18): [True: 9.35k, False: 6.22k] ------------------ 36| 9.35k| delete e; 37| 9.35k| } 38| 6.22k| delete exprList; 39| 6.22k| } 40| 3.93M|} _ZN4hsql4Expr4makeENS_8ExprTypeE: 42| 2.64k|Expr* Expr::make(ExprType type) { 43| 2.64k| Expr* e = new Expr(type); 44| 2.64k| return e; 45| 2.64k|} _ZN4hsql4Expr11makeOpUnaryENS_12OperatorTypeEPS0_: 47| 9.81k|Expr* Expr::makeOpUnary(OperatorType op, Expr* expr) { 48| 9.81k| Expr* e = new Expr(kExprOperator); 49| 9.81k| e->opType = op; 50| 9.81k| e->expr = expr; 51| 9.81k| e->expr2 = nullptr; 52| 9.81k| return e; 53| 9.81k|} _ZN4hsql4Expr12makeOpBinaryEPS0_NS_12OperatorTypeES1_: 55| 1.24M|Expr* Expr::makeOpBinary(Expr* expr1, OperatorType op, Expr* expr2) { 56| 1.24M| Expr* e = new Expr(kExprOperator); 57| 1.24M| e->opType = op; 58| 1.24M| e->expr = expr1; 59| 1.24M| e->expr2 = expr2; 60| 1.24M| return e; 61| 1.24M|} _ZN4hsql4Expr11makeBetweenEPS0_S1_S1_: 63| 814|Expr* Expr::makeBetween(Expr* expr, Expr* left, Expr* right) { 64| 814| Expr* e = new Expr(kExprOperator); 65| 814| e->expr = expr; 66| 814| e->opType = kOpBetween; 67| 814| e->exprList = new std::vector(); 68| 814| e->exprList->push_back(left); 69| 814| e->exprList->push_back(right); 70| 814| return e; 71| 814|} _ZN4hsql4Expr12makeCaseListEPS0_: 73| 2.12k|Expr* Expr::makeCaseList(Expr* caseListElement) { 74| 2.12k| Expr* e = new Expr(kExprOperator); 75| | // Case list expressions are temporary and will be integrated into the case 76| | // expressions exprList - thus assign operator type kOpNone 77| 2.12k| e->opType = kOpNone; 78| 2.12k| e->exprList = new std::vector(); 79| 2.12k| e->exprList->push_back(caseListElement); 80| 2.12k| return e; 81| 2.12k|} _ZN4hsql4Expr19makeCaseListElementEPS0_S1_: 83| 3.56k|Expr* Expr::makeCaseListElement(Expr* when, Expr* then) { 84| 3.56k| Expr* e = new Expr(kExprOperator); 85| 3.56k| e->opType = kOpCaseListElement; 86| 3.56k| e->expr = when; 87| 3.56k| e->expr2 = then; 88| 3.56k| return e; 89| 3.56k|} _ZN4hsql4Expr14caseListAppendEPS0_S1_: 91| 1.44k|Expr* Expr::caseListAppend(Expr* caseList, Expr* caseListElement) { 92| 1.44k| caseList->exprList->push_back(caseListElement); 93| 1.44k| return caseList; 94| 1.44k|} _ZN4hsql4Expr8makeCaseEPS0_S1_S1_: 96| 1.85k|Expr* Expr::makeCase(Expr* expr, Expr* caseList, Expr* elseExpr) { 97| 1.85k| Expr* e = new Expr(kExprOperator); 98| 1.85k| e->opType = kOpCase; 99| 1.85k| e->expr = expr; 100| 1.85k| e->expr2 = elseExpr; 101| 1.85k| e->exprList = caseList->exprList; 102| 1.85k| caseList->exprList = nullptr; 103| 1.85k| delete caseList; 104| 1.85k| return e; 105| 1.85k|} _ZN4hsql4Expr11makeLiteralEl: 107| 15.1k|Expr* Expr::makeLiteral(int64_t val) { 108| 15.1k| Expr* e = new Expr(kExprLiteralInt); 109| 15.1k| e->ival = val; 110| 15.1k| return e; 111| 15.1k|} _ZN4hsql4Expr11makeLiteralEd: 113| 401|Expr* Expr::makeLiteral(double value) { 114| 401| Expr* e = new Expr(kExprLiteralFloat); 115| 401| e->fval = value; 116| 401| return e; 117| 401|} _ZN4hsql4Expr11makeLiteralEPc: 119| 2.85k|Expr* Expr::makeLiteral(char* string) { 120| 2.85k| Expr* e = new Expr(kExprLiteralString); 121| 2.85k| e->name = string; 122| 2.85k| return e; 123| 2.85k|} _ZN4hsql4Expr11makeLiteralEb: 125| 1.30k|Expr* Expr::makeLiteral(bool val) { 126| 1.30k| Expr* e = new Expr(kExprLiteralInt); 127| 1.30k| e->ival = (int)val; 128| 1.30k| e->isBoolLiteral = true; 129| 1.30k| return e; 130| 1.30k|} _ZN4hsql4Expr15makeNullLiteralEv: 132| 342|Expr* Expr::makeNullLiteral() { 133| 342| Expr* e = new Expr(kExprLiteralNull); 134| 342| return e; 135| 342|} _ZN4hsql4Expr15makeDateLiteralEPc: 137| 633|Expr* Expr::makeDateLiteral(char* string) { 138| 633| Expr* e = new Expr(kExprLiteralDate); 139| 633| e->name = string; 140| 633| return e; 141| 633|} _ZN4hsql4Expr19makeIntervalLiteralElNS_13DatetimeFieldE: 143| 12.0k|Expr* Expr::makeIntervalLiteral(int64_t duration, DatetimeField unit) { 144| 12.0k| Expr* e = new Expr(kExprLiteralInterval); 145| 12.0k| e->ival = duration; 146| 12.0k| e->datetimeField = unit; 147| 12.0k| return e; 148| 12.0k|} _ZN4hsql4Expr13makeColumnRefEPc: 150| 1.28M|Expr* Expr::makeColumnRef(char* name) { 151| 1.28M| Expr* e = new Expr(kExprColumnRef); 152| 1.28M| e->name = name; 153| 1.28M| return e; 154| 1.28M|} _ZN4hsql4Expr13makeColumnRefEPcS1_: 156| 1.83k|Expr* Expr::makeColumnRef(char* table, char* name) { 157| 1.83k| Expr* e = new Expr(kExprColumnRef); 158| 1.83k| e->name = name; 159| 1.83k| e->table = table; 160| 1.83k| return e; 161| 1.83k|} _ZN4hsql4Expr8makeStarEv: 163| 1.14M|Expr* Expr::makeStar(void) { 164| 1.14M| Expr* e = new Expr(kExprStar); 165| 1.14M| return e; 166| 1.14M|} _ZN4hsql4Expr8makeStarEPc: 168| 195|Expr* Expr::makeStar(char* table) { 169| 195| Expr* e = new Expr(kExprStar); 170| 195| e->table = table; 171| 195| return e; 172| 195|} _ZN4hsql4Expr15makeFunctionRefEPcPNSt3__16vectorIPS0_NS2_9allocatorIS4_EEEEb: 174| 2.01k|Expr* Expr::makeFunctionRef(char* func_name, std::vector* exprList, bool distinct) { 175| 2.01k| Expr* e = new Expr(kExprFunctionRef); 176| 2.01k| e->name = func_name; 177| 2.01k| e->exprList = exprList; 178| 2.01k| e->distinct = distinct; 179| 2.01k| return e; 180| 2.01k|} _ZN4hsql4Expr9makeArrayEPNSt3__16vectorIPS0_NS1_9allocatorIS3_EEEE: 182| 435|Expr* Expr::makeArray(std::vector* exprList) { 183| 435| Expr* e = new Expr(kExprArray); 184| 435| e->exprList = exprList; 185| 435| return e; 186| 435|} _ZN4hsql4Expr14makeArrayIndexEPS0_l: 188| 194|Expr* Expr::makeArrayIndex(Expr* expr, int64_t index) { 189| 194| Expr* e = new Expr(kExprArrayIndex); 190| 194| e->expr = expr; 191| 194| e->ival = index; 192| 194| return e; 193| 194|} _ZN4hsql4Expr13makeParameterEi: 195| 353k|Expr* Expr::makeParameter(int id) { 196| 353k| Expr* e = new Expr(kExprParameter); 197| 353k| e->ival = id; 198| 353k| return e; 199| 353k|} _ZN4hsql4Expr10makeSelectEPNS_15SelectStatementE: 201| 579|Expr* Expr::makeSelect(SelectStatement* select) { 202| 579| Expr* e = new Expr(kExprSelect); 203| 579| e->select = select; 204| 579| return e; 205| 579|} _ZN4hsql4Expr10makeExistsEPNS_15SelectStatementE: 207| 946|Expr* Expr::makeExists(SelectStatement* select) { 208| 946| Expr* e = new Expr(kExprOperator); 209| 946| e->opType = kOpExists; 210| 946| e->select = select; 211| 946| return e; 212| 946|} _ZN4hsql4Expr14makeInOperatorEPS0_PNSt3__16vectorIS1_NS2_9allocatorIS1_EEEE: 214| 561|Expr* Expr::makeInOperator(Expr* expr, std::vector* exprList) { 215| 561| Expr* e = new Expr(kExprOperator); 216| 561| e->opType = kOpIn; 217| 561| e->expr = expr; 218| 561| e->exprList = exprList; 219| | 220| 561| return e; 221| 561|} _ZN4hsql4Expr14makeInOperatorEPS0_PNS_15SelectStatementE: 223| 389|Expr* Expr::makeInOperator(Expr* expr, SelectStatement* select) { 224| 389| Expr* e = new Expr(kExprOperator); 225| 389| e->opType = kOpIn; 226| 389| e->expr = expr; 227| 389| e->select = select; 228| | 229| 389| return e; 230| 389|} _ZN4hsql4Expr11makeExtractENS_13DatetimeFieldEPS0_: 232| 466|Expr* Expr::makeExtract(DatetimeField datetimeField, Expr* expr) { 233| 466| Expr* e = new Expr(kExprExtract); 234| 466| e->datetimeField = datetimeField; 235| 466| e->expr = expr; 236| 466| return e; 237| 466|} _ZN4hsql4Expr8makeCastEPS0_NS_10ColumnTypeE: 239| 373|Expr* Expr::makeCast(Expr* expr, ColumnType columnType) { 240| 373| Expr* e = new Expr(kExprCast); 241| 373| e->columnType = columnType; 242| 373| e->expr = expr; 243| 373| return e; 244| 373|} _ZN4hsql6substrEPKcii: 264| 2.11k|char* substr(const char* source, int from, int to) { 265| 2.11k| int len = to - from; 266| 2.11k| char* copy = (char*)malloc(len + 1); 267| 2.11k| ; 268| 2.11k| strncpy(copy, source + from, len); 269| 2.11k| copy[len] = '\0'; 270| 2.11k| return copy; 271| 2.11k|} _ZN4hsql16PrepareStatementC2Ev: 6| 815|PrepareStatement::PrepareStatement() : SQLStatement(kStmtPrepare), name(nullptr), query(nullptr) {} _ZN4hsql16PrepareStatementD2Ev: 8| 815|PrepareStatement::~PrepareStatement() { 9| 815| free(name); 10| 815| free(query); 11| 815|} _ZN4hsql12SQLStatementC2ENS_13StatementTypeE: 7| 345k|SQLStatement::SQLStatement(StatementType type) : hints(nullptr), type_(type) {} _ZN4hsql12SQLStatementD2Ev: 9| 310k|SQLStatement::~SQLStatement() { 10| 310k| if (hints) { ------------------ | Branch (10:7): [True: 1.27k, False: 309k] ------------------ 11| 1.84k| for (Expr* hint : *hints) { ------------------ | Branch (11:21): [True: 1.84k, False: 1.27k] ------------------ 12| 1.84k| delete hint; 13| 1.84k| } 14| 1.27k| } 15| 310k| delete hints; 16| 310k|} _ZN4hsql15TableConstraintC2ENS_14ConstraintTypeEPNSt3__16vectorIPcNS2_9allocatorIS4_EEEE: 8| 144k| : type(type), columnNames(columnNames) {} _ZN4hsql15TableConstraintD2Ev: 10| 144k|TableConstraint::~TableConstraint() { 11| 160k| for (char* def : *columnNames) { ------------------ | Branch (11:18): [True: 160k, False: 144k] ------------------ 12| 160k| free(def); 13| 160k| } 14| 144k| delete columnNames; 15| 144k|} _ZN4hsql16ColumnDefinitionC2EPcNS_10ColumnTypeEPNSt3__113unordered_setINS_14ConstraintTypeENS3_4hashIS5_EENS3_8equal_toIS5_EENS3_9allocatorIS5_EEEE: 19| 214k| : column_constraints(column_constraints), name(name), type(type), nullable(true) {} _ZN4hsql16ColumnDefinitionD2Ev: 21| 214k|ColumnDefinition::~ColumnDefinition() { 22| 214k| free(name); 23| 214k| delete column_constraints; 24| 214k|} _ZN4hsql10ColumnTypeC2ENS_8DataTypeElll: 27| 4.30M| : data_type(data_type), length(length), precision(precision), scale(scale) {} _ZN4hsql15DeleteStatementC2Ev: 91| 1.87k|DeleteStatement::DeleteStatement() : SQLStatement(kStmtDelete), schema(nullptr), tableName(nullptr), expr(nullptr) {} _ZN4hsql15DeleteStatementD2Ev: 93| 1.87k|DeleteStatement::~DeleteStatement() { 94| 1.87k| free(schema); 95| 1.87k| free(tableName); 96| 1.87k| delete expr; 97| 1.87k|} _ZN4hsql13DropStatementC2ENS_8DropTypeE: 101| 3.85k| : SQLStatement(kStmtDrop), type(type), schema(nullptr), name(nullptr), indexName(nullptr) {} _ZN4hsql13DropStatementD2Ev: 103| 3.85k|DropStatement::~DropStatement() { 104| 3.85k| free(schema); 105| 3.85k| free(name); 106| 3.85k| free(indexName); 107| 3.85k|} _ZN4hsql20TransactionStatementC2ENS_18TransactionCommandE: 131| 268k| : SQLStatement(kStmtTransaction), command(command) {} _ZN4hsql20TransactionStatementD2Ev: 133| 268k|TransactionStatement::~TransactionStatement() {} _ZN4hsql16ExecuteStatementC2Ev: 136| 1.56k|ExecuteStatement::ExecuteStatement() : SQLStatement(kStmtExecute), name(nullptr), parameters(nullptr) {} _ZN4hsql16ExecuteStatementD2Ev: 138| 1.56k|ExecuteStatement::~ExecuteStatement() { 139| 1.56k| free(name); 140| | 141| 1.56k| if (parameters) { ------------------ | Branch (141:7): [True: 297, False: 1.26k] ------------------ 142| 674| for (Expr* param : *parameters) { ------------------ | Branch (142:22): [True: 674, False: 297] ------------------ 143| 674| delete param; 144| 674| } 145| 297| delete parameters; 146| 297| } 147| 1.56k|} _ZN4hsql15ExportStatementC2ENS_10ImportTypeE: 151| 873| : SQLStatement(kStmtExport), type(type), filePath(nullptr), schema(nullptr), tableName(nullptr), select(nullptr) {} _ZN4hsql15ExportStatementD2Ev: 153| 873|ExportStatement::~ExportStatement() { 154| 873| free(filePath); 155| 873| free(schema); 156| 873| free(tableName); 157| 873| delete select; 158| 873|} _ZN4hsql15ImportStatementC2ENS_10ImportTypeE: 167| 561| whereClause(nullptr) {} _ZN4hsql15ImportStatementD2Ev: 169| 561|ImportStatement::~ImportStatement() { 170| 561| free(filePath); 171| 561| free(schema); 172| 561| free(tableName); 173| 561| delete whereClause; 174| 561|} _ZN4hsql15InsertStatementC2ENS_10InsertTypeE: 184| 2.48k| select(nullptr) {} _ZN4hsql15InsertStatementD2Ev: 186| 2.48k|InsertStatement::~InsertStatement() { 187| 2.48k| free(schema); 188| 2.48k| free(tableName); 189| 2.48k| delete select; 190| | 191| 2.48k| if (columns) { ------------------ | Branch (191:7): [True: 545, False: 1.93k] ------------------ 192| 739| for (char* column : *columns) { ------------------ | Branch (192:23): [True: 739, False: 545] ------------------ 193| 739| free(column); 194| 739| } 195| 545| delete columns; 196| 545| } 197| | 198| 2.48k| if (values) { ------------------ | Branch (198:7): [True: 816, False: 1.66k] ------------------ 199| 1.19k| for (Expr* expr : *values) { ------------------ | Branch (199:21): [True: 1.19k, False: 816] ------------------ 200| 1.19k| delete expr; 201| 1.19k| } 202| 816| delete values; 203| 816| } 204| 2.48k|} _ZN4hsql13ShowStatementC2ENS_8ShowTypeE: 207| 2.81k|ShowStatement::ShowStatement(ShowType type) : SQLStatement(kStmtShow), type(type), schema(nullptr), name(nullptr) {} _ZN4hsql13ShowStatementD2Ev: 209| 2.81k|ShowStatement::~ShowStatement() { 210| 2.81k| free(schema); 211| 2.81k| free(name); 212| 2.81k|} _ZN4hsql16OrderDescriptionC2ENS_9OrderTypeEPNS_4ExprE: 217| 557k|OrderDescription::OrderDescription(OrderType type, Expr* expr) : type(type), expr(expr) {} _ZN4hsql16OrderDescriptionD2Ev: 219| 557k|OrderDescription::~OrderDescription() { delete expr; } _ZN4hsql16LimitDescriptionC2EPNS_4ExprES2_: 222| 3.74k|LimitDescription::LimitDescription(Expr* limit, Expr* offset) : limit(limit), offset(offset) {} _ZN4hsql16LimitDescriptionD2Ev: 224| 3.74k|LimitDescription::~LimitDescription() { 225| 3.74k| delete limit; 226| 3.74k| delete offset; 227| 3.74k|} _ZN4hsql18GroupByDescriptionC2Ev: 230| 1.51k|GroupByDescription::GroupByDescription() : columns(nullptr), having(nullptr) {} _ZN4hsql18GroupByDescriptionD2Ev: 232| 1.51k|GroupByDescription::~GroupByDescription() { 233| 1.51k| delete having; 234| | 235| 1.51k| if (columns) { ------------------ | Branch (235:7): [True: 1.51k, False: 0] ------------------ 236| 2.08k| for (Expr* expr : *columns) { ------------------ | Branch (236:21): [True: 2.08k, False: 1.51k] ------------------ 237| 2.08k| delete expr; 238| 2.08k| } 239| 1.51k| delete columns; 240| 1.51k| } 241| 1.51k|} _ZN4hsql15WithDescriptionD2Ev: 243| 1.39k|WithDescription::~WithDescription() { 244| 1.39k| free(alias); 245| 1.39k| delete select; 246| 1.39k|} _ZN4hsql15SelectStatementC2Ev: 260| 57.8k| lockings(nullptr) {} _ZN4hsql15SelectStatementD2Ev: 262| 23.0k|SelectStatement::~SelectStatement() { 263| 23.0k| delete fromTable; 264| 23.0k| delete whereClause; 265| 23.0k| delete groupBy; 266| 23.0k| delete limit; 267| | 268| | // Delete each element in the select list. 269| 23.0k| if (selectList) { ------------------ | Branch (269:7): [True: 23.0k, False: 0] ------------------ 270| 103k| for (Expr* expr : *selectList) { ------------------ | Branch (270:21): [True: 103k, False: 23.0k] ------------------ 271| 103k| delete expr; 272| 103k| } 273| 23.0k| delete selectList; 274| 23.0k| } 275| | 276| 23.0k| if (order) { ------------------ | Branch (276:7): [True: 1.18k, False: 21.8k] ------------------ 277| 54.5k| for (OrderDescription* desc : *order) { ------------------ | Branch (277:33): [True: 54.5k, False: 1.18k] ------------------ 278| 54.5k| delete desc; 279| 54.5k| } 280| 1.18k| delete order; 281| 1.18k| } 282| | 283| 23.0k| if (withDescriptions) { ------------------ | Branch (283:7): [True: 430, False: 22.6k] ------------------ 284| 1.39k| for (WithDescription* desc : *withDescriptions) { ------------------ | Branch (284:32): [True: 1.39k, False: 430] ------------------ 285| 1.39k| delete desc; 286| 1.39k| } 287| 430| delete withDescriptions; 288| 430| } 289| | 290| 23.0k| if (setOperations) { ------------------ | Branch (290:7): [True: 2.86k, False: 20.1k] ------------------ 291| 3.13k| for (SetOperation* setOperation : *setOperations) { ------------------ | Branch (291:37): [True: 3.13k, False: 2.86k] ------------------ 292| 3.13k| delete setOperation; 293| 3.13k| } 294| 2.86k| delete setOperations; 295| 2.86k| } 296| | 297| 23.0k| if (lockings) { ------------------ | Branch (297:7): [True: 443, False: 22.6k] ------------------ 298| 3.29k| for (LockingClause* lockingClause : *lockings) { ------------------ | Branch (298:39): [True: 3.29k, False: 443] ------------------ 299| 3.29k| if (lockingClause->tables) { ------------------ | Branch (299:11): [True: 202, False: 3.09k] ------------------ 300| 396| for (char* dtable : *lockingClause->tables) { ------------------ | Branch (300:27): [True: 396, False: 202] ------------------ 301| 396| free(dtable); 302| 396| } 303| 202| delete lockingClause->tables; 304| 202| } 305| 3.29k| delete lockingClause; 306| 3.29k| } 307| 443| delete lockings; 308| 443| } 309| 23.0k|} _ZN4hsql15UpdateStatementC2Ev: 312| 1.19k|UpdateStatement::UpdateStatement() : SQLStatement(kStmtUpdate), table(nullptr), updates(nullptr), where(nullptr) {} _ZN4hsql15UpdateStatementD2Ev: 314| 1.19k|UpdateStatement::~UpdateStatement() { 315| 1.19k| delete table; 316| 1.19k| delete where; 317| | 318| 1.19k| if (updates) { ------------------ | Branch (318:7): [True: 1.19k, False: 0] ------------------ 319| 156k| for (UpdateClause* update : *updates) { ------------------ | Branch (319:31): [True: 156k, False: 1.19k] ------------------ 320| 156k| free(update->column); 321| 156k| delete update->value; 322| 156k| delete update; 323| 156k| } 324| 1.19k| delete updates; 325| 1.19k| } 326| 1.19k|} _ZN4hsql5AliasC2EPcPNSt3__16vectorIS1_NS2_9allocatorIS1_EEEE: 329| 7.46k|Alias::Alias(char* name, std::vector* columns) : name(name), columns(columns) {} _ZN4hsql5AliasD2Ev: 331| 7.46k|Alias::~Alias() { 332| 7.46k| free(name); 333| 7.46k| if (columns) { ------------------ | Branch (333:7): [True: 314, False: 7.14k] ------------------ 334| 99.2k| for (char* column : *columns) { ------------------ | Branch (334:23): [True: 99.2k, False: 314] ------------------ 335| 99.2k| free(column); 336| 99.2k| } 337| 314| delete columns; 338| 314| } 339| 7.46k|} _ZN4hsql8TableRefC2ENS_12TableRefTypeE: 343| 760k| : type(type), schema(nullptr), name(nullptr), alias(nullptr), select(nullptr), list(nullptr), join(nullptr) {} _ZN4hsql8TableRefD2Ev: 345| 760k|TableRef::~TableRef() { 346| 760k| free(schema); 347| 760k| free(name); 348| | 349| 760k| delete select; 350| 760k| delete join; 351| 760k| delete alias; 352| | 353| 760k| if (list) { ------------------ | Branch (353:7): [True: 835, False: 759k] ------------------ 354| 188k| for (TableRef* table : *list) { ------------------ | Branch (354:26): [True: 188k, False: 835] ------------------ 355| 188k| delete table; 356| 188k| } 357| 835| delete list; 358| 835| } 359| 760k|} _ZNK4hsql8TableRef7getNameEv: 363| 4.70k|const char* TableRef::getName() const { 364| 4.70k| if (alias) ------------------ | Branch (364:7): [True: 432, False: 4.27k] ------------------ 365| 432| return alias->name; 366| 4.27k| else 367| 4.27k| return name; 368| 4.70k|} _ZN4hsql14JoinDefinitionC2Ev: 371| 111k|JoinDefinition::JoinDefinition() : left(nullptr), right(nullptr), condition(nullptr), type(kJoinInner) {} _ZN4hsql14JoinDefinitionD2Ev: 373| 111k|JoinDefinition::~JoinDefinition() { 374| 111k| delete left; 375| 111k| delete right; 376| 111k| delete condition; 377| 111k|} _ZN4hsql12SetOperationC2Ev: 379| 4.38k|SetOperation::SetOperation() : nestedSelectStatement(nullptr), resultOrder(nullptr), resultLimit(nullptr) {} _ZN4hsql12SetOperationD2Ev: 381| 4.38k|SetOperation::~SetOperation() { 382| 4.38k| delete nestedSelectStatement; 383| 4.38k| delete resultLimit; 384| | 385| 4.38k| if (resultOrder) { ------------------ | Branch (385:7): [True: 264, False: 4.12k] ------------------ 386| 511| for (OrderDescription* desc : *resultOrder) { ------------------ | Branch (386:33): [True: 511, False: 264] ------------------ 387| 511| delete desc; 388| 511| } 389| 264| delete resultOrder; 390| 264| } 391| 4.38k|}