LCOV - code coverage report
Current view: top level - src/bin/pgbench - exprparse.y (source / functions) Hit Total Coverage
Test: PostgreSQL 11devel Lines: 126 127 99.2 %
Date: 2018-02-20 09:20:13 Functions: 12 12 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 28 30 93.3 %

           Branch data     Line data    Source code
       1                 :            : %{
       2                 :            : /*-------------------------------------------------------------------------
       3                 :            :  *
       4                 :            :  * exprparse.y
       5                 :            :  *    bison grammar for a simple expression syntax
       6                 :            :  *
       7                 :            :  * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
       8                 :            :  * Portions Copyright (c) 1994, Regents of the University of California
       9                 :            :  *
      10                 :            :  * src/bin/pgbench/exprparse.y
      11                 :            :  *
      12                 :            :  *-------------------------------------------------------------------------
      13                 :            :  */
      14                 :            : 
      15                 :            : #include "postgres_fe.h"
      16                 :            : 
      17                 :            : #include "pgbench.h"
      18                 :            : 
      19                 :            : PgBenchExpr *expr_parse_result;
      20                 :            : 
      21                 :            : static PgBenchExprList *make_elist(PgBenchExpr *exp, PgBenchExprList *list);
      22                 :            : static PgBenchExpr *make_null_constant(void);
      23                 :            : static PgBenchExpr *make_boolean_constant(bool bval);
      24                 :            : static PgBenchExpr *make_integer_constant(int64 ival);
      25                 :            : static PgBenchExpr *make_double_constant(double dval);
      26                 :            : static PgBenchExpr *make_variable(char *varname);
      27                 :            : static PgBenchExpr *make_op(yyscan_t yyscanner, const char *operator,
      28                 :            :         PgBenchExpr *lexpr, PgBenchExpr *rexpr);
      29                 :            : static PgBenchExpr *make_uop(yyscan_t yyscanner, const char *operator, PgBenchExpr *expr);
      30                 :            : static int  find_func(yyscan_t yyscanner, const char *fname);
      31                 :            : static PgBenchExpr *make_func(yyscan_t yyscanner, int fnumber, PgBenchExprList *args);
      32                 :            : static PgBenchExpr *make_case(yyscan_t yyscanner, PgBenchExprList *when_then_list, PgBenchExpr *else_part);
      33                 :            : 
      34                 :            : %}
      35                 :            : 
      36                 :            : %pure-parser
      37                 :            : %expect 0
      38                 :            : %name-prefix="expr_yy"
      39                 :            : 
      40                 :            : %parse-param {yyscan_t yyscanner}
      41                 :            : %lex-param   {yyscan_t yyscanner}
      42                 :            : 
      43                 :            : %union
      44                 :            : {
      45                 :            :     int64       ival;
      46                 :            :     double      dval;
      47                 :            :     bool        bval;
      48                 :            :     char       *str;
      49                 :            :     PgBenchExpr *expr;
      50                 :            :     PgBenchExprList *elist;
      51                 :            : }
      52                 :            : 
      53                 :            : %type <elist> elist when_then_list
      54                 :            : %type <expr> expr case_control
      55                 :            : %type <ival> INTEGER_CONST function
      56                 :            : %type <dval> DOUBLE_CONST
      57                 :            : %type <bval> BOOLEAN_CONST
      58                 :            : %type <str> VARIABLE FUNCTION
      59                 :            : 
      60                 :            : %token NULL_CONST INTEGER_CONST DOUBLE_CONST BOOLEAN_CONST VARIABLE FUNCTION
      61                 :            : %token AND_OP OR_OP NOT_OP NE_OP LE_OP GE_OP LS_OP RS_OP IS_OP
      62                 :            : %token CASE_KW WHEN_KW THEN_KW ELSE_KW END_KW
      63                 :            : 
      64                 :            : /* Precedence: lowest to highest, taken from postgres SQL parser */
      65                 :            : %left   OR_OP
      66                 :            : %left   AND_OP
      67                 :            : %right  NOT_OP
      68                 :            : %nonassoc IS_OP ISNULL_OP NOTNULL_OP
      69                 :            : %nonassoc '<' '>' '=' LE_OP GE_OP NE_OP
      70                 :            : %left   '|' '#' '&' LS_OP RS_OP '~'
      71                 :            : %left   '+' '-'
      72                 :            : %left   '*' '/' '%'
      73                 :            : %right  UNARY
      74                 :            : 
      75                 :            : %%
      76                 :            : 
      77                 :        590 : result: expr                { expr_parse_result = $1; }
      78                 :            : 
      79                 :          4 : elist:                      { $$ = NULL; }
      80                 :        610 :     | expr                  { $$ = make_elist($1, NULL); }
      81                 :        576 :     | elist ',' expr        { $$ = make_elist($3, $1); }
      82                 :            :     ;
      83                 :            : 
      84                 :         90 : expr: '(' expr ')'          { $$ = $2; }
      85                 :          2 :     | '+' expr %prec UNARY  { $$ = $2; }
      86                 :            :     /* unary minus "-x" implemented as "0 - x" */
      87                 :         88 :     | '-' expr %prec UNARY  { $$ = make_op(yyscanner, "-",
      88                 :            :                                            make_integer_constant(0), $2); }
      89                 :            :     /* binary ones complement "~x" implemented as 0xffff... xor x" */
      90                 :          4 :     | '~' expr              { $$ = make_op(yyscanner, "#",
      91                 :            :                                            make_integer_constant(~INT64CONST(0)), $2); }
      92                 :         24 :     | NOT_OP expr           { $$ = make_uop(yyscanner, "!not", $2); }
      93                 :         38 :     | expr '+' expr         { $$ = make_op(yyscanner, "+", $1, $3); }
      94                 :         14 :     | expr '-' expr         { $$ = make_op(yyscanner, "-", $1, $3); }
      95                 :        400 :     | expr '*' expr         { $$ = make_op(yyscanner, "*", $1, $3); }
      96                 :         24 :     | expr '/' expr         { $$ = make_op(yyscanner, "/", $1, $3); }
      97                 :          4 :     | expr '%' expr         { $$ = make_op(yyscanner, "mod", $1, $3); }
      98                 :         12 :     | expr '<' expr          { $$ = make_op(yyscanner, "<", $1, $3); }
      99                 :          6 :     | expr LE_OP expr       { $$ = make_op(yyscanner, "<=", $1, $3); }
     100                 :          8 :     | expr '>' expr          { $$ = make_op(yyscanner, "<", $3, $1); }
     101                 :          6 :     | expr GE_OP expr       { $$ = make_op(yyscanner, "<=", $3, $1); }
     102                 :         18 :     | expr '=' expr         { $$ = make_op(yyscanner, "=", $1, $3); }
     103                 :         12 :     | expr NE_OP expr       { $$ = make_op(yyscanner, "<>", $1, $3); }
     104                 :          2 :     | expr '&' expr         { $$ = make_op(yyscanner, "&", $1, $3); }
     105                 :          4 :     | expr '|' expr         { $$ = make_op(yyscanner, "|", $1, $3); }
     106                 :          2 :     | expr '#' expr         { $$ = make_op(yyscanner, "#", $1, $3); }
     107                 :          2 :     | expr LS_OP expr       { $$ = make_op(yyscanner, "<<", $1, $3); }
     108                 :          2 :     | expr RS_OP expr       { $$ = make_op(yyscanner, ">>", $1, $3); }
     109                 :         64 :     | expr AND_OP expr      { $$ = make_op(yyscanner, "!and", $1, $3); }
     110                 :         10 :     | expr OR_OP expr       { $$ = make_op(yyscanner, "!or", $1, $3); }
     111                 :            :     /* IS variants */
     112                 :          2 :     | expr ISNULL_OP        { $$ = make_op(yyscanner, "!is", $1, make_null_constant()); }
     113                 :            :     | expr NOTNULL_OP       {
     114                 :          2 :                                 $$ = make_uop(yyscanner, "!not",
     115                 :          2 :                                               make_op(yyscanner, "!is", $1, make_null_constant()));
     116                 :            :                             }
     117                 :          8 :     | expr IS_OP NULL_CONST { $$ = make_op(yyscanner, "!is", $1, make_null_constant()); }
     118                 :            :     | expr IS_OP NOT_OP NULL_CONST
     119                 :            :                             {
     120                 :          4 :                                 $$ = make_uop(yyscanner, "!not",
     121                 :          4 :                                               make_op(yyscanner, "!is", $1, make_null_constant()));
     122                 :            :                             }
     123                 :            :     | expr IS_OP BOOLEAN_CONST
     124                 :            :                             {
     125                 :          2 :                                 $$ = make_op(yyscanner, "!is", $1, make_boolean_constant($3));
     126                 :            :                             }
     127                 :            :     | expr IS_OP NOT_OP BOOLEAN_CONST
     128                 :            :                             {
     129                 :          2 :                                 $$ = make_uop(yyscanner, "!not",
     130                 :          4 :                                               make_op(yyscanner, "!is", $1, make_boolean_constant($4)));
     131                 :            :                             }
     132                 :            :     /* constants */
     133                 :         12 :     | NULL_CONST            { $$ = make_null_constant(); }
     134                 :         38 :     | BOOLEAN_CONST         { $$ = make_boolean_constant($1); }
     135                 :       1228 :     | INTEGER_CONST         { $$ = make_integer_constant($1); }
     136                 :        142 :     | DOUBLE_CONST          { $$ = make_double_constant($1); }
     137                 :            :     /* misc */
     138                 :        432 :     | VARIABLE              { $$ = make_variable($1); }
     139                 :        614 :     | function '(' elist ')' { $$ = make_func(yyscanner, $1, $3); }
     140                 :         28 :     | case_control          { $$ = $1; }
     141                 :            :     ;
     142                 :            : 
     143                 :            : when_then_list:
     144                 :          4 :       when_then_list WHEN_KW expr THEN_KW expr { $$ = make_elist($5, make_elist($3, $1)); }
     145                 :         28 :     | WHEN_KW expr THEN_KW expr { $$ = make_elist($4, make_elist($2, NULL)); }
     146                 :            : 
     147                 :            : case_control:
     148                 :          8 :       CASE_KW when_then_list END_KW { $$ = make_case(yyscanner, $2, make_null_constant()); }
     149                 :         20 :     | CASE_KW when_then_list ELSE_KW expr END_KW { $$ = make_case(yyscanner, $2, $4); }
     150                 :            : 
     151                 :        616 : function: FUNCTION          { $$ = find_func(yyscanner, $1); pg_free($1); }
     152                 :            :     ;
     153                 :            : 
     154                 :            : %%
     155                 :            : 
     156                 :            : static PgBenchExpr *
     157                 :         36 : make_null_constant(void)
     158                 :            : {
     159                 :         36 :     PgBenchExpr *expr = pg_malloc(sizeof(PgBenchExpr));
     160                 :            : 
     161                 :         36 :     expr->etype = ENODE_CONSTANT;
     162                 :         36 :     expr->u.constant.type = PGBT_NULL;
     163                 :         36 :     expr->u.constant.u.ival = 0;
     164                 :         36 :     return expr;
     165                 :            : }
     166                 :            : 
     167                 :            : static PgBenchExpr *
     168                 :       1320 : make_integer_constant(int64 ival)
     169                 :            : {
     170                 :       1320 :     PgBenchExpr *expr = pg_malloc(sizeof(PgBenchExpr));
     171                 :            : 
     172                 :       1320 :     expr->etype = ENODE_CONSTANT;
     173                 :       1320 :     expr->u.constant.type = PGBT_INT;
     174                 :       1320 :     expr->u.constant.u.ival = ival;
     175                 :       1320 :     return expr;
     176                 :            : }
     177                 :            : 
     178                 :            : static PgBenchExpr *
     179                 :        142 : make_double_constant(double dval)
     180                 :            : {
     181                 :        142 :     PgBenchExpr *expr = pg_malloc(sizeof(PgBenchExpr));
     182                 :            : 
     183                 :        142 :     expr->etype = ENODE_CONSTANT;
     184                 :        142 :     expr->u.constant.type = PGBT_DOUBLE;
     185                 :        142 :     expr->u.constant.u.dval = dval;
     186                 :        142 :     return expr;
     187                 :            : }
     188                 :            : 
     189                 :            : static PgBenchExpr *
     190                 :         42 : make_boolean_constant(bool bval)
     191                 :            : {
     192                 :         42 :     PgBenchExpr *expr = pg_malloc(sizeof(PgBenchExpr));
     193                 :            : 
     194                 :         42 :     expr->etype = ENODE_CONSTANT;
     195                 :         42 :     expr->u.constant.type = PGBT_BOOLEAN;
     196                 :         42 :     expr->u.constant.u.bval = bval;
     197                 :         42 :     return expr;
     198                 :            : }
     199                 :            : 
     200                 :            : static PgBenchExpr *
     201                 :        432 : make_variable(char *varname)
     202                 :            : {
     203                 :        432 :     PgBenchExpr *expr = pg_malloc(sizeof(PgBenchExpr));
     204                 :            : 
     205                 :        432 :     expr->etype = ENODE_VARIABLE;
     206                 :        432 :     expr->u.variable.varname = varname;
     207                 :        432 :     return expr;
     208                 :            : }
     209                 :            : 
     210                 :            : /* binary operators */
     211                 :            : static PgBenchExpr *
     212                 :        740 : make_op(yyscan_t yyscanner, const char *operator,
     213                 :            :         PgBenchExpr *lexpr, PgBenchExpr *rexpr)
     214                 :            : {
     215                 :        740 :     return make_func(yyscanner, find_func(yyscanner, operator),
     216                 :            :                      make_elist(rexpr, make_elist(lexpr, NULL)));
     217                 :            : }
     218                 :            : 
     219                 :            : /* unary operator */
     220                 :            : static PgBenchExpr *
     221                 :         32 : make_uop(yyscan_t yyscanner, const char *operator, PgBenchExpr *expr)
     222                 :            : {
     223                 :         32 :     return make_func(yyscanner, find_func(yyscanner, operator), make_elist(expr, NULL));
     224                 :            : }
     225                 :            : 
     226                 :            : /*
     227                 :            :  * List of available functions:
     228                 :            :  * - fname: function name, "!..." for special internal functions
     229                 :            :  * - nargs: number of arguments
     230                 :            :  *          -1 is a special value for least & greatest meaning #args >= 1
     231                 :            :  *          -2 is for the "CASE WHEN ..." function, which has #args >= 3 and odd
     232                 :            :  * - tag: function identifier from PgBenchFunction enum
     233                 :            :  */
     234                 :            : static const struct
     235                 :            : {
     236                 :            :     const char *fname;
     237                 :            :     int         nargs;
     238                 :            :     PgBenchFunction tag;
     239                 :            : }   PGBENCH_FUNCTIONS[] =
     240                 :            : {
     241                 :            :     /* parsed as operators, executed as functions */
     242                 :            :     {
     243                 :            :         "+", 2, PGBENCH_ADD
     244                 :            :     },
     245                 :            :     {
     246                 :            :         "-", 2, PGBENCH_SUB
     247                 :            :     },
     248                 :            :     {
     249                 :            :         "*", 2, PGBENCH_MUL
     250                 :            :     },
     251                 :            :     {
     252                 :            :         "/", 2, PGBENCH_DIV
     253                 :            :     },
     254                 :            :     {
     255                 :            :         "mod", 2, PGBENCH_MOD
     256                 :            :     },
     257                 :            :     /* actual functions */
     258                 :            :     {
     259                 :            :         "abs", 1, PGBENCH_ABS
     260                 :            :     },
     261                 :            :     {
     262                 :            :         "least", -1, PGBENCH_LEAST
     263                 :            :     },
     264                 :            :     {
     265                 :            :         "greatest", -1, PGBENCH_GREATEST
     266                 :            :     },
     267                 :            :     {
     268                 :            :         "debug", 1, PGBENCH_DEBUG
     269                 :            :     },
     270                 :            :     {
     271                 :            :         "pi", 0, PGBENCH_PI
     272                 :            :     },
     273                 :            :     {
     274                 :            :         "sqrt", 1, PGBENCH_SQRT
     275                 :            :     },
     276                 :            :     {
     277                 :            :         "ln", 1, PGBENCH_LN
     278                 :            :     },
     279                 :            :     {
     280                 :            :         "exp", 1, PGBENCH_EXP
     281                 :            :     },
     282                 :            :     {
     283                 :            :         "int", 1, PGBENCH_INT
     284                 :            :     },
     285                 :            :     {
     286                 :            :         "double", 1, PGBENCH_DOUBLE
     287                 :            :     },
     288                 :            :     {
     289                 :            :         "random", 2, PGBENCH_RANDOM
     290                 :            :     },
     291                 :            :     {
     292                 :            :         "random_gaussian", 3, PGBENCH_RANDOM_GAUSSIAN
     293                 :            :     },
     294                 :            :     {
     295                 :            :         "random_exponential", 3, PGBENCH_RANDOM_EXPONENTIAL
     296                 :            :     },
     297                 :            :     {
     298                 :            :         "random_zipfian", 3, PGBENCH_RANDOM_ZIPFIAN
     299                 :            :     },
     300                 :            :     {
     301                 :            :         "pow", 2, PGBENCH_POW
     302                 :            :     },
     303                 :            :     {
     304                 :            :         "power", 2, PGBENCH_POW
     305                 :            :     },
     306                 :            :     /* logical operators */
     307                 :            :     {
     308                 :            :         "!and", 2, PGBENCH_AND
     309                 :            :     },
     310                 :            :     {
     311                 :            :         "!or", 2, PGBENCH_OR
     312                 :            :     },
     313                 :            :     {
     314                 :            :         "!not", 1, PGBENCH_NOT
     315                 :            :     },
     316                 :            :     /* bitwise integer operators */
     317                 :            :     {
     318                 :            :         "&", 2, PGBENCH_BITAND
     319                 :            :     },
     320                 :            :     {
     321                 :            :         "|", 2, PGBENCH_BITOR
     322                 :            :     },
     323                 :            :     {
     324                 :            :         "#", 2, PGBENCH_BITXOR
     325                 :            :     },
     326                 :            :     {
     327                 :            :         "<<", 2, PGBENCH_LSHIFT
     328                 :            :     },
     329                 :            :     {
     330                 :            :         ">>", 2, PGBENCH_RSHIFT
     331                 :            :     },
     332                 :            :     /* comparison operators */
     333                 :            :     {
     334                 :            :         "=", 2, PGBENCH_EQ
     335                 :            :     },
     336                 :            :     {
     337                 :            :         "<>", 2, PGBENCH_NE
     338                 :            :     },
     339                 :            :     {
     340                 :            :         "<=", 2, PGBENCH_LE
     341                 :            :     },
     342                 :            :     {
     343                 :            :         "<", 2, PGBENCH_LT
     344                 :            :     },
     345                 :            :     {
     346                 :            :         "!is", 2, PGBENCH_IS
     347                 :            :     },
     348                 :            :     /* "case when ... then ... else ... end" construction */
     349                 :            :     {
     350                 :            :         "!case_end", -2, PGBENCH_CASE
     351                 :            :     },
     352                 :            :     /* keep as last array element */
     353                 :            :     {
     354                 :            :         NULL, 0, 0
     355                 :            :     }
     356                 :            : };
     357                 :            : 
     358                 :            : /*
     359                 :            :  * Find a function from its name
     360                 :            :  *
     361                 :            :  * return the index of the function from the PGBENCH_FUNCTIONS array
     362                 :            :  * or fail if the function is unknown.
     363                 :            :  */
     364                 :            : static int
     365                 :       1416 : find_func(yyscan_t yyscanner, const char *fname)
     366                 :            : {
     367                 :       1416 :     int         i = 0;
     368                 :            : 
     369         [ +  + ]:      17138 :     while (PGBENCH_FUNCTIONS[i].fname)
     370                 :            :     {
     371         [ +  + ]:      17136 :         if (pg_strcasecmp(fname, PGBENCH_FUNCTIONS[i].fname) == 0)
     372                 :       1414 :             return i;
     373                 :      15722 :         i++;
     374                 :            :     }
     375                 :            : 
     376                 :          2 :     expr_yyerror_more(yyscanner, "unexpected function name", fname);
     377                 :            : 
     378                 :            :     /* not reached */
     379                 :            :     return -1;
     380                 :            : }
     381                 :            : 
     382                 :            : /* Expression linked list builder */
     383                 :            : static PgBenchExprList *
     384                 :       2790 : make_elist(PgBenchExpr *expr, PgBenchExprList *list)
     385                 :            : {
     386                 :            :     PgBenchExprLink *cons;
     387                 :            : 
     388         [ +  + ]:       2790 :     if (list == NULL)
     389                 :            :     {
     390                 :       1410 :         list = pg_malloc(sizeof(PgBenchExprList));
     391                 :       1410 :         list->head = NULL;
     392                 :       1410 :         list->tail = NULL;
     393                 :            :     }
     394                 :            : 
     395                 :       2790 :     cons = pg_malloc(sizeof(PgBenchExprLink));
     396                 :       2790 :     cons->expr = expr;
     397                 :       2790 :     cons->next = NULL;
     398                 :            : 
     399         [ +  + ]:       2790 :     if (list->head == NULL)
     400                 :       1410 :         list->head = cons;
     401                 :            :     else
     402                 :       1380 :         list->tail->next = cons;
     403                 :            : 
     404                 :       2790 :     list->tail = cons;
     405                 :            : 
     406                 :       2790 :     return list;
     407                 :            : }
     408                 :            : 
     409                 :            : /* Return the length of an expression list */
     410                 :            : static int
     411                 :       1414 : elist_length(PgBenchExprList *list)
     412                 :            : {
     413         [ +  + ]:       1414 :     PgBenchExprLink *link = list != NULL ? list->head : NULL;
     414                 :       1414 :     int         len = 0;
     415                 :            : 
     416         [ +  + ]:       4204 :     for (; link != NULL; link = link->next)
     417                 :       2790 :         len++;
     418                 :            : 
     419                 :       1414 :     return len;
     420                 :            : }
     421                 :            : 
     422                 :            : /* Build function call expression */
     423                 :            : static PgBenchExpr *
     424                 :       1414 : make_func(yyscan_t yyscanner, int fnumber, PgBenchExprList *args)
     425                 :            : {
     426                 :       1414 :     PgBenchExpr *expr = pg_malloc(sizeof(PgBenchExpr));
     427                 :            : 
     428                 :            :     Assert(fnumber >= 0);
     429                 :            : 
     430   [ +  +  +  + ]:       2788 :     if (PGBENCH_FUNCTIONS[fnumber].nargs >= 0 &&
     431                 :       1374 :         PGBENCH_FUNCTIONS[fnumber].nargs != elist_length(args))
     432                 :          2 :         expr_yyerror_more(yyscanner, "unexpected number of arguments",
     433                 :            :                           PGBENCH_FUNCTIONS[fnumber].fname);
     434                 :            : 
     435                 :            :     /* check at least one arg for least & greatest */
     436   [ +  +  +  + ]:       1424 :     if (PGBENCH_FUNCTIONS[fnumber].nargs == -1 &&
     437                 :         12 :         elist_length(args) == 0)
     438                 :          2 :         expr_yyerror_more(yyscanner, "at least one argument expected",
     439                 :            :                           PGBENCH_FUNCTIONS[fnumber].fname);
     440                 :            :     /* special case: case (when ... then ...)+ (else ...)? end */
     441         [ +  + ]:       1410 :     if (PGBENCH_FUNCTIONS[fnumber].nargs == -2)
     442                 :            :     {
     443                 :         28 :         int len = elist_length(args);
     444                 :            : 
     445                 :            :         /* 'else' branch is always present, but could be a NULL-constant */
     446 [ +  - ][ -  + ]:         28 :         if (len < 3 || len % 2 != 1)
     447                 :          0 :             expr_yyerror_more(yyscanner, "odd and >= 3 number of arguments expected",
     448                 :            :                               "case control structure");
     449                 :            :     }
     450                 :            : 
     451                 :       1410 :     expr->etype = ENODE_FUNCTION;
     452                 :       1410 :     expr->u.function.function = PGBENCH_FUNCTIONS[fnumber].tag;
     453                 :            : 
     454                 :            :     /* only the link is used, the head/tail is not useful anymore */
     455         [ +  + ]:       1410 :     expr->u.function.args = args != NULL ? args->head : NULL;
     456         [ +  + ]:       1410 :     if (args)
     457                 :       1408 :         pg_free(args);
     458                 :            : 
     459                 :       1410 :     return expr;
     460                 :            : }
     461                 :            : 
     462                 :            : static PgBenchExpr *
     463                 :         28 : make_case(yyscan_t yyscanner, PgBenchExprList *when_then_list, PgBenchExpr *else_part)
     464                 :            : {
     465                 :         28 :     return make_func(yyscanner,
     466                 :            :                      find_func(yyscanner, "!case_end"),
     467                 :            :                      make_elist(else_part, when_then_list));
     468                 :            : }
     469                 :            : 
     470                 :            : /*
     471                 :            :  * exprscan.l is compiled as part of exprparse.y.  Currently, this is
     472                 :            :  * unavoidable because exprparse does not create a .h file to export
     473                 :            :  * its token symbols.  If these files ever grow large enough to be
     474                 :            :  * worth compiling separately, that could be fixed; but for now it
     475                 :            :  * seems like useless complication.
     476                 :            :  */
     477                 :            : 
     478                 :            : /* First, get rid of "#define yyscan_t" from pgbench.h */
     479                 :            : #undef yyscan_t
     480                 :            : /* ... and the yylval macro, which flex will have its own definition for */
     481                 :            : #undef yylval
     482                 :            : 
     483                 :            : #include "exprscan.c"

Generated by: LCOV version 1.13