pg_query 2.1.4 → 2.2.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (85) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +29 -0
  3. data/README.md +32 -0
  4. data/Rakefile +2 -2
  5. data/ext/pg_query/include/access/twophase.h +2 -0
  6. data/ext/pg_query/include/access/xact.h +6 -0
  7. data/ext/pg_query/include/access/xlog_internal.h +10 -1
  8. data/ext/pg_query/include/access/xlogreader.h +10 -0
  9. data/ext/pg_query/include/catalog/dependency.h +2 -0
  10. data/ext/pg_query/include/catalog/pg_class.h +1 -1
  11. data/ext/pg_query/include/catalog/pg_class_d.h +1 -1
  12. data/ext/pg_query/include/catalog/pg_control.h +2 -0
  13. data/ext/pg_query/include/catalog/pg_operator.h +3 -1
  14. data/ext/pg_query/include/catalog/pg_publication.h +3 -0
  15. data/ext/pg_query/include/catalog/pg_type.h +1 -0
  16. data/ext/pg_query/include/commands/async.h +1 -1
  17. data/ext/pg_query/include/commands/tablespace.h +2 -0
  18. data/ext/pg_query/include/commands/trigger.h +8 -0
  19. data/ext/pg_query/include/lib/simplehash.h +13 -13
  20. data/ext/pg_query/include/libpq/libpq.h +1 -0
  21. data/ext/pg_query/include/mb/pg_wchar.h +1 -0
  22. data/ext/pg_query/include/miscadmin.h +24 -11
  23. data/ext/pg_query/include/nodes/execnodes.h +2 -2
  24. data/ext/pg_query/include/nodes/parsenodes.h +5 -4
  25. data/ext/pg_query/include/nodes/pathnodes.h +2 -1
  26. data/ext/pg_query/include/nodes/pg_list.h +1 -0
  27. data/ext/pg_query/include/nodes/plannodes.h +18 -3
  28. data/ext/pg_query/include/optimizer/optimizer.h +0 -5
  29. data/ext/pg_query/include/parser/gram.h +2 -2
  30. data/ext/pg_query/include/parser/kwlist.h +1 -1
  31. data/ext/pg_query/include/parser/parse_coerce.h +1 -0
  32. data/ext/pg_query/include/pg_config.h +16 -13
  33. data/ext/pg_query/include/pg_query.h +2 -2
  34. data/ext/pg_query/include/pg_query_fingerprint_defs.c +286 -314
  35. data/ext/pg_query/include/pg_query_outfuncs_defs.c +1 -0
  36. data/ext/pg_query/include/pg_query_readfuncs_defs.c +1 -0
  37. data/ext/pg_query/include/pgstat.h +2 -1
  38. data/ext/pg_query/include/plpgsql.h +2 -2
  39. data/ext/pg_query/include/port/pg_bitutils.h +48 -2
  40. data/ext/pg_query/include/port.h +4 -0
  41. data/ext/pg_query/include/protobuf/pg_query.pb-c.h +4 -3
  42. data/ext/pg_query/include/replication/reorderbuffer.h +6 -5
  43. data/ext/pg_query/include/replication/slot.h +1 -1
  44. data/ext/pg_query/include/storage/block.h +1 -1
  45. data/ext/pg_query/include/storage/lock.h +6 -5
  46. data/ext/pg_query/include/storage/lwlock.h +1 -0
  47. data/ext/pg_query/include/storage/proc.h +14 -0
  48. data/ext/pg_query/include/storage/s_lock.h +24 -0
  49. data/ext/pg_query/include/tcop/pquery.h +6 -0
  50. data/ext/pg_query/include/utils/builtins.h +1 -0
  51. data/ext/pg_query/include/utils/inval.h +1 -0
  52. data/ext/pg_query/include/utils/portal.h +13 -0
  53. data/ext/pg_query/include/utils/rel.h +0 -1
  54. data/ext/pg_query/include/utils/relcache.h +1 -2
  55. data/ext/pg_query/include/utils/snapmgr.h +1 -0
  56. data/ext/pg_query/pg_query.pb-c.c +18 -5
  57. data/ext/pg_query/pg_query_deparse.c +8 -8
  58. data/ext/pg_query/pg_query_fingerprint.c +1 -0
  59. data/ext/pg_query/pg_query_json_plpgsql.c +68 -0
  60. data/ext/pg_query/pg_query_normalize.c +43 -7
  61. data/ext/pg_query/pg_query_outfuncs.h +1 -0
  62. data/ext/pg_query/pg_query_outfuncs_json.c +11 -0
  63. data/ext/pg_query/pg_query_parse_plpgsql.c +58 -15
  64. data/ext/pg_query/src_backend_catalog_namespace.c +1 -0
  65. data/ext/pg_query/src_backend_libpq_pqcomm.c +8 -0
  66. data/ext/pg_query/src_backend_nodes_copyfuncs.c +23 -33
  67. data/ext/pg_query/src_backend_nodes_equalfuncs.c +1 -0
  68. data/ext/pg_query/src_backend_nodes_list.c +12 -0
  69. data/ext/pg_query/src_backend_parser_gram.c +18 -3
  70. data/ext/pg_query/src_backend_parser_scan.c +493 -253
  71. data/ext/pg_query/src_backend_tcop_postgres.c +11 -1
  72. data/ext/pg_query/src_backend_utils_adt_ruleutils.c +38 -10
  73. data/ext/pg_query/src_backend_utils_misc_guc.c +1 -0
  74. data/ext/pg_query/src_common_wchar.c +11 -0
  75. data/ext/pg_query/src_pl_plpgsql_src_pl_comp.c +4 -2
  76. data/ext/pg_query/src_pl_plpgsql_src_pl_gram.c +1 -1
  77. data/ext/pg_query/src_port_pg_bitutils.c +1 -22
  78. data/ext/pg_query/src_port_snprintf.c +9 -7
  79. data/lib/pg_query/deparse.rb +7 -1
  80. data/lib/pg_query/fingerprint.rb +13 -2
  81. data/lib/pg_query/parse.rb +5 -3
  82. data/lib/pg_query/pg_query_pb.rb +2 -1
  83. data/lib/pg_query/treewalker.rb +6 -0
  84. data/lib/pg_query/version.rb +1 -1
  85. metadata +2 -2
@@ -43,8 +43,7 @@
43
43
  *--------------------------------------------------------------------
44
44
  */
45
45
 
46
- #line 2 "scan.c"
47
- #line 2 "scan.l"
46
+ #line 1 "scan.c"
48
47
  /*-------------------------------------------------------------------------
49
48
  *
50
49
  * scan.l
@@ -87,9 +86,7 @@
87
86
  #include "parser/scansup.h"
88
87
  #include "mb/pg_wchar.h"
89
88
 
90
-
91
-
92
- #line 48 "scan.c"
89
+ #line 44 "scan.c"
93
90
 
94
91
  #define YY_INT_ALIGNED short int
95
92
 
@@ -97,12 +94,246 @@
97
94
 
98
95
  #define FLEX_SCANNER
99
96
  #define YY_FLEX_MAJOR_VERSION 2
100
- #define YY_FLEX_MINOR_VERSION 5
101
- #define YY_FLEX_SUBMINOR_VERSION 35
97
+ #define YY_FLEX_MINOR_VERSION 6
98
+ #define YY_FLEX_SUBMINOR_VERSION 4
102
99
  #if YY_FLEX_SUBMINOR_VERSION > 0
103
100
  #define FLEX_BETA
104
101
  #endif
105
102
 
103
+ #ifdef yy_create_buffer
104
+ #define core_yy_create_buffer_ALREADY_DEFINED
105
+ #else
106
+ #define yy_create_buffer core_yy_create_buffer
107
+ #endif
108
+
109
+ #ifdef yy_delete_buffer
110
+ #define core_yy_delete_buffer_ALREADY_DEFINED
111
+ #else
112
+ #define yy_delete_buffer core_yy_delete_buffer
113
+ #endif
114
+
115
+ #ifdef yy_scan_buffer
116
+ #define core_yy_scan_buffer_ALREADY_DEFINED
117
+ #else
118
+ #define yy_scan_buffer core_yy_scan_buffer
119
+ #endif
120
+
121
+ #ifdef yy_scan_string
122
+ #define core_yy_scan_string_ALREADY_DEFINED
123
+ #else
124
+ #define yy_scan_string core_yy_scan_string
125
+ #endif
126
+
127
+ #ifdef yy_scan_bytes
128
+ #define core_yy_scan_bytes_ALREADY_DEFINED
129
+ #else
130
+ #define yy_scan_bytes core_yy_scan_bytes
131
+ #endif
132
+
133
+ #ifdef yy_init_buffer
134
+ #define core_yy_init_buffer_ALREADY_DEFINED
135
+ #else
136
+ #define yy_init_buffer core_yy_init_buffer
137
+ #endif
138
+
139
+ #ifdef yy_flush_buffer
140
+ #define core_yy_flush_buffer_ALREADY_DEFINED
141
+ #else
142
+ #define yy_flush_buffer core_yy_flush_buffer
143
+ #endif
144
+
145
+ #ifdef yy_load_buffer_state
146
+ #define core_yy_load_buffer_state_ALREADY_DEFINED
147
+ #else
148
+ #define yy_load_buffer_state core_yy_load_buffer_state
149
+ #endif
150
+
151
+ #ifdef yy_switch_to_buffer
152
+ #define core_yy_switch_to_buffer_ALREADY_DEFINED
153
+ #else
154
+ #define yy_switch_to_buffer core_yy_switch_to_buffer
155
+ #endif
156
+
157
+ #ifdef yypush_buffer_state
158
+ #define core_yypush_buffer_state_ALREADY_DEFINED
159
+ #else
160
+ #define yypush_buffer_state core_yypush_buffer_state
161
+ #endif
162
+
163
+ #ifdef yypop_buffer_state
164
+ #define core_yypop_buffer_state_ALREADY_DEFINED
165
+ #else
166
+ #define yypop_buffer_state core_yypop_buffer_state
167
+ #endif
168
+
169
+ #ifdef yyensure_buffer_stack
170
+ #define core_yyensure_buffer_stack_ALREADY_DEFINED
171
+ #else
172
+ #define yyensure_buffer_stack core_yyensure_buffer_stack
173
+ #endif
174
+
175
+ #ifdef yylex
176
+ #define core_yylex_ALREADY_DEFINED
177
+ #else
178
+ #define yylex core_yylex
179
+ #endif
180
+
181
+ #ifdef yyrestart
182
+ #define core_yyrestart_ALREADY_DEFINED
183
+ #else
184
+ #define yyrestart core_yyrestart
185
+ #endif
186
+
187
+ #ifdef yylex_init
188
+ #define core_yylex_init_ALREADY_DEFINED
189
+ #else
190
+ #define yylex_init core_yylex_init
191
+ #endif
192
+
193
+ #ifdef yylex_init_extra
194
+ #define core_yylex_init_extra_ALREADY_DEFINED
195
+ #else
196
+ #define yylex_init_extra core_yylex_init_extra
197
+ #endif
198
+
199
+ #ifdef yylex_destroy
200
+ #define core_yylex_destroy_ALREADY_DEFINED
201
+ #else
202
+ #define yylex_destroy core_yylex_destroy
203
+ #endif
204
+
205
+ #ifdef yyget_debug
206
+ #define core_yyget_debug_ALREADY_DEFINED
207
+ #else
208
+ #define yyget_debug core_yyget_debug
209
+ #endif
210
+
211
+ #ifdef yyset_debug
212
+ #define core_yyset_debug_ALREADY_DEFINED
213
+ #else
214
+ #define yyset_debug core_yyset_debug
215
+ #endif
216
+
217
+ #ifdef yyget_extra
218
+ #define core_yyget_extra_ALREADY_DEFINED
219
+ #else
220
+ #define yyget_extra core_yyget_extra
221
+ #endif
222
+
223
+ #ifdef yyset_extra
224
+ #define core_yyset_extra_ALREADY_DEFINED
225
+ #else
226
+ #define yyset_extra core_yyset_extra
227
+ #endif
228
+
229
+ #ifdef yyget_in
230
+ #define core_yyget_in_ALREADY_DEFINED
231
+ #else
232
+ #define yyget_in core_yyget_in
233
+ #endif
234
+
235
+ #ifdef yyset_in
236
+ #define core_yyset_in_ALREADY_DEFINED
237
+ #else
238
+ #define yyset_in core_yyset_in
239
+ #endif
240
+
241
+ #ifdef yyget_out
242
+ #define core_yyget_out_ALREADY_DEFINED
243
+ #else
244
+ #define yyget_out core_yyget_out
245
+ #endif
246
+
247
+ #ifdef yyset_out
248
+ #define core_yyset_out_ALREADY_DEFINED
249
+ #else
250
+ #define yyset_out core_yyset_out
251
+ #endif
252
+
253
+ #ifdef yyget_leng
254
+ #define core_yyget_leng_ALREADY_DEFINED
255
+ #else
256
+ #define yyget_leng core_yyget_leng
257
+ #endif
258
+
259
+ #ifdef yyget_text
260
+ #define core_yyget_text_ALREADY_DEFINED
261
+ #else
262
+ #define yyget_text core_yyget_text
263
+ #endif
264
+
265
+ #ifdef yyget_lineno
266
+ #define core_yyget_lineno_ALREADY_DEFINED
267
+ #else
268
+ #define yyget_lineno core_yyget_lineno
269
+ #endif
270
+
271
+ #ifdef yyset_lineno
272
+ #define core_yyset_lineno_ALREADY_DEFINED
273
+ #else
274
+ #define yyset_lineno core_yyset_lineno
275
+ #endif
276
+
277
+ #ifdef yyget_column
278
+ #define core_yyget_column_ALREADY_DEFINED
279
+ #else
280
+ #define yyget_column core_yyget_column
281
+ #endif
282
+
283
+ #ifdef yyset_column
284
+ #define core_yyset_column_ALREADY_DEFINED
285
+ #else
286
+ #define yyset_column core_yyset_column
287
+ #endif
288
+
289
+ #ifdef yywrap
290
+ #define core_yywrap_ALREADY_DEFINED
291
+ #else
292
+ #define yywrap core_yywrap
293
+ #endif
294
+
295
+ #ifdef yyget_lval
296
+ #define core_yyget_lval_ALREADY_DEFINED
297
+ #else
298
+ #define yyget_lval core_yyget_lval
299
+ #endif
300
+
301
+ #ifdef yyset_lval
302
+ #define core_yyset_lval_ALREADY_DEFINED
303
+ #else
304
+ #define yyset_lval core_yyset_lval
305
+ #endif
306
+
307
+ #ifdef yyget_lloc
308
+ #define core_yyget_lloc_ALREADY_DEFINED
309
+ #else
310
+ #define yyget_lloc core_yyget_lloc
311
+ #endif
312
+
313
+ #ifdef yyset_lloc
314
+ #define core_yyset_lloc_ALREADY_DEFINED
315
+ #else
316
+ #define yyset_lloc core_yyset_lloc
317
+ #endif
318
+
319
+ #ifdef yyalloc
320
+ #define core_yyalloc_ALREADY_DEFINED
321
+ #else
322
+ #define yyalloc core_yyalloc
323
+ #endif
324
+
325
+ #ifdef yyrealloc
326
+ #define core_yyrealloc_ALREADY_DEFINED
327
+ #else
328
+ #define yyrealloc core_yyrealloc
329
+ #endif
330
+
331
+ #ifdef yyfree
332
+ #define core_yyfree_ALREADY_DEFINED
333
+ #else
334
+ #define yyfree core_yyfree
335
+ #endif
336
+
106
337
  /* First, we deal with platform-specific or compiler-specific issues. */
107
338
 
108
339
  /* begin standard C headers. */
@@ -144,7 +375,6 @@ typedef int flex_int32_t;
144
375
  typedef unsigned char flex_uint8_t;
145
376
  typedef unsigned short int flex_uint16_t;
146
377
  typedef unsigned int flex_uint32_t;
147
- #endif /* ! C99 */
148
378
 
149
379
  /* Limits of integral types. */
150
380
  #ifndef INT8_MIN
@@ -175,38 +405,32 @@ typedef unsigned int flex_uint32_t;
175
405
  #define UINT32_MAX (4294967295U)
176
406
  #endif
177
407
 
178
- #endif /* ! FLEXINT_H */
179
-
180
- #ifdef __cplusplus
181
-
182
- /* The "const" storage-class-modifier is valid. */
183
- #define YY_USE_CONST
184
-
185
- #else /* ! __cplusplus */
408
+ #ifndef SIZE_MAX
409
+ #define SIZE_MAX (~(size_t)0)
410
+ #endif
186
411
 
187
- /* C99 requires __STDC__ to be defined as 1. */
188
- #if defined (__STDC__)
412
+ #endif /* ! C99 */
189
413
 
190
- #define YY_USE_CONST
414
+ #endif /* ! FLEXINT_H */
191
415
 
192
- #endif /* defined (__STDC__) */
193
- #endif /* ! __cplusplus */
416
+ /* begin standard C++ headers. */
194
417
 
195
- #ifdef YY_USE_CONST
418
+ /* TODO: this is always defined, so inline it */
196
419
  #define yyconst const
420
+
421
+ #if defined(__GNUC__) && __GNUC__ >= 3
422
+ #define yynoreturn __attribute__((__noreturn__))
197
423
  #else
198
- #define yyconst
424
+ #define yynoreturn
199
425
  #endif
200
426
 
201
427
  /* Returned upon end-of-file. */
202
428
  #define YY_NULL 0
203
429
 
204
- /* Promotes a possibly negative, possibly signed char to an unsigned
205
- * integer for use as an array index. If the signed char is negative,
206
- * we want to instead treat it as an 8-bit unsigned char, hence the
207
- * double cast.
430
+ /* Promotes a possibly negative, possibly signed char to an
431
+ * integer in range [0..255] for use as an array index.
208
432
  */
209
- #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
433
+ #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
210
434
 
211
435
  /* An opaque pointer. */
212
436
  #ifndef YY_TYPEDEF_YY_SCANNER_T
@@ -230,25 +454,29 @@ typedef void* yyscan_t;
230
454
  * definition of BEGIN.
231
455
  */
232
456
  #define BEGIN yyg->yy_start = 1 + 2 *
233
-
234
457
  /* Translate the current start state into a value that can be later handed
235
458
  * to BEGIN to return to the state. The YYSTATE alias is for lex
236
459
  * compatibility.
237
460
  */
238
461
  #define YY_START ((yyg->yy_start - 1) / 2)
239
462
  #define YYSTATE YY_START
240
-
241
463
  /* Action number for EOF rule of a given start state. */
242
464
  #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
243
-
244
465
  /* Special action meaning "start processing a new file". */
245
- #define YY_NEW_FILE core_yyrestart(yyin ,yyscanner )
246
-
466
+ #define YY_NEW_FILE yyrestart( yyin , yyscanner )
247
467
  #define YY_END_OF_BUFFER_CHAR 0
248
468
 
249
469
  /* Size of default input buffer. */
250
470
  #ifndef YY_BUF_SIZE
471
+ #ifdef __ia64__
472
+ /* On IA-64, the buffer size is 16k, not 8k.
473
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
474
+ * Ditto for the __ia64__ case accordingly.
475
+ */
476
+ #define YY_BUF_SIZE 32768
477
+ #else
251
478
  #define YY_BUF_SIZE 16384
479
+ #endif /* __ia64__ */
252
480
  #endif
253
481
 
254
482
  /* The state buf must be large enough to hold one state per character in the main buffer.
@@ -268,8 +496,9 @@ typedef size_t yy_size_t;
268
496
  #define EOB_ACT_CONTINUE_SCAN 0
269
497
  #define EOB_ACT_END_OF_FILE 1
270
498
  #define EOB_ACT_LAST_MATCH 2
271
-
499
+
272
500
  #define YY_LESS_LINENO(n)
501
+ #define YY_LINENO_REWIND_TO(ptr)
273
502
 
274
503
  /* Return all but the first "n" matched characters back to the input stream. */
275
504
  #define yyless(n) \
@@ -284,7 +513,6 @@ typedef size_t yy_size_t;
284
513
  YY_DO_BEFORE_ACTION; /* set up yytext again */ \
285
514
  } \
286
515
  while ( 0 )
287
-
288
516
  #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
289
517
 
290
518
  #ifndef YY_STRUCT_YY_BUFFER_STATE
@@ -299,7 +527,7 @@ struct yy_buffer_state
299
527
  /* Size of input buffer in bytes, not including room for EOB
300
528
  * characters.
301
529
  */
302
- yy_size_t yy_buf_size;
530
+ int yy_buf_size;
303
531
 
304
532
  /* Number of characters read into yy_ch_buf, not including EOB
305
533
  * characters.
@@ -327,7 +555,7 @@ struct yy_buffer_state
327
555
 
328
556
  int yy_bs_lineno; /**< The line count. */
329
557
  int yy_bs_column; /**< The column count. */
330
-
558
+
331
559
  /* Whether to try to fill the input buffer when we reach the
332
560
  * end of it.
333
561
  */
@@ -344,7 +572,7 @@ struct yy_buffer_state
344
572
  * possible backing-up.
345
573
  *
346
574
  * When we actually see the EOF, we change the status to "new"
347
- * (via core_yyrestart()), so that the user can continue scanning by
575
+ * (via yyrestart()), so that the user can continue scanning by
348
576
  * just pointing yyin at a new input file.
349
577
  */
350
578
  #define YY_BUFFER_EOF_PENDING 2
@@ -361,73 +589,67 @@ struct yy_buffer_state
361
589
  #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
362
590
  ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
363
591
  : NULL)
364
-
365
592
  /* Same as previous macro, but useful when we know that the buffer stack is not
366
593
  * NULL or when we need an lvalue. For internal use only.
367
594
  */
368
595
  #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
369
596
 
370
- void core_yyrestart (FILE *input_file ,yyscan_t yyscanner );
371
- void core_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
372
- YY_BUFFER_STATE core_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
373
- void core_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
374
- void core_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
375
- void core_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
376
- void core_yypop_buffer_state (yyscan_t yyscanner );
597
+ void yyrestart ( FILE *input_file , yyscan_t yyscanner );
598
+ void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
599
+ YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
600
+ void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
601
+ void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
602
+ void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
603
+ void yypop_buffer_state ( yyscan_t yyscanner );
377
604
 
378
- static void core_yyensure_buffer_stack (yyscan_t yyscanner );
379
- static void core_yy_load_buffer_state (yyscan_t yyscanner );
380
- static void core_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
605
+ static void yyensure_buffer_stack ( yyscan_t yyscanner );
606
+ static void yy_load_buffer_state ( yyscan_t yyscanner );
607
+ static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
608
+ #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
381
609
 
382
- #define YY_FLUSH_BUFFER core_yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
610
+ YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
611
+ YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
612
+ YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, yy_size_t len , yyscan_t yyscanner );
383
613
 
384
- YY_BUFFER_STATE core_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
385
- YY_BUFFER_STATE core_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
386
- YY_BUFFER_STATE core_yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
387
-
388
- void *core_yyalloc (yy_size_t ,yyscan_t yyscanner );
389
- void *core_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
390
- void core_yyfree (void * ,yyscan_t yyscanner );
391
-
392
- #define yy_new_buffer core_yy_create_buffer
614
+ void *yyalloc ( yy_size_t , yyscan_t yyscanner );
615
+ void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
616
+ void yyfree ( void * , yyscan_t yyscanner );
393
617
 
618
+ #define yy_new_buffer yy_create_buffer
394
619
  #define yy_set_interactive(is_interactive) \
395
620
  { \
396
621
  if ( ! YY_CURRENT_BUFFER ){ \
397
- core_yyensure_buffer_stack (yyscanner); \
622
+ yyensure_buffer_stack (yyscanner); \
398
623
  YY_CURRENT_BUFFER_LVALUE = \
399
- core_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
624
+ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
400
625
  } \
401
626
  YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
402
627
  }
403
-
404
628
  #define yy_set_bol(at_bol) \
405
629
  { \
406
630
  if ( ! YY_CURRENT_BUFFER ){\
407
- core_yyensure_buffer_stack (yyscanner); \
631
+ yyensure_buffer_stack (yyscanner); \
408
632
  YY_CURRENT_BUFFER_LVALUE = \
409
- core_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
633
+ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
410
634
  } \
411
635
  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
412
636
  }
413
-
414
637
  #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
415
638
 
416
639
  /* Begin user sect3 */
417
640
 
418
- #define core_yywrap(n) 1
641
+ #define core_yywrap(yyscanner) (/*CONSTCOND*/1)
419
642
  #define YY_SKIP_YYWRAP
643
+ typedef flex_uint8_t YY_CHAR;
420
644
 
421
- typedef unsigned char YY_CHAR;
422
-
423
- typedef yyconst struct yy_trans_info *yy_state_type;
645
+ typedef const struct yy_trans_info *yy_state_type;
424
646
 
425
647
  #define yytext_ptr yytext_r
426
648
 
427
- static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
428
- static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
429
- static int yy_get_next_buffer (yyscan_t yyscanner );
430
- static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
649
+ static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
650
+ static yy_state_type yy_try_NUL_trans ( yy_state_type current_state , yyscan_t yyscanner);
651
+ static int yy_get_next_buffer ( yyscan_t yyscanner );
652
+ static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
431
653
 
432
654
  /* Done after the current pattern has been matched and before the
433
655
  * corresponding action - sets up yytext.
@@ -438,7 +660,6 @@ static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
438
660
  yyg->yy_hold_char = *yy_cp; \
439
661
  *yy_cp = '\0'; \
440
662
  yyg->yy_c_buf_p = yy_cp;
441
-
442
663
  #define YY_NUM_RULES 66
443
664
  #define YY_END_OF_BUFFER 67
444
665
  struct yy_trans_info
@@ -446,7 +667,7 @@ struct yy_trans_info
446
667
  flex_int16_t yy_verify;
447
668
  flex_int16_t yy_nxt;
448
669
  };
449
- static yyconst struct yy_trans_info yy_transition[17678] =
670
+ static const struct yy_trans_info yy_transition[17678] =
450
671
  {
451
672
  { 0, 0 }, { 0,17422 }, { 0, 0 }, { 0,17420 }, { 1,6192 },
452
673
  { 2,6192 }, { 3,6192 }, { 4,6192 }, { 5,6192 }, { 6,6192 },
@@ -4282,7 +4503,7 @@ static yyconst struct yy_trans_info yy_transition[17678] =
4282
4503
  { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
4283
4504
  { 0, 0 }, { 0, 0 }, { 257, 67 }, { 1, 0 }, };
4284
4505
 
4285
- static __thread yyconst struct yy_trans_info *yy_start_state_list[25] =
4506
+ static __thread const struct yy_trans_info *yy_start_state_list[25] =
4286
4507
  {
4287
4508
  &yy_transition[1],
4288
4509
  &yy_transition[3],
@@ -4376,7 +4597,7 @@ const uint16 ScanKeywordTokens[] = {
4376
4597
  #define YY_EXTRA_TYPE core_yy_extra_type *
4377
4598
 
4378
4599
  /*
4379
- * Each call to core_yylex must set yylloc to the location of the found token
4600
+ * Each call to yylex must set yylloc to the location of the found token
4380
4601
  * (expressed as a byte offset from the start of the input text).
4381
4602
  * When we parse a token that requires multiple lexer rules to process,
4382
4603
  * this should be done in the first such rule, else yylloc will point
@@ -4425,6 +4646,7 @@ static void check_escape_warning(core_yyscan_t yyscanner);
4425
4646
  extern int core_yyget_column(yyscan_t yyscanner);
4426
4647
  extern void core_yyset_column(int column_no, yyscan_t yyscanner);
4427
4648
 
4649
+ #line 4600 "scan.c"
4428
4650
  #define YY_NO_INPUT 1
4429
4651
  /*
4430
4652
  * OK, here is a short description of lex/flex rules behavior.
@@ -4453,16 +4675,6 @@ extern void core_yyset_column(int column_no, yyscan_t yyscanner);
4453
4675
  * The default one is probably not the right thing.
4454
4676
  */
4455
4677
 
4456
-
4457
-
4458
-
4459
-
4460
-
4461
-
4462
-
4463
-
4464
-
4465
-
4466
4678
  /*
4467
4679
  * In order to make the world safe for Windows and Mac clients as well as
4468
4680
  * Unix ones, we accept either \n or \r as a newline. A DOS-style \r\n
@@ -4583,7 +4795,7 @@ extern void core_yyset_column(int column_no, yyscan_t yyscanner);
4583
4795
  * Note that xcstart must appear before operator, as explained above!
4584
4796
  * Also whitespace (comment) must appear before operator.
4585
4797
  */
4586
- #line 4538 "scan.c"
4798
+ #line 4749 "scan.c"
4587
4799
 
4588
4800
  #define INITIAL 0
4589
4801
  #define xb 1
@@ -4648,7 +4860,7 @@ struct yyguts_t
4648
4860
 
4649
4861
  }; /* end struct yyguts_t */
4650
4862
 
4651
- static int yy_init_globals (yyscan_t yyscanner );
4863
+ static int yy_init_globals ( yyscan_t yyscanner );
4652
4864
 
4653
4865
  /* This must go here because YYSTYPE and YYLTYPE are included
4654
4866
  * from bison output in section 1.*/
@@ -4656,46 +4868,50 @@ static int yy_init_globals (yyscan_t yyscanner );
4656
4868
 
4657
4869
  # define yylloc yyg->yylloc_r
4658
4870
 
4659
- int core_yylex_init (yyscan_t* scanner);
4871
+ int yylex_init (yyscan_t* scanner);
4660
4872
 
4661
- int core_yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
4873
+ int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
4662
4874
 
4663
4875
  /* Accessor methods to globals.
4664
4876
  These are made visible to non-reentrant scanners for convenience. */
4665
4877
 
4666
- int core_yylex_destroy (yyscan_t yyscanner );
4878
+ int yylex_destroy ( yyscan_t yyscanner );
4879
+
4880
+ int yyget_debug ( yyscan_t yyscanner );
4881
+
4882
+ void yyset_debug ( int debug_flag , yyscan_t yyscanner );
4667
4883
 
4668
- int core_yyget_debug (yyscan_t yyscanner );
4884
+ YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
4669
4885
 
4670
- void core_yyset_debug (int debug_flag ,yyscan_t yyscanner );
4886
+ void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
4671
4887
 
4672
- YY_EXTRA_TYPE core_yyget_extra (yyscan_t yyscanner );
4888
+ FILE *yyget_in ( yyscan_t yyscanner );
4673
4889
 
4674
- void core_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
4890
+ void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
4675
4891
 
4676
- FILE *core_yyget_in (yyscan_t yyscanner );
4892
+ FILE *yyget_out ( yyscan_t yyscanner );
4677
4893
 
4678
- void core_yyset_in (FILE * in_str ,yyscan_t yyscanner );
4894
+ void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
4679
4895
 
4680
- FILE *core_yyget_out (yyscan_t yyscanner );
4896
+ yy_size_t yyget_leng ( yyscan_t yyscanner );
4681
4897
 
4682
- void core_yyset_out (FILE * out_str ,yyscan_t yyscanner );
4898
+ char *yyget_text ( yyscan_t yyscanner );
4683
4899
 
4684
- yy_size_t core_yyget_leng (yyscan_t yyscanner );
4900
+ int yyget_lineno ( yyscan_t yyscanner );
4685
4901
 
4686
- char *core_yyget_text (yyscan_t yyscanner );
4902
+ void yyset_lineno ( int _line_number , yyscan_t yyscanner );
4687
4903
 
4688
- int core_yyget_lineno (yyscan_t yyscanner );
4904
+ int yyget_column ( yyscan_t yyscanner );
4689
4905
 
4690
- void core_yyset_lineno (int line_number ,yyscan_t yyscanner );
4906
+ void yyset_column ( int _column_no , yyscan_t yyscanner );
4691
4907
 
4692
- YYSTYPE * core_yyget_lval (yyscan_t yyscanner );
4908
+ YYSTYPE * yyget_lval ( yyscan_t yyscanner );
4693
4909
 
4694
- void core_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
4910
+ void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );
4695
4911
 
4696
- YYLTYPE *core_yyget_lloc (yyscan_t yyscanner );
4912
+ YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
4697
4913
 
4698
- void core_yyset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
4914
+ void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
4699
4915
 
4700
4916
  /* Macros after this point can all be overridden by user definitions in
4701
4917
  * section 1.
@@ -4703,33 +4919,41 @@ void core_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
4703
4919
 
4704
4920
  #ifndef YY_SKIP_YYWRAP
4705
4921
  #ifdef __cplusplus
4706
- extern "C" int core_yywrap (yyscan_t yyscanner );
4922
+ extern "C" int yywrap ( yyscan_t yyscanner );
4707
4923
  #else
4708
- extern int core_yywrap (yyscan_t yyscanner );
4924
+ extern int yywrap ( yyscan_t yyscanner );
4709
4925
  #endif
4710
4926
  #endif
4711
4927
 
4928
+ #ifndef YY_NO_UNPUT
4929
+
4930
+ #endif
4931
+
4712
4932
  #ifndef yytext_ptr
4713
- static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
4933
+ static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
4714
4934
  #endif
4715
4935
 
4716
4936
  #ifdef YY_NEED_STRLEN
4717
- static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
4937
+ static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
4718
4938
  #endif
4719
4939
 
4720
4940
  #ifndef YY_NO_INPUT
4721
-
4722
4941
  #ifdef __cplusplus
4723
- static int yyinput (yyscan_t yyscanner );
4942
+ static int yyinput ( yyscan_t yyscanner );
4724
4943
  #else
4725
- static int input (yyscan_t yyscanner );
4944
+ static int input ( yyscan_t yyscanner );
4726
4945
  #endif
4727
4946
 
4728
4947
  #endif
4729
4948
 
4730
4949
  /* Amount of stuff to slurp up with each read. */
4731
4950
  #ifndef YY_READ_BUF_SIZE
4951
+ #ifdef __ia64__
4952
+ /* On IA-64, the buffer size is 16k, not 8k */
4953
+ #define YY_READ_BUF_SIZE 16384
4954
+ #else
4732
4955
  #define YY_READ_BUF_SIZE 8192
4956
+ #endif /* __ia64__ */
4733
4957
  #endif
4734
4958
 
4735
4959
  /* Copy whatever the last rule matched to the standard output. */
@@ -4737,7 +4961,7 @@ static int input (yyscan_t yyscanner );
4737
4961
  /* This used to be an fputs(), but since the string might contain NUL's,
4738
4962
  * we now use fwrite().
4739
4963
  */
4740
- #define ECHO fwrite( yytext, yyleng, 1, yyout )
4964
+ #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
4741
4965
  #endif
4742
4966
 
4743
4967
  /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
@@ -4761,7 +4985,7 @@ static int input (yyscan_t yyscanner );
4761
4985
  else \
4762
4986
  { \
4763
4987
  errno=0; \
4764
- while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
4988
+ while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
4765
4989
  { \
4766
4990
  if( errno != EINTR) \
4767
4991
  { \
@@ -4802,10 +5026,10 @@ static int input (yyscan_t yyscanner );
4802
5026
  #ifndef YY_DECL
4803
5027
  #define YY_DECL_IS_OURS 1
4804
5028
 
4805
- extern int core_yylex \
4806
- (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
5029
+ extern int yylex \
5030
+ (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);
4807
5031
 
4808
- #define YY_DECL int core_yylex \
5032
+ #define YY_DECL int yylex \
4809
5033
  (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
4810
5034
  #endif /* !YY_DECL */
4811
5035
 
@@ -4818,7 +5042,7 @@ extern int core_yylex \
4818
5042
 
4819
5043
  /* Code executed at the end of each rule. */
4820
5044
  #ifndef YY_BREAK
4821
- #define YY_BREAK break;
5045
+ #define YY_BREAK /*LINTED*/break;
4822
5046
  #endif
4823
5047
 
4824
5048
  #define YY_RULE_SETUP \
@@ -4828,16 +5052,11 @@ extern int core_yylex \
4828
5052
  */
4829
5053
  YY_DECL
4830
5054
  {
4831
- register yy_state_type yy_current_state;
4832
- register char *yy_cp, *yy_bp;
4833
- register int yy_act;
5055
+ yy_state_type yy_current_state;
5056
+ char *yy_cp, *yy_bp;
5057
+ int yy_act;
4834
5058
  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
4835
5059
 
4836
- #line 420 "scan.l"
4837
-
4838
-
4839
- #line 4791 "scan.c"
4840
-
4841
5060
  yylval = yylval_param;
4842
5061
 
4843
5062
  yylloc = yylloc_param;
@@ -4860,15 +5079,21 @@ YY_DECL
4860
5079
  yyout = stdout;
4861
5080
 
4862
5081
  if ( ! YY_CURRENT_BUFFER ) {
4863
- core_yyensure_buffer_stack (yyscanner);
5082
+ yyensure_buffer_stack (yyscanner);
4864
5083
  YY_CURRENT_BUFFER_LVALUE =
4865
- core_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
5084
+ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
4866
5085
  }
4867
5086
 
4868
- core_yy_load_buffer_state(yyscanner );
5087
+ yy_load_buffer_state( yyscanner );
4869
5088
  }
4870
5089
 
4871
- while ( 1 ) /* loops until end-of-file is reached */
5090
+ {
5091
+ #line 420 "scan.l"
5092
+
5093
+
5094
+ #line 5045 "scan.c"
5095
+
5096
+ while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
4872
5097
  {
4873
5098
  yy_cp = yyg->yy_c_buf_p;
4874
5099
 
@@ -4883,12 +5108,12 @@ YY_DECL
4883
5108
  yy_current_state = yy_start_state_list[yyg->yy_start];
4884
5109
  yy_match:
4885
5110
  {
4886
- register yyconst struct yy_trans_info *yy_trans_info;
5111
+ const struct yy_trans_info *yy_trans_info;
4887
5112
 
4888
- register YY_CHAR yy_c;
5113
+ YY_CHAR yy_c;
4889
5114
 
4890
5115
  for ( yy_c = YY_SC_TO_UI(*yy_cp);
4891
- (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->
5116
+ (yy_trans_info = &yy_current_state[yy_c])->
4892
5117
  yy_verify == yy_c;
4893
5118
  yy_c = YY_SC_TO_UI(*++yy_cp) )
4894
5119
  yy_current_state += yy_trans_info->yy_nxt;
@@ -5140,6 +5365,7 @@ case 19:
5140
5365
  case 20:
5141
5366
  /* rule 20 can match eol */
5142
5367
  #line 585 "scan.l"
5368
+ YY_RULE_SETUP
5143
5369
  case YY_STATE_EOF(xqs):
5144
5370
  #line 585 "scan.l"
5145
5371
  {
@@ -5267,6 +5493,7 @@ case 26:
5267
5493
  case 27:
5268
5494
  /* rule 27 can match eol */
5269
5495
  #line 685 "scan.l"
5496
+ YY_RULE_SETUP
5270
5497
  case YY_STATE_EOF(xeu):
5271
5498
  #line 685 "scan.l"
5272
5499
  {
@@ -5658,12 +5885,15 @@ YY_RULE_SETUP
5658
5885
  * spacing between ? as a substition character and a simple operator (e.g. "?=?")
5659
5886
  */
5660
5887
  if (yytext[0] == '?' &&
5888
+ strcmp(yytext, "?<@") != 0 && strcmp(yytext, "?@>") != 0 &&
5889
+ strcmp(yytext, "?~") != 0 && strcmp(yytext, "?@") != 0 &&
5661
5890
  strcmp(yytext, "?|") != 0 && strcmp(yytext, "?&") != 0 &&
5662
5891
  strcmp(yytext, "?#") != 0 && strcmp(yytext, "?-") != 0 &&
5663
5892
  strcmp(yytext, "?-|") != 0 && strcmp(yytext, "?||") != 0)
5664
5893
  nchars = 1;
5665
5894
 
5666
5895
  if (yytext[0] != '?' && strchr(yytext, '?') &&
5896
+ strcmp(yytext, "^?") != 0 && strcmp(yytext, "#?") != 0 &&
5667
5897
  strcmp(yytext, "@?") != 0)
5668
5898
  /* Lex up to just before the ? character */
5669
5899
  nchars = strchr(yytext, '?') - yytext;
@@ -5719,7 +5949,7 @@ YY_RULE_SETUP
5719
5949
  YY_BREAK
5720
5950
  case 57:
5721
5951
  YY_RULE_SETUP
5722
- #line 1016 "scan.l"
5952
+ #line 1019 "scan.l"
5723
5953
  {
5724
5954
  SET_YYLLOC();
5725
5955
  yylval->ival = atol(yytext + 1);
@@ -5728,7 +5958,7 @@ YY_RULE_SETUP
5728
5958
  YY_BREAK
5729
5959
  case 58:
5730
5960
  YY_RULE_SETUP
5731
- #line 1022 "scan.l"
5961
+ #line 1025 "scan.l"
5732
5962
  {
5733
5963
  SET_YYLLOC();
5734
5964
  return process_integer_literal(yytext, yylval);
@@ -5736,7 +5966,7 @@ YY_RULE_SETUP
5736
5966
  YY_BREAK
5737
5967
  case 59:
5738
5968
  YY_RULE_SETUP
5739
- #line 1026 "scan.l"
5969
+ #line 1029 "scan.l"
5740
5970
  {
5741
5971
  SET_YYLLOC();
5742
5972
  yylval->str = pstrdup(yytext);
@@ -5745,7 +5975,7 @@ YY_RULE_SETUP
5745
5975
  YY_BREAK
5746
5976
  case 60:
5747
5977
  YY_RULE_SETUP
5748
- #line 1031 "scan.l"
5978
+ #line 1034 "scan.l"
5749
5979
  {
5750
5980
  /* throw back the .., and treat as integer */
5751
5981
  yyless(yyleng - 2);
@@ -5755,7 +5985,7 @@ YY_RULE_SETUP
5755
5985
  YY_BREAK
5756
5986
  case 61:
5757
5987
  YY_RULE_SETUP
5758
- #line 1037 "scan.l"
5988
+ #line 1040 "scan.l"
5759
5989
  {
5760
5990
  SET_YYLLOC();
5761
5991
  yylval->str = pstrdup(yytext);
@@ -5764,7 +5994,7 @@ YY_RULE_SETUP
5764
5994
  YY_BREAK
5765
5995
  case 62:
5766
5996
  YY_RULE_SETUP
5767
- #line 1042 "scan.l"
5997
+ #line 1045 "scan.l"
5768
5998
  {
5769
5999
  /*
5770
6000
  * throw back the [Ee], and figure out whether what
@@ -5777,7 +6007,7 @@ YY_RULE_SETUP
5777
6007
  YY_BREAK
5778
6008
  case 63:
5779
6009
  YY_RULE_SETUP
5780
- #line 1051 "scan.l"
6010
+ #line 1054 "scan.l"
5781
6011
  {
5782
6012
  /* throw back the [Ee][+-], and proceed as above */
5783
6013
  yyless(yyleng - 2);
@@ -5787,7 +6017,7 @@ YY_RULE_SETUP
5787
6017
  YY_BREAK
5788
6018
  case 64:
5789
6019
  YY_RULE_SETUP
5790
- #line 1059 "scan.l"
6020
+ #line 1062 "scan.l"
5791
6021
  {
5792
6022
  int kwnum;
5793
6023
  char *ident;
@@ -5821,14 +6051,14 @@ YY_RULE_SETUP
5821
6051
  YY_BREAK
5822
6052
  case 65:
5823
6053
  YY_RULE_SETUP
5824
- #line 1090 "scan.l"
6054
+ #line 1093 "scan.l"
5825
6055
  {
5826
6056
  SET_YYLLOC();
5827
6057
  return yytext[0];
5828
6058
  }
5829
6059
  YY_BREAK
5830
6060
  case YY_STATE_EOF(INITIAL):
5831
- #line 1095 "scan.l"
6061
+ #line 1098 "scan.l"
5832
6062
  {
5833
6063
  SET_YYLLOC();
5834
6064
  yyterminate();
@@ -5836,10 +6066,10 @@ case YY_STATE_EOF(INITIAL):
5836
6066
  YY_BREAK
5837
6067
  case 66:
5838
6068
  YY_RULE_SETUP
5839
- #line 1100 "scan.l"
6069
+ #line 1103 "scan.l"
5840
6070
  YY_FATAL_ERROR( "flex scanner jammed" );
5841
6071
  YY_BREAK
5842
- #line 5794 "scan.c"
6072
+ #line 6023 "scan.c"
5843
6073
 
5844
6074
  case YY_END_OF_BUFFER:
5845
6075
  {
@@ -5855,7 +6085,7 @@ YY_FATAL_ERROR( "flex scanner jammed" );
5855
6085
  /* We're scanning a new file or input source. It's
5856
6086
  * possible that this happened because the user
5857
6087
  * just pointed yyin at a new source and called
5858
- * core_yylex(). If so, then we have to assure
6088
+ * yylex(). If so, then we have to assure
5859
6089
  * consistency between YY_CURRENT_BUFFER and our
5860
6090
  * globals. Here is the right place to do so, because
5861
6091
  * this is the first action (other than possibly a
@@ -5915,7 +6145,7 @@ YY_FATAL_ERROR( "flex scanner jammed" );
5915
6145
  {
5916
6146
  yyg->yy_did_buffer_switch_on_eof = 0;
5917
6147
 
5918
- if ( core_yywrap(yyscanner ) )
6148
+ if ( yywrap( yyscanner ) )
5919
6149
  {
5920
6150
  /* Note: because we've taken care in
5921
6151
  * yy_get_next_buffer() to have set up
@@ -5968,7 +6198,8 @@ YY_FATAL_ERROR( "flex scanner jammed" );
5968
6198
  "fatal flex scanner internal error--no action found" );
5969
6199
  } /* end of action switch */
5970
6200
  } /* end of scanning one token */
5971
- } /* end of core_yylex */
6201
+ } /* end of user's declarations */
6202
+ } /* end of yylex */
5972
6203
 
5973
6204
  /* yy_get_next_buffer - try to read in a new buffer
5974
6205
  *
@@ -5980,9 +6211,9 @@ YY_FATAL_ERROR( "flex scanner jammed" );
5980
6211
  static int yy_get_next_buffer (yyscan_t yyscanner)
5981
6212
  {
5982
6213
  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
5983
- register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
5984
- register char *source = yyg->yytext_ptr;
5985
- register int number_to_move, i;
6214
+ char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
6215
+ char *source = yyg->yytext_ptr;
6216
+ int number_to_move, i;
5986
6217
  int ret_val;
5987
6218
 
5988
6219
  if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
@@ -6011,7 +6242,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
6011
6242
  /* Try to read more data. */
6012
6243
 
6013
6244
  /* First move last chars to start of buffer. */
6014
- number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
6245
+ number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);
6015
6246
 
6016
6247
  for ( i = 0; i < number_to_move; ++i )
6017
6248
  *(dest++) = *(source++);
@@ -6031,7 +6262,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
6031
6262
  { /* Not enough room in the buffer - grow it. */
6032
6263
 
6033
6264
  /* just a shorter name for the current buffer */
6034
- YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
6265
+ YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
6035
6266
 
6036
6267
  int yy_c_buf_p_offset =
6037
6268
  (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
@@ -6047,11 +6278,12 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
6047
6278
 
6048
6279
  b->yy_ch_buf = (char *)
6049
6280
  /* Include room in for 2 EOB chars. */
6050
- core_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
6281
+ yyrealloc( (void *) b->yy_ch_buf,
6282
+ (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
6051
6283
  }
6052
6284
  else
6053
6285
  /* Can't grow it, we don't own it. */
6054
- b->yy_ch_buf = 0;
6286
+ b->yy_ch_buf = NULL;
6055
6287
 
6056
6288
  if ( ! b->yy_ch_buf )
6057
6289
  YY_FATAL_ERROR(
@@ -6079,7 +6311,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
6079
6311
  if ( number_to_move == YY_MORE_ADJ )
6080
6312
  {
6081
6313
  ret_val = EOB_ACT_END_OF_FILE;
6082
- core_yyrestart(yyin ,yyscanner);
6314
+ yyrestart( yyin , yyscanner);
6083
6315
  }
6084
6316
 
6085
6317
  else
@@ -6093,12 +6325,15 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
6093
6325
  else
6094
6326
  ret_val = EOB_ACT_CONTINUE_SCAN;
6095
6327
 
6096
- if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
6328
+ if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
6097
6329
  /* Extend the array by 50%, plus the number we really need. */
6098
6330
  yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
6099
- YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) core_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
6331
+ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
6332
+ (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
6100
6333
  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
6101
6334
  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
6335
+ /* "- 2" to take care of EOB's */
6336
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
6102
6337
  }
6103
6338
 
6104
6339
  yyg->yy_n_chars += number_to_move;
@@ -6114,8 +6349,8 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
6114
6349
 
6115
6350
  static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
6116
6351
  {
6117
- register yy_state_type yy_current_state;
6118
- register char *yy_cp;
6352
+ yy_state_type yy_current_state;
6353
+ char *yy_cp;
6119
6354
  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
6120
6355
 
6121
6356
  yy_current_state = yy_start_state_list[yyg->yy_start];
@@ -6135,20 +6370,24 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
6135
6370
  */
6136
6371
  static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
6137
6372
  {
6138
- register int yy_is_jam;
6373
+ int yy_is_jam;
6139
6374
  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
6140
6375
 
6141
- register int yy_c = 256;
6142
- register yyconst struct yy_trans_info *yy_trans_info;
6376
+ int yy_c = 256;
6377
+ const struct yy_trans_info *yy_trans_info;
6143
6378
 
6144
6379
  yy_trans_info = &yy_current_state[(unsigned int) yy_c];
6145
6380
  yy_current_state += yy_trans_info->yy_nxt;
6146
6381
  yy_is_jam = (yy_trans_info->yy_verify != yy_c);
6147
6382
 
6148
- (void) yyg;
6383
+ (void)yyg;
6149
6384
  return yy_is_jam ? 0 : yy_current_state;
6150
6385
  }
6151
6386
 
6387
+ #ifndef YY_NO_UNPUT
6388
+
6389
+ #endif
6390
+
6152
6391
  #ifndef YY_NO_INPUT
6153
6392
  #ifdef __cplusplus
6154
6393
  static int yyinput (yyscan_t yyscanner)
@@ -6191,13 +6430,13 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
6191
6430
  */
6192
6431
 
6193
6432
  /* Reset buffer status. */
6194
- core_yyrestart(yyin ,yyscanner);
6433
+ yyrestart( yyin , yyscanner);
6195
6434
 
6196
6435
  /*FALLTHROUGH*/
6197
6436
 
6198
6437
  case EOB_ACT_END_OF_FILE:
6199
6438
  {
6200
- if ( core_yywrap(yyscanner ) )
6439
+ if ( yywrap( yyscanner ) )
6201
6440
  return 0;
6202
6441
 
6203
6442
  if ( ! yyg->yy_did_buffer_switch_on_eof )
@@ -6229,34 +6468,34 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
6229
6468
  * @param yyscanner The scanner object.
6230
6469
  * @note This function does not reset the start condition to @c INITIAL .
6231
6470
  */
6232
- void core_yyrestart (FILE * input_file , yyscan_t yyscanner)
6471
+ void yyrestart (FILE * input_file , yyscan_t yyscanner)
6233
6472
  {
6234
6473
  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
6235
6474
 
6236
6475
  if ( ! YY_CURRENT_BUFFER ){
6237
- core_yyensure_buffer_stack (yyscanner);
6476
+ yyensure_buffer_stack (yyscanner);
6238
6477
  YY_CURRENT_BUFFER_LVALUE =
6239
- core_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
6478
+ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
6240
6479
  }
6241
6480
 
6242
- core_yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
6243
- core_yy_load_buffer_state(yyscanner );
6481
+ yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
6482
+ yy_load_buffer_state( yyscanner );
6244
6483
  }
6245
6484
 
6246
6485
  /** Switch to a different input buffer.
6247
6486
  * @param new_buffer The new input buffer.
6248
6487
  * @param yyscanner The scanner object.
6249
6488
  */
6250
- void core_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
6489
+ void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
6251
6490
  {
6252
6491
  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
6253
6492
 
6254
6493
  /* TODO. We should be able to replace this entire function body
6255
6494
  * with
6256
- * core_yypop_buffer_state();
6257
- * core_yypush_buffer_state(new_buffer);
6495
+ * yypop_buffer_state();
6496
+ * yypush_buffer_state(new_buffer);
6258
6497
  */
6259
- core_yyensure_buffer_stack (yyscanner);
6498
+ yyensure_buffer_stack (yyscanner);
6260
6499
  if ( YY_CURRENT_BUFFER == new_buffer )
6261
6500
  return;
6262
6501
 
@@ -6269,17 +6508,17 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
6269
6508
  }
6270
6509
 
6271
6510
  YY_CURRENT_BUFFER_LVALUE = new_buffer;
6272
- core_yy_load_buffer_state(yyscanner );
6511
+ yy_load_buffer_state( yyscanner );
6273
6512
 
6274
6513
  /* We don't actually know whether we did this switch during
6275
- * EOF (core_yywrap()) processing, but the only time this flag
6276
- * is looked at is after core_yywrap() is called, so it's safe
6514
+ * EOF (yywrap()) processing, but the only time this flag
6515
+ * is looked at is after yywrap() is called, so it's safe
6277
6516
  * to go ahead and always set it.
6278
6517
  */
6279
6518
  yyg->yy_did_buffer_switch_on_eof = 1;
6280
6519
  }
6281
6520
 
6282
- static void core_yy_load_buffer_state (yyscan_t yyscanner)
6521
+ static void yy_load_buffer_state (yyscan_t yyscanner)
6283
6522
  {
6284
6523
  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
6285
6524
  yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
@@ -6294,32 +6533,32 @@ static void core_yy_load_buffer_state (yyscan_t yyscanner)
6294
6533
  * @param yyscanner The scanner object.
6295
6534
  * @return the allocated buffer state.
6296
6535
  */
6297
- YY_BUFFER_STATE core_yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
6536
+ YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
6298
6537
  {
6299
6538
  YY_BUFFER_STATE b;
6300
6539
 
6301
- b = (YY_BUFFER_STATE) core_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
6540
+ b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
6302
6541
  if ( ! b )
6303
- YY_FATAL_ERROR( "out of dynamic memory in core_yy_create_buffer()" );
6542
+ YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
6304
6543
 
6305
6544
  b->yy_buf_size = size;
6306
6545
 
6307
6546
  /* yy_ch_buf has to be 2 characters longer than the size given because
6308
6547
  * we need to put in 2 end-of-buffer characters.
6309
6548
  */
6310
- b->yy_ch_buf = (char *) core_yyalloc(b->yy_buf_size + 2 ,yyscanner );
6549
+ b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
6311
6550
  if ( ! b->yy_ch_buf )
6312
- YY_FATAL_ERROR( "out of dynamic memory in core_yy_create_buffer()" );
6551
+ YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
6313
6552
 
6314
6553
  b->yy_is_our_buffer = 1;
6315
6554
 
6316
- core_yy_init_buffer(b,file ,yyscanner);
6555
+ yy_init_buffer( b, file , yyscanner);
6317
6556
 
6318
6557
  return b;
6319
6558
  }
6320
6559
 
6321
6560
  /** Destroy the buffer.
6322
- * @param b a buffer created with core_yy_create_buffer()
6561
+ * @param b a buffer created with yy_create_buffer()
6323
6562
  * @param yyscanner The scanner object.
6324
6563
  */
6325
6564
 
@@ -6327,21 +6566,21 @@ static void core_yy_load_buffer_state (yyscan_t yyscanner)
6327
6566
 
6328
6567
  /* Initializes or reinitializes a buffer.
6329
6568
  * This function is sometimes called more than once on the same buffer,
6330
- * such as during a core_yyrestart() or at EOF.
6569
+ * such as during a yyrestart() or at EOF.
6331
6570
  */
6332
- static void core_yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
6571
+ static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
6333
6572
 
6334
6573
  {
6335
6574
  int oerrno = errno;
6336
6575
  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
6337
6576
 
6338
- core_yy_flush_buffer(b ,yyscanner);
6577
+ yy_flush_buffer( b , yyscanner);
6339
6578
 
6340
6579
  b->yy_input_file = file;
6341
6580
  b->yy_fill_buffer = 1;
6342
6581
 
6343
- /* If b is the current buffer, then core_yy_init_buffer was _probably_
6344
- * called from core_yyrestart() or through yy_get_next_buffer.
6582
+ /* If b is the current buffer, then yy_init_buffer was _probably_
6583
+ * called from yyrestart() or through yy_get_next_buffer.
6345
6584
  * In that case, we don't want to reset the lineno or column.
6346
6585
  */
6347
6586
  if (b != YY_CURRENT_BUFFER){
@@ -6358,7 +6597,7 @@ static void core_yy_load_buffer_state (yyscan_t yyscanner)
6358
6597
  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
6359
6598
  * @param yyscanner The scanner object.
6360
6599
  */
6361
- void core_yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
6600
+ void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
6362
6601
  {
6363
6602
  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
6364
6603
  if ( ! b )
@@ -6379,7 +6618,7 @@ static void core_yy_load_buffer_state (yyscan_t yyscanner)
6379
6618
  b->yy_buffer_status = YY_BUFFER_NEW;
6380
6619
 
6381
6620
  if ( b == YY_CURRENT_BUFFER )
6382
- core_yy_load_buffer_state(yyscanner );
6621
+ yy_load_buffer_state( yyscanner );
6383
6622
  }
6384
6623
 
6385
6624
  /** Pushes the new state onto the stack. The new state becomes
@@ -6399,7 +6638,7 @@ static void core_yy_load_buffer_state (yyscan_t yyscanner)
6399
6638
  /* Allocates the stack if it does not exist.
6400
6639
  * Guarantees space for at least one push.
6401
6640
  */
6402
- static void core_yyensure_buffer_stack (yyscan_t yyscanner)
6641
+ static void yyensure_buffer_stack (yyscan_t yyscanner)
6403
6642
  {
6404
6643
  yy_size_t num_to_alloc;
6405
6644
  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
@@ -6410,15 +6649,15 @@ static void core_yyensure_buffer_stack (yyscan_t yyscanner)
6410
6649
  * scanner will even need a stack. We use 2 instead of 1 to avoid an
6411
6650
  * immediate realloc on the next call.
6412
6651
  */
6413
- num_to_alloc = 1;
6414
- yyg->yy_buffer_stack = (struct yy_buffer_state**)core_yyalloc
6652
+ num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
6653
+ yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
6415
6654
  (num_to_alloc * sizeof(struct yy_buffer_state*)
6416
6655
  , yyscanner);
6417
6656
  if ( ! yyg->yy_buffer_stack )
6418
- YY_FATAL_ERROR( "out of dynamic memory in core_yyensure_buffer_stack()" );
6419
-
6657
+ YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
6658
+
6420
6659
  memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
6421
-
6660
+
6422
6661
  yyg->yy_buffer_stack_max = num_to_alloc;
6423
6662
  yyg->yy_buffer_stack_top = 0;
6424
6663
  return;
@@ -6427,15 +6666,15 @@ static void core_yyensure_buffer_stack (yyscan_t yyscanner)
6427
6666
  if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
6428
6667
 
6429
6668
  /* Increase the buffer to prepare for a possible push. */
6430
- int grow_size = 8 /* arbitrary grow size */;
6669
+ yy_size_t grow_size = 8 /* arbitrary grow size */;
6431
6670
 
6432
6671
  num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
6433
- yyg->yy_buffer_stack = (struct yy_buffer_state**)core_yyrealloc
6672
+ yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
6434
6673
  (yyg->yy_buffer_stack,
6435
6674
  num_to_alloc * sizeof(struct yy_buffer_state*)
6436
6675
  , yyscanner);
6437
6676
  if ( ! yyg->yy_buffer_stack )
6438
- YY_FATAL_ERROR( "out of dynamic memory in core_yyensure_buffer_stack()" );
6677
+ YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
6439
6678
 
6440
6679
  /* zero only the new slots.*/
6441
6680
  memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
@@ -6447,9 +6686,9 @@ static void core_yyensure_buffer_stack (yyscan_t yyscanner)
6447
6686
  * @param base the character buffer
6448
6687
  * @param size the size in bytes of the character buffer
6449
6688
  * @param yyscanner The scanner object.
6450
- * @return the newly allocated buffer state object.
6689
+ * @return the newly allocated buffer state object.
6451
6690
  */
6452
- YY_BUFFER_STATE core_yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
6691
+ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
6453
6692
  {
6454
6693
  YY_BUFFER_STATE b;
6455
6694
 
@@ -6457,41 +6696,41 @@ YY_BUFFER_STATE core_yy_scan_buffer (char * base, yy_size_t size , yyscan_t yy
6457
6696
  base[size-2] != YY_END_OF_BUFFER_CHAR ||
6458
6697
  base[size-1] != YY_END_OF_BUFFER_CHAR )
6459
6698
  /* They forgot to leave room for the EOB's. */
6460
- return 0;
6699
+ return NULL;
6461
6700
 
6462
- b = (YY_BUFFER_STATE) core_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
6701
+ b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
6463
6702
  if ( ! b )
6464
- YY_FATAL_ERROR( "out of dynamic memory in core_yy_scan_buffer()" );
6703
+ YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
6465
6704
 
6466
- b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
6705
+ b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
6467
6706
  b->yy_buf_pos = b->yy_ch_buf = base;
6468
6707
  b->yy_is_our_buffer = 0;
6469
- b->yy_input_file = 0;
6708
+ b->yy_input_file = NULL;
6470
6709
  b->yy_n_chars = b->yy_buf_size;
6471
6710
  b->yy_is_interactive = 0;
6472
6711
  b->yy_at_bol = 1;
6473
6712
  b->yy_fill_buffer = 0;
6474
6713
  b->yy_buffer_status = YY_BUFFER_NEW;
6475
6714
 
6476
- core_yy_switch_to_buffer(b ,yyscanner );
6715
+ yy_switch_to_buffer( b , yyscanner );
6477
6716
 
6478
6717
  return b;
6479
6718
  }
6480
6719
 
6481
- /** Setup the input buffer state to scan a string. The next call to core_yylex() will
6720
+ /** Setup the input buffer state to scan a string. The next call to yylex() will
6482
6721
  * scan from a @e copy of @a str.
6483
6722
  * @param yystr a NUL-terminated string to scan
6484
6723
  * @param yyscanner The scanner object.
6485
6724
  * @return the newly allocated buffer state object.
6486
6725
  * @note If you want to scan bytes that may contain NUL values, then use
6487
- * core_yy_scan_bytes() instead.
6726
+ * yy_scan_bytes() instead.
6488
6727
  */
6489
6728
 
6490
6729
 
6491
- /** Setup the input buffer state to scan the given bytes. The next call to core_yylex() will
6730
+ /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
6492
6731
  * scan from a @e copy of @a bytes.
6493
- * @param bytes the byte buffer to scan
6494
- * @param len the number of bytes in the buffer pointed to by @a bytes.
6732
+ * @param yybytes the byte buffer to scan
6733
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
6495
6734
  * @param yyscanner The scanner object.
6496
6735
  * @return the newly allocated buffer state object.
6497
6736
  */
@@ -6501,9 +6740,11 @@ YY_BUFFER_STATE core_yy_scan_buffer (char * base, yy_size_t size , yyscan_t yy
6501
6740
  #define YY_EXIT_FAILURE 2
6502
6741
  #endif
6503
6742
 
6504
- static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
6743
+ static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
6505
6744
  {
6506
- (void) fprintf( stderr, "%s\n", msg );
6745
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
6746
+ (void)yyg;
6747
+ fprintf( stderr, "%s\n", msg );
6507
6748
  exit( YY_EXIT_FAILURE );
6508
6749
  }
6509
6750
 
@@ -6514,7 +6755,7 @@ static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
6514
6755
  do \
6515
6756
  { \
6516
6757
  /* Undo effects of setting up yytext. */ \
6517
- int yyless_macro_arg = (n); \
6758
+ yy_size_t yyless_macro_arg = (n); \
6518
6759
  YY_LESS_LINENO(yyless_macro_arg);\
6519
6760
  yytext[yyleng] = yyg->yy_hold_char; \
6520
6761
  yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
@@ -6566,29 +6807,29 @@ static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
6566
6807
  * @param user_defined The data to be associated with this scanner.
6567
6808
  * @param yyscanner The scanner object.
6568
6809
  */
6569
- void core_yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
6810
+ void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
6570
6811
  {
6571
6812
  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
6572
6813
  yyextra = user_defined ;
6573
6814
  }
6574
6815
 
6575
6816
  /** Set the current line number.
6576
- * @param line_number
6817
+ * @param _line_number line number
6577
6818
  * @param yyscanner The scanner object.
6578
6819
  */
6579
6820
 
6580
6821
 
6581
6822
  /** Set the current column.
6582
- * @param line_number
6823
+ * @param _column_no column number
6583
6824
  * @param yyscanner The scanner object.
6584
6825
  */
6585
6826
 
6586
6827
 
6587
6828
  /** Set the input stream. This does not discard the current
6588
6829
  * input buffer.
6589
- * @param in_str A readable stream.
6830
+ * @param _in_str A readable stream.
6590
6831
  * @param yyscanner The scanner object.
6591
- * @see core_yy_switch_to_buffer
6832
+ * @see yy_switch_to_buffer
6592
6833
  */
6593
6834
 
6594
6835
 
@@ -6610,20 +6851,18 @@ void core_yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
6610
6851
 
6611
6852
  /* User-visible API */
6612
6853
 
6613
- /* core_yylex_init is special because it creates the scanner itself, so it is
6854
+ /* yylex_init is special because it creates the scanner itself, so it is
6614
6855
  * the ONLY reentrant function that doesn't take the scanner as the last argument.
6615
6856
  * That's why we explicitly handle the declaration, instead of using our macros.
6616
6857
  */
6617
-
6618
- int core_yylex_init(yyscan_t* ptr_yy_globals)
6619
-
6858
+ int yylex_init(yyscan_t* ptr_yy_globals)
6620
6859
  {
6621
6860
  if (ptr_yy_globals == NULL){
6622
6861
  errno = EINVAL;
6623
6862
  return 1;
6624
6863
  }
6625
6864
 
6626
- *ptr_yy_globals = (yyscan_t) core_yyalloc ( sizeof( struct yyguts_t ), NULL );
6865
+ *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
6627
6866
 
6628
6867
  if (*ptr_yy_globals == NULL){
6629
6868
  errno = ENOMEM;
@@ -6636,27 +6875,26 @@ int core_yylex_init(yyscan_t* ptr_yy_globals)
6636
6875
  return yy_init_globals ( *ptr_yy_globals );
6637
6876
  }
6638
6877
 
6639
- /* core_yylex_init_extra has the same functionality as core_yylex_init, but follows the
6878
+ /* yylex_init_extra has the same functionality as yylex_init, but follows the
6640
6879
  * convention of taking the scanner as the last argument. Note however, that
6641
6880
  * this is a *pointer* to a scanner, as it will be allocated by this call (and
6642
6881
  * is the reason, too, why this function also must handle its own declaration).
6643
- * The user defined value in the first argument will be available to core_yyalloc in
6882
+ * The user defined value in the first argument will be available to yyalloc in
6644
6883
  * the yyextra field.
6645
6884
  */
6646
6885
 
6647
6886
 
6648
-
6649
6887
  static int yy_init_globals (yyscan_t yyscanner)
6650
6888
  {
6651
6889
  struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
6652
6890
  /* Initialization is the same as for the non-reentrant scanner.
6653
- * This function is called from core_yylex_destroy(), so don't allocate here.
6891
+ * This function is called from yylex_destroy(), so don't allocate here.
6654
6892
  */
6655
6893
 
6656
- yyg->yy_buffer_stack = 0;
6894
+ yyg->yy_buffer_stack = NULL;
6657
6895
  yyg->yy_buffer_stack_top = 0;
6658
6896
  yyg->yy_buffer_stack_max = 0;
6659
- yyg->yy_c_buf_p = (char *) 0;
6897
+ yyg->yy_c_buf_p = NULL;
6660
6898
  yyg->yy_init = 0;
6661
6899
  yyg->yy_start = 0;
6662
6900
 
@@ -6669,17 +6907,17 @@ static int yy_init_globals (yyscan_t yyscanner)
6669
6907
  yyin = stdin;
6670
6908
  yyout = stdout;
6671
6909
  #else
6672
- yyin = (FILE *) 0;
6673
- yyout = (FILE *) 0;
6910
+ yyin = NULL;
6911
+ yyout = NULL;
6674
6912
  #endif
6675
6913
 
6676
6914
  /* For future reference: Set errno on error, since we are called by
6677
- * core_yylex_init()
6915
+ * yylex_init()
6678
6916
  */
6679
6917
  return 0;
6680
6918
  }
6681
6919
 
6682
- /* core_yylex_destroy is for both reentrant and non-reentrant scanners. */
6920
+ /* yylex_destroy is for both reentrant and non-reentrant scanners. */
6683
6921
 
6684
6922
 
6685
6923
  /*
@@ -6687,18 +6925,21 @@ static int yy_init_globals (yyscan_t yyscanner)
6687
6925
  */
6688
6926
 
6689
6927
  #ifndef yytext_ptr
6690
- static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
6928
+ static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
6691
6929
  {
6692
- register int i;
6930
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
6931
+ (void)yyg;
6932
+
6933
+ int i;
6693
6934
  for ( i = 0; i < n; ++i )
6694
6935
  s1[i] = s2[i];
6695
6936
  }
6696
6937
  #endif
6697
6938
 
6698
6939
  #ifdef YY_NEED_STRLEN
6699
- static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
6940
+ static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
6700
6941
  {
6701
- register int n;
6942
+ int n;
6702
6943
  for ( n = 0; s[n]; ++n )
6703
6944
  ;
6704
6945
 
@@ -6708,14 +6949,13 @@ static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
6708
6949
 
6709
6950
  #define YYTABLES_NAME "yytables"
6710
6951
 
6711
- #line 1100 "scan.l"
6712
-
6952
+ #line 1103 "scan.l"
6713
6953
 
6714
6954
 
6715
6955
  /* LCOV_EXCL_STOP */
6716
6956
 
6717
6957
  /*
6718
- * Arrange access to yyextra for subroutines of the main core_yylex() function.
6958
+ * Arrange access to yyextra for subroutines of the main yylex() function.
6719
6959
  * We expect each subroutine to have a yyscanner parameter. Rather than
6720
6960
  * use the yyget_xxx functions, which might or might not get inlined by the
6721
6961
  * compiler, we cheat just a bit and cast yyscanner to the right type.
@@ -6817,7 +7057,7 @@ cancel_scanner_errposition_callback(ScannerCallbackState *scbstate)
6817
7057
  * Report a lexer or grammar error.
6818
7058
  *
6819
7059
  * The message's cursor position is whatever YYLLOC was last set to,
6820
- * ie, the start of the current token if called within core_yylex(), or the
7060
+ * ie, the start of the current token if called within yylex(), or the
6821
7061
  * most recently lexed token if called from the grammar.
6822
7062
  * This is OK for syntax error messages from the Bison parser, because Bison
6823
7063
  * parsers report error as soon as the first unparsable token is reached.
@@ -6860,8 +7100,8 @@ scanner_init(const char *str,
6860
7100
  Size slen = strlen(str);
6861
7101
  yyscan_t scanner;
6862
7102
 
6863
- if (core_yylex_init(&scanner) != 0)
6864
- elog(ERROR, "core_yylex_init() failed: %m");
7103
+ if (yylex_init(&scanner) != 0)
7104
+ elog(ERROR, "yylex_init() failed: %m");
6865
7105
 
6866
7106
  core_yyset_extra(yyext, scanner);
6867
7107
 
@@ -6879,7 +7119,7 @@ scanner_init(const char *str,
6879
7119
  yyext->scanbuflen = slen;
6880
7120
  memcpy(yyext->scanbuf, str, slen);
6881
7121
  yyext->scanbuf[slen] = yyext->scanbuf[slen + 1] = YY_END_OF_BUFFER_CHAR;
6882
- core_yy_scan_buffer(yyext->scanbuf,slen + 2,scanner);
7122
+ yy_scan_buffer(yyext->scanbuf, slen + 2, scanner);
6883
7123
 
6884
7124
  /* initialize literal buffer to a reasonable but expansible size */
6885
7125
  yyext->literalalloc = 1024;
@@ -6897,7 +7137,7 @@ void
6897
7137
  scanner_finish(core_yyscan_t yyscanner)
6898
7138
  {
6899
7139
  /*
6900
- * We don't bother to call core_yylex_destroy(), because all it would do is
7140
+ * We don't bother to call yylex_destroy(), because all it would do is
6901
7141
  * pfree a small amount of control storage. It's cheaper to leak the
6902
7142
  * storage until the parsing context is destroyed. The amount of space
6903
7143
  * involved is usually negligible compared to the output parse tree