PostgreSQL Source Code  git master
gramparse.h File Reference
#include "nodes/parsenodes.h"
#include "parser/scanner.h"
#include "parser/gram.h"
Include dependency graph for gramparse.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  base_yy_extra_type
 

Macros

#define pg_yyget_extra(yyscanner)   (*((base_yy_extra_type **) (yyscanner)))
 

Typedefs

typedef struct base_yy_extra_type base_yy_extra_type
 

Functions

int base_yylex (YYSTYPE *lvalp, YYLTYPE *llocp, core_yyscan_t yyscanner)
 
void parser_init (base_yy_extra_type *yyext)
 
int base_yyparse (core_yyscan_t yyscanner)
 

Macro Definition Documentation

◆ pg_yyget_extra

#define pg_yyget_extra (   yyscanner)    (*((base_yy_extra_type **) (yyscanner)))

Definition at line 64 of file gramparse.h.

Referenced by base_yylex().

Typedef Documentation

◆ base_yy_extra_type

Function Documentation

◆ base_yylex()

int base_yylex ( YYSTYPE *  lvalp,
YYLTYPE llocp,
core_yyscan_t  yyscanner 
)

Definition at line 93 of file parser.c.

References Assert, check_uescapechar(), base_yy_extra_type::core_yy_extra, core_yylex(), base_yy_extra_type::have_lookahead, base_yy_extra_type::lookahead_end, base_yy_extra_type::lookahead_hold_char, base_yy_extra_type::lookahead_token, base_yy_extra_type::lookahead_yylloc, base_yy_extra_type::lookahead_yylval, next_token(), pg_yyget_extra, core_yy_extra_type::scanbuf, scanner_yyerror(), core_YYSTYPE::str, str_udeescape(), truncate_identifier(), YYLTYPE, and yyscanner.

Referenced by filtered_base_yylex().

94 {
96  int cur_token;
97  int next_token;
98  int cur_token_length;
99  YYLTYPE cur_yylloc;
100 
101  /* Get next token --- we might already have it */
102  if (yyextra->have_lookahead)
103  {
104  cur_token = yyextra->lookahead_token;
105  lvalp->core_yystype = yyextra->lookahead_yylval;
106  *llocp = yyextra->lookahead_yylloc;
107  *(yyextra->lookahead_end) = yyextra->lookahead_hold_char;
108  yyextra->have_lookahead = false;
109  }
110  else
111  cur_token = core_yylex(&(lvalp->core_yystype), llocp, yyscanner);
112 
113  /*
114  * If this token isn't one that requires lookahead, just return it. If it
115  * does, determine the token length. (We could get that via strlen(), but
116  * since we have such a small set of possibilities, hardwiring seems
117  * feasible and more efficient --- at least for the fixed-length cases.)
118  */
119  switch (cur_token)
120  {
121  case NOT:
122  cur_token_length = 3;
123  break;
124  case NULLS_P:
125  cur_token_length = 5;
126  break;
127  case WITH:
128  cur_token_length = 4;
129  break;
130  case UIDENT:
131  case USCONST:
132  cur_token_length = strlen(yyextra->core_yy_extra.scanbuf + *llocp);
133  break;
134  default:
135  return cur_token;
136  }
137 
138  /*
139  * Identify end+1 of current token. core_yylex() has temporarily stored a
140  * '\0' here, and will undo that when we call it again. We need to redo
141  * it to fully revert the lookahead call for error reporting purposes.
142  */
143  yyextra->lookahead_end = yyextra->core_yy_extra.scanbuf +
144  *llocp + cur_token_length;
145  Assert(*(yyextra->lookahead_end) == '\0');
146 
147  /*
148  * Save and restore *llocp around the call. It might look like we could
149  * avoid this by just passing &lookahead_yylloc to core_yylex(), but that
150  * does not work because flex actually holds onto the last-passed pointer
151  * internally, and will use that for error reporting. We need any error
152  * reports to point to the current token, not the next one.
153  */
154  cur_yylloc = *llocp;
155 
156  /* Get next token, saving outputs into lookahead variables */
157  next_token = core_yylex(&(yyextra->lookahead_yylval), llocp, yyscanner);
158  yyextra->lookahead_token = next_token;
159  yyextra->lookahead_yylloc = *llocp;
160 
161  *llocp = cur_yylloc;
162 
163  /* Now revert the un-truncation of the current token */
164  yyextra->lookahead_hold_char = *(yyextra->lookahead_end);
165  *(yyextra->lookahead_end) = '\0';
166 
167  yyextra->have_lookahead = true;
168 
169  /* Replace cur_token if needed, based on lookahead */
170  switch (cur_token)
171  {
172  case NOT:
173  /* Replace NOT by NOT_LA if it's followed by BETWEEN, IN, etc */
174  switch (next_token)
175  {
176  case BETWEEN:
177  case IN_P:
178  case LIKE:
179  case ILIKE:
180  case SIMILAR:
181  cur_token = NOT_LA;
182  break;
183  }
184  break;
185 
186  case NULLS_P:
187  /* Replace NULLS_P by NULLS_LA if it's followed by FIRST or LAST */
188  switch (next_token)
189  {
190  case FIRST_P:
191  case LAST_P:
192  cur_token = NULLS_LA;
193  break;
194  }
195  break;
196 
197  case WITH:
198  /* Replace WITH by WITH_LA if it's followed by TIME or ORDINALITY */
199  switch (next_token)
200  {
201  case TIME:
202  case ORDINALITY:
203  cur_token = WITH_LA;
204  break;
205  }
206  break;
207 
208  case UIDENT:
209  case USCONST:
210  /* Look ahead for UESCAPE */
211  if (next_token == UESCAPE)
212  {
213  /* Yup, so get third token, which had better be SCONST */
214  const char *escstr;
215 
216  /* Again save and restore *llocp */
217  cur_yylloc = *llocp;
218 
219  /* Un-truncate current token so errors point to third token */
220  *(yyextra->lookahead_end) = yyextra->lookahead_hold_char;
221 
222  /* Get third token */
223  next_token = core_yylex(&(yyextra->lookahead_yylval),
224  llocp, yyscanner);
225 
226  /* If we throw error here, it will point to third token */
227  if (next_token != SCONST)
228  scanner_yyerror("UESCAPE must be followed by a simple string literal",
229  yyscanner);
230 
231  escstr = yyextra->lookahead_yylval.str;
232  if (strlen(escstr) != 1 || !check_uescapechar(escstr[0]))
233  scanner_yyerror("invalid Unicode escape character",
234  yyscanner);
235 
236  /* Now restore *llocp; errors will point to first token */
237  *llocp = cur_yylloc;
238 
239  /* Apply Unicode conversion */
240  lvalp->core_yystype.str =
241  str_udeescape(lvalp->core_yystype.str,
242  escstr[0],
243  *llocp,
244  yyscanner);
245 
246  /*
247  * We don't need to revert the un-truncation of UESCAPE. What
248  * we do want to do is clear have_lookahead, thereby consuming
249  * all three tokens.
250  */
251  yyextra->have_lookahead = false;
252  }
253  else
254  {
255  /* No UESCAPE, so convert using default escape character */
256  lvalp->core_yystype.str =
257  str_udeescape(lvalp->core_yystype.str,
258  '\\',
259  *llocp,
260  yyscanner);
261  }
262 
263  if (cur_token == UIDENT)
264  {
265  /* It's an identifier, so truncate as appropriate */
266  truncate_identifier(lvalp->core_yystype.str,
267  strlen(lvalp->core_yystype.str),
268  true);
269  cur_token = IDENT;
270  }
271  else if (cur_token == USCONST)
272  {
273  cur_token = SCONST;
274  }
275  break;
276  }
277 
278  return cur_token;
279 }
char * lookahead_end
Definition: gramparse.h:49
core_YYSTYPE lookahead_yylval
Definition: gramparse.h:47
core_yy_extra_type core_yy_extra
Definition: gramparse.h:40
static bool next_token(char **lineptr, char *buf, int bufsz, bool *initial_quote, bool *terminating_comma, int elevel, char **err_msg)
Definition: hba.c:195
char * scanbuf
Definition: scanner.h:72
static bool check_uescapechar(unsigned char escape)
Definition: parser.c:307
void scanner_yyerror(const char *message, core_yyscan_t yyscanner) pg_attribute_noreturn()
void truncate_identifier(char *ident, int len, bool warn)
Definition: scansup.c:186
static char * str_udeescape(const char *str, char escape, int position, core_yyscan_t yyscanner)
Definition: parser.c:327
#define YYLTYPE
Definition: scanner.h:44
int core_yylex(core_YYSTYPE *lvalp, YYLTYPE *llocp, core_yyscan_t yyscanner)
#define pg_yyget_extra(yyscanner)
Definition: gramparse.h:64
char * str
Definition: scanner.h:32
#define Assert(condition)
Definition: c.h:745
YYLTYPE lookahead_yylloc
Definition: gramparse.h:48
char lookahead_hold_char
Definition: gramparse.h:50
static core_yyscan_t yyscanner
Definition: pl_scanner.c:106

◆ base_yyparse()

int base_yyparse ( core_yyscan_t  yyscanner)

Referenced by main(), and raw_parser().

◆ parser_init()

void parser_init ( base_yy_extra_type yyext)

Referenced by raw_parser().