PostgreSQL Source Code git master
exprscan.l File Reference
#include "postgres_fe.h"
#include "fe_utils/psqlscan_int.h"
#include "pgbench.h"
#include "exprparse.h"
Include dependency graph for exprscan.l:

Go to the source code of this file.

Functions

int yylex (YYSTYPE *yylval_param, yyscan_t yyscanner)
 
void expr_yyerror_more (yyscan_t yyscanner, const char *message, const char *more)
 
void expr_yyerror (PgBenchExpr **expr_parse_result_p, yyscan_t yyscanner, const char *message)
 
bool expr_lex_one_word (PsqlScanState state, PQExpBuffer word_buf, int *offset)
 
yyscan_t expr_scanner_init (PsqlScanState state, const char *source, int lineno, int start_offset, const char *command)
 
void expr_scanner_finish (yyscan_t yyscanner)
 
int expr_scanner_offset (PsqlScanState state)
 
char * expr_scanner_get_substring (PsqlScanState state, int start_offset, int end_offset, bool chomp)
 
int expr_scanner_get_lineno (PsqlScanState state, int offset)
 

Variables

static const char * expr_source = NULL
 
static int expr_lineno = 0
 
static int expr_start_offset = 0
 
static const char * expr_command = NULL
 
static bool last_was_newline = false
 

Function Documentation

◆ expr_lex_one_word()

bool expr_lex_one_word ( PsqlScanState  state,
PQExpBuffer  word_buf,
int *  offset 
)

Definition at line 315 of file exprscan.l.

316{
317 int lexresult;
318 YYSTYPE lval;
int YYSTYPE
Definition: psqlscanslash.l:39
319
320 /* Must be scanning already */
321 Assert(state->scanbufhandle != NULL);
#define Assert(condition)
Definition: c.h:815
Definition: regguts.h:323
322
323 /* Set current output target */
324 state->output_buf = word_buf;
325 resetPQExpBuffer(word_buf);
void resetPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:146
326
327 /* Set input source */
328 if (state->buffer_stack != NULL)
329 yy_switch_to_buffer(state->buffer_stack->buf, state->scanner);
330 else
331 yy_switch_to_buffer(state->scanbufhandle, state->scanner);
332
333 /* Set start state */
334 state->start_state = INITIAL;
335
336 /* And lex. */
337 lexresult = yylex(&lval, state->scanner);
int yylex(YYSTYPE *yylval_param, yyscan_t yyscanner)
Definition: exprscan.l:94
338
339 /*
340 * Save start offset of word, if any. We could do this more efficiently,
341 * but for now this seems fine.
342 */
343 if (lexresult)
344 *offset = expr_scanner_offset(state) - word_buf->len;
345 else
346 *offset = -1;
int expr_scanner_offset(PsqlScanState state)
Definition: exprscan.l:415
347
348 /*
349 * In case the caller returns to using the regular SQL lexer, reselect the
350 * appropriate initial state.
351 */
void psql_scan_reselect_sql_lexer(PsqlScanState state)
Definition: psqlscan.l:1295
353
354 return (bool) lexresult;
355}

References Assert, expr_scanner_offset(), PQExpBufferData::len, psql_scan_reselect_sql_lexer(), resetPQExpBuffer(), and yylex().

Referenced by process_backslash_command().

◆ expr_scanner_finish()

void expr_scanner_finish ( yyscan_t  yyscanner)

Definition at line 396 of file exprscan.l.

397{
398 PsqlScanState state = yyget_extra(yyscanner);
399
400 /*
401 * Reselect appropriate initial state for SQL lexer.
402 */
404}

References psql_scan_reselect_sql_lexer().

Referenced by process_backslash_command().

◆ expr_scanner_get_lineno()

int expr_scanner_get_lineno ( PsqlScanState  state,
int  offset 
)

Definition at line 456 of file exprscan.l.

457{
458 int lineno = 1;
459 const char *p = state->scanbuf;
460
461 while (*p && offset > 0)
462 {
463 if (*p == '\n')
464 lineno++;
465 p++, offset--;
466 }
467 return lineno;
468}

Referenced by ParseScript(), and process_backslash_command().

◆ expr_scanner_get_substring()

char * expr_scanner_get_substring ( PsqlScanState  state,
int  start_offset,
int  end_offset,
bool  chomp 
)

Definition at line 426 of file exprscan.l.

429{
430 char *result;
431 const char *scanptr = state->scanbuf + start_offset;
432 int slen = end_offset - start_offset;
433
434 Assert(slen >= 0);
435 Assert(end_offset <= strlen(state->scanbuf));
436
437 if (chomp)
438 {
439 while (slen > 0 &&
440 (scanptr[slen - 1] == '\n' || scanptr[slen - 1] == '\r'))
441 slen--;
442 }
443
444 result = (char *) pg_malloc(slen + 1);
445 memcpy(result, scanptr, slen);
446 result[slen] = '\0';
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
447
448 return result;
449}

References Assert, and pg_malloc().

Referenced by expr_yyerror_more(), and process_backslash_command().

◆ expr_scanner_init()

yyscan_t expr_scanner_init ( PsqlScanState  state,
const char *  source,
int  lineno,
int  start_offset,
const char *  command 
)

Definition at line 364 of file exprscan.l.

367{
368 /* Save error context info */
370 expr_lineno = lineno;
371 expr_start_offset = start_offset;
372 expr_command = command;
static int expr_lineno
Definition: exprscan.l:40
static const char * expr_source
Definition: exprscan.l:39
static int expr_start_offset
Definition: exprscan.l:41
static const char * expr_command
Definition: exprscan.l:42
static rewind_source * source
Definition: pg_rewind.c:89
373
374 /* Must be scanning already */
375 Assert(state->scanbufhandle != NULL);
376
377 /* Set current output target */
378 state->output_buf = NULL;
379
380 /* Set input source */
381 if (state->buffer_stack != NULL)
382 yy_switch_to_buffer(state->buffer_stack->buf, state->scanner);
383 else
384 yy_switch_to_buffer(state->scanbufhandle, state->scanner);
385
386 /* Set start state */
387 state->start_state = EXPR;
388
389 return state->scanner;
390}

References Assert, expr_command, expr_lineno, expr_source, expr_start_offset, and source.

Referenced by process_backslash_command().

◆ expr_scanner_offset()

int expr_scanner_offset ( PsqlScanState  state)

Definition at line 415 of file exprscan.l.

416{
417 return strlen(state->scanbuf);
418}

Referenced by expr_lex_one_word(), expr_yyerror_more(), ParseScript(), and process_backslash_command().

◆ expr_yyerror()

void expr_yyerror ( PgBenchExpr **  expr_parse_result_p,
yyscan_t  yyscanner,
const char *  message 
)

Definition at line 304 of file exprscan.l.

305{
306 expr_yyerror_more(yyscanner, message, NULL);
void expr_yyerror_more(yyscan_t yyscanner, const char *message, const char *more)
Definition: exprscan.l:271
307}

References expr_yyerror_more().

◆ expr_yyerror_more()

void expr_yyerror_more ( yyscan_t  yyscanner,
const char *  message,
const char *  more 
)

Definition at line 271 of file exprscan.l.

272{
273 PsqlScanState state = yyget_extra(yyscanner);
274 int error_detection_offset = expr_scanner_offset(state) - 1;
275 YYSTYPE lval;
276 char *full_line;
277
278 /*
279 * While parsing an expression, we may not have collected the whole line
280 * yet from the input source. Lex till EOL so we can report whole line.
281 * (If we're at EOF, it's okay to call yylex() an extra time.)
282 */
283 if (!last_was_newline)
284 {
285 while (yylex(&lval, yyscanner))
286 /* skip */ ;
287 }
static bool last_was_newline
Definition: exprscan.l:45
288
289 /* Extract the line, trimming trailing newline if any */
293 true);
char * expr_scanner_get_substring(PsqlScanState state, int start_offset, int end_offset, bool chomp)
Definition: exprscan.l:426
294
296 message, more, error_detection_offset - expr_start_offset);
void syntax_error(const char *source, int lineno, const char *line, const char *command, const char *msg, const char *more, int column)
Definition: pgbench.c:5501
297}

References expr_command, expr_lineno, expr_scanner_get_substring(), expr_scanner_offset(), expr_source, expr_start_offset, last_was_newline, syntax_error(), and yylex().

Referenced by expr_yyerror().

◆ yylex()

int yylex ( YYSTYPE yylval_param,
yyscan_t  yyscanner 
)

Definition at line 94 of file exprscan.l.

96 {
97 /* Declare some local variables inside yylex(), for convenience */
98 PsqlScanState cur_state = yyextra;
#define yyextra
Definition: scan.l:1118
99
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
109 /* Reset was-newline flag */
110 last_was_newline = false;
111%}
112
113 /* INITIAL state */
114
115{nonspace}+ {
116 /* Found a word, emit and return it */
117 psqlscan_emit(cur_state, yytext, yyleng);
118 return 1;
119 }
void psqlscan_emit(PsqlScanState state, const char *txt, int len)
Definition: psqlscan.l:1463
#define yyleng
Definition: scan.l:1124
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 /* Found "word\\\r?\n", emit and return just "word" */
127 int wordlen = yyleng - 2;
128 if (yytext[wordlen] == '\r')
129 wordlen--;
130 Assert(yytext[wordlen] == '\\');
131 psqlscan_emit(cur_state, yytext, wordlen);
132 return 1;
133 }
134
135{space}+ { /* ignore */ }
136
137{continuation} { /* ignore */ }
138
139{newline} {
140 /* report end of command */
141 last_was_newline = true;
142 return 0;
143 }
144
145 /* EXPR state */
146
147<EXPR>{
148
149"+" { return '+'; }
150"-" { return '-'; }
151"*" { return '*'; }
152"/" { return '/'; }
153"%" { return '%'; } /* C version, also in Pg SQL */
154"=" { return '='; }
155"<>" { return NE_OP; }
156"!=" { return NE_OP; } /* C version, also in Pg SQL */
157"<=" { return LE_OP; }
158">=" { return GE_OP; }
159"<<" { return LS_OP; }
160">>" { return RS_OP; }
161"<" { return '<'; }
162">" { return '>'; }
163"|" { return '|'; }
164"&" { return '&'; }
165"#" { return '#'; }
166"~" { return '~'; }
167
168"(" { return '('; }
169")" { return ')'; }
170"," { return ','; }
171
172{and} { return AND_OP; }
173{or} { return OR_OP; }
174{not} { return NOT_OP; }
175{is} { return IS_OP; }
176{isnull} { return ISNULL_OP; }
177{notnull} { return NOTNULL_OP; }
178
179{case} { return CASE_KW; }
180{when} { return WHEN_KW; }
181{then} { return THEN_KW; }
182{else} { return ELSE_KW; }
183{end} { return END_KW; }
184
185:{alnum}+ {
186 yylval->str = pg_strdup(yytext + 1);
187 return VARIABLE;
188 }
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
189
190{null} { return NULL_CONST; }
191{true} {
192 yylval->bval = true;
193 return BOOLEAN_CONST;
194 }
195{false} {
196 yylval->bval = false;
197 return BOOLEAN_CONST;
198 }
199"9223372036854775808" {
200 /*
201 * 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 }
208{digit}+ {
209 if (!strtoint64(yytext, true, &yylval->ival))
210 expr_yyerror_more(yyscanner, "bigint constant overflow",
211 strdup(yytext));
212 return INTEGER_CONST;
213 }
bool strtoint64(const char *str, bool errorOK, int64 *result)
Definition: pgbench.c:988
214{digit}+(\.{digit}*)?([eE][-+]?{digit}+)? {
215 if (!strtodouble(yytext, true, &yylval->dval))
216 expr_yyerror_more(yyscanner, "double constant overflow",
217 strdup(yytext));
218 return DOUBLE_CONST;
219 }
bool strtodouble(const char *str, bool errorOK, double *dv)
Definition: pgbench.c:1059
220\.{digit}+([eE][-+]?{digit}+)? {
221 if (!strtodouble(yytext, true, &yylval->dval))
222 expr_yyerror_more(yyscanner, "double constant overflow",
223 strdup(yytext));
224 return DOUBLE_CONST;
225 }
226{alpha}{alnum}* {
227 yylval->str = pg_strdup(yytext);
228 return FUNCTION;
229 }
230
231{space}+ { /* ignore */ }
232
233{continuation} { /* ignore */ }
234
235{newline} {
236 /* report end of command */
237 last_was_newline = true;
238 return 0;
239 }
240
241. {
242 /*
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 pg_strdup(yytext));
248 /* NOTREACHED, syntax_error calls exit() */
249 return 0;
250 }
251
252}
253
254<<EOF>> {
255 if (cur_state->buffer_stack == NULL)
256 return 0; /* end of input reached */
257
258 /*
259 * We were expanding a variable, so pop the inclusion
260 * stack and keep lexing
261 */
262 psqlscan_pop_buffer_stack(cur_state);
264 }
void psqlscan_select_top_buffer(PsqlScanState state)
Definition: psqlscan.l:1377
void psqlscan_pop_buffer_stack(PsqlScanState state)
Definition: psqlscan.l:1359
265
266%%

Referenced by expr_lex_one_word(), and expr_yyerror_more().

Variable Documentation

◆ expr_command

const char* expr_command = NULL
static

Definition at line 42 of file exprscan.l.

Referenced by expr_scanner_init(), and expr_yyerror_more().

◆ expr_lineno

int expr_lineno = 0
static

Definition at line 40 of file exprscan.l.

Referenced by expr_scanner_init(), and expr_yyerror_more().

◆ expr_source

const char* expr_source = NULL
static

Definition at line 39 of file exprscan.l.

Referenced by expr_scanner_init(), and expr_yyerror_more().

◆ expr_start_offset

int expr_start_offset = 0
static

Definition at line 41 of file exprscan.l.

Referenced by expr_scanner_init(), and expr_yyerror_more().

◆ last_was_newline

bool last_was_newline = false
static

Definition at line 45 of file exprscan.l.

Referenced by expr_yyerror_more().