Line data Source code
1 : %top{
2 : /*-------------------------------------------------------------------------
3 : *
4 : * exprscan.l
5 : * lexical scanner for pgbench backslash commands
6 : *
7 : * This lexer supports two operating modes:
8 : *
9 : * In INITIAL state, just parse off whitespace-separated words (this mode
10 : * is basically equivalent to strtok(), which is what we used to use).
11 : *
12 : * In EXPR state, lex for the simple expression syntax of exprparse.y.
13 : *
14 : * In either mode, stop upon hitting newline or end of string.
15 : *
16 : * Note that this lexer operates within the framework created by psqlscan.l,
17 : *
18 : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
19 : * Portions Copyright (c) 1994, Regents of the University of California
20 : *
21 : * src/bin/pgbench/exprscan.l
22 : *
23 : *-------------------------------------------------------------------------
24 : */
25 : #include "postgres_fe.h"
26 :
27 : /*
28 : * NB: include exprparse.h only AFTER including pgbench.h, because pgbench.h
29 : * contains definitions needed for YYSTYPE. Likewise, pgbench.h must come after
30 : * psqlscan_int.h for yyscan_t.
31 : */
32 : #include "fe_utils/psqlscan_int.h"
33 : #include "pgbench.h"
34 : #include "exprparse.h"
35 : }
36 :
37 : %{
38 : /* context information for reporting errors in expressions */
39 : static const char *expr_source = NULL;
40 : static int expr_lineno = 0;
41 : static int expr_start_offset = 0;
42 : static const char *expr_command = NULL;
43 :
44 : /* indicates whether last yylex() call read a newline */
45 : static bool last_was_newline = false;
46 :
47 : /* LCOV_EXCL_START */
48 :
49 : %}
50 :
51 : /* Except for the prefix, these options should match psqlscan.l */
52 : %option reentrant
53 : %option bison-bridge
54 : %option 8bit
55 : %option never-interactive
56 : %option nodefault
57 : %option noinput
58 : %option nounput
59 : %option noyywrap
60 : %option warn
61 : %option prefix="expr_yy"
62 :
63 : /* Character classes */
64 : alpha [a-zA-Z\200-\377_]
65 : digit [0-9]
66 : alnum [A-Za-z\200-\377_0-9]
67 : /* {space} + {nonspace} + {newline} should cover all characters */
68 : space [ \t\r\f\v]
69 : nonspace [^ \t\r\f\v\n]
70 : newline [\n]
71 :
72 : /* Line continuation marker */
73 : continuation \\\r?{newline}
74 :
75 : /* case insensitive keywords */
76 : and [Aa][Nn][Dd]
77 : or [Oo][Rr]
78 : not [Nn][Oo][Tt]
79 : case [Cc][Aa][Ss][Ee]
80 : when [Ww][Hh][Ee][Nn]
81 : then [Tt][Hh][Ee][Nn]
82 : else [Ee][Ll][Ss][Ee]
83 : end [Ee][Nn][Dd]
84 : true [Tt][Rr][Uu][Ee]
85 : false [Ff][Aa][Ll][Ss][Ee]
86 : null [Nn][Uu][Ll][Ll]
87 : is [Ii][Ss]
88 : isnull [Ii][Ss][Nn][Uu][Ll][Ll]
89 : notnull [Nn][Oo][Tt][Nn][Uu][Ll][Ll]
90 :
91 : /* Exclusive states */
92 : %x EXPR
93 :
94 : %%
95 :
96 : %{
97 : /* Declare some local variables inside yylex(), for convenience */
98 : PsqlScanState cur_state = yyextra;
99 5107 :
100 : /*
101 : * Force flex into the state indicated by start_state. This has a
102 : * couple of purposes: it lets some of the functions below set a new
103 : * starting state without ugly direct access to flex variables, and it
104 : * allows us to transition from one flex lexer to another so that we
105 : * can lex different parts of the source string using separate lexers.
106 : */
107 : BEGIN(cur_state->start_state);
108 5107 :
109 : /* Reset was-newline flag */
110 : last_was_newline = false;
111 5107 : %}
112 :
113 : /* INITIAL state */
114 :
115 : {nonspace}+ {
116 : /* Found a word, emit and return it */
117 : psqlscan_emit(cur_state, yytext, yyleng);
118 1185 : return 1;
119 1185 : }
120 :
121 : /*
122 : * We need this rule to avoid returning "word\" instead of recognizing
123 : * a continuation marker just after a word:
124 : */
125 : {nonspace}+{continuation} {
126 1 : /* Found "word\\\r?\n", emit and return just "word" */
127 : int wordlen = yyleng - 2;
128 1 : if (yytext[wordlen] == '\r')
129 1 : wordlen--;
130 0 : Assert(yytext[wordlen] == '\\');
131 : psqlscan_emit(cur_state, yytext, wordlen);
132 1 : return 1;
133 1 : }
134 :
135 : {space}+ { /* ignore */ }
136 655 :
137 655 : {continuation} { /* ignore */ }
138 1 :
139 1 : {newline} {
140 108 : /* report end of command */
141 : last_was_newline = true;
142 108 : return 0;
143 108 : }
144 :
145 : /* EXPR state */
146 :
147 : <EXPR>{
148 53 :
149 : "+" { return '+'; }
150 53 : "-" { return '-'; }
151 65 : "*" { return '*'; }
152 65 : "/" { return '/'; }
153 204 : "%" { return '%'; } /* C version, also in Pg SQL */
154 13 : "=" { return '='; }
155 2 : "<>" { return NE_OP; }
156 32 : "!=" { return NE_OP; } /* C version, also in Pg SQL */
157 5 : "<=" { return LE_OP; }
158 3 : ">=" { return GE_OP; }
159 4 : "<<" { return LS_OP; }
160 3 : ">>" { return RS_OP; }
161 7 : "<" { return '<'; }
162 1 : ">" { return '>'; }
163 10 : "|" { return '|'; }
164 6 : "&" { return '&'; }
165 2 : "#" { return '#'; }
166 1 : "~" { return '~'; }
167 1 :
168 2 : "(" { return '('; }
169 451 : ")" { return ')'; }
170 453 : "," { return ','; }
171 453 :
172 343 : {and} { return AND_OP; }
173 44 : {or} { return OR_OP; }
174 5 : {not} { return NOT_OP; }
175 5 : {is} { return IS_OP; }
176 15 : {isnull} { return ISNULL_OP; }
177 8 : {notnull} { return NOTNULL_OP; }
178 1 :
179 1 : {case} { return CASE_KW; }
180 15 : {when} { return WHEN_KW; }
181 16 : {then} { return THEN_KW; }
182 16 : {else} { return ELSE_KW; }
183 17 : {end} { return END_KW; }
184 11 :
185 15 : :{alnum}+ {
186 272 : yylval->str = pg_strdup(yytext + 1);
187 272 : return VARIABLE;
188 272 : }
189 :
190 : {null} { return NULL_CONST; }
191 12 : {true} {
192 : yylval->bval = true;
193 21 : return BOOLEAN_CONST;
194 21 : }
195 : {false} {
196 : yylval->bval = false;
197 13 : return BOOLEAN_CONST;
198 13 : }
199 : "9223372036854775808" {
200 : /*
201 1 : * Special handling for PG_INT64_MIN, which can't
202 : * accurately be represented here, as the minus sign is
203 : * lexed separately and INT64_MIN can't be represented as
204 : * a positive integer.
205 : */
206 : return MAXINT_PLUS_ONE_CONST;
207 1 : }
208 : {digit}+ {
209 : if (!strtoint64(yytext, true, &yylval->ival))
210 797 : expr_yyerror_more(yyscanner, "bigint constant overflow",
211 1 : strdup(yytext));
212 1 : return INTEGER_CONST;
213 796 : }
214 : {digit}+(\.{digit}*)?([eE][-+]?{digit}+)? {
215 : if (!strtodouble(yytext, true, &yylval->dval))
216 61 : expr_yyerror_more(yyscanner, "double constant overflow",
217 1 : strdup(yytext));
218 1 : return DOUBLE_CONST;
219 60 : }
220 : \.{digit}+([eE][-+]?{digit}+)? {
221 : if (!strtodouble(yytext, true, &yylval->dval))
222 2 : expr_yyerror_more(yyscanner, "double constant overflow",
223 1 : strdup(yytext));
224 1 : return DOUBLE_CONST;
225 1 : }
226 : {alpha}{alnum}* {
227 : yylval->str = pg_strdup(yytext);
228 399 : return FUNCTION;
229 399 : }
230 :
231 : {space}+ { /* ignore */ }
232 1656 :
233 1656 : {continuation} { /* ignore */ }
234 17 :
235 17 : {newline} {
236 368 : /* report end of command */
237 : last_was_newline = true;
238 368 : return 0;
239 368 : }
240 :
241 : . {
242 1 : /*
243 : * must strdup yytext so that expr_yyerror_more doesn't
244 : * change it while finding end of line
245 : */
246 : expr_yyerror_more(yyscanner, "unexpected character",
247 1 : pg_strdup(yytext));
248 1 : /* NOTREACHED, syntax_error calls exit() */
249 : return 0;
250 : }
251 :
252 : }
253 :
254 57 : <<EOF>> {
255 : if (cur_state->buffer_stack == NULL)
256 57 : return 0; /* end of input reached */
257 57 :
258 : /*
259 : * We were expanding a variable, so pop the inclusion
260 : * stack and keep lexing
261 : */
262 : psqlscan_pop_buffer_stack(cur_state);
263 0 : psqlscan_select_top_buffer(cur_state);
264 0 : }
265 :
266 0 : %%
267 0 :
268 : /* LCOV_EXCL_STOP */
269 :
270 : void
271 : expr_yyerror_more(yyscan_t yyscanner, const char *message, const char *more)
272 19 : {
273 : PsqlScanState state = yyget_extra(yyscanner);
274 19 : int lineno;
275 : int error_detection_offset;
276 : YYSTYPE lval;
277 : char *full_line;
278 :
279 : psql_scan_get_location(state, &lineno, &error_detection_offset);
280 19 : error_detection_offset--;
281 19 :
282 : /*
283 : * While parsing an expression, we may not have collected the whole line
284 : * yet from the input source. Lex till EOL so we can report whole line.
285 : * (If we're at EOF, it's okay to call yylex() an extra time.)
286 : */
287 : if (!last_was_newline)
288 19 : {
289 : while (yylex(&lval, yyscanner))
290 25 : /* skip */ ;
291 : }
292 :
293 : /* Extract the line, trimming trailing newline if any */
294 : full_line = expr_scanner_get_substring(state,
295 19 : expr_start_offset,
296 : true);
297 :
298 : syntax_error(expr_source, expr_lineno, full_line, expr_command,
299 19 : message, more, error_detection_offset - expr_start_offset);
300 : }
301 :
302 : /*
303 : * (The first argument is enforced by Bison to match the first argument of
304 : * yyparse(), but it is not used here.)
305 : */
306 : void
307 : expr_yyerror(PgBenchExpr **expr_parse_result_p, yyscan_t yyscanner, const char *message)
308 6 : {
309 : expr_yyerror_more(yyscanner, message, NULL);
310 6 : }
311 :
312 : /*
313 : * Collect a space-separated word from a backslash command and return it
314 : * in word_buf, along with its starting string offset in *offset.
315 : * Returns true if successful, false if at end of command.
316 : */
317 : bool
318 : expr_lex_one_word(PsqlScanState state, PQExpBuffer word_buf, int *offset)
319 1318 : {
320 : int lexresult;
321 : YYSTYPE lval;
322 :
323 : /* Must be scanning already */
324 : Assert(state->scanbufhandle != NULL);
325 :
326 : /* Set current output target */
327 : state->output_buf = word_buf;
328 1318 : resetPQExpBuffer(word_buf);
329 1318 :
330 : /* Set input source */
331 : if (state->buffer_stack != NULL)
332 1318 : yy_switch_to_buffer(state->buffer_stack->buf, state->scanner);
333 0 : else
334 : yy_switch_to_buffer(state->scanbufhandle, state->scanner);
335 1318 :
336 : /* Set start state */
337 : state->start_state = INITIAL;
338 1318 :
339 : /* And lex. */
340 : lexresult = yylex(&lval, state->scanner);
341 1318 :
342 : /* Save start offset of word, if any. */
343 : if (lexresult)
344 1318 : {
345 : int lineno;
346 : int end_offset;
347 :
348 : psql_scan_get_location(state, &lineno, &end_offset);
349 1186 : *offset = end_offset - word_buf->len;
350 1186 : }
351 : else
352 : *offset = -1;
353 132 :
354 : /*
355 : * In case the caller returns to using the regular SQL lexer, reselect the
356 : * appropriate initial state.
357 : */
358 : psql_scan_reselect_sql_lexer(state);
359 1318 :
360 : return (bool) lexresult;
361 1318 : }
362 :
363 : /*
364 : * Prepare to lex an expression via expr_yyparse().
365 : *
366 : * Returns the yyscan_t that is to be passed to expr_yyparse().
367 : * (This is just state->scanner, but callers don't need to know that.)
368 : */
369 : yyscan_t
370 : expr_scanner_init(PsqlScanState state,
371 399 : const char *source, int lineno, int start_offset,
372 : const char *command)
373 : {
374 : /* Save error context info */
375 : expr_source = source;
376 399 : expr_lineno = lineno;
377 399 : expr_start_offset = start_offset;
378 399 : expr_command = command;
379 399 :
380 : /* Must be scanning already */
381 : Assert(state->scanbufhandle != NULL);
382 :
383 : /* Set current output target */
384 : state->output_buf = NULL;
385 399 :
386 : /* Set input source */
387 : if (state->buffer_stack != NULL)
388 399 : yy_switch_to_buffer(state->buffer_stack->buf, state->scanner);
389 0 : else
390 : yy_switch_to_buffer(state->scanbufhandle, state->scanner);
391 399 :
392 : /* Set start state */
393 : state->start_state = EXPR;
394 399 :
395 : return state->scanner;
396 399 : }
397 :
398 : /*
399 : * Finish lexing an expression.
400 : */
401 : void
402 : expr_scanner_finish(yyscan_t yyscanner)
403 380 : {
404 : PsqlScanState state = yyget_extra(yyscanner);
405 380 :
406 : /*
407 : * Reselect appropriate initial state for SQL lexer.
408 : */
409 : psql_scan_reselect_sql_lexer(state);
410 380 : }
411 380 :
412 : /*
413 : * Get a malloc'd copy of the lexer input string from start_offset
414 : * to end of current lexer token. If chomp is true, drop any trailing
415 : * newline(s).
416 : *
417 : * We rely on the knowledge that flex modifies the scan buffer by storing
418 : * a NUL at the end of the current token (yytext). Note that this might
419 : * not work quite right if we were parsing a sub-buffer, but since pgbench
420 : * never invokes that functionality, it doesn't matter. Also, this will
421 : * give the wrong answer (the whole remainder of the input) if called
422 : * before any yylex() call has been done.
423 : */
424 : char *
425 : expr_scanner_get_substring(PsqlScanState state,
426 530 : int start_offset,
427 : bool chomp)
428 : {
429 : char *result;
430 : const char *scanptr = state->scanbuf + start_offset;
431 530 : size_t slen = strlen(scanptr);
432 530 :
433 : if (chomp)
434 530 : {
435 : while (slen > 0 &&
436 1006 : (scanptr[slen - 1] == '\n' || scanptr[slen - 1] == '\r'))
437 1006 : slen--;
438 476 : }
439 :
440 : result = (char *) pg_malloc(slen + 1);
441 530 : memcpy(result, scanptr, slen);
442 530 : result[slen] = '\0';
443 530 :
444 : return result;
445 530 : }
446 : /* END: function "expr_scanner_get_substring" */
|
