1diff -Naur postgresql-9.0.8/contrib/cube/cubeparse.c postgresql/contrib/cube/cubeparse.c 2--- postgresql-9.0.8/contrib/cube/cubeparse.c 2012-05-31 16:28:05.000000000 -0700 3+++ postgresql/contrib/cube/cubeparse.c 2012-06-08 14:09:22.000000000 -0700 4@@ -1,23 +1,24 @@ 5- 6-/* A Bison parser, made by GNU Bison 2.4.1. */ 7+/* A Bison parser, made by GNU Bison 2.3. */ 8 9 /* Skeleton implementation for Bison's Yacc-like parsers in C 10- 11- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 12+ 13+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 14 Free Software Foundation, Inc. 15- 16- This program is free software: you can redistribute it and/or modify 17+ 18+ This program is free software; you can redistribute it and/or modify 19 it under the terms of the GNU General Public License as published by 20- the Free Software Foundation, either version 3 of the License, or 21- (at your option) any later version. 22- 23+ the Free Software Foundation; either version 2, or (at your option) 24+ any later version. 25+ 26 This program is distributed in the hope that it will be useful, 27 but WITHOUT ANY WARRANTY; without even the implied warranty of 28 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 29 GNU General Public License for more details. 30- 31+ 32 You should have received a copy of the GNU General Public License 33- along with this program. If not, see <http://www.gnu.org/licenses/>. */ 34+ along with this program; if not, write to the Free Software 35+ Foundation, Inc., 51 Franklin Street, Fifth Floor, 36+ Boston, MA 02110-1301, USA. */ 37 38 /* As a special exception, you may create a larger work that contains 39 part or all of the Bison parser skeleton and distribute that work 40@@ -28,7 +29,7 @@ 41 special exception, which will cause the skeleton and the resulting 42 Bison output files to be licensed under the GNU General Public 43 License without this special exception. 44- 45+ 46 This special exception was added by the Free Software Foundation in 47 version 2.2 of Bison. */ 48 49@@ -46,7 +47,7 @@ 50 #define YYBISON 1 51 52 /* Bison version. */ 53-#define YYBISON_VERSION "2.4.1" 54+#define YYBISON_VERSION "2.3" 55 56 /* Skeleton name. */ 57 #define YYSKELETON_NAME "yacc.c" 58@@ -54,28 +55,45 @@ 59 /* Pure parsers. */ 60 #define YYPURE 0 61 62-/* Push parsers. */ 63-#define YYPUSH 0 64- 65-/* Pull parsers. */ 66-#define YYPULL 1 67- 68 /* Using locations. */ 69 #define YYLSP_NEEDED 0 70 71 /* Substitute the variable and function names. */ 72-#define yyparse cube_yyparse 73-#define yylex cube_yylex 74-#define yyerror cube_yyerror 75-#define yylval cube_yylval 76-#define yychar cube_yychar 77-#define yydebug cube_yydebug 78-#define yynerrs cube_yynerrs 79+#define yyparse cube_yyparse 80+#define yylex cube_yylex 81+#define yyerror cube_yyerror 82+#define yylval cube_yylval 83+#define yychar cube_yychar 84+#define yydebug cube_yydebug 85+#define yynerrs cube_yynerrs 86 87 88-/* Copy the first part of user declarations. */ 89+/* Tokens. */ 90+#ifndef YYTOKENTYPE 91+# define YYTOKENTYPE 92+ /* Put the tokens into the symbol table, so that GDB and other debuggers 93+ know about them. */ 94+ enum yytokentype { 95+ CUBEFLOAT = 258, 96+ O_PAREN = 259, 97+ C_PAREN = 260, 98+ O_BRACKET = 261, 99+ C_BRACKET = 262, 100+ COMMA = 263 101+ }; 102+#endif 103+/* Tokens. */ 104+#define CUBEFLOAT 258 105+#define O_PAREN 259 106+#define C_PAREN 260 107+#define O_BRACKET 261 108+#define C_BRACKET 262 109+#define COMMA 263 110+ 111 112-/* Line 189 of yacc.c */ 113+ 114+ 115+/* Copy the first part of user declarations. */ 116 #line 1 "cubeparse.y" 117 118 /* NdBox = [(lowerleft),(upperright)] */ 119@@ -116,9 +134,6 @@ 120 121 122 123-/* Line 189 of yacc.c */ 124-#line 121 "cubeparse.c" 125- 126 /* Enabling traces. */ 127 #ifndef YYDEBUG 128 # define YYDEBUG 0 129@@ -137,37 +152,20 @@ 130 # define YYTOKEN_TABLE 0 131 #endif 132 133- 134-/* Tokens. */ 135-#ifndef YYTOKENTYPE 136-# define YYTOKENTYPE 137- /* Put the tokens into the symbol table, so that GDB and other debuggers 138- know about them. */ 139- enum yytokentype { 140- CUBEFLOAT = 258, 141- O_PAREN = 259, 142- C_PAREN = 260, 143- O_BRACKET = 261, 144- C_BRACKET = 262, 145- COMMA = 263 146- }; 147-#endif 148- 149- 150- 151 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 152 typedef int YYSTYPE; 153-# define YYSTYPE_IS_TRIVIAL 1 154 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 155 # define YYSTYPE_IS_DECLARED 1 156+# define YYSTYPE_IS_TRIVIAL 1 157 #endif 158 159 160+ 161 /* Copy the second part of user declarations. */ 162 163 164-/* Line 264 of yacc.c */ 165-#line 171 "cubeparse.c" 166+/* Line 216 of yacc.c. */ 167+#line 169 "cubeparse.c" 168 169 #ifdef short 170 # undef short 171@@ -217,7 +215,7 @@ 172 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 173 174 #ifndef YY_ 175-# if YYENABLE_NLS 176+# if defined YYENABLE_NLS && YYENABLE_NLS 177 # if ENABLE_NLS 178 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 179 # define YY_(msgid) dgettext ("bison-runtime", msgid) 180@@ -242,14 +240,14 @@ 181 #if (defined __STDC__ || defined __C99__FUNC__ \ 182 || defined __cplusplus || defined _MSC_VER) 183 static int 184-YYID (int yyi) 185+YYID (int i) 186 #else 187 static int 188-YYID (yyi) 189- int yyi; 190+YYID (i) 191+ int i; 192 #endif 193 { 194- return yyi; 195+ return i; 196 } 197 #endif 198 199@@ -330,9 +328,9 @@ 200 /* A type that is properly aligned for any stack member. */ 201 union yyalloc 202 { 203- yytype_int16 yyss_alloc; 204- YYSTYPE yyvs_alloc; 205-}; 206+ yytype_int16 yyss; 207+ YYSTYPE yyvs; 208+ }; 209 210 /* The size of the maximum gap between one aligned stack and the next. */ 211 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 212@@ -366,12 +364,12 @@ 213 elements in the stack, and YYPTR gives the new location of the 214 stack. Advance YYPTR to a properly aligned location for the next 215 stack. */ 216-# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 217+# define YYSTACK_RELOCATE(Stack) \ 218 do \ 219 { \ 220 YYSIZE_T yynewbytes; \ 221- YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 222- Stack = &yyptr->Stack_alloc; \ 223+ YYCOPY (&yyptr->Stack, Stack, yysize); \ 224+ Stack = &yyptr->Stack; \ 225 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 226 yyptr += yynewbytes / sizeof (*yyptr); \ 227 } \ 228@@ -613,7 +611,7 @@ 229 we won't break user code: when these are the locations we know. */ 230 231 #ifndef YY_LOCATION_PRINT 232-# if YYLTYPE_IS_TRIVIAL 233+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 234 # define YY_LOCATION_PRINT(File, Loc) \ 235 fprintf (File, "%d.%d-%d.%d", \ 236 (Loc).first_line, (Loc).first_column, \ 237@@ -724,20 +722,17 @@ 238 #if (defined __STDC__ || defined __C99__FUNC__ \ 239 || defined __cplusplus || defined _MSC_VER) 240 static void 241-yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 242+yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) 243 #else 244 static void 245-yy_stack_print (yybottom, yytop) 246- yytype_int16 *yybottom; 247- yytype_int16 *yytop; 248+yy_stack_print (bottom, top) 249+ yytype_int16 *bottom; 250+ yytype_int16 *top; 251 #endif 252 { 253 YYFPRINTF (stderr, "Stack now"); 254- for (; yybottom <= yytop; yybottom++) 255- { 256- int yybot = *yybottom; 257- YYFPRINTF (stderr, " %d", yybot); 258- } 259+ for (; bottom <= top; ++bottom) 260+ YYFPRINTF (stderr, " %d", *bottom); 261 YYFPRINTF (stderr, "\n"); 262 } 263 264@@ -771,11 +766,11 @@ 265 /* The symbols being reduced. */ 266 for (yyi = 0; yyi < yynrhs; yyi++) 267 { 268- YYFPRINTF (stderr, " $%d = ", yyi + 1); 269+ fprintf (stderr, " $%d = ", yyi + 1); 270 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 271 &(yyvsp[(yyi + 1) - (yynrhs)]) 272 ); 273- YYFPRINTF (stderr, "\n"); 274+ fprintf (stderr, "\n"); 275 } 276 } 277 278@@ -1055,8 +1050,10 @@ 279 break; 280 } 281 } 282+ 283 284 /* Prevent warnings from -Wmissing-prototypes. */ 285+ 286 #ifdef YYPARSE_PARAM 287 #if defined __STDC__ || defined __cplusplus 288 int yyparse (void *YYPARSE_PARAM); 289@@ -1072,10 +1069,11 @@ 290 #endif /* ! YYPARSE_PARAM */ 291 292 293-/* The lookahead symbol. */ 294+ 295+/* The look-ahead symbol. */ 296 int yychar; 297 298-/* The semantic value of the lookahead symbol. */ 299+/* The semantic value of the look-ahead symbol. */ 300 YYSTYPE yylval; 301 302 /* Number of syntax errors so far. */ 303@@ -1083,9 +1081,9 @@ 304 305 306 307-/*-------------------------. 308-| yyparse or yypush_parse. | 309-`-------------------------*/ 310+/*----------. 311+| yyparse. | 312+`----------*/ 313 314 #ifdef YYPARSE_PARAM 315 #if (defined __STDC__ || defined __C99__FUNC__ \ 316@@ -1109,39 +1107,14 @@ 317 #endif 318 #endif 319 { 320- 321- 322- int yystate; 323- /* Number of tokens to shift before error messages enabled. */ 324- int yyerrstatus; 325- 326- /* The stacks and their tools: 327- `yyss': related to states. 328- `yyvs': related to semantic values. 329- 330- Refer to the stacks thru separate pointers, to allow yyoverflow 331- to reallocate them elsewhere. */ 332- 333- /* The state stack. */ 334- yytype_int16 yyssa[YYINITDEPTH]; 335- yytype_int16 *yyss; 336- yytype_int16 *yyssp; 337- 338- /* The semantic value stack. */ 339- YYSTYPE yyvsa[YYINITDEPTH]; 340- YYSTYPE *yyvs; 341- YYSTYPE *yyvsp; 342- 343- YYSIZE_T yystacksize; 344- 345+ 346+ int yystate; 347 int yyn; 348 int yyresult; 349- /* Lookahead token as an internal (translated) token number. */ 350- int yytoken; 351- /* The variables used to return semantic value and location from the 352- action routines. */ 353- YYSTYPE yyval; 354- 355+ /* Number of tokens to shift before error messages enabled. */ 356+ int yyerrstatus; 357+ /* Look-ahead token as an internal (translated) token number. */ 358+ int yytoken = 0; 359 #if YYERROR_VERBOSE 360 /* Buffer for error messages, and its allocated size. */ 361 char yymsgbuf[128]; 362@@ -1149,28 +1122,51 @@ 363 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 364 #endif 365 366+ /* Three stacks and their tools: 367+ `yyss': related to states, 368+ `yyvs': related to semantic values, 369+ `yyls': related to locations. 370+ 371+ Refer to the stacks thru separate pointers, to allow yyoverflow 372+ to reallocate them elsewhere. */ 373+ 374+ /* The state stack. */ 375+ yytype_int16 yyssa[YYINITDEPTH]; 376+ yytype_int16 *yyss = yyssa; 377+ yytype_int16 *yyssp; 378+ 379+ /* The semantic value stack. */ 380+ YYSTYPE yyvsa[YYINITDEPTH]; 381+ YYSTYPE *yyvs = yyvsa; 382+ YYSTYPE *yyvsp; 383+ 384+ 385+ 386 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 387 388+ YYSIZE_T yystacksize = YYINITDEPTH; 389+ 390+ /* The variables used to return semantic value and location from the 391+ action routines. */ 392+ YYSTYPE yyval; 393+ 394+ 395 /* The number of symbols on the RHS of the reduced rule. 396 Keep to zero when no symbol should be popped. */ 397 int yylen = 0; 398 399- yytoken = 0; 400- yyss = yyssa; 401- yyvs = yyvsa; 402- yystacksize = YYINITDEPTH; 403- 404 YYDPRINTF ((stderr, "Starting parse\n")); 405 406 yystate = 0; 407 yyerrstatus = 0; 408 yynerrs = 0; 409- yychar = YYEMPTY; /* Cause a token to be read. */ 410+ yychar = YYEMPTY; /* Cause a token to be read. */ 411 412 /* Initialize stack pointers. 413 Waste one element of value and location stack 414 so that they stay on the same level as the state stack. 415 The wasted elements are never initialized. */ 416+ 417 yyssp = yyss; 418 yyvsp = yyvs; 419 420@@ -1200,6 +1196,7 @@ 421 YYSTYPE *yyvs1 = yyvs; 422 yytype_int16 *yyss1 = yyss; 423 424+ 425 /* Each stack pointer address is followed by the size of the 426 data in use in that stack, in bytes. This used to be a 427 conditional around just the two extra args, but that might 428@@ -1207,6 +1204,7 @@ 429 yyoverflow (YY_("memory exhausted"), 430 &yyss1, yysize * sizeof (*yyssp), 431 &yyvs1, yysize * sizeof (*yyvsp), 432+ 433 &yystacksize); 434 435 yyss = yyss1; 436@@ -1229,8 +1227,9 @@ 437 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 438 if (! yyptr) 439 goto yyexhaustedlab; 440- YYSTACK_RELOCATE (yyss_alloc, yyss); 441- YYSTACK_RELOCATE (yyvs_alloc, yyvs); 442+ YYSTACK_RELOCATE (yyss); 443+ YYSTACK_RELOCATE (yyvs); 444+ 445 # undef YYSTACK_RELOCATE 446 if (yyss1 != yyssa) 447 YYSTACK_FREE (yyss1); 448@@ -1241,6 +1240,7 @@ 449 yyssp = yyss + yysize - 1; 450 yyvsp = yyvs + yysize - 1; 451 452+ 453 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 454 (unsigned long int) yystacksize)); 455 456@@ -1250,9 +1250,6 @@ 457 458 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 459 460- if (yystate == YYFINAL) 461- YYACCEPT; 462- 463 goto yybackup; 464 465 /*-----------. 466@@ -1261,16 +1258,16 @@ 467 yybackup: 468 469 /* Do appropriate processing given the current state. Read a 470- lookahead token if we need one and don't already have one. */ 471+ look-ahead token if we need one and don't already have one. */ 472 473- /* First try to decide what to do without reference to lookahead token. */ 474+ /* First try to decide what to do without reference to look-ahead token. */ 475 yyn = yypact[yystate]; 476 if (yyn == YYPACT_NINF) 477 goto yydefault; 478 479- /* Not known => get a lookahead token if don't already have one. */ 480+ /* Not known => get a look-ahead token if don't already have one. */ 481 482- /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 483+ /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 484 if (yychar == YYEMPTY) 485 { 486 YYDPRINTF ((stderr, "Reading a token: ")); 487@@ -1302,16 +1299,20 @@ 488 goto yyreduce; 489 } 490 491+ if (yyn == YYFINAL) 492+ YYACCEPT; 493+ 494 /* Count tokens shifted since error; after three, turn off error 495 status. */ 496 if (yyerrstatus) 497 yyerrstatus--; 498 499- /* Shift the lookahead token. */ 500+ /* Shift the look-ahead token. */ 501 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 502 503- /* Discard the shifted token. */ 504- yychar = YYEMPTY; 505+ /* Discard the shifted token unless it is eof. */ 506+ if (yychar != YYEOF) 507+ yychar = YYEMPTY; 508 509 yystate = yyn; 510 *++yyvsp = yylval; 511@@ -1351,8 +1352,6 @@ 512 switch (yyn) 513 { 514 case 2: 515- 516-/* Line 1455 of yacc.c */ 517 #line 51 "cubeparse.y" 518 { 519 520@@ -1382,8 +1381,6 @@ 521 break; 522 523 case 3: 524- 525-/* Line 1455 of yacc.c */ 526 #line 77 "cubeparse.y" 527 { 528 int dim; 529@@ -1412,8 +1409,6 @@ 530 break; 531 532 case 4: 533- 534-/* Line 1455 of yacc.c */ 535 #line 103 "cubeparse.y" 536 { 537 int dim; 538@@ -1433,8 +1428,6 @@ 539 break; 540 541 case 5: 542- 543-/* Line 1455 of yacc.c */ 544 #line 121 "cubeparse.y" 545 { 546 int dim; 547@@ -1453,8 +1446,6 @@ 548 break; 549 550 case 6: 551- 552-/* Line 1455 of yacc.c */ 553 #line 138 "cubeparse.y" 554 { 555 (yyval) = (yyvsp[(2) - (3)]); 556@@ -1462,8 +1453,6 @@ 557 break; 558 559 case 7: 560- 561-/* Line 1455 of yacc.c */ 562 #line 144 "cubeparse.y" 563 { 564 /* alloc enough space to be sure whole list will fit */ 565@@ -1473,8 +1462,6 @@ 566 break; 567 568 case 8: 569- 570-/* Line 1455 of yacc.c */ 571 #line 150 "cubeparse.y" 572 { 573 (yyval) = (yyvsp[(1) - (3)]); 574@@ -1484,9 +1471,8 @@ 575 break; 576 577 578- 579-/* Line 1455 of yacc.c */ 580-#line 1490 "cubeparse.c" 581+/* Line 1267 of yacc.c. */ 582+#line 1476 "cubeparse.c" 583 default: break; 584 } 585 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 586@@ -1497,6 +1483,7 @@ 587 588 *++yyvsp = yyval; 589 590+ 591 /* Now `shift' the result of the reduction. Determine what state 592 that goes to, based on the state we popped back to and the rule 593 number reduced by. */ 594@@ -1561,7 +1548,7 @@ 595 596 if (yyerrstatus == 3) 597 { 598- /* If just tried and failed to reuse lookahead token after an 599+ /* If just tried and failed to reuse look-ahead token after an 600 error, discard it. */ 601 602 if (yychar <= YYEOF) 603@@ -1578,7 +1565,7 @@ 604 } 605 } 606 607- /* Else will try to reuse lookahead token after shifting the error 608+ /* Else will try to reuse look-ahead token after shifting the error 609 token. */ 610 goto yyerrlab1; 611 612@@ -1635,6 +1622,9 @@ 613 YY_STACK_PRINT (yyss, yyssp); 614 } 615 616+ if (yyn == YYFINAL) 617+ YYACCEPT; 618+ 619 *++yyvsp = yylval; 620 621 622@@ -1659,7 +1649,7 @@ 623 yyresult = 1; 624 goto yyreturn; 625 626-#if !defined(yyoverflow) || YYERROR_VERBOSE 627+#ifndef yyoverflow 628 /*-------------------------------------------------. 629 | yyexhaustedlab -- memory exhaustion comes here. | 630 `-------------------------------------------------*/ 631@@ -1670,7 +1660,7 @@ 632 #endif 633 634 yyreturn: 635- if (yychar != YYEMPTY) 636+ if (yychar != YYEOF && yychar != YYEMPTY) 637 yydestruct ("Cleanup: discarding lookahead", 638 yytoken, &yylval); 639 /* Do not reclaim the symbols of the rule which action triggered 640@@ -1696,8 +1686,6 @@ 641 } 642 643 644- 645-/* Line 1675 of yacc.c */ 646 #line 157 "cubeparse.y" 647 648 649diff -Naur postgresql-9.0.8/contrib/cube/cubeparse.tab.c postgresql/contrib/cube/cubeparse.tab.c 650--- postgresql-9.0.8/contrib/cube/cubeparse.tab.c 1969-12-31 16:00:00.000000000 -0800 651+++ postgresql/contrib/cube/cubeparse.tab.c 2012-06-08 14:08:43.000000000 -0700 652@@ -0,0 +1,1764 @@ 653+/* A Bison parser, made by GNU Bison 2.3. */ 654+ 655+/* Skeleton implementation for Bison's Yacc-like parsers in C 656+ 657+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 658+ Free Software Foundation, Inc. 659+ 660+ This program is free software; you can redistribute it and/or modify 661+ it under the terms of the GNU General Public License as published by 662+ the Free Software Foundation; either version 2, or (at your option) 663+ any later version. 664+ 665+ This program is distributed in the hope that it will be useful, 666+ but WITHOUT ANY WARRANTY; without even the implied warranty of 667+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 668+ GNU General Public License for more details. 669+ 670+ You should have received a copy of the GNU General Public License 671+ along with this program; if not, write to the Free Software 672+ Foundation, Inc., 51 Franklin Street, Fifth Floor, 673+ Boston, MA 02110-1301, USA. */ 674+ 675+/* As a special exception, you may create a larger work that contains 676+ part or all of the Bison parser skeleton and distribute that work 677+ under terms of your choice, so long as that work isn't itself a 678+ parser generator using the skeleton or a modified version thereof 679+ as a parser skeleton. Alternatively, if you modify or redistribute 680+ the parser skeleton itself, you may (at your option) remove this 681+ special exception, which will cause the skeleton and the resulting 682+ Bison output files to be licensed under the GNU General Public 683+ License without this special exception. 684+ 685+ This special exception was added by the Free Software Foundation in 686+ version 2.2 of Bison. */ 687+ 688+/* C LALR(1) parser skeleton written by Richard Stallman, by 689+ simplifying the original so-called "semantic" parser. */ 690+ 691+/* All symbols defined below should begin with yy or YY, to avoid 692+ infringing on user name space. This should be done even for local 693+ variables, as they might otherwise be expanded by user macros. 694+ There are some unavoidable exceptions within include files to 695+ define necessary library symbols; they are noted "INFRINGES ON 696+ USER NAME SPACE" below. */ 697+ 698+/* Identify Bison output. */ 699+#define YYBISON 1 700+ 701+/* Bison version. */ 702+#define YYBISON_VERSION "2.3" 703+ 704+/* Skeleton name. */ 705+#define YYSKELETON_NAME "yacc.c" 706+ 707+/* Pure parsers. */ 708+#define YYPURE 0 709+ 710+/* Using locations. */ 711+#define YYLSP_NEEDED 0 712+ 713+/* Substitute the variable and function names. */ 714+#define yyparse cube_yyparse 715+#define yylex cube_yylex 716+#define yyerror cube_yyerror 717+#define yylval cube_yylval 718+#define yychar cube_yychar 719+#define yydebug cube_yydebug 720+#define yynerrs cube_yynerrs 721+ 722+ 723+/* Tokens. */ 724+#ifndef YYTOKENTYPE 725+# define YYTOKENTYPE 726+ /* Put the tokens into the symbol table, so that GDB and other debuggers 727+ know about them. */ 728+ enum yytokentype { 729+ CUBEFLOAT = 258, 730+ O_PAREN = 259, 731+ C_PAREN = 260, 732+ O_BRACKET = 261, 733+ C_BRACKET = 262, 734+ COMMA = 263 735+ }; 736+#endif 737+/* Tokens. */ 738+#define CUBEFLOAT 258 739+#define O_PAREN 259 740+#define C_PAREN 260 741+#define O_BRACKET 261 742+#define C_BRACKET 262 743+#define COMMA 263 744+ 745+ 746+ 747+ 748+/* Copy the first part of user declarations. */ 749+#line 1 "cubeparse.y" 750+ 751+/* NdBox = [(lowerleft),(upperright)] */ 752+/* [(xLL(1)...xLL(N)),(xUR(1)...xUR(n))] */ 753+ 754+/* $PostgreSQL: pgsql/contrib/cube/cubeparse.y,v 1.19 2008/11/26 08:45:11 petere Exp $ */ 755+ 756+#define YYPARSE_PARAM result /* need this to pass a pointer (void *) to yyparse */ 757+#define YYSTYPE char * 758+#define YYDEBUG 1 759+ 760+#include "postgres.h" 761+ 762+#include "cubedata.h" 763+ 764+/* 765+ * Bison doesn't allocate anything that needs to live across parser calls, 766+ * so we can easily have it use palloc instead of malloc. This prevents 767+ * memory leaks if we error out during parsing. Note this only works with 768+ * bison >= 2.0. However, in bison 1.875 the default is to use alloca() 769+ * if possible, so there's not really much problem anyhow, at least if 770+ * you're building with gcc. 771+ */ 772+#define YYMALLOC palloc 773+#define YYFREE pfree 774+ 775+extern int cube_yylex(void); 776+ 777+static char *scanbuf; 778+static int scanbuflen; 779+ 780+void cube_yyerror(const char *message); 781+int cube_yyparse(void *result); 782+ 783+static int delim_count(char *s, char delim); 784+static NDBOX * write_box(unsigned int dim, char *str1, char *str2); 785+static NDBOX * write_point_as_box(char *s, int dim); 786+ 787+ 788+ 789+/* Enabling traces. */ 790+#ifndef YYDEBUG 791+# define YYDEBUG 0 792+#endif 793+ 794+/* Enabling verbose error messages. */ 795+#ifdef YYERROR_VERBOSE 796+# undef YYERROR_VERBOSE 797+# define YYERROR_VERBOSE 1 798+#else 799+# define YYERROR_VERBOSE 0 800+#endif 801+ 802+/* Enabling the token table. */ 803+#ifndef YYTOKEN_TABLE 804+# define YYTOKEN_TABLE 0 805+#endif 806+ 807+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 808+typedef int YYSTYPE; 809+# define yystype YYSTYPE /* obsolescent; will be withdrawn */ 810+# define YYSTYPE_IS_DECLARED 1 811+# define YYSTYPE_IS_TRIVIAL 1 812+#endif 813+ 814+ 815+ 816+/* Copy the second part of user declarations. */ 817+ 818+ 819+/* Line 216 of yacc.c. */ 820+#line 169 "cubeparse.tab.c" 821+ 822+#ifdef short 823+# undef short 824+#endif 825+ 826+#ifdef YYTYPE_UINT8 827+typedef YYTYPE_UINT8 yytype_uint8; 828+#else 829+typedef unsigned char yytype_uint8; 830+#endif 831+ 832+#ifdef YYTYPE_INT8 833+typedef YYTYPE_INT8 yytype_int8; 834+#elif (defined __STDC__ || defined __C99__FUNC__ \ 835+ || defined __cplusplus || defined _MSC_VER) 836+typedef signed char yytype_int8; 837+#else 838+typedef short int yytype_int8; 839+#endif 840+ 841+#ifdef YYTYPE_UINT16 842+typedef YYTYPE_UINT16 yytype_uint16; 843+#else 844+typedef unsigned short int yytype_uint16; 845+#endif 846+ 847+#ifdef YYTYPE_INT16 848+typedef YYTYPE_INT16 yytype_int16; 849+#else 850+typedef short int yytype_int16; 851+#endif 852+ 853+#ifndef YYSIZE_T 854+# ifdef __SIZE_TYPE__ 855+# define YYSIZE_T __SIZE_TYPE__ 856+# elif defined size_t 857+# define YYSIZE_T size_t 858+# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 859+ || defined __cplusplus || defined _MSC_VER) 860+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 861+# define YYSIZE_T size_t 862+# else 863+# define YYSIZE_T unsigned int 864+# endif 865+#endif 866+ 867+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 868+ 869+#ifndef YY_ 870+# if defined YYENABLE_NLS && YYENABLE_NLS 871+# if ENABLE_NLS 872+# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 873+# define YY_(msgid) dgettext ("bison-runtime", msgid) 874+# endif 875+# endif 876+# ifndef YY_ 877+# define YY_(msgid) msgid 878+# endif 879+#endif 880+ 881+/* Suppress unused-variable warnings by "using" E. */ 882+#if ! defined lint || defined __GNUC__ 883+# define YYUSE(e) ((void) (e)) 884+#else 885+# define YYUSE(e) /* empty */ 886+#endif 887+ 888+/* Identity function, used to suppress warnings about constant conditions. */ 889+#ifndef lint 890+# define YYID(n) (n) 891+#else 892+#if (defined __STDC__ || defined __C99__FUNC__ \ 893+ || defined __cplusplus || defined _MSC_VER) 894+static int 895+YYID (int i) 896+#else 897+static int 898+YYID (i) 899+ int i; 900+#endif 901+{ 902+ return i; 903+} 904+#endif 905+ 906+#if ! defined yyoverflow || YYERROR_VERBOSE 907+ 908+/* The parser invokes alloca or malloc; define the necessary symbols. */ 909+ 910+# ifdef YYSTACK_USE_ALLOCA 911+# if YYSTACK_USE_ALLOCA 912+# ifdef __GNUC__ 913+# define YYSTACK_ALLOC __builtin_alloca 914+# elif defined __BUILTIN_VA_ARG_INCR 915+# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 916+# elif defined _AIX 917+# define YYSTACK_ALLOC __alloca 918+# elif defined _MSC_VER 919+# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 920+# define alloca _alloca 921+# else 922+# define YYSTACK_ALLOC alloca 923+# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 924+ || defined __cplusplus || defined _MSC_VER) 925+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 926+# ifndef _STDLIB_H 927+# define _STDLIB_H 1 928+# endif 929+# endif 930+# endif 931+# endif 932+# endif 933+ 934+# ifdef YYSTACK_ALLOC 935+ /* Pacify GCC's `empty if-body' warning. */ 936+# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 937+# ifndef YYSTACK_ALLOC_MAXIMUM 938+ /* The OS might guarantee only one guard page at the bottom of the stack, 939+ and a page size can be as small as 4096 bytes. So we cannot safely 940+ invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 941+ to allow for a few compiler-allocated temporary stack slots. */ 942+# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 943+# endif 944+# else 945+# define YYSTACK_ALLOC YYMALLOC 946+# define YYSTACK_FREE YYFREE 947+# ifndef YYSTACK_ALLOC_MAXIMUM 948+# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 949+# endif 950+# if (defined __cplusplus && ! defined _STDLIB_H \ 951+ && ! ((defined YYMALLOC || defined malloc) \ 952+ && (defined YYFREE || defined free))) 953+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 954+# ifndef _STDLIB_H 955+# define _STDLIB_H 1 956+# endif 957+# endif 958+# ifndef YYMALLOC 959+# define YYMALLOC malloc 960+# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 961+ || defined __cplusplus || defined _MSC_VER) 962+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 963+# endif 964+# endif 965+# ifndef YYFREE 966+# define YYFREE free 967+# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 968+ || defined __cplusplus || defined _MSC_VER) 969+void free (void *); /* INFRINGES ON USER NAME SPACE */ 970+# endif 971+# endif 972+# endif 973+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 974+ 975+ 976+#if (! defined yyoverflow \ 977+ && (! defined __cplusplus \ 978+ || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 979+ 980+/* A type that is properly aligned for any stack member. */ 981+union yyalloc 982+{ 983+ yytype_int16 yyss; 984+ YYSTYPE yyvs; 985+ }; 986+ 987+/* The size of the maximum gap between one aligned stack and the next. */ 988+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 989+ 990+/* The size of an array large to enough to hold all stacks, each with 991+ N elements. */ 992+# define YYSTACK_BYTES(N) \ 993+ ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 994+ + YYSTACK_GAP_MAXIMUM) 995+ 996+/* Copy COUNT objects from FROM to TO. The source and destination do 997+ not overlap. */ 998+# ifndef YYCOPY 999+# if defined __GNUC__ && 1 < __GNUC__ 1000+# define YYCOPY(To, From, Count) \ 1001+ __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 1002+# else 1003+# define YYCOPY(To, From, Count) \ 1004+ do \ 1005+ { \ 1006+ YYSIZE_T yyi; \ 1007+ for (yyi = 0; yyi < (Count); yyi++) \ 1008+ (To)[yyi] = (From)[yyi]; \ 1009+ } \ 1010+ while (YYID (0)) 1011+# endif 1012+# endif 1013+ 1014+/* Relocate STACK from its old location to the new one. The 1015+ local variables YYSIZE and YYSTACKSIZE give the old and new number of 1016+ elements in the stack, and YYPTR gives the new location of the 1017+ stack. Advance YYPTR to a properly aligned location for the next 1018+ stack. */ 1019+# define YYSTACK_RELOCATE(Stack) \ 1020+ do \ 1021+ { \ 1022+ YYSIZE_T yynewbytes; \ 1023+ YYCOPY (&yyptr->Stack, Stack, yysize); \ 1024+ Stack = &yyptr->Stack; \ 1025+ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 1026+ yyptr += yynewbytes / sizeof (*yyptr); \ 1027+ } \ 1028+ while (YYID (0)) 1029+ 1030+#endif 1031+ 1032+/* YYFINAL -- State number of the termination state. */ 1033+#define YYFINAL 9 1034+/* YYLAST -- Last index in YYTABLE. */ 1035+#define YYLAST 17 1036+ 1037+/* YYNTOKENS -- Number of terminals. */ 1038+#define YYNTOKENS 9 1039+/* YYNNTS -- Number of nonterminals. */ 1040+#define YYNNTS 4 1041+/* YYNRULES -- Number of rules. */ 1042+#define YYNRULES 8 1043+/* YYNRULES -- Number of states. */ 1044+#define YYNSTATES 18 1045+ 1046+/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 1047+#define YYUNDEFTOK 2 1048+#define YYMAXUTOK 263 1049+ 1050+#define YYTRANSLATE(YYX) \ 1051+ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 1052+ 1053+/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 1054+static const yytype_uint8 yytranslate[] = 1055+{ 1056+ 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1057+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1058+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1059+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1060+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1061+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1062+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1063+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1064+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1065+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1066+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1067+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1068+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1069+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1070+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1071+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1072+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1073+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1074+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1075+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1076+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1077+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1078+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1079+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1080+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1081+ 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 1082+ 5, 6, 7, 8 1083+}; 1084+ 1085+#if YYDEBUG 1086+/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 1087+ YYRHS. */ 1088+static const yytype_uint8 yyprhs[] = 1089+{ 1090+ 0, 0, 3, 9, 13, 15, 17, 21, 23 1091+}; 1092+ 1093+/* YYRHS -- A `-1'-separated list of the rules' RHS. */ 1094+static const yytype_int8 yyrhs[] = 1095+{ 1096+ 10, 0, -1, 6, 11, 8, 11, 7, -1, 11, 1097+ 8, 11, -1, 11, -1, 12, -1, 4, 12, 5, 1098+ -1, 3, -1, 12, 8, 3, -1 1099+}; 1100+ 1101+/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 1102+static const yytype_uint8 yyrline[] = 1103+{ 1104+ 0, 51, 51, 77, 103, 121, 138, 144, 150 1105+}; 1106+#endif 1107+ 1108+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 1109+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 1110+ First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 1111+static const char *const yytname[] = 1112+{ 1113+ "$end", "error", "$undefined", "CUBEFLOAT", "O_PAREN", "C_PAREN", 1114+ "O_BRACKET", "C_BRACKET", "COMMA", "$accept", "box", "paren_list", 1115+ "list", 0 1116+}; 1117+#endif 1118+ 1119+# ifdef YYPRINT 1120+/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 1121+ token YYLEX-NUM. */ 1122+static const yytype_uint16 yytoknum[] = 1123+{ 1124+ 0, 256, 257, 258, 259, 260, 261, 262, 263 1125+}; 1126+# endif 1127+ 1128+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 1129+static const yytype_uint8 yyr1[] = 1130+{ 1131+ 0, 9, 10, 10, 10, 10, 11, 12, 12 1132+}; 1133+ 1134+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 1135+static const yytype_uint8 yyr2[] = 1136+{ 1137+ 0, 2, 5, 3, 1, 1, 3, 1, 3 1138+}; 1139+ 1140+/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 1141+ STATE-NUM when YYTABLE doesn't specify something else to do. Zero 1142+ means the default is an error. */ 1143+static const yytype_uint8 yydefact[] = 1144+{ 1145+ 0, 7, 0, 0, 0, 4, 5, 0, 0, 1, 1146+ 0, 0, 6, 0, 3, 8, 0, 2 1147+}; 1148+ 1149+/* YYDEFGOTO[NTERM-NUM]. */ 1150+static const yytype_int8 yydefgoto[] = 1151+{ 1152+ -1, 4, 5, 6 1153+}; 1154+ 1155+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 1156+ STATE-NUM. */ 1157+#define YYPACT_NINF -4 1158+static const yytype_int8 yypact[] = 1159+{ 1160+ -2, -4, 3, -1, 9, 4, 5, 0, 6, -4, 1161+ -1, 8, -4, -1, -4, -4, 10, -4 1162+}; 1163+ 1164+/* YYPGOTO[NTERM-NUM]. */ 1165+static const yytype_int8 yypgoto[] = 1166+{ 1167+ -4, -4, -3, 13 1168+}; 1169+ 1170+/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 1171+ positive, shift that token. If negative, reduce the rule which 1172+ number is the opposite. If zero, do what YYDEFACT says. 1173+ If YYTABLE_NINF, syntax error. */ 1174+#define YYTABLE_NINF -1 1175+static const yytype_uint8 yytable[] = 1176+{ 1177+ 8, 1, 2, 2, 3, 12, 1, 14, 11, 9, 1178+ 16, 15, 10, 11, 13, 7, 0, 17 1179+}; 1180+ 1181+static const yytype_int8 yycheck[] = 1182+{ 1183+ 3, 3, 4, 4, 6, 5, 3, 10, 8, 0, 1184+ 13, 3, 8, 8, 8, 2, -1, 7 1185+}; 1186+ 1187+/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 1188+ symbol of state STATE-NUM. */ 1189+static const yytype_uint8 yystos[] = 1190+{ 1191+ 0, 3, 4, 6, 10, 11, 12, 12, 11, 0, 1192+ 8, 8, 5, 8, 11, 3, 11, 7 1193+}; 1194+ 1195+#define yyerrok (yyerrstatus = 0) 1196+#define yyclearin (yychar = YYEMPTY) 1197+#define YYEMPTY (-2) 1198+#define YYEOF 0 1199+ 1200+#define YYACCEPT goto yyacceptlab 1201+#define YYABORT goto yyabortlab 1202+#define YYERROR goto yyerrorlab 1203+ 1204+ 1205+/* Like YYERROR except do call yyerror. This remains here temporarily 1206+ to ease the transition to the new meaning of YYERROR, for GCC. 1207+ Once GCC version 2 has supplanted version 1, this can go. */ 1208+ 1209+#define YYFAIL goto yyerrlab 1210+ 1211+#define YYRECOVERING() (!!yyerrstatus) 1212+ 1213+#define YYBACKUP(Token, Value) \ 1214+do \ 1215+ if (yychar == YYEMPTY && yylen == 1) \ 1216+ { \ 1217+ yychar = (Token); \ 1218+ yylval = (Value); \ 1219+ yytoken = YYTRANSLATE (yychar); \ 1220+ YYPOPSTACK (1); \ 1221+ goto yybackup; \ 1222+ } \ 1223+ else \ 1224+ { \ 1225+ yyerror (YY_("syntax error: cannot back up")); \ 1226+ YYERROR; \ 1227+ } \ 1228+while (YYID (0)) 1229+ 1230+ 1231+#define YYTERROR 1 1232+#define YYERRCODE 256 1233+ 1234+ 1235+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 1236+ If N is 0, then set CURRENT to the empty location which ends 1237+ the previous symbol: RHS[0] (always defined). */ 1238+ 1239+#define YYRHSLOC(Rhs, K) ((Rhs)[K]) 1240+#ifndef YYLLOC_DEFAULT 1241+# define YYLLOC_DEFAULT(Current, Rhs, N) \ 1242+ do \ 1243+ if (YYID (N)) \ 1244+ { \ 1245+ (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 1246+ (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 1247+ (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 1248+ (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 1249+ } \ 1250+ else \ 1251+ { \ 1252+ (Current).first_line = (Current).last_line = \ 1253+ YYRHSLOC (Rhs, 0).last_line; \ 1254+ (Current).first_column = (Current).last_column = \ 1255+ YYRHSLOC (Rhs, 0).last_column; \ 1256+ } \ 1257+ while (YYID (0)) 1258+#endif 1259+ 1260+ 1261+/* YY_LOCATION_PRINT -- Print the location on the stream. 1262+ This macro was not mandated originally: define only if we know 1263+ we won't break user code: when these are the locations we know. */ 1264+ 1265+#ifndef YY_LOCATION_PRINT 1266+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 1267+# define YY_LOCATION_PRINT(File, Loc) \ 1268+ fprintf (File, "%d.%d-%d.%d", \ 1269+ (Loc).first_line, (Loc).first_column, \ 1270+ (Loc).last_line, (Loc).last_column) 1271+# else 1272+# define YY_LOCATION_PRINT(File, Loc) ((void) 0) 1273+# endif 1274+#endif 1275+ 1276+ 1277+/* YYLEX -- calling `yylex' with the right arguments. */ 1278+ 1279+#ifdef YYLEX_PARAM 1280+# define YYLEX yylex (YYLEX_PARAM) 1281+#else 1282+# define YYLEX yylex () 1283+#endif 1284+ 1285+/* Enable debugging if requested. */ 1286+#if YYDEBUG 1287+ 1288+# ifndef YYFPRINTF 1289+# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 1290+# define YYFPRINTF fprintf 1291+# endif 1292+ 1293+# define YYDPRINTF(Args) \ 1294+do { \ 1295+ if (yydebug) \ 1296+ YYFPRINTF Args; \ 1297+} while (YYID (0)) 1298+ 1299+# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 1300+do { \ 1301+ if (yydebug) \ 1302+ { \ 1303+ YYFPRINTF (stderr, "%s ", Title); \ 1304+ yy_symbol_print (stderr, \ 1305+ Type, Value); \ 1306+ YYFPRINTF (stderr, "\n"); \ 1307+ } \ 1308+} while (YYID (0)) 1309+ 1310+ 1311+/*--------------------------------. 1312+| Print this symbol on YYOUTPUT. | 1313+`--------------------------------*/ 1314+ 1315+/*ARGSUSED*/ 1316+#if (defined __STDC__ || defined __C99__FUNC__ \ 1317+ || defined __cplusplus || defined _MSC_VER) 1318+static void 1319+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1320+#else 1321+static void 1322+yy_symbol_value_print (yyoutput, yytype, yyvaluep) 1323+ FILE *yyoutput; 1324+ int yytype; 1325+ YYSTYPE const * const yyvaluep; 1326+#endif 1327+{ 1328+ if (!yyvaluep) 1329+ return; 1330+# ifdef YYPRINT 1331+ if (yytype < YYNTOKENS) 1332+ YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1333+# else 1334+ YYUSE (yyoutput); 1335+# endif 1336+ switch (yytype) 1337+ { 1338+ default: 1339+ break; 1340+ } 1341+} 1342+ 1343+ 1344+/*--------------------------------. 1345+| Print this symbol on YYOUTPUT. | 1346+`--------------------------------*/ 1347+ 1348+#if (defined __STDC__ || defined __C99__FUNC__ \ 1349+ || defined __cplusplus || defined _MSC_VER) 1350+static void 1351+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1352+#else 1353+static void 1354+yy_symbol_print (yyoutput, yytype, yyvaluep) 1355+ FILE *yyoutput; 1356+ int yytype; 1357+ YYSTYPE const * const yyvaluep; 1358+#endif 1359+{ 1360+ if (yytype < YYNTOKENS) 1361+ YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1362+ else 1363+ YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1364+ 1365+ yy_symbol_value_print (yyoutput, yytype, yyvaluep); 1366+ YYFPRINTF (yyoutput, ")"); 1367+} 1368+ 1369+/*------------------------------------------------------------------. 1370+| yy_stack_print -- Print the state stack from its BOTTOM up to its | 1371+| TOP (included). | 1372+`------------------------------------------------------------------*/ 1373+ 1374+#if (defined __STDC__ || defined __C99__FUNC__ \ 1375+ || defined __cplusplus || defined _MSC_VER) 1376+static void 1377+yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) 1378+#else 1379+static void 1380+yy_stack_print (bottom, top) 1381+ yytype_int16 *bottom; 1382+ yytype_int16 *top; 1383+#endif 1384+{ 1385+ YYFPRINTF (stderr, "Stack now"); 1386+ for (; bottom <= top; ++bottom) 1387+ YYFPRINTF (stderr, " %d", *bottom); 1388+ YYFPRINTF (stderr, "\n"); 1389+} 1390+ 1391+# define YY_STACK_PRINT(Bottom, Top) \ 1392+do { \ 1393+ if (yydebug) \ 1394+ yy_stack_print ((Bottom), (Top)); \ 1395+} while (YYID (0)) 1396+ 1397+ 1398+/*------------------------------------------------. 1399+| Report that the YYRULE is going to be reduced. | 1400+`------------------------------------------------*/ 1401+ 1402+#if (defined __STDC__ || defined __C99__FUNC__ \ 1403+ || defined __cplusplus || defined _MSC_VER) 1404+static void 1405+yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 1406+#else 1407+static void 1408+yy_reduce_print (yyvsp, yyrule) 1409+ YYSTYPE *yyvsp; 1410+ int yyrule; 1411+#endif 1412+{ 1413+ int yynrhs = yyr2[yyrule]; 1414+ int yyi; 1415+ unsigned long int yylno = yyrline[yyrule]; 1416+ YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 1417+ yyrule - 1, yylno); 1418+ /* The symbols being reduced. */ 1419+ for (yyi = 0; yyi < yynrhs; yyi++) 1420+ { 1421+ fprintf (stderr, " $%d = ", yyi + 1); 1422+ yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 1423+ &(yyvsp[(yyi + 1) - (yynrhs)]) 1424+ ); 1425+ fprintf (stderr, "\n"); 1426+ } 1427+} 1428+ 1429+# define YY_REDUCE_PRINT(Rule) \ 1430+do { \ 1431+ if (yydebug) \ 1432+ yy_reduce_print (yyvsp, Rule); \ 1433+} while (YYID (0)) 1434+ 1435+/* Nonzero means print parse trace. It is left uninitialized so that 1436+ multiple parsers can coexist. */ 1437+int yydebug; 1438+#else /* !YYDEBUG */ 1439+# define YYDPRINTF(Args) 1440+# define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1441+# define YY_STACK_PRINT(Bottom, Top) 1442+# define YY_REDUCE_PRINT(Rule) 1443+#endif /* !YYDEBUG */ 1444+ 1445+ 1446+/* YYINITDEPTH -- initial size of the parser's stacks. */ 1447+#ifndef YYINITDEPTH 1448+# define YYINITDEPTH 200 1449+#endif 1450+ 1451+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1452+ if the built-in stack extension method is used). 1453+ 1454+ Do not make this value too large; the results are undefined if 1455+ YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1456+ evaluated with infinite-precision integer arithmetic. */ 1457+ 1458+#ifndef YYMAXDEPTH 1459+# define YYMAXDEPTH 10000 1460+#endif 1461+ 1462+ 1463+ 1464+#if YYERROR_VERBOSE 1465+ 1466+# ifndef yystrlen 1467+# if defined __GLIBC__ && defined _STRING_H 1468+# define yystrlen strlen 1469+# else 1470+/* Return the length of YYSTR. */ 1471+#if (defined __STDC__ || defined __C99__FUNC__ \ 1472+ || defined __cplusplus || defined _MSC_VER) 1473+static YYSIZE_T 1474+yystrlen (const char *yystr) 1475+#else 1476+static YYSIZE_T 1477+yystrlen (yystr) 1478+ const char *yystr; 1479+#endif 1480+{ 1481+ YYSIZE_T yylen; 1482+ for (yylen = 0; yystr[yylen]; yylen++) 1483+ continue; 1484+ return yylen; 1485+} 1486+# endif 1487+# endif 1488+ 1489+# ifndef yystpcpy 1490+# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1491+# define yystpcpy stpcpy 1492+# else 1493+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1494+ YYDEST. */ 1495+#if (defined __STDC__ || defined __C99__FUNC__ \ 1496+ || defined __cplusplus || defined _MSC_VER) 1497+static char * 1498+yystpcpy (char *yydest, const char *yysrc) 1499+#else 1500+static char * 1501+yystpcpy (yydest, yysrc) 1502+ char *yydest; 1503+ const char *yysrc; 1504+#endif 1505+{ 1506+ char *yyd = yydest; 1507+ const char *yys = yysrc; 1508+ 1509+ while ((*yyd++ = *yys++) != '\0') 1510+ continue; 1511+ 1512+ return yyd - 1; 1513+} 1514+# endif 1515+# endif 1516+ 1517+# ifndef yytnamerr 1518+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1519+ quotes and backslashes, so that it's suitable for yyerror. The 1520+ heuristic is that double-quoting is unnecessary unless the string 1521+ contains an apostrophe, a comma, or backslash (other than 1522+ backslash-backslash). YYSTR is taken from yytname. If YYRES is 1523+ null, do not copy; instead, return the length of what the result 1524+ would have been. */ 1525+static YYSIZE_T 1526+yytnamerr (char *yyres, const char *yystr) 1527+{ 1528+ if (*yystr == '"') 1529+ { 1530+ YYSIZE_T yyn = 0; 1531+ char const *yyp = yystr; 1532+ 1533+ for (;;) 1534+ switch (*++yyp) 1535+ { 1536+ case '\'': 1537+ case ',': 1538+ goto do_not_strip_quotes; 1539+ 1540+ case '\\': 1541+ if (*++yyp != '\\') 1542+ goto do_not_strip_quotes; 1543+ /* Fall through. */ 1544+ default: 1545+ if (yyres) 1546+ yyres[yyn] = *yyp; 1547+ yyn++; 1548+ break; 1549+ 1550+ case '"': 1551+ if (yyres) 1552+ yyres[yyn] = '\0'; 1553+ return yyn; 1554+ } 1555+ do_not_strip_quotes: ; 1556+ } 1557+ 1558+ if (! yyres) 1559+ return yystrlen (yystr); 1560+ 1561+ return yystpcpy (yyres, yystr) - yyres; 1562+} 1563+# endif 1564+ 1565+/* Copy into YYRESULT an error message about the unexpected token 1566+ YYCHAR while in state YYSTATE. Return the number of bytes copied, 1567+ including the terminating null byte. If YYRESULT is null, do not 1568+ copy anything; just return the number of bytes that would be 1569+ copied. As a special case, return 0 if an ordinary "syntax error" 1570+ message will do. Return YYSIZE_MAXIMUM if overflow occurs during 1571+ size calculation. */ 1572+static YYSIZE_T 1573+yysyntax_error (char *yyresult, int yystate, int yychar) 1574+{ 1575+ int yyn = yypact[yystate]; 1576+ 1577+ if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 1578+ return 0; 1579+ else 1580+ { 1581+ int yytype = YYTRANSLATE (yychar); 1582+ YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 1583+ YYSIZE_T yysize = yysize0; 1584+ YYSIZE_T yysize1; 1585+ int yysize_overflow = 0; 1586+ enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1587+ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1588+ int yyx; 1589+ 1590+# if 0 1591+ /* This is so xgettext sees the translatable formats that are 1592+ constructed on the fly. */ 1593+ YY_("syntax error, unexpected %s"); 1594+ YY_("syntax error, unexpected %s, expecting %s"); 1595+ YY_("syntax error, unexpected %s, expecting %s or %s"); 1596+ YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 1597+ YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 1598+# endif 1599+ char *yyfmt; 1600+ char const *yyf; 1601+ static char const yyunexpected[] = "syntax error, unexpected %s"; 1602+ static char const yyexpecting[] = ", expecting %s"; 1603+ static char const yyor[] = " or %s"; 1604+ char yyformat[sizeof yyunexpected 1605+ + sizeof yyexpecting - 1 1606+ + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 1607+ * (sizeof yyor - 1))]; 1608+ char const *yyprefix = yyexpecting; 1609+ 1610+ /* Start YYX at -YYN if negative to avoid negative indexes in 1611+ YYCHECK. */ 1612+ int yyxbegin = yyn < 0 ? -yyn : 0; 1613+ 1614+ /* Stay within bounds of both yycheck and yytname. */ 1615+ int yychecklim = YYLAST - yyn + 1; 1616+ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1617+ int yycount = 1; 1618+ 1619+ yyarg[0] = yytname[yytype]; 1620+ yyfmt = yystpcpy (yyformat, yyunexpected); 1621+ 1622+ for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1623+ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 1624+ { 1625+ if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1626+ { 1627+ yycount = 1; 1628+ yysize = yysize0; 1629+ yyformat[sizeof yyunexpected - 1] = '\0'; 1630+ break; 1631+ } 1632+ yyarg[yycount++] = yytname[yyx]; 1633+ yysize1 = yysize + yytnamerr (0, yytname[yyx]); 1634+ yysize_overflow |= (yysize1 < yysize); 1635+ yysize = yysize1; 1636+ yyfmt = yystpcpy (yyfmt, yyprefix); 1637+ yyprefix = yyor; 1638+ } 1639+ 1640+ yyf = YY_(yyformat); 1641+ yysize1 = yysize + yystrlen (yyf); 1642+ yysize_overflow |= (yysize1 < yysize); 1643+ yysize = yysize1; 1644+ 1645+ if (yysize_overflow) 1646+ return YYSIZE_MAXIMUM; 1647+ 1648+ if (yyresult) 1649+ { 1650+ /* Avoid sprintf, as that infringes on the user's name space. 1651+ Don't have undefined behavior even if the translation 1652+ produced a string with the wrong number of "%s"s. */ 1653+ char *yyp = yyresult; 1654+ int yyi = 0; 1655+ while ((*yyp = *yyf) != '\0') 1656+ { 1657+ if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 1658+ { 1659+ yyp += yytnamerr (yyp, yyarg[yyi++]); 1660+ yyf += 2; 1661+ } 1662+ else 1663+ { 1664+ yyp++; 1665+ yyf++; 1666+ } 1667+ } 1668+ } 1669+ return yysize; 1670+ } 1671+} 1672+#endif /* YYERROR_VERBOSE */ 1673+ 1674+ 1675+/*-----------------------------------------------. 1676+| Release the memory associated to this symbol. | 1677+`-----------------------------------------------*/ 1678+ 1679+/*ARGSUSED*/ 1680+#if (defined __STDC__ || defined __C99__FUNC__ \ 1681+ || defined __cplusplus || defined _MSC_VER) 1682+static void 1683+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1684+#else 1685+static void 1686+yydestruct (yymsg, yytype, yyvaluep) 1687+ const char *yymsg; 1688+ int yytype; 1689+ YYSTYPE *yyvaluep; 1690+#endif 1691+{ 1692+ YYUSE (yyvaluep); 1693+ 1694+ if (!yymsg) 1695+ yymsg = "Deleting"; 1696+ YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1697+ 1698+ switch (yytype) 1699+ { 1700+ 1701+ default: 1702+ break; 1703+ } 1704+} 1705+ 1706+ 1707+/* Prevent warnings from -Wmissing-prototypes. */ 1708+ 1709+#ifdef YYPARSE_PARAM 1710+#if defined __STDC__ || defined __cplusplus 1711+int yyparse (void *YYPARSE_PARAM); 1712+#else 1713+int yyparse (); 1714+#endif 1715+#else /* ! YYPARSE_PARAM */ 1716+#if defined __STDC__ || defined __cplusplus 1717+int yyparse (void); 1718+#else 1719+int yyparse (); 1720+#endif 1721+#endif /* ! YYPARSE_PARAM */ 1722+ 1723+ 1724+ 1725+/* The look-ahead symbol. */ 1726+int yychar; 1727+ 1728+/* The semantic value of the look-ahead symbol. */ 1729+YYSTYPE yylval; 1730+ 1731+/* Number of syntax errors so far. */ 1732+int yynerrs; 1733+ 1734+ 1735+ 1736+/*----------. 1737+| yyparse. | 1738+`----------*/ 1739+ 1740+#ifdef YYPARSE_PARAM 1741+#if (defined __STDC__ || defined __C99__FUNC__ \ 1742+ || defined __cplusplus || defined _MSC_VER) 1743+int 1744+yyparse (void *YYPARSE_PARAM) 1745+#else 1746+int 1747+yyparse (YYPARSE_PARAM) 1748+ void *YYPARSE_PARAM; 1749+#endif 1750+#else /* ! YYPARSE_PARAM */ 1751+#if (defined __STDC__ || defined __C99__FUNC__ \ 1752+ || defined __cplusplus || defined _MSC_VER) 1753+int 1754+yyparse (void) 1755+#else 1756+int 1757+yyparse () 1758+ 1759+#endif 1760+#endif 1761+{ 1762+ 1763+ int yystate; 1764+ int yyn; 1765+ int yyresult; 1766+ /* Number of tokens to shift before error messages enabled. */ 1767+ int yyerrstatus; 1768+ /* Look-ahead token as an internal (translated) token number. */ 1769+ int yytoken = 0; 1770+#if YYERROR_VERBOSE 1771+ /* Buffer for error messages, and its allocated size. */ 1772+ char yymsgbuf[128]; 1773+ char *yymsg = yymsgbuf; 1774+ YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1775+#endif 1776+ 1777+ /* Three stacks and their tools: 1778+ `yyss': related to states, 1779+ `yyvs': related to semantic values, 1780+ `yyls': related to locations. 1781+ 1782+ Refer to the stacks thru separate pointers, to allow yyoverflow 1783+ to reallocate them elsewhere. */ 1784+ 1785+ /* The state stack. */ 1786+ yytype_int16 yyssa[YYINITDEPTH]; 1787+ yytype_int16 *yyss = yyssa; 1788+ yytype_int16 *yyssp; 1789+ 1790+ /* The semantic value stack. */ 1791+ YYSTYPE yyvsa[YYINITDEPTH]; 1792+ YYSTYPE *yyvs = yyvsa; 1793+ YYSTYPE *yyvsp; 1794+ 1795+ 1796+ 1797+#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1798+ 1799+ YYSIZE_T yystacksize = YYINITDEPTH; 1800+ 1801+ /* The variables used to return semantic value and location from the 1802+ action routines. */ 1803+ YYSTYPE yyval; 1804+ 1805+ 1806+ /* The number of symbols on the RHS of the reduced rule. 1807+ Keep to zero when no symbol should be popped. */ 1808+ int yylen = 0; 1809+ 1810+ YYDPRINTF ((stderr, "Starting parse\n")); 1811+ 1812+ yystate = 0; 1813+ yyerrstatus = 0; 1814+ yynerrs = 0; 1815+ yychar = YYEMPTY; /* Cause a token to be read. */ 1816+ 1817+ /* Initialize stack pointers. 1818+ Waste one element of value and location stack 1819+ so that they stay on the same level as the state stack. 1820+ The wasted elements are never initialized. */ 1821+ 1822+ yyssp = yyss; 1823+ yyvsp = yyvs; 1824+ 1825+ goto yysetstate; 1826+ 1827+/*------------------------------------------------------------. 1828+| yynewstate -- Push a new state, which is found in yystate. | 1829+`------------------------------------------------------------*/ 1830+ yynewstate: 1831+ /* In all cases, when you get here, the value and location stacks 1832+ have just been pushed. So pushing a state here evens the stacks. */ 1833+ yyssp++; 1834+ 1835+ yysetstate: 1836+ *yyssp = yystate; 1837+ 1838+ if (yyss + yystacksize - 1 <= yyssp) 1839+ { 1840+ /* Get the current used size of the three stacks, in elements. */ 1841+ YYSIZE_T yysize = yyssp - yyss + 1; 1842+ 1843+#ifdef yyoverflow 1844+ { 1845+ /* Give user a chance to reallocate the stack. Use copies of 1846+ these so that the &'s don't force the real ones into 1847+ memory. */ 1848+ YYSTYPE *yyvs1 = yyvs; 1849+ yytype_int16 *yyss1 = yyss; 1850+ 1851+ 1852+ /* Each stack pointer address is followed by the size of the 1853+ data in use in that stack, in bytes. This used to be a 1854+ conditional around just the two extra args, but that might 1855+ be undefined if yyoverflow is a macro. */ 1856+ yyoverflow (YY_("memory exhausted"), 1857+ &yyss1, yysize * sizeof (*yyssp), 1858+ &yyvs1, yysize * sizeof (*yyvsp), 1859+ 1860+ &yystacksize); 1861+ 1862+ yyss = yyss1; 1863+ yyvs = yyvs1; 1864+ } 1865+#else /* no yyoverflow */ 1866+# ifndef YYSTACK_RELOCATE 1867+ goto yyexhaustedlab; 1868+# else 1869+ /* Extend the stack our own way. */ 1870+ if (YYMAXDEPTH <= yystacksize) 1871+ goto yyexhaustedlab; 1872+ yystacksize *= 2; 1873+ if (YYMAXDEPTH < yystacksize) 1874+ yystacksize = YYMAXDEPTH; 1875+ 1876+ { 1877+ yytype_int16 *yyss1 = yyss; 1878+ union yyalloc *yyptr = 1879+ (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1880+ if (! yyptr) 1881+ goto yyexhaustedlab; 1882+ YYSTACK_RELOCATE (yyss); 1883+ YYSTACK_RELOCATE (yyvs); 1884+ 1885+# undef YYSTACK_RELOCATE 1886+ if (yyss1 != yyssa) 1887+ YYSTACK_FREE (yyss1); 1888+ } 1889+# endif 1890+#endif /* no yyoverflow */ 1891+ 1892+ yyssp = yyss + yysize - 1; 1893+ yyvsp = yyvs + yysize - 1; 1894+ 1895+ 1896+ YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1897+ (unsigned long int) yystacksize)); 1898+ 1899+ if (yyss + yystacksize - 1 <= yyssp) 1900+ YYABORT; 1901+ } 1902+ 1903+ YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1904+ 1905+ goto yybackup; 1906+ 1907+/*-----------. 1908+| yybackup. | 1909+`-----------*/ 1910+yybackup: 1911+ 1912+ /* Do appropriate processing given the current state. Read a 1913+ look-ahead token if we need one and don't already have one. */ 1914+ 1915+ /* First try to decide what to do without reference to look-ahead token. */ 1916+ yyn = yypact[yystate]; 1917+ if (yyn == YYPACT_NINF) 1918+ goto yydefault; 1919+ 1920+ /* Not known => get a look-ahead token if don't already have one. */ 1921+ 1922+ /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 1923+ if (yychar == YYEMPTY) 1924+ { 1925+ YYDPRINTF ((stderr, "Reading a token: ")); 1926+ yychar = YYLEX; 1927+ } 1928+ 1929+ if (yychar <= YYEOF) 1930+ { 1931+ yychar = yytoken = YYEOF; 1932+ YYDPRINTF ((stderr, "Now at end of input.\n")); 1933+ } 1934+ else 1935+ { 1936+ yytoken = YYTRANSLATE (yychar); 1937+ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1938+ } 1939+ 1940+ /* If the proper action on seeing token YYTOKEN is to reduce or to 1941+ detect an error, take that action. */ 1942+ yyn += yytoken; 1943+ if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1944+ goto yydefault; 1945+ yyn = yytable[yyn]; 1946+ if (yyn <= 0) 1947+ { 1948+ if (yyn == 0 || yyn == YYTABLE_NINF) 1949+ goto yyerrlab; 1950+ yyn = -yyn; 1951+ goto yyreduce; 1952+ } 1953+ 1954+ if (yyn == YYFINAL) 1955+ YYACCEPT; 1956+ 1957+ /* Count tokens shifted since error; after three, turn off error 1958+ status. */ 1959+ if (yyerrstatus) 1960+ yyerrstatus--; 1961+ 1962+ /* Shift the look-ahead token. */ 1963+ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1964+ 1965+ /* Discard the shifted token unless it is eof. */ 1966+ if (yychar != YYEOF) 1967+ yychar = YYEMPTY; 1968+ 1969+ yystate = yyn; 1970+ *++yyvsp = yylval; 1971+ 1972+ goto yynewstate; 1973+ 1974+ 1975+/*-----------------------------------------------------------. 1976+| yydefault -- do the default action for the current state. | 1977+`-----------------------------------------------------------*/ 1978+yydefault: 1979+ yyn = yydefact[yystate]; 1980+ if (yyn == 0) 1981+ goto yyerrlab; 1982+ goto yyreduce; 1983+ 1984+ 1985+/*-----------------------------. 1986+| yyreduce -- Do a reduction. | 1987+`-----------------------------*/ 1988+yyreduce: 1989+ /* yyn is the number of a rule to reduce with. */ 1990+ yylen = yyr2[yyn]; 1991+ 1992+ /* If YYLEN is nonzero, implement the default value of the action: 1993+ `$$ = $1'. 1994+ 1995+ Otherwise, the following line sets YYVAL to garbage. 1996+ This behavior is undocumented and Bison 1997+ users should not rely upon it. Assigning to YYVAL 1998+ unconditionally makes the parser a bit smaller, and it avoids a 1999+ GCC warning that YYVAL may be used uninitialized. */ 2000+ yyval = yyvsp[1-yylen]; 2001+ 2002+ 2003+ YY_REDUCE_PRINT (yyn); 2004+ switch (yyn) 2005+ { 2006+ case 2: 2007+#line 51 "cubeparse.y" 2008+ { 2009+ 2010+ int dim; 2011+ 2012+ dim = delim_count((yyvsp[(2) - (5)]), ',') + 1; 2013+ if ( (delim_count((yyvsp[(4) - (5)]), ',') + 1) != dim ) { 2014+ ereport(ERROR, 2015+ (errcode(ERRCODE_SYNTAX_ERROR), 2016+ errmsg("bad cube representation"), 2017+ errdetail("Different point dimensions in (%s) and (%s).", 2018+ (yyvsp[(2) - (5)]), (yyvsp[(4) - (5)])))); 2019+ YYABORT; 2020+ } 2021+ if (dim > CUBE_MAX_DIM) { 2022+ ereport(ERROR, 2023+ (errcode(ERRCODE_SYNTAX_ERROR), 2024+ errmsg("bad cube representation"), 2025+ errdetail("A cube cannot have more than %d dimensions.", 2026+ CUBE_MAX_DIM))); 2027+ YYABORT; 2028+ } 2029+ 2030+ *((void **)result) = write_box( dim, (yyvsp[(2) - (5)]), (yyvsp[(4) - (5)]) ); 2031+ 2032+ ;} 2033+ break; 2034+ 2035+ case 3: 2036+#line 77 "cubeparse.y" 2037+ { 2038+ int dim; 2039+ 2040+ dim = delim_count((yyvsp[(1) - (3)]), ',') + 1; 2041+ 2042+ if ( (delim_count((yyvsp[(3) - (3)]), ',') + 1) != dim ) { 2043+ ereport(ERROR, 2044+ (errcode(ERRCODE_SYNTAX_ERROR), 2045+ errmsg("bad cube representation"), 2046+ errdetail("Different point dimensions in (%s) and (%s).", 2047+ (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])))); 2048+ YYABORT; 2049+ } 2050+ if (dim > CUBE_MAX_DIM) { 2051+ ereport(ERROR, 2052+ (errcode(ERRCODE_SYNTAX_ERROR), 2053+ errmsg("bad cube representation"), 2054+ errdetail("A cube cannot have more than %d dimensions.", 2055+ CUBE_MAX_DIM))); 2056+ YYABORT; 2057+ } 2058+ 2059+ *((void **)result) = write_box( dim, (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)]) ); 2060+ ;} 2061+ break; 2062+ 2063+ case 4: 2064+#line 103 "cubeparse.y" 2065+ { 2066+ int dim; 2067+ 2068+ dim = delim_count((yyvsp[(1) - (1)]), ',') + 1; 2069+ if (dim > CUBE_MAX_DIM) { 2070+ ereport(ERROR, 2071+ (errcode(ERRCODE_SYNTAX_ERROR), 2072+ errmsg("bad cube representation"), 2073+ errdetail("A cube cannot have more than %d dimensions.", 2074+ CUBE_MAX_DIM))); 2075+ YYABORT; 2076+ } 2077+ 2078+ *((void **)result) = write_point_as_box((yyvsp[(1) - (1)]), dim); 2079+ ;} 2080+ break; 2081+ 2082+ case 5: 2083+#line 121 "cubeparse.y" 2084+ { 2085+ int dim; 2086+ 2087+ dim = delim_count((yyvsp[(1) - (1)]), ',') + 1; 2088+ if (dim > CUBE_MAX_DIM) { 2089+ ereport(ERROR, 2090+ (errcode(ERRCODE_SYNTAX_ERROR), 2091+ errmsg("bad cube representation"), 2092+ errdetail("A cube cannot have more than %d dimensions.", 2093+ CUBE_MAX_DIM))); 2094+ YYABORT; 2095+ } 2096+ *((void **)result) = write_point_as_box((yyvsp[(1) - (1)]), dim); 2097+ ;} 2098+ break; 2099+ 2100+ case 6: 2101+#line 138 "cubeparse.y" 2102+ { 2103+ (yyval) = (yyvsp[(2) - (3)]); 2104+ ;} 2105+ break; 2106+ 2107+ case 7: 2108+#line 144 "cubeparse.y" 2109+ { 2110+ /* alloc enough space to be sure whole list will fit */ 2111+ (yyval) = palloc(scanbuflen + 1); 2112+ strcpy((yyval), (yyvsp[(1) - (1)])); 2113+ ;} 2114+ break; 2115+ 2116+ case 8: 2117+#line 150 "cubeparse.y" 2118+ { 2119+ (yyval) = (yyvsp[(1) - (3)]); 2120+ strcat((yyval), ","); 2121+ strcat((yyval), (yyvsp[(3) - (3)])); 2122+ ;} 2123+ break; 2124+ 2125+ 2126+/* Line 1267 of yacc.c. */ 2127+#line 1476 "cubeparse.tab.c" 2128+ default: break; 2129+ } 2130+ YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 2131+ 2132+ YYPOPSTACK (yylen); 2133+ yylen = 0; 2134+ YY_STACK_PRINT (yyss, yyssp); 2135+ 2136+ *++yyvsp = yyval; 2137+ 2138+ 2139+ /* Now `shift' the result of the reduction. Determine what state 2140+ that goes to, based on the state we popped back to and the rule 2141+ number reduced by. */ 2142+ 2143+ yyn = yyr1[yyn]; 2144+ 2145+ yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 2146+ if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 2147+ yystate = yytable[yystate]; 2148+ else 2149+ yystate = yydefgoto[yyn - YYNTOKENS]; 2150+ 2151+ goto yynewstate; 2152+ 2153+ 2154+/*------------------------------------. 2155+| yyerrlab -- here on detecting error | 2156+`------------------------------------*/ 2157+yyerrlab: 2158+ /* If not already recovering from an error, report this error. */ 2159+ if (!yyerrstatus) 2160+ { 2161+ ++yynerrs; 2162+#if ! YYERROR_VERBOSE 2163+ yyerror (YY_("syntax error")); 2164+#else 2165+ { 2166+ YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 2167+ if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 2168+ { 2169+ YYSIZE_T yyalloc = 2 * yysize; 2170+ if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 2171+ yyalloc = YYSTACK_ALLOC_MAXIMUM; 2172+ if (yymsg != yymsgbuf) 2173+ YYSTACK_FREE (yymsg); 2174+ yymsg = (char *) YYSTACK_ALLOC (yyalloc); 2175+ if (yymsg) 2176+ yymsg_alloc = yyalloc; 2177+ else 2178+ { 2179+ yymsg = yymsgbuf; 2180+ yymsg_alloc = sizeof yymsgbuf; 2181+ } 2182+ } 2183+ 2184+ if (0 < yysize && yysize <= yymsg_alloc) 2185+ { 2186+ (void) yysyntax_error (yymsg, yystate, yychar); 2187+ yyerror (yymsg); 2188+ } 2189+ else 2190+ { 2191+ yyerror (YY_("syntax error")); 2192+ if (yysize != 0) 2193+ goto yyexhaustedlab; 2194+ } 2195+ } 2196+#endif 2197+ } 2198+ 2199+ 2200+ 2201+ if (yyerrstatus == 3) 2202+ { 2203+ /* If just tried and failed to reuse look-ahead token after an 2204+ error, discard it. */ 2205+ 2206+ if (yychar <= YYEOF) 2207+ { 2208+ /* Return failure if at end of input. */ 2209+ if (yychar == YYEOF) 2210+ YYABORT; 2211+ } 2212+ else 2213+ { 2214+ yydestruct ("Error: discarding", 2215+ yytoken, &yylval); 2216+ yychar = YYEMPTY; 2217+ } 2218+ } 2219+ 2220+ /* Else will try to reuse look-ahead token after shifting the error 2221+ token. */ 2222+ goto yyerrlab1; 2223+ 2224+ 2225+/*---------------------------------------------------. 2226+| yyerrorlab -- error raised explicitly by YYERROR. | 2227+`---------------------------------------------------*/ 2228+yyerrorlab: 2229+ 2230+ /* Pacify compilers like GCC when the user code never invokes 2231+ YYERROR and the label yyerrorlab therefore never appears in user 2232+ code. */ 2233+ if (/*CONSTCOND*/ 0) 2234+ goto yyerrorlab; 2235+ 2236+ /* Do not reclaim the symbols of the rule which action triggered 2237+ this YYERROR. */ 2238+ YYPOPSTACK (yylen); 2239+ yylen = 0; 2240+ YY_STACK_PRINT (yyss, yyssp); 2241+ yystate = *yyssp; 2242+ goto yyerrlab1; 2243+ 2244+ 2245+/*-------------------------------------------------------------. 2246+| yyerrlab1 -- common code for both syntax error and YYERROR. | 2247+`-------------------------------------------------------------*/ 2248+yyerrlab1: 2249+ yyerrstatus = 3; /* Each real token shifted decrements this. */ 2250+ 2251+ for (;;) 2252+ { 2253+ yyn = yypact[yystate]; 2254+ if (yyn != YYPACT_NINF) 2255+ { 2256+ yyn += YYTERROR; 2257+ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2258+ { 2259+ yyn = yytable[yyn]; 2260+ if (0 < yyn) 2261+ break; 2262+ } 2263+ } 2264+ 2265+ /* Pop the current state because it cannot handle the error token. */ 2266+ if (yyssp == yyss) 2267+ YYABORT; 2268+ 2269+ 2270+ yydestruct ("Error: popping", 2271+ yystos[yystate], yyvsp); 2272+ YYPOPSTACK (1); 2273+ yystate = *yyssp; 2274+ YY_STACK_PRINT (yyss, yyssp); 2275+ } 2276+ 2277+ if (yyn == YYFINAL) 2278+ YYACCEPT; 2279+ 2280+ *++yyvsp = yylval; 2281+ 2282+ 2283+ /* Shift the error token. */ 2284+ YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2285+ 2286+ yystate = yyn; 2287+ goto yynewstate; 2288+ 2289+ 2290+/*-------------------------------------. 2291+| yyacceptlab -- YYACCEPT comes here. | 2292+`-------------------------------------*/ 2293+yyacceptlab: 2294+ yyresult = 0; 2295+ goto yyreturn; 2296+ 2297+/*-----------------------------------. 2298+| yyabortlab -- YYABORT comes here. | 2299+`-----------------------------------*/ 2300+yyabortlab: 2301+ yyresult = 1; 2302+ goto yyreturn; 2303+ 2304+#ifndef yyoverflow 2305+/*-------------------------------------------------. 2306+| yyexhaustedlab -- memory exhaustion comes here. | 2307+`-------------------------------------------------*/ 2308+yyexhaustedlab: 2309+ yyerror (YY_("memory exhausted")); 2310+ yyresult = 2; 2311+ /* Fall through. */ 2312+#endif 2313+ 2314+yyreturn: 2315+ if (yychar != YYEOF && yychar != YYEMPTY) 2316+ yydestruct ("Cleanup: discarding lookahead", 2317+ yytoken, &yylval); 2318+ /* Do not reclaim the symbols of the rule which action triggered 2319+ this YYABORT or YYACCEPT. */ 2320+ YYPOPSTACK (yylen); 2321+ YY_STACK_PRINT (yyss, yyssp); 2322+ while (yyssp != yyss) 2323+ { 2324+ yydestruct ("Cleanup: popping", 2325+ yystos[*yyssp], yyvsp); 2326+ YYPOPSTACK (1); 2327+ } 2328+#ifndef yyoverflow 2329+ if (yyss != yyssa) 2330+ YYSTACK_FREE (yyss); 2331+#endif 2332+#if YYERROR_VERBOSE 2333+ if (yymsg != yymsgbuf) 2334+ YYSTACK_FREE (yymsg); 2335+#endif 2336+ /* Make sure YYID is used. */ 2337+ return YYID (yyresult); 2338+} 2339+ 2340+ 2341+#line 157 "cubeparse.y" 2342+ 2343+ 2344+static int 2345+delim_count(char *s, char delim) 2346+{ 2347+ int ndelim = 0; 2348+ 2349+ while ((s = strchr(s, delim)) != NULL) 2350+ { 2351+ ndelim++; 2352+ s++; 2353+ } 2354+ return (ndelim); 2355+} 2356+ 2357+static NDBOX * 2358+write_box(unsigned int dim, char *str1, char *str2) 2359+{ 2360+ NDBOX * bp; 2361+ char * s; 2362+ int i; 2363+ int size = offsetof(NDBOX, x[0]) + sizeof(double) * dim * 2; 2364+ 2365+ bp = palloc0(size); 2366+ SET_VARSIZE(bp, size); 2367+ bp->dim = dim; 2368+ 2369+ s = str1; 2370+ bp->x[i=0] = strtod(s, NULL); 2371+ while ((s = strchr(s, ',')) != NULL) { 2372+ s++; i++; 2373+ bp->x[i] = strtod(s, NULL); 2374+ } 2375+ 2376+ s = str2; 2377+ bp->x[i=dim] = strtod(s, NULL); 2378+ while ((s = strchr(s, ',')) != NULL) { 2379+ s++; i++; 2380+ bp->x[i] = strtod(s, NULL); 2381+ } 2382+ 2383+ return(bp); 2384+} 2385+ 2386+ 2387+static NDBOX * 2388+write_point_as_box(char *str, int dim) 2389+{ 2390+ NDBOX * bp; 2391+ int i, size; 2392+ double x; 2393+ char * s = str; 2394+ 2395+ size = offsetof(NDBOX, x[0]) + sizeof(double) * dim * 2; 2396+ 2397+ bp = palloc0(size); 2398+ SET_VARSIZE(bp, size); 2399+ bp->dim = dim; 2400+ 2401+ i = 0; 2402+ x = strtod(s, NULL); 2403+ bp->x[0] = x; 2404+ bp->x[dim] = x; 2405+ while ((s = strchr(s, ',')) != NULL) { 2406+ s++; i++; 2407+ x = strtod(s, NULL); 2408+ bp->x[i] = x; 2409+ bp->x[i+dim] = x; 2410+ } 2411+ 2412+ return(bp); 2413+} 2414+ 2415+#include "cubescan.c" 2416+ 2417diff -Naur postgresql-9.0.8/contrib/seg/segparse.c postgresql/contrib/seg/segparse.c 2418--- postgresql-9.0.8/contrib/seg/segparse.c 2012-05-31 16:28:05.000000000 -0700 2419+++ postgresql/contrib/seg/segparse.c 2012-06-08 14:10:27.000000000 -0700 2420@@ -1,23 +1,24 @@ 2421- 2422-/* A Bison parser, made by GNU Bison 2.4.1. */ 2423+/* A Bison parser, made by GNU Bison 2.3. */ 2424 2425 /* Skeleton implementation for Bison's Yacc-like parsers in C 2426- 2427- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 2428+ 2429+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 2430 Free Software Foundation, Inc. 2431- 2432- This program is free software: you can redistribute it and/or modify 2433+ 2434+ This program is free software; you can redistribute it and/or modify 2435 it under the terms of the GNU General Public License as published by 2436- the Free Software Foundation, either version 3 of the License, or 2437- (at your option) any later version. 2438- 2439+ the Free Software Foundation; either version 2, or (at your option) 2440+ any later version. 2441+ 2442 This program is distributed in the hope that it will be useful, 2443 but WITHOUT ANY WARRANTY; without even the implied warranty of 2444 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 2445 GNU General Public License for more details. 2446- 2447+ 2448 You should have received a copy of the GNU General Public License 2449- along with this program. If not, see <http://www.gnu.org/licenses/>. */ 2450+ along with this program; if not, write to the Free Software 2451+ Foundation, Inc., 51 Franklin Street, Fifth Floor, 2452+ Boston, MA 02110-1301, USA. */ 2453 2454 /* As a special exception, you may create a larger work that contains 2455 part or all of the Bison parser skeleton and distribute that work 2456@@ -28,7 +29,7 @@ 2457 special exception, which will cause the skeleton and the resulting 2458 Bison output files to be licensed under the GNU General Public 2459 License without this special exception. 2460- 2461+ 2462 This special exception was added by the Free Software Foundation in 2463 version 2.2 of Bison. */ 2464 2465@@ -46,7 +47,7 @@ 2466 #define YYBISON 1 2467 2468 /* Bison version. */ 2469-#define YYBISON_VERSION "2.4.1" 2470+#define YYBISON_VERSION "2.3" 2471 2472 /* Skeleton name. */ 2473 #define YYSKELETON_NAME "yacc.c" 2474@@ -54,28 +55,41 @@ 2475 /* Pure parsers. */ 2476 #define YYPURE 0 2477 2478-/* Push parsers. */ 2479-#define YYPUSH 0 2480- 2481-/* Pull parsers. */ 2482-#define YYPULL 1 2483- 2484 /* Using locations. */ 2485 #define YYLSP_NEEDED 0 2486 2487 /* Substitute the variable and function names. */ 2488-#define yyparse seg_yyparse 2489-#define yylex seg_yylex 2490-#define yyerror seg_yyerror 2491-#define yylval seg_yylval 2492-#define yychar seg_yychar 2493-#define yydebug seg_yydebug 2494-#define yynerrs seg_yynerrs 2495+#define yyparse seg_yyparse 2496+#define yylex seg_yylex 2497+#define yyerror seg_yyerror 2498+#define yylval seg_yylval 2499+#define yychar seg_yychar 2500+#define yydebug seg_yydebug 2501+#define yynerrs seg_yynerrs 2502 2503 2504-/* Copy the first part of user declarations. */ 2505+/* Tokens. */ 2506+#ifndef YYTOKENTYPE 2507+# define YYTOKENTYPE 2508+ /* Put the tokens into the symbol table, so that GDB and other debuggers 2509+ know about them. */ 2510+ enum yytokentype { 2511+ SEGFLOAT = 258, 2512+ RANGE = 259, 2513+ PLUMIN = 260, 2514+ EXTENSION = 261 2515+ }; 2516+#endif 2517+/* Tokens. */ 2518+#define SEGFLOAT 258 2519+#define RANGE 259 2520+#define PLUMIN 260 2521+#define EXTENSION 261 2522+ 2523 2524-/* Line 189 of yacc.c */ 2525+ 2526+ 2527+/* Copy the first part of user declarations. */ 2528 #line 1 "segparse.y" 2529 2530 #define YYPARSE_PARAM result /* need this to pass a pointer (void *) to yyparse */ 2531@@ -118,9 +132,6 @@ 2532 2533 2534 2535-/* Line 189 of yacc.c */ 2536-#line 123 "segparse.c" 2537- 2538 /* Enabling traces. */ 2539 #ifndef YYDEBUG 2540 # define YYDEBUG 0 2541@@ -139,52 +150,32 @@ 2542 # define YYTOKEN_TABLE 0 2543 #endif 2544 2545- 2546-/* Tokens. */ 2547-#ifndef YYTOKENTYPE 2548-# define YYTOKENTYPE 2549- /* Put the tokens into the symbol table, so that GDB and other debuggers 2550- know about them. */ 2551- enum yytokentype { 2552- SEGFLOAT = 258, 2553- RANGE = 259, 2554- PLUMIN = 260, 2555- EXTENSION = 261 2556- }; 2557-#endif 2558- 2559- 2560- 2561 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 2562 typedef union YYSTYPE 2563-{ 2564- 2565-/* Line 214 of yacc.c */ 2566 #line 46 "segparse.y" 2567- 2568+{ 2569 struct BND { 2570 float val; 2571 char ext; 2572 char sigd; 2573 } bnd; 2574 char * text; 2575- 2576- 2577- 2578-/* Line 214 of yacc.c */ 2579-#line 176 "segparse.c" 2580-} YYSTYPE; 2581-# define YYSTYPE_IS_TRIVIAL 1 2582+} 2583+/* Line 193 of yacc.c. */ 2584+#line 166 "segparse.c" 2585+ YYSTYPE; 2586 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 2587 # define YYSTYPE_IS_DECLARED 1 2588+# define YYSTYPE_IS_TRIVIAL 1 2589 #endif 2590 2591 2592+ 2593 /* Copy the second part of user declarations. */ 2594 2595 2596-/* Line 264 of yacc.c */ 2597-#line 188 "segparse.c" 2598+/* Line 216 of yacc.c. */ 2599+#line 179 "segparse.c" 2600 2601 #ifdef short 2602 # undef short 2603@@ -234,7 +225,7 @@ 2604 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 2605 2606 #ifndef YY_ 2607-# if YYENABLE_NLS 2608+# if defined YYENABLE_NLS && YYENABLE_NLS 2609 # if ENABLE_NLS 2610 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 2611 # define YY_(msgid) dgettext ("bison-runtime", msgid) 2612@@ -259,14 +250,14 @@ 2613 #if (defined __STDC__ || defined __C99__FUNC__ \ 2614 || defined __cplusplus || defined _MSC_VER) 2615 static int 2616-YYID (int yyi) 2617+YYID (int i) 2618 #else 2619 static int 2620-YYID (yyi) 2621- int yyi; 2622+YYID (i) 2623+ int i; 2624 #endif 2625 { 2626- return yyi; 2627+ return i; 2628 } 2629 #endif 2630 2631@@ -347,9 +338,9 @@ 2632 /* A type that is properly aligned for any stack member. */ 2633 union yyalloc 2634 { 2635- yytype_int16 yyss_alloc; 2636- YYSTYPE yyvs_alloc; 2637-}; 2638+ yytype_int16 yyss; 2639+ YYSTYPE yyvs; 2640+ }; 2641 2642 /* The size of the maximum gap between one aligned stack and the next. */ 2643 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 2644@@ -383,12 +374,12 @@ 2645 elements in the stack, and YYPTR gives the new location of the 2646 stack. Advance YYPTR to a properly aligned location for the next 2647 stack. */ 2648-# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 2649+# define YYSTACK_RELOCATE(Stack) \ 2650 do \ 2651 { \ 2652 YYSIZE_T yynewbytes; \ 2653- YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 2654- Stack = &yyptr->Stack_alloc; \ 2655+ YYCOPY (&yyptr->Stack, Stack, yysize); \ 2656+ Stack = &yyptr->Stack; \ 2657 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 2658 yyptr += yynewbytes / sizeof (*yyptr); \ 2659 } \ 2660@@ -629,7 +620,7 @@ 2661 we won't break user code: when these are the locations we know. */ 2662 2663 #ifndef YY_LOCATION_PRINT 2664-# if YYLTYPE_IS_TRIVIAL 2665+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 2666 # define YY_LOCATION_PRINT(File, Loc) \ 2667 fprintf (File, "%d.%d-%d.%d", \ 2668 (Loc).first_line, (Loc).first_column, \ 2669@@ -740,20 +731,17 @@ 2670 #if (defined __STDC__ || defined __C99__FUNC__ \ 2671 || defined __cplusplus || defined _MSC_VER) 2672 static void 2673-yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 2674+yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) 2675 #else 2676 static void 2677-yy_stack_print (yybottom, yytop) 2678- yytype_int16 *yybottom; 2679- yytype_int16 *yytop; 2680+yy_stack_print (bottom, top) 2681+ yytype_int16 *bottom; 2682+ yytype_int16 *top; 2683 #endif 2684 { 2685 YYFPRINTF (stderr, "Stack now"); 2686- for (; yybottom <= yytop; yybottom++) 2687- { 2688- int yybot = *yybottom; 2689- YYFPRINTF (stderr, " %d", yybot); 2690- } 2691+ for (; bottom <= top; ++bottom) 2692+ YYFPRINTF (stderr, " %d", *bottom); 2693 YYFPRINTF (stderr, "\n"); 2694 } 2695 2696@@ -787,11 +775,11 @@ 2697 /* The symbols being reduced. */ 2698 for (yyi = 0; yyi < yynrhs; yyi++) 2699 { 2700- YYFPRINTF (stderr, " $%d = ", yyi + 1); 2701+ fprintf (stderr, " $%d = ", yyi + 1); 2702 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 2703 &(yyvsp[(yyi + 1) - (yynrhs)]) 2704 ); 2705- YYFPRINTF (stderr, "\n"); 2706+ fprintf (stderr, "\n"); 2707 } 2708 } 2709 2710@@ -1071,8 +1059,10 @@ 2711 break; 2712 } 2713 } 2714+ 2715 2716 /* Prevent warnings from -Wmissing-prototypes. */ 2717+ 2718 #ifdef YYPARSE_PARAM 2719 #if defined __STDC__ || defined __cplusplus 2720 int yyparse (void *YYPARSE_PARAM); 2721@@ -1088,10 +1078,11 @@ 2722 #endif /* ! YYPARSE_PARAM */ 2723 2724 2725-/* The lookahead symbol. */ 2726+ 2727+/* The look-ahead symbol. */ 2728 int yychar; 2729 2730-/* The semantic value of the lookahead symbol. */ 2731+/* The semantic value of the look-ahead symbol. */ 2732 YYSTYPE yylval; 2733 2734 /* Number of syntax errors so far. */ 2735@@ -1099,9 +1090,9 @@ 2736 2737 2738 2739-/*-------------------------. 2740-| yyparse or yypush_parse. | 2741-`-------------------------*/ 2742+/*----------. 2743+| yyparse. | 2744+`----------*/ 2745 2746 #ifdef YYPARSE_PARAM 2747 #if (defined __STDC__ || defined __C99__FUNC__ \ 2748@@ -1125,39 +1116,14 @@ 2749 #endif 2750 #endif 2751 { 2752- 2753- 2754- int yystate; 2755- /* Number of tokens to shift before error messages enabled. */ 2756- int yyerrstatus; 2757- 2758- /* The stacks and their tools: 2759- `yyss': related to states. 2760- `yyvs': related to semantic values. 2761- 2762- Refer to the stacks thru separate pointers, to allow yyoverflow 2763- to reallocate them elsewhere. */ 2764- 2765- /* The state stack. */ 2766- yytype_int16 yyssa[YYINITDEPTH]; 2767- yytype_int16 *yyss; 2768- yytype_int16 *yyssp; 2769- 2770- /* The semantic value stack. */ 2771- YYSTYPE yyvsa[YYINITDEPTH]; 2772- YYSTYPE *yyvs; 2773- YYSTYPE *yyvsp; 2774- 2775- YYSIZE_T yystacksize; 2776- 2777+ 2778+ int yystate; 2779 int yyn; 2780 int yyresult; 2781- /* Lookahead token as an internal (translated) token number. */ 2782- int yytoken; 2783- /* The variables used to return semantic value and location from the 2784- action routines. */ 2785- YYSTYPE yyval; 2786- 2787+ /* Number of tokens to shift before error messages enabled. */ 2788+ int yyerrstatus; 2789+ /* Look-ahead token as an internal (translated) token number. */ 2790+ int yytoken = 0; 2791 #if YYERROR_VERBOSE 2792 /* Buffer for error messages, and its allocated size. */ 2793 char yymsgbuf[128]; 2794@@ -1165,28 +1131,51 @@ 2795 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 2796 #endif 2797 2798+ /* Three stacks and their tools: 2799+ `yyss': related to states, 2800+ `yyvs': related to semantic values, 2801+ `yyls': related to locations. 2802+ 2803+ Refer to the stacks thru separate pointers, to allow yyoverflow 2804+ to reallocate them elsewhere. */ 2805+ 2806+ /* The state stack. */ 2807+ yytype_int16 yyssa[YYINITDEPTH]; 2808+ yytype_int16 *yyss = yyssa; 2809+ yytype_int16 *yyssp; 2810+ 2811+ /* The semantic value stack. */ 2812+ YYSTYPE yyvsa[YYINITDEPTH]; 2813+ YYSTYPE *yyvs = yyvsa; 2814+ YYSTYPE *yyvsp; 2815+ 2816+ 2817+ 2818 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 2819 2820+ YYSIZE_T yystacksize = YYINITDEPTH; 2821+ 2822+ /* The variables used to return semantic value and location from the 2823+ action routines. */ 2824+ YYSTYPE yyval; 2825+ 2826+ 2827 /* The number of symbols on the RHS of the reduced rule. 2828 Keep to zero when no symbol should be popped. */ 2829 int yylen = 0; 2830 2831- yytoken = 0; 2832- yyss = yyssa; 2833- yyvs = yyvsa; 2834- yystacksize = YYINITDEPTH; 2835- 2836 YYDPRINTF ((stderr, "Starting parse\n")); 2837 2838 yystate = 0; 2839 yyerrstatus = 0; 2840 yynerrs = 0; 2841- yychar = YYEMPTY; /* Cause a token to be read. */ 2842+ yychar = YYEMPTY; /* Cause a token to be read. */ 2843 2844 /* Initialize stack pointers. 2845 Waste one element of value and location stack 2846 so that they stay on the same level as the state stack. 2847 The wasted elements are never initialized. */ 2848+ 2849 yyssp = yyss; 2850 yyvsp = yyvs; 2851 2852@@ -1216,6 +1205,7 @@ 2853 YYSTYPE *yyvs1 = yyvs; 2854 yytype_int16 *yyss1 = yyss; 2855 2856+ 2857 /* Each stack pointer address is followed by the size of the 2858 data in use in that stack, in bytes. This used to be a 2859 conditional around just the two extra args, but that might 2860@@ -1223,6 +1213,7 @@ 2861 yyoverflow (YY_("memory exhausted"), 2862 &yyss1, yysize * sizeof (*yyssp), 2863 &yyvs1, yysize * sizeof (*yyvsp), 2864+ 2865 &yystacksize); 2866 2867 yyss = yyss1; 2868@@ -1245,8 +1236,9 @@ 2869 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 2870 if (! yyptr) 2871 goto yyexhaustedlab; 2872- YYSTACK_RELOCATE (yyss_alloc, yyss); 2873- YYSTACK_RELOCATE (yyvs_alloc, yyvs); 2874+ YYSTACK_RELOCATE (yyss); 2875+ YYSTACK_RELOCATE (yyvs); 2876+ 2877 # undef YYSTACK_RELOCATE 2878 if (yyss1 != yyssa) 2879 YYSTACK_FREE (yyss1); 2880@@ -1257,6 +1249,7 @@ 2881 yyssp = yyss + yysize - 1; 2882 yyvsp = yyvs + yysize - 1; 2883 2884+ 2885 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 2886 (unsigned long int) yystacksize)); 2887 2888@@ -1266,9 +1259,6 @@ 2889 2890 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 2891 2892- if (yystate == YYFINAL) 2893- YYACCEPT; 2894- 2895 goto yybackup; 2896 2897 /*-----------. 2898@@ -1277,16 +1267,16 @@ 2899 yybackup: 2900 2901 /* Do appropriate processing given the current state. Read a 2902- lookahead token if we need one and don't already have one. */ 2903+ look-ahead token if we need one and don't already have one. */ 2904 2905- /* First try to decide what to do without reference to lookahead token. */ 2906+ /* First try to decide what to do without reference to look-ahead token. */ 2907 yyn = yypact[yystate]; 2908 if (yyn == YYPACT_NINF) 2909 goto yydefault; 2910 2911- /* Not known => get a lookahead token if don't already have one. */ 2912+ /* Not known => get a look-ahead token if don't already have one. */ 2913 2914- /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 2915+ /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 2916 if (yychar == YYEMPTY) 2917 { 2918 YYDPRINTF ((stderr, "Reading a token: ")); 2919@@ -1318,16 +1308,20 @@ 2920 goto yyreduce; 2921 } 2922 2923+ if (yyn == YYFINAL) 2924+ YYACCEPT; 2925+ 2926 /* Count tokens shifted since error; after three, turn off error 2927 status. */ 2928 if (yyerrstatus) 2929 yyerrstatus--; 2930 2931- /* Shift the lookahead token. */ 2932+ /* Shift the look-ahead token. */ 2933 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 2934 2935- /* Discard the shifted token. */ 2936- yychar = YYEMPTY; 2937+ /* Discard the shifted token unless it is eof. */ 2938+ if (yychar != YYEOF) 2939+ yychar = YYEMPTY; 2940 2941 yystate = yyn; 2942 *++yyvsp = yylval; 2943@@ -1367,8 +1361,6 @@ 2944 switch (yyn) 2945 { 2946 case 2: 2947- 2948-/* Line 1455 of yacc.c */ 2949 #line 67 "segparse.y" 2950 { 2951 ((SEG *)result)->lower = (yyvsp[(1) - (3)].bnd).val - (yyvsp[(3) - (3)].bnd).val; 2952@@ -1383,8 +1375,6 @@ 2953 break; 2954 2955 case 3: 2956- 2957-/* Line 1455 of yacc.c */ 2958 #line 78 "segparse.y" 2959 { 2960 ((SEG *)result)->lower = (yyvsp[(1) - (3)].bnd).val; 2961@@ -1405,8 +1395,6 @@ 2962 break; 2963 2964 case 4: 2965- 2966-/* Line 1455 of yacc.c */ 2967 #line 95 "segparse.y" 2968 { 2969 ((SEG *)result)->lower = (yyvsp[(1) - (2)].bnd).val; 2970@@ -1419,8 +1407,6 @@ 2971 break; 2972 2973 case 5: 2974- 2975-/* Line 1455 of yacc.c */ 2976 #line 104 "segparse.y" 2977 { 2978 ((SEG *)result)->lower = -HUGE_VAL; 2979@@ -1433,8 +1419,6 @@ 2980 break; 2981 2982 case 6: 2983- 2984-/* Line 1455 of yacc.c */ 2985 #line 113 "segparse.y" 2986 { 2987 ((SEG *)result)->lower = ((SEG *)result)->upper = (yyvsp[(1) - (1)].bnd).val; 2988@@ -1444,8 +1428,6 @@ 2989 break; 2990 2991 case 7: 2992- 2993-/* Line 1455 of yacc.c */ 2994 #line 121 "segparse.y" 2995 { 2996 /* temp variable avoids a gcc 3.3.x bug on Sparc64 */ 2997@@ -1458,8 +1440,6 @@ 2998 break; 2999 3000 case 8: 3001- 3002-/* Line 1455 of yacc.c */ 3003 #line 130 "segparse.y" 3004 { 3005 /* temp variable avoids a gcc 3.3.x bug on Sparc64 */ 3006@@ -1472,8 +1452,6 @@ 3007 break; 3008 3009 case 9: 3010- 3011-/* Line 1455 of yacc.c */ 3012 #line 141 "segparse.y" 3013 { 3014 /* temp variable avoids a gcc 3.3.x bug on Sparc64 */ 3015@@ -1486,9 +1464,8 @@ 3016 break; 3017 3018 3019- 3020-/* Line 1455 of yacc.c */ 3021-#line 1492 "segparse.c" 3022+/* Line 1267 of yacc.c. */ 3023+#line 1469 "segparse.c" 3024 default: break; 3025 } 3026 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 3027@@ -1499,6 +1476,7 @@ 3028 3029 *++yyvsp = yyval; 3030 3031+ 3032 /* Now `shift' the result of the reduction. Determine what state 3033 that goes to, based on the state we popped back to and the rule 3034 number reduced by. */ 3035@@ -1563,7 +1541,7 @@ 3036 3037 if (yyerrstatus == 3) 3038 { 3039- /* If just tried and failed to reuse lookahead token after an 3040+ /* If just tried and failed to reuse look-ahead token after an 3041 error, discard it. */ 3042 3043 if (yychar <= YYEOF) 3044@@ -1580,7 +1558,7 @@ 3045 } 3046 } 3047 3048- /* Else will try to reuse lookahead token after shifting the error 3049+ /* Else will try to reuse look-ahead token after shifting the error 3050 token. */ 3051 goto yyerrlab1; 3052 3053@@ -1637,6 +1615,9 @@ 3054 YY_STACK_PRINT (yyss, yyssp); 3055 } 3056 3057+ if (yyn == YYFINAL) 3058+ YYACCEPT; 3059+ 3060 *++yyvsp = yylval; 3061 3062 3063@@ -1661,7 +1642,7 @@ 3064 yyresult = 1; 3065 goto yyreturn; 3066 3067-#if !defined(yyoverflow) || YYERROR_VERBOSE 3068+#ifndef yyoverflow 3069 /*-------------------------------------------------. 3070 | yyexhaustedlab -- memory exhaustion comes here. | 3071 `-------------------------------------------------*/ 3072@@ -1672,7 +1653,7 @@ 3073 #endif 3074 3075 yyreturn: 3076- if (yychar != YYEMPTY) 3077+ if (yychar != YYEOF && yychar != YYEMPTY) 3078 yydestruct ("Cleanup: discarding lookahead", 3079 yytoken, &yylval); 3080 /* Do not reclaim the symbols of the rule which action triggered 3081@@ -1698,8 +1679,6 @@ 3082 } 3083 3084 3085- 3086-/* Line 1675 of yacc.c */ 3087 #line 151 "segparse.y" 3088 3089 3090diff -Naur postgresql-9.0.8/src/backend/bootstrap/bootparse.c postgresql/src/backend/bootstrap/bootparse.c 3091--- postgresql-9.0.8/src/backend/bootstrap/bootparse.c 2012-05-31 16:27:57.000000000 -0700 3092+++ postgresql/src/backend/bootstrap/bootparse.c 2012-06-08 14:11:06.000000000 -0700 3093@@ -1,23 +1,24 @@ 3094- 3095-/* A Bison parser, made by GNU Bison 2.4.1. */ 3096+/* A Bison parser, made by GNU Bison 2.3. */ 3097 3098 /* Skeleton implementation for Bison's Yacc-like parsers in C 3099- 3100- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 3101+ 3102+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 3103 Free Software Foundation, Inc. 3104- 3105- This program is free software: you can redistribute it and/or modify 3106+ 3107+ This program is free software; you can redistribute it and/or modify 3108 it under the terms of the GNU General Public License as published by 3109- the Free Software Foundation, either version 3 of the License, or 3110- (at your option) any later version. 3111- 3112+ the Free Software Foundation; either version 2, or (at your option) 3113+ any later version. 3114+ 3115 This program is distributed in the hope that it will be useful, 3116 but WITHOUT ANY WARRANTY; without even the implied warranty of 3117 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 3118 GNU General Public License for more details. 3119- 3120+ 3121 You should have received a copy of the GNU General Public License 3122- along with this program. If not, see <http://www.gnu.org/licenses/>. */ 3123+ along with this program; if not, write to the Free Software 3124+ Foundation, Inc., 51 Franklin Street, Fifth Floor, 3125+ Boston, MA 02110-1301, USA. */ 3126 3127 /* As a special exception, you may create a larger work that contains 3128 part or all of the Bison parser skeleton and distribute that work 3129@@ -28,7 +29,7 @@ 3130 special exception, which will cause the skeleton and the resulting 3131 Bison output files to be licensed under the GNU General Public 3132 License without this special exception. 3133- 3134+ 3135 This special exception was added by the Free Software Foundation in 3136 version 2.2 of Bison. */ 3137 3138@@ -46,7 +47,7 @@ 3139 #define YYBISON 1 3140 3141 /* Bison version. */ 3142-#define YYBISON_VERSION "2.4.1" 3143+#define YYBISON_VERSION "2.3" 3144 3145 /* Skeleton name. */ 3146 #define YYSKELETON_NAME "yacc.c" 3147@@ -54,28 +55,85 @@ 3148 /* Pure parsers. */ 3149 #define YYPURE 0 3150 3151-/* Push parsers. */ 3152-#define YYPUSH 0 3153- 3154-/* Pull parsers. */ 3155-#define YYPULL 1 3156- 3157 /* Using locations. */ 3158 #define YYLSP_NEEDED 0 3159 3160 /* Substitute the variable and function names. */ 3161-#define yyparse boot_yyparse 3162-#define yylex boot_yylex 3163-#define yyerror boot_yyerror 3164-#define yylval boot_yylval 3165-#define yychar boot_yychar 3166-#define yydebug boot_yydebug 3167-#define yynerrs boot_yynerrs 3168+#define yyparse boot_yyparse 3169+#define yylex boot_yylex 3170+#define yyerror boot_yyerror 3171+#define yylval boot_yylval 3172+#define yychar boot_yychar 3173+#define yydebug boot_yydebug 3174+#define yynerrs boot_yynerrs 3175+ 3176+ 3177+/* Tokens. */ 3178+#ifndef YYTOKENTYPE 3179+# define YYTOKENTYPE 3180+ /* Put the tokens into the symbol table, so that GDB and other debuggers 3181+ know about them. */ 3182+ enum yytokentype { 3183+ CONST_P = 258, 3184+ ID = 259, 3185+ OPEN = 260, 3186+ XCLOSE = 261, 3187+ XCREATE = 262, 3188+ INSERT_TUPLE = 263, 3189+ XDECLARE = 264, 3190+ INDEX = 265, 3191+ ON = 266, 3192+ USING = 267, 3193+ XBUILD = 268, 3194+ INDICES = 269, 3195+ UNIQUE = 270, 3196+ XTOAST = 271, 3197+ COMMA = 272, 3198+ EQUALS = 273, 3199+ LPAREN = 274, 3200+ RPAREN = 275, 3201+ OBJ_ID = 276, 3202+ XBOOTSTRAP = 277, 3203+ XSHARED_RELATION = 278, 3204+ XWITHOUT_OIDS = 279, 3205+ XROWTYPE_OID = 280, 3206+ NULLVAL = 281, 3207+ low = 282, 3208+ high = 283 3209+ }; 3210+#endif 3211+/* Tokens. */ 3212+#define CONST_P 258 3213+#define ID 259 3214+#define OPEN 260 3215+#define XCLOSE 261 3216+#define XCREATE 262 3217+#define INSERT_TUPLE 263 3218+#define XDECLARE 264 3219+#define INDEX 265 3220+#define ON 266 3221+#define USING 267 3222+#define XBUILD 268 3223+#define INDICES 269 3224+#define UNIQUE 270 3225+#define XTOAST 271 3226+#define COMMA 272 3227+#define EQUALS 273 3228+#define LPAREN 274 3229+#define RPAREN 275 3230+#define OBJ_ID 276 3231+#define XBOOTSTRAP 277 3232+#define XSHARED_RELATION 278 3233+#define XWITHOUT_OIDS 279 3234+#define XROWTYPE_OID 280 3235+#define NULLVAL 281 3236+#define low 282 3237+#define high 283 3238 3239 3240-/* Copy the first part of user declarations. */ 3241 3242-/* Line 189 of yacc.c */ 3243+ 3244+/* Copy the first part of user declarations. */ 3245 #line 1 "bootparse.y" 3246 3247 /*------------------------------------------------------------------------- 3248@@ -170,9 +228,6 @@ 3249 3250 3251 3252-/* Line 189 of yacc.c */ 3253-#line 175 "bootparse.c" 3254- 3255 /* Enabling traces. */ 3256 #ifndef YYDEBUG 3257 # define YYDEBUG 0 3258@@ -191,73 +246,31 @@ 3259 # define YYTOKEN_TABLE 0 3260 #endif 3261 3262- 3263-/* Tokens. */ 3264-#ifndef YYTOKENTYPE 3265-# define YYTOKENTYPE 3266- /* Put the tokens into the symbol table, so that GDB and other debuggers 3267- know about them. */ 3268- enum yytokentype { 3269- CONST_P = 258, 3270- ID = 259, 3271- OPEN = 260, 3272- XCLOSE = 261, 3273- XCREATE = 262, 3274- INSERT_TUPLE = 263, 3275- XDECLARE = 264, 3276- INDEX = 265, 3277- ON = 266, 3278- USING = 267, 3279- XBUILD = 268, 3280- INDICES = 269, 3281- UNIQUE = 270, 3282- XTOAST = 271, 3283- COMMA = 272, 3284- EQUALS = 273, 3285- LPAREN = 274, 3286- RPAREN = 275, 3287- OBJ_ID = 276, 3288- XBOOTSTRAP = 277, 3289- XSHARED_RELATION = 278, 3290- XWITHOUT_OIDS = 279, 3291- XROWTYPE_OID = 280, 3292- NULLVAL = 281, 3293- low = 282, 3294- high = 283 3295- }; 3296-#endif 3297- 3298- 3299- 3300 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 3301 typedef union YYSTYPE 3302-{ 3303- 3304-/* Line 214 of yacc.c */ 3305 #line 98 "bootparse.y" 3306- 3307+{ 3308 List *list; 3309 IndexElem *ielem; 3310 char *str; 3311 int ival; 3312 Oid oidval; 3313- 3314- 3315- 3316-/* Line 214 of yacc.c */ 3317-#line 249 "bootparse.c" 3318-} YYSTYPE; 3319-# define YYSTYPE_IS_TRIVIAL 1 3320+} 3321+/* Line 193 of yacc.c. */ 3322+#line 261 "bootparse.c" 3323+ YYSTYPE; 3324 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 3325 # define YYSTYPE_IS_DECLARED 1 3326+# define YYSTYPE_IS_TRIVIAL 1 3327 #endif 3328 3329 3330+ 3331 /* Copy the second part of user declarations. */ 3332 3333 3334-/* Line 264 of yacc.c */ 3335-#line 261 "bootparse.c" 3336+/* Line 216 of yacc.c. */ 3337+#line 274 "bootparse.c" 3338 3339 #ifdef short 3340 # undef short 3341@@ -307,7 +320,7 @@ 3342 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 3343 3344 #ifndef YY_ 3345-# if YYENABLE_NLS 3346+# if defined YYENABLE_NLS && YYENABLE_NLS 3347 # if ENABLE_NLS 3348 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 3349 # define YY_(msgid) dgettext ("bison-runtime", msgid) 3350@@ -332,14 +345,14 @@ 3351 #if (defined __STDC__ || defined __C99__FUNC__ \ 3352 || defined __cplusplus || defined _MSC_VER) 3353 static int 3354-YYID (int yyi) 3355+YYID (int i) 3356 #else 3357 static int 3358-YYID (yyi) 3359- int yyi; 3360+YYID (i) 3361+ int i; 3362 #endif 3363 { 3364- return yyi; 3365+ return i; 3366 } 3367 #endif 3368 3369@@ -420,9 +433,9 @@ 3370 /* A type that is properly aligned for any stack member. */ 3371 union yyalloc 3372 { 3373- yytype_int16 yyss_alloc; 3374- YYSTYPE yyvs_alloc; 3375-}; 3376+ yytype_int16 yyss; 3377+ YYSTYPE yyvs; 3378+ }; 3379 3380 /* The size of the maximum gap between one aligned stack and the next. */ 3381 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 3382@@ -456,12 +469,12 @@ 3383 elements in the stack, and YYPTR gives the new location of the 3384 stack. Advance YYPTR to a properly aligned location for the next 3385 stack. */ 3386-# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 3387+# define YYSTACK_RELOCATE(Stack) \ 3388 do \ 3389 { \ 3390 YYSIZE_T yynewbytes; \ 3391- YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 3392- Stack = &yyptr->Stack_alloc; \ 3393+ YYCOPY (&yyptr->Stack, Stack, yysize); \ 3394+ Stack = &yyptr->Stack; \ 3395 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 3396 yyptr += yynewbytes / sizeof (*yyptr); \ 3397 } \ 3398@@ -581,7 +594,7 @@ 3399 "OBJ_ID", "XBOOTSTRAP", "XSHARED_RELATION", "XWITHOUT_OIDS", 3400 "XROWTYPE_OID", "NULLVAL", "low", "high", "$accept", "TopLevel", 3401 "Boot_Queries", "Boot_Query", "Boot_OpenStmt", "Boot_CloseStmt", 3402- "Boot_CreateStmt", "$@1", "$@2", "Boot_InsertStmt", "$@3", 3403+ "Boot_CreateStmt", "@1", "@2", "Boot_InsertStmt", "@3", 3404 "Boot_DeclareIndexStmt", "Boot_DeclareUniqueIndexStmt", 3405 "Boot_DeclareToastStmt", "Boot_BuildIndsStmt", "boot_index_params", 3406 "boot_index_param", "optbootstrap", "optsharedrelation", 3407@@ -792,7 +805,7 @@ 3408 we won't break user code: when these are the locations we know. */ 3409 3410 #ifndef YY_LOCATION_PRINT 3411-# if YYLTYPE_IS_TRIVIAL 3412+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 3413 # define YY_LOCATION_PRINT(File, Loc) \ 3414 fprintf (File, "%d.%d-%d.%d", \ 3415 (Loc).first_line, (Loc).first_column, \ 3416@@ -903,20 +916,17 @@ 3417 #if (defined __STDC__ || defined __C99__FUNC__ \ 3418 || defined __cplusplus || defined _MSC_VER) 3419 static void 3420-yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 3421+yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) 3422 #else 3423 static void 3424-yy_stack_print (yybottom, yytop) 3425- yytype_int16 *yybottom; 3426- yytype_int16 *yytop; 3427+yy_stack_print (bottom, top) 3428+ yytype_int16 *bottom; 3429+ yytype_int16 *top; 3430 #endif 3431 { 3432 YYFPRINTF (stderr, "Stack now"); 3433- for (; yybottom <= yytop; yybottom++) 3434- { 3435- int yybot = *yybottom; 3436- YYFPRINTF (stderr, " %d", yybot); 3437- } 3438+ for (; bottom <= top; ++bottom) 3439+ YYFPRINTF (stderr, " %d", *bottom); 3440 YYFPRINTF (stderr, "\n"); 3441 } 3442 3443@@ -950,11 +960,11 @@ 3444 /* The symbols being reduced. */ 3445 for (yyi = 0; yyi < yynrhs; yyi++) 3446 { 3447- YYFPRINTF (stderr, " $%d = ", yyi + 1); 3448+ fprintf (stderr, " $%d = ", yyi + 1); 3449 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 3450 &(yyvsp[(yyi + 1) - (yynrhs)]) 3451 ); 3452- YYFPRINTF (stderr, "\n"); 3453+ fprintf (stderr, "\n"); 3454 } 3455 } 3456 3457@@ -1234,8 +1244,10 @@ 3458 break; 3459 } 3460 } 3461+ 3462 3463 /* Prevent warnings from -Wmissing-prototypes. */ 3464+ 3465 #ifdef YYPARSE_PARAM 3466 #if defined __STDC__ || defined __cplusplus 3467 int yyparse (void *YYPARSE_PARAM); 3468@@ -1251,10 +1263,11 @@ 3469 #endif /* ! YYPARSE_PARAM */ 3470 3471 3472-/* The lookahead symbol. */ 3473+ 3474+/* The look-ahead symbol. */ 3475 int yychar; 3476 3477-/* The semantic value of the lookahead symbol. */ 3478+/* The semantic value of the look-ahead symbol. */ 3479 YYSTYPE yylval; 3480 3481 /* Number of syntax errors so far. */ 3482@@ -1262,9 +1275,9 @@ 3483 3484 3485 3486-/*-------------------------. 3487-| yyparse or yypush_parse. | 3488-`-------------------------*/ 3489+/*----------. 3490+| yyparse. | 3491+`----------*/ 3492 3493 #ifdef YYPARSE_PARAM 3494 #if (defined __STDC__ || defined __C99__FUNC__ \ 3495@@ -1288,39 +1301,14 @@ 3496 #endif 3497 #endif 3498 { 3499- 3500- 3501- int yystate; 3502- /* Number of tokens to shift before error messages enabled. */ 3503- int yyerrstatus; 3504- 3505- /* The stacks and their tools: 3506- `yyss': related to states. 3507- `yyvs': related to semantic values. 3508- 3509- Refer to the stacks thru separate pointers, to allow yyoverflow 3510- to reallocate them elsewhere. */ 3511- 3512- /* The state stack. */ 3513- yytype_int16 yyssa[YYINITDEPTH]; 3514- yytype_int16 *yyss; 3515- yytype_int16 *yyssp; 3516- 3517- /* The semantic value stack. */ 3518- YYSTYPE yyvsa[YYINITDEPTH]; 3519- YYSTYPE *yyvs; 3520- YYSTYPE *yyvsp; 3521- 3522- YYSIZE_T yystacksize; 3523- 3524+ 3525+ int yystate; 3526 int yyn; 3527 int yyresult; 3528- /* Lookahead token as an internal (translated) token number. */ 3529- int yytoken; 3530- /* The variables used to return semantic value and location from the 3531- action routines. */ 3532- YYSTYPE yyval; 3533- 3534+ /* Number of tokens to shift before error messages enabled. */ 3535+ int yyerrstatus; 3536+ /* Look-ahead token as an internal (translated) token number. */ 3537+ int yytoken = 0; 3538 #if YYERROR_VERBOSE 3539 /* Buffer for error messages, and its allocated size. */ 3540 char yymsgbuf[128]; 3541@@ -1328,28 +1316,51 @@ 3542 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 3543 #endif 3544 3545+ /* Three stacks and their tools: 3546+ `yyss': related to states, 3547+ `yyvs': related to semantic values, 3548+ `yyls': related to locations. 3549+ 3550+ Refer to the stacks thru separate pointers, to allow yyoverflow 3551+ to reallocate them elsewhere. */ 3552+ 3553+ /* The state stack. */ 3554+ yytype_int16 yyssa[YYINITDEPTH]; 3555+ yytype_int16 *yyss = yyssa; 3556+ yytype_int16 *yyssp; 3557+ 3558+ /* The semantic value stack. */ 3559+ YYSTYPE yyvsa[YYINITDEPTH]; 3560+ YYSTYPE *yyvs = yyvsa; 3561+ YYSTYPE *yyvsp; 3562+ 3563+ 3564+ 3565 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 3566 3567+ YYSIZE_T yystacksize = YYINITDEPTH; 3568+ 3569+ /* The variables used to return semantic value and location from the 3570+ action routines. */ 3571+ YYSTYPE yyval; 3572+ 3573+ 3574 /* The number of symbols on the RHS of the reduced rule. 3575 Keep to zero when no symbol should be popped. */ 3576 int yylen = 0; 3577 3578- yytoken = 0; 3579- yyss = yyssa; 3580- yyvs = yyvsa; 3581- yystacksize = YYINITDEPTH; 3582- 3583 YYDPRINTF ((stderr, "Starting parse\n")); 3584 3585 yystate = 0; 3586 yyerrstatus = 0; 3587 yynerrs = 0; 3588- yychar = YYEMPTY; /* Cause a token to be read. */ 3589+ yychar = YYEMPTY; /* Cause a token to be read. */ 3590 3591 /* Initialize stack pointers. 3592 Waste one element of value and location stack 3593 so that they stay on the same level as the state stack. 3594 The wasted elements are never initialized. */ 3595+ 3596 yyssp = yyss; 3597 yyvsp = yyvs; 3598 3599@@ -1379,6 +1390,7 @@ 3600 YYSTYPE *yyvs1 = yyvs; 3601 yytype_int16 *yyss1 = yyss; 3602 3603+ 3604 /* Each stack pointer address is followed by the size of the 3605 data in use in that stack, in bytes. This used to be a 3606 conditional around just the two extra args, but that might 3607@@ -1386,6 +1398,7 @@ 3608 yyoverflow (YY_("memory exhausted"), 3609 &yyss1, yysize * sizeof (*yyssp), 3610 &yyvs1, yysize * sizeof (*yyvsp), 3611+ 3612 &yystacksize); 3613 3614 yyss = yyss1; 3615@@ -1408,8 +1421,9 @@ 3616 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 3617 if (! yyptr) 3618 goto yyexhaustedlab; 3619- YYSTACK_RELOCATE (yyss_alloc, yyss); 3620- YYSTACK_RELOCATE (yyvs_alloc, yyvs); 3621+ YYSTACK_RELOCATE (yyss); 3622+ YYSTACK_RELOCATE (yyvs); 3623+ 3624 # undef YYSTACK_RELOCATE 3625 if (yyss1 != yyssa) 3626 YYSTACK_FREE (yyss1); 3627@@ -1420,6 +1434,7 @@ 3628 yyssp = yyss + yysize - 1; 3629 yyvsp = yyvs + yysize - 1; 3630 3631+ 3632 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 3633 (unsigned long int) yystacksize)); 3634 3635@@ -1429,9 +1444,6 @@ 3636 3637 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 3638 3639- if (yystate == YYFINAL) 3640- YYACCEPT; 3641- 3642 goto yybackup; 3643 3644 /*-----------. 3645@@ -1440,16 +1452,16 @@ 3646 yybackup: 3647 3648 /* Do appropriate processing given the current state. Read a 3649- lookahead token if we need one and don't already have one. */ 3650+ look-ahead token if we need one and don't already have one. */ 3651 3652- /* First try to decide what to do without reference to lookahead token. */ 3653+ /* First try to decide what to do without reference to look-ahead token. */ 3654 yyn = yypact[yystate]; 3655 if (yyn == YYPACT_NINF) 3656 goto yydefault; 3657 3658- /* Not known => get a lookahead token if don't already have one. */ 3659+ /* Not known => get a look-ahead token if don't already have one. */ 3660 3661- /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 3662+ /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 3663 if (yychar == YYEMPTY) 3664 { 3665 YYDPRINTF ((stderr, "Reading a token: ")); 3666@@ -1481,16 +1493,20 @@ 3667 goto yyreduce; 3668 } 3669 3670+ if (yyn == YYFINAL) 3671+ YYACCEPT; 3672+ 3673 /* Count tokens shifted since error; after three, turn off error 3674 status. */ 3675 if (yyerrstatus) 3676 yyerrstatus--; 3677 3678- /* Shift the lookahead token. */ 3679+ /* Shift the look-ahead token. */ 3680 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 3681 3682- /* Discard the shifted token. */ 3683- yychar = YYEMPTY; 3684+ /* Discard the shifted token unless it is eof. */ 3685+ if (yychar != YYEOF) 3686+ yychar = YYEMPTY; 3687 3688 yystate = yyn; 3689 *++yyvsp = yylval; 3690@@ -1530,8 +1546,6 @@ 3691 switch (yyn) 3692 { 3693 case 14: 3694- 3695-/* Line 1455 of yacc.c */ 3696 #line 148 "bootparse.y" 3697 { 3698 do_start(); 3699@@ -1541,8 +1555,6 @@ 3700 break; 3701 3702 case 15: 3703- 3704-/* Line 1455 of yacc.c */ 3705 #line 157 "bootparse.y" 3706 { 3707 do_start(); 3708@@ -1552,8 +1564,6 @@ 3709 break; 3710 3711 case 16: 3712- 3713-/* Line 1455 of yacc.c */ 3714 #line 163 "bootparse.y" 3715 { 3716 do_start(); 3717@@ -1563,8 +1573,6 @@ 3718 break; 3719 3720 case 17: 3721- 3722-/* Line 1455 of yacc.c */ 3723 #line 172 "bootparse.y" 3724 { 3725 do_start(); 3726@@ -1578,8 +1586,6 @@ 3727 break; 3728 3729 case 18: 3730- 3731-/* Line 1455 of yacc.c */ 3732 #line 182 "bootparse.y" 3733 { 3734 do_end(); 3735@@ -1587,8 +1593,6 @@ 3736 break; 3737 3738 case 19: 3739- 3740-/* Line 1455 of yacc.c */ 3741 #line 186 "bootparse.y" 3742 { 3743 TupleDesc tupdesc; 3744@@ -1660,8 +1664,6 @@ 3745 break; 3746 3747 case 20: 3748- 3749-/* Line 1455 of yacc.c */ 3750 #line 257 "bootparse.y" 3751 { 3752 do_start(); 3753@@ -1674,8 +1676,6 @@ 3754 break; 3755 3756 case 21: 3757- 3758-/* Line 1455 of yacc.c */ 3759 #line 266 "bootparse.y" 3760 { 3761 if (num_columns_read != numattr) 3762@@ -1689,8 +1689,6 @@ 3763 break; 3764 3765 case 22: 3766- 3767-/* Line 1455 of yacc.c */ 3768 #line 279 "bootparse.y" 3769 { 3770 do_start(); 3771@@ -1709,8 +1707,6 @@ 3772 break; 3773 3774 case 23: 3775- 3776-/* Line 1455 of yacc.c */ 3777 #line 297 "bootparse.y" 3778 { 3779 do_start(); 3780@@ -1729,8 +1725,6 @@ 3781 break; 3782 3783 case 24: 3784- 3785-/* Line 1455 of yacc.c */ 3786 #line 315 "bootparse.y" 3787 { 3788 do_start(); 3789@@ -1741,8 +1735,6 @@ 3790 break; 3791 3792 case 25: 3793- 3794-/* Line 1455 of yacc.c */ 3795 #line 325 "bootparse.y" 3796 { 3797 do_start(); 3798@@ -1752,22 +1744,16 @@ 3799 break; 3800 3801 case 26: 3802- 3803-/* Line 1455 of yacc.c */ 3804 #line 334 "bootparse.y" 3805 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].ielem)); ;} 3806 break; 3807 3808 case 27: 3809- 3810-/* Line 1455 of yacc.c */ 3811 #line 335 "bootparse.y" 3812 { (yyval.list) = list_make1((yyvsp[(1) - (1)].ielem)); ;} 3813 break; 3814 3815 case 28: 3816- 3817-/* Line 1455 of yacc.c */ 3818 #line 340 "bootparse.y" 3819 { 3820 IndexElem *n = makeNode(IndexElem); 3821@@ -1782,64 +1768,46 @@ 3822 break; 3823 3824 case 29: 3825- 3826-/* Line 1455 of yacc.c */ 3827 #line 353 "bootparse.y" 3828 { (yyval.ival) = 1; ;} 3829 break; 3830 3831 case 30: 3832- 3833-/* Line 1455 of yacc.c */ 3834 #line 354 "bootparse.y" 3835 { (yyval.ival) = 0; ;} 3836 break; 3837 3838 case 31: 3839- 3840-/* Line 1455 of yacc.c */ 3841 #line 358 "bootparse.y" 3842 { (yyval.ival) = 1; ;} 3843 break; 3844 3845 case 32: 3846- 3847-/* Line 1455 of yacc.c */ 3848 #line 359 "bootparse.y" 3849 { (yyval.ival) = 0; ;} 3850 break; 3851 3852 case 33: 3853- 3854-/* Line 1455 of yacc.c */ 3855 #line 363 "bootparse.y" 3856 { (yyval.ival) = 1; ;} 3857 break; 3858 3859 case 34: 3860- 3861-/* Line 1455 of yacc.c */ 3862 #line 364 "bootparse.y" 3863 { (yyval.ival) = 0; ;} 3864 break; 3865 3866 case 35: 3867- 3868-/* Line 1455 of yacc.c */ 3869 #line 368 "bootparse.y" 3870 { (yyval.oidval) = (yyvsp[(2) - (2)].oidval); ;} 3871 break; 3872 3873 case 36: 3874- 3875-/* Line 1455 of yacc.c */ 3876 #line 369 "bootparse.y" 3877 { (yyval.oidval) = InvalidOid; ;} 3878 break; 3879 3880 case 39: 3881- 3882-/* Line 1455 of yacc.c */ 3883 #line 379 "bootparse.y" 3884 { 3885 if (++numattr > MAXATTR) 3886@@ -1849,65 +1817,48 @@ 3887 break; 3888 3889 case 40: 3890- 3891-/* Line 1455 of yacc.c */ 3892 #line 387 "bootparse.y" 3893 { (yyval.oidval) = atooid((yyvsp[(1) - (1)].str)); ;} 3894 break; 3895 3896 case 41: 3897- 3898-/* Line 1455 of yacc.c */ 3899 #line 391 "bootparse.y" 3900 { (yyval.oidval) = (yyvsp[(3) - (3)].oidval); ;} 3901 break; 3902 3903 case 42: 3904- 3905-/* Line 1455 of yacc.c */ 3906 #line 392 "bootparse.y" 3907 { (yyval.oidval) = InvalidOid; ;} 3908 break; 3909 3910 case 46: 3911- 3912-/* Line 1455 of yacc.c */ 3913 #line 403 "bootparse.y" 3914 { InsertOneValue((yyvsp[(1) - (1)].str), num_columns_read++); ;} 3915 break; 3916 3917 case 47: 3918- 3919-/* Line 1455 of yacc.c */ 3920 #line 405 "bootparse.y" 3921 { InsertOneValue((yyvsp[(1) - (1)].str), num_columns_read++); ;} 3922 break; 3923 3924 case 48: 3925- 3926-/* Line 1455 of yacc.c */ 3927 #line 407 "bootparse.y" 3928 { InsertOneNull(num_columns_read++); ;} 3929 break; 3930 3931 case 49: 3932- 3933-/* Line 1455 of yacc.c */ 3934 #line 411 "bootparse.y" 3935 { (yyval.str) = yylval.str; ;} 3936 break; 3937 3938 case 50: 3939- 3940-/* Line 1455 of yacc.c */ 3941 #line 415 "bootparse.y" 3942 { (yyval.str) = yylval.str; ;} 3943 break; 3944 3945 3946- 3947-/* Line 1455 of yacc.c */ 3948-#line 1911 "bootparse.c" 3949+/* Line 1267 of yacc.c. */ 3950+#line 1862 "bootparse.c" 3951 default: break; 3952 } 3953 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 3954@@ -1918,6 +1869,7 @@ 3955 3956 *++yyvsp = yyval; 3957 3958+ 3959 /* Now `shift' the result of the reduction. Determine what state 3960 that goes to, based on the state we popped back to and the rule 3961 number reduced by. */ 3962@@ -1982,7 +1934,7 @@ 3963 3964 if (yyerrstatus == 3) 3965 { 3966- /* If just tried and failed to reuse lookahead token after an 3967+ /* If just tried and failed to reuse look-ahead token after an 3968 error, discard it. */ 3969 3970 if (yychar <= YYEOF) 3971@@ -1999,7 +1951,7 @@ 3972 } 3973 } 3974 3975- /* Else will try to reuse lookahead token after shifting the error 3976+ /* Else will try to reuse look-ahead token after shifting the error 3977 token. */ 3978 goto yyerrlab1; 3979 3980@@ -2056,6 +2008,9 @@ 3981 YY_STACK_PRINT (yyss, yyssp); 3982 } 3983 3984+ if (yyn == YYFINAL) 3985+ YYACCEPT; 3986+ 3987 *++yyvsp = yylval; 3988 3989 3990@@ -2080,7 +2035,7 @@ 3991 yyresult = 1; 3992 goto yyreturn; 3993 3994-#if !defined(yyoverflow) || YYERROR_VERBOSE 3995+#ifndef yyoverflow 3996 /*-------------------------------------------------. 3997 | yyexhaustedlab -- memory exhaustion comes here. | 3998 `-------------------------------------------------*/ 3999@@ -2091,7 +2046,7 @@ 4000 #endif 4001 4002 yyreturn: 4003- if (yychar != YYEMPTY) 4004+ if (yychar != YYEOF && yychar != YYEMPTY) 4005 yydestruct ("Cleanup: discarding lookahead", 4006 yytoken, &yylval); 4007 /* Do not reclaim the symbols of the rule which action triggered 4008@@ -2117,8 +2072,6 @@ 4009 } 4010 4011 4012- 4013-/* Line 1675 of yacc.c */ 4014 #line 417 "bootparse.y" 4015 4016 4017 4018diff -Naur postgresql-9.0.8/src/pl/plpgsql/src/pl_gram.c postgresql/src/pl/plpgsql/src/pl_gram.c 4019--- postgresql-9.0.8/src/pl/plpgsql/src/pl_gram.c 2012-05-31 16:28:05.000000000 -0700 4020+++ postgresql/src/pl/plpgsql/src/pl_gram.c 2012-06-08 14:27:02.000000000 -0700 4021@@ -1,23 +1,24 @@ 4022- 4023-/* A Bison parser, made by GNU Bison 2.4.1. */ 4024+/* A Bison parser, made by GNU Bison 2.3. */ 4025 4026 /* Skeleton implementation for Bison's Yacc-like parsers in C 4027- 4028- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 4029+ 4030+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 4031 Free Software Foundation, Inc. 4032- 4033- This program is free software: you can redistribute it and/or modify 4034+ 4035+ This program is free software; you can redistribute it and/or modify 4036 it under the terms of the GNU General Public License as published by 4037- the Free Software Foundation, either version 3 of the License, or 4038- (at your option) any later version. 4039- 4040+ the Free Software Foundation; either version 2, or (at your option) 4041+ any later version. 4042+ 4043 This program is distributed in the hope that it will be useful, 4044 but WITHOUT ANY WARRANTY; without even the implied warranty of 4045 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 4046 GNU General Public License for more details. 4047- 4048+ 4049 You should have received a copy of the GNU General Public License 4050- along with this program. If not, see <http://www.gnu.org/licenses/>. */ 4051+ along with this program; if not, write to the Free Software 4052+ Foundation, Inc., 51 Franklin Street, Fifth Floor, 4053+ Boston, MA 02110-1301, USA. */ 4054 4055 /* As a special exception, you may create a larger work that contains 4056 part or all of the Bison parser skeleton and distribute that work 4057@@ -28,7 +29,7 @@ 4058 special exception, which will cause the skeleton and the resulting 4059 Bison output files to be licensed under the GNU General Public 4060 License without this special exception. 4061- 4062+ 4063 This special exception was added by the Free Software Foundation in 4064 version 2.2 of Bison. */ 4065 4066@@ -46,7 +47,7 @@ 4067 #define YYBISON 1 4068 4069 /* Bison version. */ 4070-#define YYBISON_VERSION "2.4.1" 4071+#define YYBISON_VERSION "2.3" 4072 4073 /* Skeleton name. */ 4074 #define YYSKELETON_NAME "yacc.c" 4075@@ -54,28 +55,213 @@ 4076 /* Pure parsers. */ 4077 #define YYPURE 0 4078 4079-/* Push parsers. */ 4080-#define YYPUSH 0 4081- 4082-/* Pull parsers. */ 4083-#define YYPULL 1 4084- 4085 /* Using locations. */ 4086 #define YYLSP_NEEDED 1 4087 4088 /* Substitute the variable and function names. */ 4089-#define yyparse plpgsql_yyparse 4090-#define yylex plpgsql_yylex 4091-#define yyerror plpgsql_yyerror 4092-#define yylval plpgsql_yylval 4093-#define yychar plpgsql_yychar 4094-#define yydebug plpgsql_yydebug 4095-#define yynerrs plpgsql_yynerrs 4096-#define yylloc plpgsql_yylloc 4097+#define yyparse plpgsql_yyparse 4098+#define yylex plpgsql_yylex 4099+#define yyerror plpgsql_yyerror 4100+#define yylval plpgsql_yylval 4101+#define yychar plpgsql_yychar 4102+#define yydebug plpgsql_yydebug 4103+#define yynerrs plpgsql_yynerrs 4104+#define yylloc plpgsql_yylloc 4105+ 4106+/* Tokens. */ 4107+#ifndef YYTOKENTYPE 4108+# define YYTOKENTYPE 4109+ /* Put the tokens into the symbol table, so that GDB and other debuggers 4110+ know about them. */ 4111+ enum yytokentype { 4112+ IDENT = 258, 4113+ FCONST = 259, 4114+ SCONST = 260, 4115+ BCONST = 261, 4116+ XCONST = 262, 4117+ Op = 263, 4118+ ICONST = 264, 4119+ PARAM = 265, 4120+ TYPECAST = 266, 4121+ DOT_DOT = 267, 4122+ COLON_EQUALS = 268, 4123+ T_WORD = 269, 4124+ T_CWORD = 270, 4125+ T_DATUM = 271, 4126+ LESS_LESS = 272, 4127+ GREATER_GREATER = 273, 4128+ K_ABSOLUTE = 274, 4129+ K_ALIAS = 275, 4130+ K_ALL = 276, 4131+ K_BACKWARD = 277, 4132+ K_BEGIN = 278, 4133+ K_BY = 279, 4134+ K_CASE = 280, 4135+ K_CLOSE = 281, 4136+ K_CONSTANT = 282, 4137+ K_CONTINUE = 283, 4138+ K_CURSOR = 284, 4139+ K_DEBUG = 285, 4140+ K_DECLARE = 286, 4141+ K_DEFAULT = 287, 4142+ K_DETAIL = 288, 4143+ K_DIAGNOSTICS = 289, 4144+ K_DUMP = 290, 4145+ K_ELSE = 291, 4146+ K_ELSIF = 292, 4147+ K_END = 293, 4148+ K_ERRCODE = 294, 4149+ K_ERROR = 295, 4150+ K_EXCEPTION = 296, 4151+ K_EXECUTE = 297, 4152+ K_EXIT = 298, 4153+ K_FETCH = 299, 4154+ K_FIRST = 300, 4155+ K_FOR = 301, 4156+ K_FORWARD = 302, 4157+ K_FROM = 303, 4158+ K_GET = 304, 4159+ K_HINT = 305, 4160+ K_IF = 306, 4161+ K_IN = 307, 4162+ K_INFO = 308, 4163+ K_INSERT = 309, 4164+ K_INTO = 310, 4165+ K_IS = 311, 4166+ K_LAST = 312, 4167+ K_LOG = 313, 4168+ K_LOOP = 314, 4169+ K_MESSAGE = 315, 4170+ K_MOVE = 316, 4171+ K_NEXT = 317, 4172+ K_NO = 318, 4173+ K_NOT = 319, 4174+ K_NOTICE = 320, 4175+ K_NULL = 321, 4176+ K_OPEN = 322, 4177+ K_OPTION = 323, 4178+ K_OR = 324, 4179+ K_PERFORM = 325, 4180+ K_PRIOR = 326, 4181+ K_QUERY = 327, 4182+ K_RAISE = 328, 4183+ K_RELATIVE = 329, 4184+ K_RESULT_OID = 330, 4185+ K_RETURN = 331, 4186+ K_REVERSE = 332, 4187+ K_ROWTYPE = 333, 4188+ K_ROW_COUNT = 334, 4189+ K_SCROLL = 335, 4190+ K_SQLSTATE = 336, 4191+ K_STRICT = 337, 4192+ K_THEN = 338, 4193+ K_TO = 339, 4194+ K_TYPE = 340, 4195+ K_USE_COLUMN = 341, 4196+ K_USE_VARIABLE = 342, 4197+ K_USING = 343, 4198+ K_VARIABLE_CONFLICT = 344, 4199+ K_WARNING = 345, 4200+ K_WHEN = 346, 4201+ K_WHILE = 347 4202+ }; 4203+#endif 4204+/* Tokens. */ 4205+#define IDENT 258 4206+#define FCONST 259 4207+#define SCONST 260 4208+#define BCONST 261 4209+#define XCONST 262 4210+#define Op 263 4211+#define ICONST 264 4212+#define PARAM 265 4213+#define TYPECAST 266 4214+#define DOT_DOT 267 4215+#define COLON_EQUALS 268 4216+#define T_WORD 269 4217+#define T_CWORD 270 4218+#define T_DATUM 271 4219+#define LESS_LESS 272 4220+#define GREATER_GREATER 273 4221+#define K_ABSOLUTE 274 4222+#define K_ALIAS 275 4223+#define K_ALL 276 4224+#define K_BACKWARD 277 4225+#define K_BEGIN 278 4226+#define K_BY 279 4227+#define K_CASE 280 4228+#define K_CLOSE 281 4229+#define K_CONSTANT 282 4230+#define K_CONTINUE 283 4231+#define K_CURSOR 284 4232+#define K_DEBUG 285 4233+#define K_DECLARE 286 4234+#define K_DEFAULT 287 4235+#define K_DETAIL 288 4236+#define K_DIAGNOSTICS 289 4237+#define K_DUMP 290 4238+#define K_ELSE 291 4239+#define K_ELSIF 292 4240+#define K_END 293 4241+#define K_ERRCODE 294 4242+#define K_ERROR 295 4243+#define K_EXCEPTION 296 4244+#define K_EXECUTE 297 4245+#define K_EXIT 298 4246+#define K_FETCH 299 4247+#define K_FIRST 300 4248+#define K_FOR 301 4249+#define K_FORWARD 302 4250+#define K_FROM 303 4251+#define K_GET 304 4252+#define K_HINT 305 4253+#define K_IF 306 4254+#define K_IN 307 4255+#define K_INFO 308 4256+#define K_INSERT 309 4257+#define K_INTO 310 4258+#define K_IS 311 4259+#define K_LAST 312 4260+#define K_LOG 313 4261+#define K_LOOP 314 4262+#define K_MESSAGE 315 4263+#define K_MOVE 316 4264+#define K_NEXT 317 4265+#define K_NO 318 4266+#define K_NOT 319 4267+#define K_NOTICE 320 4268+#define K_NULL 321 4269+#define K_OPEN 322 4270+#define K_OPTION 323 4271+#define K_OR 324 4272+#define K_PERFORM 325 4273+#define K_PRIOR 326 4274+#define K_QUERY 327 4275+#define K_RAISE 328 4276+#define K_RELATIVE 329 4277+#define K_RESULT_OID 330 4278+#define K_RETURN 331 4279+#define K_REVERSE 332 4280+#define K_ROWTYPE 333 4281+#define K_ROW_COUNT 334 4282+#define K_SCROLL 335 4283+#define K_SQLSTATE 336 4284+#define K_STRICT 337 4285+#define K_THEN 338 4286+#define K_TO 339 4287+#define K_TYPE 340 4288+#define K_USE_COLUMN 341 4289+#define K_USE_VARIABLE 342 4290+#define K_USING 343 4291+#define K_VARIABLE_CONFLICT 344 4292+#define K_WARNING 345 4293+#define K_WHEN 346 4294+#define K_WHILE 347 4295 4296-/* Copy the first part of user declarations. */ 4297 4298-/* Line 189 of yacc.c */ 4299+ 4300+ 4301+/* Copy the first part of user declarations. */ 4302 #line 1 "gram.y" 4303 4304 /*------------------------------------------------------------------------- 4305@@ -186,9 +372,6 @@ 4306 4307 4308 4309-/* Line 189 of yacc.c */ 4310-#line 191 "pl_gram.c" 4311- 4312 /* Enabling traces. */ 4313 #ifndef YYDEBUG 4314 # define YYDEBUG 0 4315@@ -207,115 +390,10 @@ 4316 # define YYTOKEN_TABLE 0 4317 #endif 4318 4319- 4320-/* Tokens. */ 4321-#ifndef YYTOKENTYPE 4322-# define YYTOKENTYPE 4323- /* Put the tokens into the symbol table, so that GDB and other debuggers 4324- know about them. */ 4325- enum yytokentype { 4326- IDENT = 258, 4327- FCONST = 259, 4328- SCONST = 260, 4329- BCONST = 261, 4330- XCONST = 262, 4331- Op = 263, 4332- ICONST = 264, 4333- PARAM = 265, 4334- TYPECAST = 266, 4335- DOT_DOT = 267, 4336- COLON_EQUALS = 268, 4337- T_WORD = 269, 4338- T_CWORD = 270, 4339- T_DATUM = 271, 4340- LESS_LESS = 272, 4341- GREATER_GREATER = 273, 4342- K_ABSOLUTE = 274, 4343- K_ALIAS = 275, 4344- K_ALL = 276, 4345- K_BACKWARD = 277, 4346- K_BEGIN = 278, 4347- K_BY = 279, 4348- K_CASE = 280, 4349- K_CLOSE = 281, 4350- K_CONSTANT = 282, 4351- K_CONTINUE = 283, 4352- K_CURSOR = 284, 4353- K_DEBUG = 285, 4354- K_DECLARE = 286, 4355- K_DEFAULT = 287, 4356- K_DETAIL = 288, 4357- K_DIAGNOSTICS = 289, 4358- K_DUMP = 290, 4359- K_ELSE = 291, 4360- K_ELSIF = 292, 4361- K_END = 293, 4362- K_ERRCODE = 294, 4363- K_ERROR = 295, 4364- K_EXCEPTION = 296, 4365- K_EXECUTE = 297, 4366- K_EXIT = 298, 4367- K_FETCH = 299, 4368- K_FIRST = 300, 4369- K_FOR = 301, 4370- K_FORWARD = 302, 4371- K_FROM = 303, 4372- K_GET = 304, 4373- K_HINT = 305, 4374- K_IF = 306, 4375- K_IN = 307, 4376- K_INFO = 308, 4377- K_INSERT = 309, 4378- K_INTO = 310, 4379- K_IS = 311, 4380- K_LAST = 312, 4381- K_LOG = 313, 4382- K_LOOP = 314, 4383- K_MESSAGE = 315, 4384- K_MOVE = 316, 4385- K_NEXT = 317, 4386- K_NO = 318, 4387- K_NOT = 319, 4388- K_NOTICE = 320, 4389- K_NULL = 321, 4390- K_OPEN = 322, 4391- K_OPTION = 323, 4392- K_OR = 324, 4393- K_PERFORM = 325, 4394- K_PRIOR = 326, 4395- K_QUERY = 327, 4396- K_RAISE = 328, 4397- K_RELATIVE = 329, 4398- K_RESULT_OID = 330, 4399- K_RETURN = 331, 4400- K_REVERSE = 332, 4401- K_ROWTYPE = 333, 4402- K_ROW_COUNT = 334, 4403- K_SCROLL = 335, 4404- K_SQLSTATE = 336, 4405- K_STRICT = 337, 4406- K_THEN = 338, 4407- K_TO = 339, 4408- K_TYPE = 340, 4409- K_USE_COLUMN = 341, 4410- K_USE_VARIABLE = 342, 4411- K_USING = 343, 4412- K_VARIABLE_CONFLICT = 344, 4413- K_WARNING = 345, 4414- K_WHEN = 346, 4415- K_WHILE = 347 4416- }; 4417-#endif 4418- 4419- 4420- 4421 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 4422 typedef union YYSTYPE 4423-{ 4424- 4425-/* Line 214 of yacc.c */ 4426 #line 114 "gram.y" 4427- 4428+{ 4429 core_YYSTYPE core_yystype; 4430 /* these fields must match core_YYSTYPE: */ 4431 int ival; 4432@@ -364,15 +442,13 @@ 4433 PLpgSQL_diag_item *diagitem; 4434 PLpgSQL_stmt_fetch *fetch; 4435 PLpgSQL_case_when *casewhen; 4436- 4437- 4438- 4439-/* Line 214 of yacc.c */ 4440-#line 372 "pl_gram.c" 4441-} YYSTYPE; 4442-# define YYSTYPE_IS_TRIVIAL 1 4443+} 4444+/* Line 193 of yacc.c. */ 4445+#line 448 "pl_gram.c" 4446+ YYSTYPE; 4447 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 4448 # define YYSTYPE_IS_DECLARED 1 4449+# define YYSTYPE_IS_TRIVIAL 1 4450 #endif 4451 4452 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED 4453@@ -392,8 +468,8 @@ 4454 /* Copy the second part of user declarations. */ 4455 4456 4457-/* Line 264 of yacc.c */ 4458-#line 397 "pl_gram.c" 4459+/* Line 216 of yacc.c. */ 4460+#line 473 "pl_gram.c" 4461 4462 #ifdef short 4463 # undef short 4464@@ -443,7 +519,7 @@ 4465 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 4466 4467 #ifndef YY_ 4468-# if YYENABLE_NLS 4469+# if defined YYENABLE_NLS && YYENABLE_NLS 4470 # if ENABLE_NLS 4471 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 4472 # define YY_(msgid) dgettext ("bison-runtime", msgid) 4473@@ -468,14 +544,14 @@ 4474 #if (defined __STDC__ || defined __C99__FUNC__ \ 4475 || defined __cplusplus || defined _MSC_VER) 4476 static int 4477-YYID (int yyi) 4478+YYID (int i) 4479 #else 4480 static int 4481-YYID (yyi) 4482- int yyi; 4483+YYID (i) 4484+ int i; 4485 #endif 4486 { 4487- return yyi; 4488+ return i; 4489 } 4490 #endif 4491 4492@@ -557,9 +633,9 @@ 4493 /* A type that is properly aligned for any stack member. */ 4494 union yyalloc 4495 { 4496- yytype_int16 yyss_alloc; 4497- YYSTYPE yyvs_alloc; 4498- YYLTYPE yyls_alloc; 4499+ yytype_int16 yyss; 4500+ YYSTYPE yyvs; 4501+ YYLTYPE yyls; 4502 }; 4503 4504 /* The size of the maximum gap between one aligned stack and the next. */ 4505@@ -594,12 +670,12 @@ 4506 elements in the stack, and YYPTR gives the new location of the 4507 stack. Advance YYPTR to a properly aligned location for the next 4508 stack. */ 4509-# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 4510+# define YYSTACK_RELOCATE(Stack) \ 4511 do \ 4512 { \ 4513 YYSIZE_T yynewbytes; \ 4514- YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 4515- Stack = &yyptr->Stack_alloc; \ 4516+ YYCOPY (&yyptr->Stack, Stack, yysize); \ 4517+ Stack = &yyptr->Stack; \ 4518 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 4519 yyptr += yynewbytes / sizeof (*yyptr); \ 4520 } \ 4521@@ -790,7 +866,7 @@ 4522 "K_WARNING", "K_WHEN", "K_WHILE", "'#'", "';'", "'('", "')'", "','", 4523 "'='", "'['", "$accept", "pl_function", "comp_options", "comp_option", 4524 "opt_semi", "pl_block", "decl_sect", "decl_start", "decl_stmts", 4525- "decl_stmt", "decl_statement", "$@1", "opt_scrollable", 4526+ "decl_stmt", "decl_statement", "@1", "opt_scrollable", 4527 "decl_cursor_query", "decl_cursor_args", "decl_cursor_arglist", 4528 "decl_cursor_arg", "decl_is_for", "decl_aliasitem", "decl_varname", 4529 "decl_const", "decl_datatype", "decl_notnull", "decl_defval", 4530@@ -1176,7 +1252,7 @@ 4531 we won't break user code: when these are the locations we know. */ 4532 4533 #ifndef YY_LOCATION_PRINT 4534-# if YYLTYPE_IS_TRIVIAL 4535+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 4536 # define YY_LOCATION_PRINT(File, Loc) \ 4537 fprintf (File, "%d.%d-%d.%d", \ 4538 (Loc).first_line, (Loc).first_column, \ 4539@@ -1292,20 +1368,17 @@ 4540 #if (defined __STDC__ || defined __C99__FUNC__ \ 4541 || defined __cplusplus || defined _MSC_VER) 4542 static void 4543-yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 4544+yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) 4545 #else 4546 static void 4547-yy_stack_print (yybottom, yytop) 4548- yytype_int16 *yybottom; 4549- yytype_int16 *yytop; 4550+yy_stack_print (bottom, top) 4551+ yytype_int16 *bottom; 4552+ yytype_int16 *top; 4553 #endif 4554 { 4555 YYFPRINTF (stderr, "Stack now"); 4556- for (; yybottom <= yytop; yybottom++) 4557- { 4558- int yybot = *yybottom; 4559- YYFPRINTF (stderr, " %d", yybot); 4560- } 4561+ for (; bottom <= top; ++bottom) 4562+ YYFPRINTF (stderr, " %d", *bottom); 4563 YYFPRINTF (stderr, "\n"); 4564 } 4565 4566@@ -1340,11 +1413,11 @@ 4567 /* The symbols being reduced. */ 4568 for (yyi = 0; yyi < yynrhs; yyi++) 4569 { 4570- YYFPRINTF (stderr, " $%d = ", yyi + 1); 4571+ fprintf (stderr, " $%d = ", yyi + 1); 4572 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 4573 &(yyvsp[(yyi + 1) - (yynrhs)]) 4574 , &(yylsp[(yyi + 1) - (yynrhs)]) ); 4575- YYFPRINTF (stderr, "\n"); 4576+ fprintf (stderr, "\n"); 4577 } 4578 } 4579 4580@@ -1626,8 +1699,10 @@ 4581 break; 4582 } 4583 } 4584+ 4585 4586 /* Prevent warnings from -Wmissing-prototypes. */ 4587+ 4588 #ifdef YYPARSE_PARAM 4589 #if defined __STDC__ || defined __cplusplus 4590 int yyparse (void *YYPARSE_PARAM); 4591@@ -1643,23 +1718,23 @@ 4592 #endif /* ! YYPARSE_PARAM */ 4593 4594 4595-/* The lookahead symbol. */ 4596+ 4597+/* The look-ahead symbol. */ 4598 int yychar; 4599 4600-/* The semantic value of the lookahead symbol. */ 4601+/* The semantic value of the look-ahead symbol. */ 4602 YYSTYPE yylval; 4603 4604-/* Location data for the lookahead symbol. */ 4605-YYLTYPE yylloc; 4606- 4607 /* Number of syntax errors so far. */ 4608 int yynerrs; 4609+/* Location data for the look-ahead symbol. */ 4610+YYLTYPE yylloc; 4611 4612 4613 4614-/*-------------------------. 4615-| yyparse or yypush_parse. | 4616-`-------------------------*/ 4617+/*----------. 4618+| yyparse. | 4619+`----------*/ 4620 4621 #ifdef YYPARSE_PARAM 4622 #if (defined __STDC__ || defined __C99__FUNC__ \ 4623@@ -1683,49 +1758,14 @@ 4624 #endif 4625 #endif 4626 { 4627- 4628- 4629- int yystate; 4630- /* Number of tokens to shift before error messages enabled. */ 4631- int yyerrstatus; 4632- 4633- /* The stacks and their tools: 4634- `yyss': related to states. 4635- `yyvs': related to semantic values. 4636- `yyls': related to locations. 4637- 4638- Refer to the stacks thru separate pointers, to allow yyoverflow 4639- to reallocate them elsewhere. */ 4640- 4641- /* The state stack. */ 4642- yytype_int16 yyssa[YYINITDEPTH]; 4643- yytype_int16 *yyss; 4644- yytype_int16 *yyssp; 4645- 4646- /* The semantic value stack. */ 4647- YYSTYPE yyvsa[YYINITDEPTH]; 4648- YYSTYPE *yyvs; 4649- YYSTYPE *yyvsp; 4650- 4651- /* The location stack. */ 4652- YYLTYPE yylsa[YYINITDEPTH]; 4653- YYLTYPE *yyls; 4654- YYLTYPE *yylsp; 4655- 4656- /* The locations where the error started and ended. */ 4657- YYLTYPE yyerror_range[2]; 4658- 4659- YYSIZE_T yystacksize; 4660- 4661+ 4662+ int yystate; 4663 int yyn; 4664 int yyresult; 4665- /* Lookahead token as an internal (translated) token number. */ 4666- int yytoken; 4667- /* The variables used to return semantic value and location from the 4668- action routines. */ 4669- YYSTYPE yyval; 4670- YYLTYPE yyloc; 4671- 4672+ /* Number of tokens to shift before error messages enabled. */ 4673+ int yyerrstatus; 4674+ /* Look-ahead token as an internal (translated) token number. */ 4675+ int yytoken = 0; 4676 #if YYERROR_VERBOSE 4677 /* Buffer for error messages, and its allocated size. */ 4678 char yymsgbuf[128]; 4679@@ -1733,37 +1773,63 @@ 4680 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 4681 #endif 4682 4683+ /* Three stacks and their tools: 4684+ `yyss': related to states, 4685+ `yyvs': related to semantic values, 4686+ `yyls': related to locations. 4687+ 4688+ Refer to the stacks thru separate pointers, to allow yyoverflow 4689+ to reallocate them elsewhere. */ 4690+ 4691+ /* The state stack. */ 4692+ yytype_int16 yyssa[YYINITDEPTH]; 4693+ yytype_int16 *yyss = yyssa; 4694+ yytype_int16 *yyssp; 4695+ 4696+ /* The semantic value stack. */ 4697+ YYSTYPE yyvsa[YYINITDEPTH]; 4698+ YYSTYPE *yyvs = yyvsa; 4699+ YYSTYPE *yyvsp; 4700+ 4701+ /* The location stack. */ 4702+ YYLTYPE yylsa[YYINITDEPTH]; 4703+ YYLTYPE *yyls = yylsa; 4704+ YYLTYPE *yylsp; 4705+ /* The locations where the error started and ended. */ 4706+ YYLTYPE yyerror_range[2]; 4707+ 4708 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) 4709 4710+ YYSIZE_T yystacksize = YYINITDEPTH; 4711+ 4712+ /* The variables used to return semantic value and location from the 4713+ action routines. */ 4714+ YYSTYPE yyval; 4715+ YYLTYPE yyloc; 4716+ 4717 /* The number of symbols on the RHS of the reduced rule. 4718 Keep to zero when no symbol should be popped. */ 4719 int yylen = 0; 4720 4721- yytoken = 0; 4722- yyss = yyssa; 4723- yyvs = yyvsa; 4724- yyls = yylsa; 4725- yystacksize = YYINITDEPTH; 4726- 4727 YYDPRINTF ((stderr, "Starting parse\n")); 4728 4729 yystate = 0; 4730 yyerrstatus = 0; 4731 yynerrs = 0; 4732- yychar = YYEMPTY; /* Cause a token to be read. */ 4733+ yychar = YYEMPTY; /* Cause a token to be read. */ 4734 4735 /* Initialize stack pointers. 4736 Waste one element of value and location stack 4737 so that they stay on the same level as the state stack. 4738 The wasted elements are never initialized. */ 4739+ 4740 yyssp = yyss; 4741 yyvsp = yyvs; 4742 yylsp = yyls; 4743- 4744-#if YYLTYPE_IS_TRIVIAL 4745+#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 4746 /* Initialize the default location before parsing starts. */ 4747 yylloc.first_line = yylloc.last_line = 1; 4748- yylloc.first_column = yylloc.last_column = 1; 4749+ yylloc.first_column = yylloc.last_column = 0; 4750 #endif 4751 4752 goto yysetstate; 4753@@ -1802,7 +1868,6 @@ 4754 &yyvs1, yysize * sizeof (*yyvsp), 4755 &yyls1, yysize * sizeof (*yylsp), 4756 &yystacksize); 4757- 4758 yyls = yyls1; 4759 yyss = yyss1; 4760 yyvs = yyvs1; 4761@@ -1824,9 +1889,9 @@ 4762 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 4763 if (! yyptr) 4764 goto yyexhaustedlab; 4765- YYSTACK_RELOCATE (yyss_alloc, yyss); 4766- YYSTACK_RELOCATE (yyvs_alloc, yyvs); 4767- YYSTACK_RELOCATE (yyls_alloc, yyls); 4768+ YYSTACK_RELOCATE (yyss); 4769+ YYSTACK_RELOCATE (yyvs); 4770+ YYSTACK_RELOCATE (yyls); 4771 # undef YYSTACK_RELOCATE 4772 if (yyss1 != yyssa) 4773 YYSTACK_FREE (yyss1); 4774@@ -1847,9 +1912,6 @@ 4775 4776 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 4777 4778- if (yystate == YYFINAL) 4779- YYACCEPT; 4780- 4781 goto yybackup; 4782 4783 /*-----------. 4784@@ -1858,16 +1920,16 @@ 4785 yybackup: 4786 4787 /* Do appropriate processing given the current state. Read a 4788- lookahead token if we need one and don't already have one. */ 4789+ look-ahead token if we need one and don't already have one. */ 4790 4791- /* First try to decide what to do without reference to lookahead token. */ 4792+ /* First try to decide what to do without reference to look-ahead token. */ 4793 yyn = yypact[yystate]; 4794 if (yyn == YYPACT_NINF) 4795 goto yydefault; 4796 4797- /* Not known => get a lookahead token if don't already have one. */ 4798+ /* Not known => get a look-ahead token if don't already have one. */ 4799 4800- /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 4801+ /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 4802 if (yychar == YYEMPTY) 4803 { 4804 YYDPRINTF ((stderr, "Reading a token: ")); 4805@@ -1899,16 +1961,20 @@ 4806 goto yyreduce; 4807 } 4808 4809+ if (yyn == YYFINAL) 4810+ YYACCEPT; 4811+ 4812 /* Count tokens shifted since error; after three, turn off error 4813 status. */ 4814 if (yyerrstatus) 4815 yyerrstatus--; 4816 4817- /* Shift the lookahead token. */ 4818+ /* Shift the look-ahead token. */ 4819 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 4820 4821- /* Discard the shifted token. */ 4822- yychar = YYEMPTY; 4823+ /* Discard the shifted token unless it is eof. */ 4824+ if (yychar != YYEOF) 4825+ yychar = YYEMPTY; 4826 4827 yystate = yyn; 4828 *++yyvsp = yylval; 4829@@ -1949,8 +2015,6 @@ 4830 switch (yyn) 4831 { 4832 case 2: 4833- 4834-/* Line 1455 of yacc.c */ 4835 #line 317 "gram.y" 4836 { 4837 plpgsql_parse_result = (PLpgSQL_stmt_block *) (yyvsp[(2) - (3)].stmt); 4838@@ -1958,8 +2022,6 @@ 4839 break; 4840 4841 case 5: 4842- 4843-/* Line 1455 of yacc.c */ 4844 #line 327 "gram.y" 4845 { 4846 plpgsql_DumpExecTree = true; 4847@@ -1967,8 +2029,6 @@ 4848 break; 4849 4850 case 6: 4851- 4852-/* Line 1455 of yacc.c */ 4853 #line 331 "gram.y" 4854 { 4855 plpgsql_curr_compile->resolve_option = PLPGSQL_RESOLVE_ERROR; 4856@@ -1976,8 +2036,6 @@ 4857 break; 4858 4859 case 7: 4860- 4861-/* Line 1455 of yacc.c */ 4862 #line 335 "gram.y" 4863 { 4864 plpgsql_curr_compile->resolve_option = PLPGSQL_RESOLVE_VARIABLE; 4865@@ -1985,8 +2043,6 @@ 4866 break; 4867 4868 case 8: 4869- 4870-/* Line 1455 of yacc.c */ 4871 #line 339 "gram.y" 4872 { 4873 plpgsql_curr_compile->resolve_option = PLPGSQL_RESOLVE_COLUMN; 4874@@ -1994,8 +2050,6 @@ 4875 break; 4876 4877 case 11: 4878- 4879-/* Line 1455 of yacc.c */ 4880 #line 349 "gram.y" 4881 { 4882 PLpgSQL_stmt_block *new; 4883@@ -2018,8 +2072,6 @@ 4884 break; 4885 4886 case 12: 4887- 4888-/* Line 1455 of yacc.c */ 4889 #line 371 "gram.y" 4890 { 4891 /* done with decls, so resume identifier lookup */ 4892@@ -2031,8 +2083,6 @@ 4893 break; 4894 4895 case 13: 4896- 4897-/* Line 1455 of yacc.c */ 4898 #line 379 "gram.y" 4899 { 4900 plpgsql_IdentifierLookup = IDENTIFIER_LOOKUP_NORMAL; 4901@@ -2043,8 +2093,6 @@ 4902 break; 4903 4904 case 14: 4905- 4906-/* Line 1455 of yacc.c */ 4907 #line 386 "gram.y" 4908 { 4909 plpgsql_IdentifierLookup = IDENTIFIER_LOOKUP_NORMAL; 4910@@ -2055,8 +2103,6 @@ 4911 break; 4912 4913 case 15: 4914- 4915-/* Line 1455 of yacc.c */ 4916 #line 395 "gram.y" 4917 { 4918 /* Forget any variables created before block */ 4919@@ -2070,8 +2116,6 @@ 4920 break; 4921 4922 case 19: 4923- 4924-/* Line 1455 of yacc.c */ 4925 #line 412 "gram.y" 4926 { 4927 /* We allow useless extra DECLAREs */ 4928@@ -2079,8 +2123,6 @@ 4929 break; 4930 4931 case 20: 4932- 4933-/* Line 1455 of yacc.c */ 4934 #line 416 "gram.y" 4935 { 4936 /* 4937@@ -2095,8 +2137,6 @@ 4938 break; 4939 4940 case 21: 4941- 4942-/* Line 1455 of yacc.c */ 4943 #line 429 "gram.y" 4944 { 4945 PLpgSQL_variable *var; 4946@@ -2138,8 +2178,6 @@ 4947 break; 4948 4949 case 22: 4950- 4951-/* Line 1455 of yacc.c */ 4952 #line 467 "gram.y" 4953 { 4954 plpgsql_ns_additem((yyvsp[(4) - (5)].nsitem)->itemtype, 4955@@ -2148,15 +2186,11 @@ 4956 break; 4957 4958 case 23: 4959- 4960-/* Line 1455 of yacc.c */ 4961 #line 472 "gram.y" 4962 { plpgsql_ns_push((yyvsp[(1) - (3)].varname).name); ;} 4963 break; 4964 4965 case 24: 4966- 4967-/* Line 1455 of yacc.c */ 4968 #line 474 "gram.y" 4969 { 4970 PLpgSQL_var *new; 4971@@ -2207,8 +2241,6 @@ 4972 break; 4973 4974 case 25: 4975- 4976-/* Line 1455 of yacc.c */ 4977 #line 523 "gram.y" 4978 { 4979 (yyval.ival) = 0; 4980@@ -2216,8 +2248,6 @@ 4981 break; 4982 4983 case 26: 4984- 4985-/* Line 1455 of yacc.c */ 4986 #line 527 "gram.y" 4987 { 4988 (yyval.ival) = CURSOR_OPT_NO_SCROLL; 4989@@ -2225,8 +2255,6 @@ 4990 break; 4991 4992 case 27: 4993- 4994-/* Line 1455 of yacc.c */ 4995 #line 531 "gram.y" 4996 { 4997 (yyval.ival) = CURSOR_OPT_SCROLL; 4998@@ -2234,8 +2262,6 @@ 4999 break; 5000 5001 case 28: 5002- 5003-/* Line 1455 of yacc.c */ 5004 #line 537 "gram.y" 5005 { 5006 (yyval.expr) = read_sql_stmt(""); 5007@@ -2243,8 +2269,6 @@ 5008 break; 5009 5010 case 29: 5011- 5012-/* Line 1455 of yacc.c */ 5013 #line 543 "gram.y" 5014 { 5015 (yyval.datum) = NULL; 5016@@ -2252,8 +2276,6 @@ 5017 break; 5018 5019 case 30: 5020- 5021-/* Line 1455 of yacc.c */ 5022 #line 547 "gram.y" 5023 { 5024 PLpgSQL_row *new; 5025@@ -2284,8 +2306,6 @@ 5026 break; 5027 5028 case 31: 5029- 5030-/* Line 1455 of yacc.c */ 5031 #line 576 "gram.y" 5032 { 5033 (yyval.list) = list_make1((yyvsp[(1) - (1)].datum)); 5034@@ -2293,8 +2313,6 @@ 5035 break; 5036 5037 case 32: 5038- 5039-/* Line 1455 of yacc.c */ 5040 #line 580 "gram.y" 5041 { 5042 (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].datum)); 5043@@ -2302,8 +2320,6 @@ 5044 break; 5045 5046 case 33: 5047- 5048-/* Line 1455 of yacc.c */ 5049 #line 586 "gram.y" 5050 { 5051 (yyval.datum) = (PLpgSQL_datum *) 5052@@ -2313,8 +2329,6 @@ 5053 break; 5054 5055 case 36: 5056- 5057-/* Line 1455 of yacc.c */ 5058 #line 597 "gram.y" 5059 { 5060 PLpgSQL_nsitem *nsi; 5061@@ -2333,8 +2347,6 @@ 5062 break; 5063 5064 case 37: 5065- 5066-/* Line 1455 of yacc.c */ 5067 #line 612 "gram.y" 5068 { 5069 PLpgSQL_nsitem *nsi; 5070@@ -2364,8 +2376,6 @@ 5071 break; 5072 5073 case 38: 5074- 5075-/* Line 1455 of yacc.c */ 5076 #line 640 "gram.y" 5077 { 5078 (yyval.varname).name = (yyvsp[(1) - (1)].word).ident; 5079@@ -2382,8 +2392,6 @@ 5080 break; 5081 5082 case 39: 5083- 5084-/* Line 1455 of yacc.c */ 5085 #line 653 "gram.y" 5086 { 5087 (yyval.varname).name = pstrdup((yyvsp[(1) - (1)].keyword)); 5088@@ -2400,22 +2408,16 @@ 5089 break; 5090 5091 case 40: 5092- 5093-/* Line 1455 of yacc.c */ 5094 #line 668 "gram.y" 5095 { (yyval.boolean) = false; ;} 5096 break; 5097 5098 case 41: 5099- 5100-/* Line 1455 of yacc.c */ 5101 #line 670 "gram.y" 5102 { (yyval.boolean) = true; ;} 5103 break; 5104 5105 case 42: 5106- 5107-/* Line 1455 of yacc.c */ 5108 #line 674 "gram.y" 5109 { 5110 /* 5111@@ -2428,29 +2430,21 @@ 5112 break; 5113 5114 case 43: 5115- 5116-/* Line 1455 of yacc.c */ 5117 #line 685 "gram.y" 5118 { (yyval.boolean) = false; ;} 5119 break; 5120 5121 case 44: 5122- 5123-/* Line 1455 of yacc.c */ 5124 #line 687 "gram.y" 5125 { (yyval.boolean) = true; ;} 5126 break; 5127 5128 case 45: 5129- 5130-/* Line 1455 of yacc.c */ 5131 #line 691 "gram.y" 5132 { (yyval.expr) = NULL; ;} 5133 break; 5134 5135 case 46: 5136- 5137-/* Line 1455 of yacc.c */ 5138 #line 693 "gram.y" 5139 { 5140 (yyval.expr) = read_sql_expression(';', ";"); 5141@@ -2458,22 +2452,16 @@ 5142 break; 5143 5144 case 51: 5145- 5146-/* Line 1455 of yacc.c */ 5147 #line 707 "gram.y" 5148 { (yyval.list) = NIL; ;} 5149 break; 5150 5151 case 52: 5152- 5153-/* Line 1455 of yacc.c */ 5154 #line 709 "gram.y" 5155 { (yyval.list) = (yyvsp[(1) - (1)].list); ;} 5156 break; 5157 5158 case 53: 5159- 5160-/* Line 1455 of yacc.c */ 5161 #line 713 "gram.y" 5162 { 5163 if ((yyvsp[(2) - (2)].stmt) == NULL) 5164@@ -2484,8 +2472,6 @@ 5165 break; 5166 5167 case 54: 5168- 5169-/* Line 1455 of yacc.c */ 5170 #line 720 "gram.y" 5171 { 5172 if ((yyvsp[(1) - (1)].stmt) == NULL) 5173@@ -2496,141 +2482,101 @@ 5174 break; 5175 5176 case 55: 5177- 5178-/* Line 1455 of yacc.c */ 5179 #line 729 "gram.y" 5180 { (yyval.stmt) = (yyvsp[(1) - (2)].stmt); ;} 5181 break; 5182 5183 case 56: 5184- 5185-/* Line 1455 of yacc.c */ 5186 #line 731 "gram.y" 5187 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5188 break; 5189 5190 case 57: 5191- 5192-/* Line 1455 of yacc.c */ 5193 #line 733 "gram.y" 5194 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5195 break; 5196 5197 case 58: 5198- 5199-/* Line 1455 of yacc.c */ 5200 #line 735 "gram.y" 5201 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5202 break; 5203 5204 case 59: 5205- 5206-/* Line 1455 of yacc.c */ 5207 #line 737 "gram.y" 5208 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5209 break; 5210 5211 case 60: 5212- 5213-/* Line 1455 of yacc.c */ 5214 #line 739 "gram.y" 5215 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5216 break; 5217 5218 case 61: 5219- 5220-/* Line 1455 of yacc.c */ 5221 #line 741 "gram.y" 5222 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5223 break; 5224 5225 case 62: 5226- 5227-/* Line 1455 of yacc.c */ 5228 #line 743 "gram.y" 5229 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5230 break; 5231 5232 case 63: 5233- 5234-/* Line 1455 of yacc.c */ 5235 #line 745 "gram.y" 5236 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5237 break; 5238 5239 case 64: 5240- 5241-/* Line 1455 of yacc.c */ 5242 #line 747 "gram.y" 5243 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5244 break; 5245 5246 case 65: 5247- 5248-/* Line 1455 of yacc.c */ 5249 #line 749 "gram.y" 5250 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5251 break; 5252 5253 case 66: 5254- 5255-/* Line 1455 of yacc.c */ 5256 #line 751 "gram.y" 5257 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5258 break; 5259 5260 case 67: 5261- 5262-/* Line 1455 of yacc.c */ 5263 #line 753 "gram.y" 5264 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5265 break; 5266 5267 case 68: 5268- 5269-/* Line 1455 of yacc.c */ 5270 #line 755 "gram.y" 5271 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5272 break; 5273 5274 case 69: 5275- 5276-/* Line 1455 of yacc.c */ 5277 #line 757 "gram.y" 5278 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5279 break; 5280 5281 case 70: 5282- 5283-/* Line 1455 of yacc.c */ 5284 #line 759 "gram.y" 5285 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5286 break; 5287 5288 case 71: 5289- 5290-/* Line 1455 of yacc.c */ 5291 #line 761 "gram.y" 5292 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5293 break; 5294 5295 case 72: 5296- 5297-/* Line 1455 of yacc.c */ 5298 #line 763 "gram.y" 5299 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5300 break; 5301 5302 case 73: 5303- 5304-/* Line 1455 of yacc.c */ 5305 #line 765 "gram.y" 5306 { (yyval.stmt) = (yyvsp[(1) - (1)].stmt); ;} 5307 break; 5308 5309 case 74: 5310- 5311-/* Line 1455 of yacc.c */ 5312 #line 769 "gram.y" 5313 { 5314 PLpgSQL_stmt_perform *new; 5315@@ -2645,8 +2591,6 @@ 5316 break; 5317 5318 case 75: 5319- 5320-/* Line 1455 of yacc.c */ 5321 #line 782 "gram.y" 5322 { 5323 PLpgSQL_stmt_assign *new; 5324@@ -2662,8 +2606,6 @@ 5325 break; 5326 5327 case 76: 5328- 5329-/* Line 1455 of yacc.c */ 5330 #line 796 "gram.y" 5331 { 5332 PLpgSQL_stmt_getdiag *new; 5333@@ -2678,8 +2620,6 @@ 5334 break; 5335 5336 case 77: 5337- 5338-/* Line 1455 of yacc.c */ 5339 #line 809 "gram.y" 5340 { 5341 (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].diagitem)); 5342@@ -2687,8 +2627,6 @@ 5343 break; 5344 5345 case 78: 5346- 5347-/* Line 1455 of yacc.c */ 5348 #line 813 "gram.y" 5349 { 5350 (yyval.list) = list_make1((yyvsp[(1) - (1)].diagitem)); 5351@@ -2696,8 +2634,6 @@ 5352 break; 5353 5354 case 79: 5355- 5356-/* Line 1455 of yacc.c */ 5357 #line 819 "gram.y" 5358 { 5359 PLpgSQL_diag_item *new; 5360@@ -2711,8 +2647,6 @@ 5361 break; 5362 5363 case 80: 5364- 5365-/* Line 1455 of yacc.c */ 5366 #line 831 "gram.y" 5367 { 5368 int tok = yylex(); 5369@@ -2729,8 +2663,6 @@ 5370 break; 5371 5372 case 81: 5373- 5374-/* Line 1455 of yacc.c */ 5375 #line 846 "gram.y" 5376 { 5377 check_assignable((yyvsp[(1) - (1)].wdatum).datum, (yylsp[(1) - (1)])); 5378@@ -2746,8 +2678,6 @@ 5379 break; 5380 5381 case 82: 5382- 5383-/* Line 1455 of yacc.c */ 5384 #line 858 "gram.y" 5385 { 5386 /* just to give a better message than "syntax error" */ 5387@@ -2756,8 +2686,6 @@ 5388 break; 5389 5390 case 83: 5391- 5392-/* Line 1455 of yacc.c */ 5393 #line 863 "gram.y" 5394 { 5395 /* just to give a better message than "syntax error" */ 5396@@ -2766,8 +2694,6 @@ 5397 break; 5398 5399 case 84: 5400- 5401-/* Line 1455 of yacc.c */ 5402 #line 871 "gram.y" 5403 { 5404 check_assignable((yyvsp[(1) - (1)].wdatum).datum, (yylsp[(1) - (1)])); 5405@@ -2776,8 +2702,6 @@ 5406 break; 5407 5408 case 85: 5409- 5410-/* Line 1455 of yacc.c */ 5411 #line 876 "gram.y" 5412 { 5413 PLpgSQL_arrayelem *new; 5414@@ -2794,8 +2718,6 @@ 5415 break; 5416 5417 case 86: 5418- 5419-/* Line 1455 of yacc.c */ 5420 #line 891 "gram.y" 5421 { 5422 PLpgSQL_stmt_if *new; 5423@@ -2812,8 +2734,6 @@ 5424 break; 5425 5426 case 87: 5427- 5428-/* Line 1455 of yacc.c */ 5429 #line 906 "gram.y" 5430 { 5431 (yyval.list) = NIL; 5432@@ -2821,8 +2741,6 @@ 5433 break; 5434 5435 case 88: 5436- 5437-/* Line 1455 of yacc.c */ 5438 #line 910 "gram.y" 5439 { 5440 /*---------- 5441@@ -2855,8 +2773,6 @@ 5442 break; 5443 5444 case 89: 5445- 5446-/* Line 1455 of yacc.c */ 5447 #line 940 "gram.y" 5448 { 5449 (yyval.list) = (yyvsp[(2) - (2)].list); 5450@@ -2864,8 +2780,6 @@ 5451 break; 5452 5453 case 90: 5454- 5455-/* Line 1455 of yacc.c */ 5456 #line 946 "gram.y" 5457 { 5458 (yyval.stmt) = make_case((yylsp[(1) - (7)]), (yyvsp[(2) - (7)].expr), (yyvsp[(3) - (7)].list), (yyvsp[(4) - (7)].list)); 5459@@ -2873,8 +2787,6 @@ 5460 break; 5461 5462 case 91: 5463- 5464-/* Line 1455 of yacc.c */ 5465 #line 952 "gram.y" 5466 { 5467 PLpgSQL_expr *expr = NULL; 5468@@ -2891,8 +2803,6 @@ 5469 break; 5470 5471 case 92: 5472- 5473-/* Line 1455 of yacc.c */ 5474 #line 967 "gram.y" 5475 { 5476 (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].casewhen)); 5477@@ -2900,8 +2810,6 @@ 5478 break; 5479 5480 case 93: 5481- 5482-/* Line 1455 of yacc.c */ 5483 #line 971 "gram.y" 5484 { 5485 (yyval.list) = list_make1((yyvsp[(1) - (1)].casewhen)); 5486@@ -2909,8 +2817,6 @@ 5487 break; 5488 5489 case 94: 5490- 5491-/* Line 1455 of yacc.c */ 5492 #line 977 "gram.y" 5493 { 5494 PLpgSQL_case_when *new = palloc(sizeof(PLpgSQL_case_when)); 5495@@ -2923,8 +2829,6 @@ 5496 break; 5497 5498 case 95: 5499- 5500-/* Line 1455 of yacc.c */ 5501 #line 988 "gram.y" 5502 { 5503 (yyval.list) = NIL; 5504@@ -2932,8 +2836,6 @@ 5505 break; 5506 5507 case 96: 5508- 5509-/* Line 1455 of yacc.c */ 5510 #line 992 "gram.y" 5511 { 5512 /* 5513@@ -2950,8 +2852,6 @@ 5514 break; 5515 5516 case 97: 5517- 5518-/* Line 1455 of yacc.c */ 5519 #line 1007 "gram.y" 5520 { 5521 PLpgSQL_stmt_loop *new; 5522@@ -2970,8 +2870,6 @@ 5523 break; 5524 5525 case 98: 5526- 5527-/* Line 1455 of yacc.c */ 5528 #line 1024 "gram.y" 5529 { 5530 PLpgSQL_stmt_while *new; 5531@@ -2991,8 +2889,6 @@ 5532 break; 5533 5534 case 99: 5535- 5536-/* Line 1455 of yacc.c */ 5537 #line 1042 "gram.y" 5538 { 5539 /* This runs after we've scanned the loop body */ 5540@@ -3028,8 +2924,6 @@ 5541 break; 5542 5543 case 100: 5544- 5545-/* Line 1455 of yacc.c */ 5546 #line 1076 "gram.y" 5547 { 5548 int tok = yylex(); 5549@@ -3273,8 +3167,6 @@ 5550 break; 5551 5552 case 101: 5553- 5554-/* Line 1455 of yacc.c */ 5555 #line 1336 "gram.y" 5556 { 5557 (yyval.forvariable).name = NameOfDatum(&((yyvsp[(1) - (1)].wdatum))); 5558@@ -3310,8 +3202,6 @@ 5559 break; 5560 5561 case 102: 5562- 5563-/* Line 1455 of yacc.c */ 5564 #line 1368 "gram.y" 5565 { 5566 int tok; 5567@@ -3330,8 +3220,6 @@ 5568 break; 5569 5570 case 103: 5571- 5572-/* Line 1455 of yacc.c */ 5573 #line 1383 "gram.y" 5574 { 5575 /* just to give a better message than "syntax error" */ 5576@@ -3340,8 +3228,6 @@ 5577 break; 5578 5579 case 104: 5580- 5581-/* Line 1455 of yacc.c */ 5582 #line 1390 "gram.y" 5583 { 5584 PLpgSQL_stmt_exit *new; 5585@@ -3358,8 +3244,6 @@ 5586 break; 5587 5588 case 105: 5589- 5590-/* Line 1455 of yacc.c */ 5591 #line 1405 "gram.y" 5592 { 5593 (yyval.boolean) = true; 5594@@ -3367,8 +3251,6 @@ 5595 break; 5596 5597 case 106: 5598- 5599-/* Line 1455 of yacc.c */ 5600 #line 1409 "gram.y" 5601 { 5602 (yyval.boolean) = false; 5603@@ -3376,8 +3258,6 @@ 5604 break; 5605 5606 case 107: 5607- 5608-/* Line 1455 of yacc.c */ 5609 #line 1415 "gram.y" 5610 { 5611 int tok; 5612@@ -3405,8 +3285,6 @@ 5613 break; 5614 5615 case 108: 5616- 5617-/* Line 1455 of yacc.c */ 5618 #line 1441 "gram.y" 5619 { 5620 PLpgSQL_stmt_raise *new; 5621@@ -3547,8 +3425,6 @@ 5622 break; 5623 5624 case 109: 5625- 5626-/* Line 1455 of yacc.c */ 5627 #line 1580 "gram.y" 5628 { 5629 (yyval.loop_body).stmts = (yyvsp[(1) - (5)].list); 5630@@ -3558,8 +3434,6 @@ 5631 break; 5632 5633 case 110: 5634- 5635-/* Line 1455 of yacc.c */ 5636 #line 1598 "gram.y" 5637 { 5638 (yyval.stmt) = make_execsql_stmt(K_INSERT, (yylsp[(1) - (1)])); 5639@@ -3567,8 +3441,6 @@ 5640 break; 5641 5642 case 111: 5643- 5644-/* Line 1455 of yacc.c */ 5645 #line 1602 "gram.y" 5646 { 5647 int tok; 5648@@ -3582,8 +3454,6 @@ 5649 break; 5650 5651 case 112: 5652- 5653-/* Line 1455 of yacc.c */ 5654 #line 1612 "gram.y" 5655 { 5656 int tok; 5657@@ -3597,8 +3467,6 @@ 5658 break; 5659 5660 case 113: 5661- 5662-/* Line 1455 of yacc.c */ 5663 #line 1624 "gram.y" 5664 { 5665 PLpgSQL_stmt_dynexecute *new; 5666@@ -3663,8 +3531,6 @@ 5667 break; 5668 5669 case 114: 5670- 5671-/* Line 1455 of yacc.c */ 5672 #line 1688 "gram.y" 5673 { 5674 PLpgSQL_stmt_open *new; 5675@@ -3743,8 +3609,6 @@ 5676 break; 5677 5678 case 115: 5679- 5680-/* Line 1455 of yacc.c */ 5681 #line 1765 "gram.y" 5682 { 5683 PLpgSQL_stmt_fetch *fetch = (yyvsp[(2) - (4)].fetch); 5684@@ -3778,8 +3642,6 @@ 5685 break; 5686 5687 case 116: 5688- 5689-/* Line 1455 of yacc.c */ 5690 #line 1797 "gram.y" 5691 { 5692 PLpgSQL_stmt_fetch *fetch = (yyvsp[(2) - (4)].fetch); 5693@@ -3793,8 +3655,6 @@ 5694 break; 5695 5696 case 117: 5697- 5698-/* Line 1455 of yacc.c */ 5699 #line 1809 "gram.y" 5700 { 5701 (yyval.fetch) = read_fetch_direction(); 5702@@ -3802,8 +3662,6 @@ 5703 break; 5704 5705 case 118: 5706- 5707-/* Line 1455 of yacc.c */ 5708 #line 1815 "gram.y" 5709 { 5710 PLpgSQL_stmt_close *new; 5711@@ -3818,8 +3676,6 @@ 5712 break; 5713 5714 case 119: 5715- 5716-/* Line 1455 of yacc.c */ 5717 #line 1828 "gram.y" 5718 { 5719 /* We do not bother building a node for NULL */ 5720@@ -3828,8 +3684,6 @@ 5721 break; 5722 5723 case 120: 5724- 5725-/* Line 1455 of yacc.c */ 5726 #line 1835 "gram.y" 5727 { 5728 if ((yyvsp[(1) - (1)].wdatum).datum->dtype != PLPGSQL_DTYPE_VAR) 5729@@ -3849,8 +3703,6 @@ 5730 break; 5731 5732 case 121: 5733- 5734-/* Line 1455 of yacc.c */ 5735 #line 1851 "gram.y" 5736 { 5737 /* just to give a better message than "syntax error" */ 5738@@ -3859,8 +3711,6 @@ 5739 break; 5740 5741 case 122: 5742- 5743-/* Line 1455 of yacc.c */ 5744 #line 1856 "gram.y" 5745 { 5746 /* just to give a better message than "syntax error" */ 5747@@ -3869,15 +3719,11 @@ 5748 break; 5749 5750 case 123: 5751- 5752-/* Line 1455 of yacc.c */ 5753 #line 1863 "gram.y" 5754 { (yyval.exception_block) = NULL; ;} 5755 break; 5756 5757 case 124: 5758- 5759-/* Line 1455 of yacc.c */ 5760 #line 1865 "gram.y" 5761 { 5762 /* 5763@@ -3908,8 +3754,6 @@ 5764 break; 5765 5766 case 125: 5767- 5768-/* Line 1455 of yacc.c */ 5769 #line 1892 "gram.y" 5770 { 5771 PLpgSQL_exception_block *new = (yyvsp[(2) - (3)].exception_block); 5772@@ -3920,8 +3764,6 @@ 5773 break; 5774 5775 case 126: 5776- 5777-/* Line 1455 of yacc.c */ 5778 #line 1901 "gram.y" 5779 { 5780 (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].exception)); 5781@@ -3929,8 +3771,6 @@ 5782 break; 5783 5784 case 127: 5785- 5786-/* Line 1455 of yacc.c */ 5787 #line 1905 "gram.y" 5788 { 5789 (yyval.list) = list_make1((yyvsp[(1) - (1)].exception)); 5790@@ -3938,8 +3778,6 @@ 5791 break; 5792 5793 case 128: 5794- 5795-/* Line 1455 of yacc.c */ 5796 #line 1911 "gram.y" 5797 { 5798 PLpgSQL_exception *new; 5799@@ -3954,8 +3792,6 @@ 5800 break; 5801 5802 case 129: 5803- 5804-/* Line 1455 of yacc.c */ 5805 #line 1924 "gram.y" 5806 { 5807 PLpgSQL_condition *old; 5808@@ -3968,8 +3804,6 @@ 5809 break; 5810 5811 case 130: 5812- 5813-/* Line 1455 of yacc.c */ 5814 #line 1933 "gram.y" 5815 { 5816 (yyval.condition) = (yyvsp[(1) - (1)].condition); 5817@@ -3977,8 +3811,6 @@ 5818 break; 5819 5820 case 131: 5821- 5822-/* Line 1455 of yacc.c */ 5823 #line 1939 "gram.y" 5824 { 5825 if (strcmp((yyvsp[(1) - (1)].str), "sqlstate") != 0) 5826@@ -4016,36 +3848,26 @@ 5827 break; 5828 5829 case 132: 5830- 5831-/* Line 1455 of yacc.c */ 5832 #line 1975 "gram.y" 5833 { (yyval.expr) = read_sql_expression(';', ";"); ;} 5834 break; 5835 5836 case 133: 5837- 5838-/* Line 1455 of yacc.c */ 5839 #line 1979 "gram.y" 5840 { (yyval.expr) = read_sql_expression(']', "]"); ;} 5841 break; 5842 5843 case 134: 5844- 5845-/* Line 1455 of yacc.c */ 5846 #line 1983 "gram.y" 5847 { (yyval.expr) = read_sql_expression(K_THEN, "THEN"); ;} 5848 break; 5849 5850 case 135: 5851- 5852-/* Line 1455 of yacc.c */ 5853 #line 1987 "gram.y" 5854 { (yyval.expr) = read_sql_expression(K_LOOP, "LOOP"); ;} 5855 break; 5856 5857 case 136: 5858- 5859-/* Line 1455 of yacc.c */ 5860 #line 1991 "gram.y" 5861 { 5862 plpgsql_ns_push(NULL); 5863@@ -4054,8 +3876,6 @@ 5864 break; 5865 5866 case 137: 5867- 5868-/* Line 1455 of yacc.c */ 5869 #line 1996 "gram.y" 5870 { 5871 plpgsql_ns_push((yyvsp[(2) - (3)].str)); 5872@@ -4064,8 +3884,6 @@ 5873 break; 5874 5875 case 138: 5876- 5877-/* Line 1455 of yacc.c */ 5878 #line 2003 "gram.y" 5879 { 5880 (yyval.str) = NULL; 5881@@ -4073,8 +3891,6 @@ 5882 break; 5883 5884 case 139: 5885- 5886-/* Line 1455 of yacc.c */ 5887 #line 2007 "gram.y" 5888 { 5889 if (plpgsql_ns_lookup_label(plpgsql_ns_top(), (yyvsp[(1) - (1)].str)) == NULL) 5890@@ -4084,22 +3900,16 @@ 5891 break; 5892 5893 case 140: 5894- 5895-/* Line 1455 of yacc.c */ 5896 #line 2015 "gram.y" 5897 { (yyval.expr) = NULL; ;} 5898 break; 5899 5900 case 141: 5901- 5902-/* Line 1455 of yacc.c */ 5903 #line 2017 "gram.y" 5904 { (yyval.expr) = (yyvsp[(2) - (2)].expr); ;} 5905 break; 5906 5907 case 142: 5908- 5909-/* Line 1455 of yacc.c */ 5910 #line 2024 "gram.y" 5911 { 5912 (yyval.str) = (yyvsp[(1) - (1)].word).ident; 5913@@ -4107,8 +3917,6 @@ 5914 break; 5915 5916 case 143: 5917- 5918-/* Line 1455 of yacc.c */ 5919 #line 2028 "gram.y" 5920 { 5921 if ((yyvsp[(1) - (1)].wdatum).ident == NULL) /* composite name not OK */ 5922@@ -4118,9 +3926,8 @@ 5923 break; 5924 5925 5926- 5927-/* Line 1455 of yacc.c */ 5928-#line 4124 "pl_gram.c" 5929+/* Line 1267 of yacc.c. */ 5930+#line 3931 "pl_gram.c" 5931 default: break; 5932 } 5933 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 5934@@ -4196,7 +4003,7 @@ 5935 5936 if (yyerrstatus == 3) 5937 { 5938- /* If just tried and failed to reuse lookahead token after an 5939+ /* If just tried and failed to reuse look-ahead token after an 5940 error, discard it. */ 5941 5942 if (yychar <= YYEOF) 5943@@ -4213,7 +4020,7 @@ 5944 } 5945 } 5946 5947- /* Else will try to reuse lookahead token after shifting the error 5948+ /* Else will try to reuse look-ahead token after shifting the error 5949 token. */ 5950 goto yyerrlab1; 5951 5952@@ -4271,11 +4078,14 @@ 5953 YY_STACK_PRINT (yyss, yyssp); 5954 } 5955 5956+ if (yyn == YYFINAL) 5957+ YYACCEPT; 5958+ 5959 *++yyvsp = yylval; 5960 5961 yyerror_range[1] = yylloc; 5962 /* Using YYLLOC is tempting, but would change the location of 5963- the lookahead. YYLOC is available though. */ 5964+ the look-ahead. YYLOC is available though. */ 5965 YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2); 5966 *++yylsp = yyloc; 5967 5968@@ -4300,7 +4110,7 @@ 5969 yyresult = 1; 5970 goto yyreturn; 5971 5972-#if !defined(yyoverflow) || YYERROR_VERBOSE 5973+#ifndef yyoverflow 5974 /*-------------------------------------------------. 5975 | yyexhaustedlab -- memory exhaustion comes here. | 5976 `-------------------------------------------------*/ 5977@@ -4311,7 +4121,7 @@ 5978 #endif 5979 5980 yyreturn: 5981- if (yychar != YYEMPTY) 5982+ if (yychar != YYEOF && yychar != YYEMPTY) 5983 yydestruct ("Cleanup: discarding lookahead", 5984 yytoken, &yylval, &yylloc); 5985 /* Do not reclaim the symbols of the rule which action triggered 5986@@ -4337,8 +4147,6 @@ 5987 } 5988 5989 5990- 5991-/* Line 1675 of yacc.c */ 5992 #line 2074 "gram.y" 5993 5994 5995diff -Naur postgresql-9.0.8/src/pl/plpgsql/src/pl_gram.h postgresql/src/pl/plpgsql/src/pl_gram.h 5996--- postgresql-9.0.8/src/pl/plpgsql/src/pl_gram.h 2012-05-31 16:28:05.000000000 -0700 5997+++ postgresql/src/pl/plpgsql/src/pl_gram.h 2012-06-08 14:27:02.000000000 -0700 5998@@ -1,23 +1,24 @@ 5999- 6000-/* A Bison parser, made by GNU Bison 2.4.1. */ 6001+/* A Bison parser, made by GNU Bison 2.3. */ 6002 6003 /* Skeleton interface for Bison's Yacc-like parsers in C 6004- 6005- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 6006+ 6007+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 6008 Free Software Foundation, Inc. 6009- 6010- This program is free software: you can redistribute it and/or modify 6011+ 6012+ This program is free software; you can redistribute it and/or modify 6013 it under the terms of the GNU General Public License as published by 6014- the Free Software Foundation, either version 3 of the License, or 6015- (at your option) any later version. 6016- 6017+ the Free Software Foundation; either version 2, or (at your option) 6018+ any later version. 6019+ 6020 This program is distributed in the hope that it will be useful, 6021 but WITHOUT ANY WARRANTY; without even the implied warranty of 6022 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 6023 GNU General Public License for more details. 6024- 6025+ 6026 You should have received a copy of the GNU General Public License 6027- along with this program. If not, see <http://www.gnu.org/licenses/>. */ 6028+ along with this program; if not, write to the Free Software 6029+ Foundation, Inc., 51 Franklin Street, Fifth Floor, 6030+ Boston, MA 02110-1301, USA. */ 6031 6032 /* As a special exception, you may create a larger work that contains 6033 part or all of the Bison parser skeleton and distribute that work 6034@@ -28,11 +29,10 @@ 6035 special exception, which will cause the skeleton and the resulting 6036 Bison output files to be licensed under the GNU General Public 6037 License without this special exception. 6038- 6039+ 6040 This special exception was added by the Free Software Foundation in 6041 version 2.2 of Bison. */ 6042 6043- 6044 /* Tokens. */ 6045 #ifndef YYTOKENTYPE 6046 # define YYTOKENTYPE 6047@@ -131,16 +131,105 @@ 6048 K_WHILE = 347 6049 }; 6050 #endif 6051+/* Tokens. */ 6052+#define IDENT 258 6053+#define FCONST 259 6054+#define SCONST 260 6055+#define BCONST 261 6056+#define XCONST 262 6057+#define Op 263 6058+#define ICONST 264 6059+#define PARAM 265 6060+#define TYPECAST 266 6061+#define DOT_DOT 267 6062+#define COLON_EQUALS 268 6063+#define T_WORD 269 6064+#define T_CWORD 270 6065+#define T_DATUM 271 6066+#define LESS_LESS 272 6067+#define GREATER_GREATER 273 6068+#define K_ABSOLUTE 274 6069+#define K_ALIAS 275 6070+#define K_ALL 276 6071+#define K_BACKWARD 277 6072+#define K_BEGIN 278 6073+#define K_BY 279 6074+#define K_CASE 280 6075+#define K_CLOSE 281 6076+#define K_CONSTANT 282 6077+#define K_CONTINUE 283 6078+#define K_CURSOR 284 6079+#define K_DEBUG 285 6080+#define K_DECLARE 286 6081+#define K_DEFAULT 287 6082+#define K_DETAIL 288 6083+#define K_DIAGNOSTICS 289 6084+#define K_DUMP 290 6085+#define K_ELSE 291 6086+#define K_ELSIF 292 6087+#define K_END 293 6088+#define K_ERRCODE 294 6089+#define K_ERROR 295 6090+#define K_EXCEPTION 296 6091+#define K_EXECUTE 297 6092+#define K_EXIT 298 6093+#define K_FETCH 299 6094+#define K_FIRST 300 6095+#define K_FOR 301 6096+#define K_FORWARD 302 6097+#define K_FROM 303 6098+#define K_GET 304 6099+#define K_HINT 305 6100+#define K_IF 306 6101+#define K_IN 307 6102+#define K_INFO 308 6103+#define K_INSERT 309 6104+#define K_INTO 310 6105+#define K_IS 311 6106+#define K_LAST 312 6107+#define K_LOG 313 6108+#define K_LOOP 314 6109+#define K_MESSAGE 315 6110+#define K_MOVE 316 6111+#define K_NEXT 317 6112+#define K_NO 318 6113+#define K_NOT 319 6114+#define K_NOTICE 320 6115+#define K_NULL 321 6116+#define K_OPEN 322 6117+#define K_OPTION 323 6118+#define K_OR 324 6119+#define K_PERFORM 325 6120+#define K_PRIOR 326 6121+#define K_QUERY 327 6122+#define K_RAISE 328 6123+#define K_RELATIVE 329 6124+#define K_RESULT_OID 330 6125+#define K_RETURN 331 6126+#define K_REVERSE 332 6127+#define K_ROWTYPE 333 6128+#define K_ROW_COUNT 334 6129+#define K_SCROLL 335 6130+#define K_SQLSTATE 336 6131+#define K_STRICT 337 6132+#define K_THEN 338 6133+#define K_TO 339 6134+#define K_TYPE 340 6135+#define K_USE_COLUMN 341 6136+#define K_USE_VARIABLE 342 6137+#define K_USING 343 6138+#define K_VARIABLE_CONFLICT 344 6139+#define K_WARNING 345 6140+#define K_WHEN 346 6141+#define K_WHILE 347 6142+ 6143 6144 6145 6146 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 6147 typedef union YYSTYPE 6148-{ 6149- 6150-/* Line 1676 of yacc.c */ 6151 #line 114 "gram.y" 6152- 6153+{ 6154 core_YYSTYPE core_yystype; 6155 /* these fields must match core_YYSTYPE: */ 6156 int ival; 6157@@ -189,15 +278,13 @@ 6158 PLpgSQL_diag_item *diagitem; 6159 PLpgSQL_stmt_fetch *fetch; 6160 PLpgSQL_case_when *casewhen; 6161- 6162- 6163- 6164-/* Line 1676 of yacc.c */ 6165-#line 197 "pl_gram.h" 6166-} YYSTYPE; 6167-# define YYSTYPE_IS_TRIVIAL 1 6168+} 6169+/* Line 1529 of yacc.c. */ 6170+#line 284 "pl_gram.h" 6171+ YYSTYPE; 6172 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 6173 # define YYSTYPE_IS_DECLARED 1 6174+# define YYSTYPE_IS_TRIVIAL 1 6175 #endif 6176 6177 extern YYSTYPE plpgsql_yylval; 6178@@ -216,4 +303,3 @@ 6179 #endif 6180 6181 extern YYLTYPE plpgsql_yylloc; 6182- 6183--- postgresql-9.0.12/src/interfaces/ecpg/preproc/preproc.c 2013-02-04 13:44:29.000000000 -0800 6184+++ postgresql/src/interfaces/ecpg/preproc/preproc.c 2013-03-19 20:10:29.000000000 -0700 6185@@ -1,23 +1,24 @@ 6186- 6187-/* A Bison parser, made by GNU Bison 2.4.1. */ 6188+/* A Bison parser, made by GNU Bison 2.3. */ 6189 6190 /* Skeleton implementation for Bison's Yacc-like parsers in C 6191- 6192- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 6193+ 6194+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 6195 Free Software Foundation, Inc. 6196- 6197- This program is free software: you can redistribute it and/or modify 6198+ 6199+ This program is free software; you can redistribute it and/or modify 6200 it under the terms of the GNU General Public License as published by 6201- the Free Software Foundation, either version 3 of the License, or 6202- (at your option) any later version. 6203- 6204+ the Free Software Foundation; either version 2, or (at your option) 6205+ any later version. 6206+ 6207 This program is distributed in the hope that it will be useful, 6208 but WITHOUT ANY WARRANTY; without even the implied warranty of 6209 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 6210 GNU General Public License for more details. 6211- 6212+ 6213 You should have received a copy of the GNU General Public License 6214- along with this program. If not, see <http://www.gnu.org/licenses/>. */ 6215+ along with this program; if not, write to the Free Software 6216+ Foundation, Inc., 51 Franklin Street, Fifth Floor, 6217+ Boston, MA 02110-1301, USA. */ 6218 6219 /* As a special exception, you may create a larger work that contains 6220 part or all of the Bison parser skeleton and distribute that work 6221@@ -28,7 +29,7 @@ 6222 special exception, which will cause the skeleton and the resulting 6223 Bison output files to be licensed under the GNU General Public 6224 License without this special exception. 6225- 6226+ 6227 This special exception was added by the Free Software Foundation in 6228 version 2.2 of Bison. */ 6229 6230@@ -46,7 +47,7 @@ 6231 #define YYBISON 1 6232 6233 /* Bison version. */ 6234-#define YYBISON_VERSION "2.4.1" 6235+#define YYBISON_VERSION "2.3" 6236 6237 /* Skeleton name. */ 6238 #define YYSKELETON_NAME "yacc.c" 6239@@ -54,512 +55,18 @@ 6240 /* Pure parsers. */ 6241 #define YYPURE 0 6242 6243-/* Push parsers. */ 6244-#define YYPUSH 0 6245- 6246-/* Pull parsers. */ 6247-#define YYPULL 1 6248- 6249 /* Using locations. */ 6250 #define YYLSP_NEEDED 1 6251 6252 /* Substitute the variable and function names. */ 6253-#define yyparse base_yyparse 6254-#define yylex base_yylex 6255-#define yyerror base_yyerror 6256-#define yylval base_yylval 6257-#define yychar base_yychar 6258-#define yydebug base_yydebug 6259-#define yynerrs base_yynerrs 6260-#define yylloc base_yylloc 6261- 6262-/* Copy the first part of user declarations. */ 6263- 6264-/* Line 189 of yacc.c */ 6265-#line 5 "preproc.y" 6266- 6267-#include "postgres_fe.h" 6268- 6269-#include "extern.h" 6270-#include "ecpg_config.h" 6271-#include <unistd.h> 6272- 6273-/* Location tracking support --- simpler than bison's default */ 6274-#define YYLLOC_DEFAULT(Current, Rhs, N) \ 6275- do { \ 6276- if (N) \ 6277- (Current) = (Rhs)[1]; \ 6278- else \ 6279- (Current) = (Rhs)[0]; \ 6280- } while (0) 6281- 6282-/* 6283- * The %name-prefix option below will make bison call base_yylex, but we 6284- * really want it to call filtered_base_yylex (see parser.c). 6285- */ 6286-#define base_yylex filtered_base_yylex 6287- 6288-/* 6289- * This is only here so the string gets into the POT. Bison uses it 6290- * internally. 6291- */ 6292-#define bison_gettext_dummy gettext_noop("syntax error") 6293- 6294-/* 6295- * Variables containing simple states. 6296- */ 6297-int struct_level = 0; 6298-int braces_open; /* brace level counter */ 6299-char *current_function; 6300-int ecpg_internal_var = 0; 6301-char *connection = NULL; 6302-char *input_filename = NULL; 6303- 6304-static int FoundInto = 0; 6305-static int initializer = 0; 6306-static int pacounter = 1; 6307-static char pacounter_buffer[sizeof(int) * CHAR_BIT * 10 / 3]; /* a rough guess at the size we need */ 6308-static struct this_type actual_type[STRUCT_DEPTH]; 6309-static char *actual_startline[STRUCT_DEPTH]; 6310-static int varchar_counter = 1; 6311- 6312-/* temporarily store struct members while creating the data structure */ 6313-struct ECPGstruct_member *struct_member_list[STRUCT_DEPTH] = { NULL }; 6314- 6315-/* also store struct type so we can do a sizeof() later */ 6316-static char *ECPGstruct_sizeof = NULL; 6317- 6318-/* for forward declarations we have to store some data as well */ 6319-static char *forward_name = NULL; 6320- 6321-struct ECPGtype ecpg_no_indicator = {ECPGt_NO_INDICATOR, NULL, NULL, NULL, {NULL}, 0}; 6322-struct variable no_indicator = {"no_indicator", &ecpg_no_indicator, 0, NULL}; 6323- 6324-struct ECPGtype ecpg_query = {ECPGt_char_variable, NULL, NULL, NULL, {NULL}, 0}; 6325- 6326-/* 6327- * Handle parsing errors and warnings 6328- */ 6329-void 6330-mmerror(int error_code, enum errortype type, const char *error, ...) 6331-{ 6332- va_list ap; 6333- 6334- /* internationalize the error message string */ 6335- error = _(error); 6336- 6337- fprintf(stderr, "%s:%d: ", input_filename, yylineno); 6338- 6339- switch(type) 6340- { 6341- case ET_WARNING: 6342- fprintf(stderr, _("WARNING: ")); 6343- break; 6344- case ET_ERROR: 6345- case ET_FATAL: 6346- fprintf(stderr, _("ERROR: ")); 6347- break; 6348- } 6349- 6350- va_start(ap, error); 6351- vfprintf(stderr, error, ap); 6352- va_end(ap); 6353- 6354- fprintf(stderr, "\n"); 6355- 6356- switch(type) 6357- { 6358- case ET_WARNING: 6359- break; 6360- case ET_ERROR: 6361- ret_value = error_code; 6362- break; 6363- case ET_FATAL: 6364- if (yyin) 6365- fclose(yyin); 6366- if (yyout) 6367- fclose(yyout); 6368- 6369- if (strcmp(output_filename, "-") != 0 && unlink(output_filename) != 0) 6370- fprintf(stderr, _("could not remove output file \"%s\"\n"), output_filename); 6371- exit(error_code); 6372- } 6373-} 6374- 6375-/* 6376- * string concatenation 6377- */ 6378- 6379-static char * 6380-cat2_str(char *str1, char *str2) 6381-{ 6382- char * res_str = (char *)mm_alloc(strlen(str1) + strlen(str2) + 2); 6383- 6384- strcpy(res_str, str1); 6385- if (strlen(str1) != 0 && strlen(str2) != 0) 6386- strcat(res_str, " "); 6387- strcat(res_str, str2); 6388- free(str1); 6389- free(str2); 6390- return(res_str); 6391-} 6392- 6393-static char * 6394-cat_str(int count, ...) 6395-{ 6396- va_list args; 6397- int i; 6398- char *res_str; 6399- 6400- va_start(args, count); 6401- 6402- res_str = va_arg(args, char *); 6403- 6404- /* now add all other strings */ 6405- for (i = 1; i < count; i++) 6406- res_str = cat2_str(res_str, va_arg(args, char *)); 6407- 6408- va_end(args); 6409- 6410- return(res_str); 6411-} 6412- 6413-char * 6414-make_str(const char *str) 6415-{ 6416- char * res_str = (char *)mm_alloc(strlen(str) + 1); 6417- 6418- strcpy(res_str, str); 6419- return res_str; 6420-} 6421- 6422-static char * 6423-make2_str(char *str1, char *str2) 6424-{ 6425- char * res_str = (char *)mm_alloc(strlen(str1) + strlen(str2) + 1); 6426- 6427- strcpy(res_str, str1); 6428- strcat(res_str, str2); 6429- free(str1); 6430- free(str2); 6431- return(res_str); 6432-} 6433- 6434-static char * 6435-make3_str(char *str1, char *str2, char *str3) 6436-{ 6437- char * res_str = (char *)mm_alloc(strlen(str1) + strlen(str2) +strlen(str3) + 1); 6438- 6439- strcpy(res_str, str1); 6440- strcat(res_str, str2); 6441- strcat(res_str, str3); 6442- free(str1); 6443- free(str2); 6444- free(str3); 6445- return(res_str); 6446-} 6447- 6448-/* and the rest */ 6449-static char * 6450-make_name(void) 6451-{ 6452- return mm_strdup(yytext); 6453-} 6454- 6455-static char * 6456-create_questionmarks(char *name, bool array) 6457-{ 6458- struct variable *p = find_variable(name); 6459- int count; 6460- char *result = EMPTY; 6461- 6462- /* In case we have a struct, we have to print as many "?" as there are attributes in the struct 6463- * An array is only allowed together with an element argument 6464- * This is essantially only used for inserts, but using a struct as input parameter is an error anywhere else 6465- * so we don't have to worry here. */ 6466- 6467- if (p->type->type == ECPGt_struct || (array && p->type->type == ECPGt_array && p->type->u.element->type == ECPGt_struct)) 6468- { 6469- struct ECPGstruct_member *m; 6470- 6471- if (p->type->type == ECPGt_struct) 6472- m = p->type->u.members; 6473- else 6474- m = p->type->u.element->u.members; 6475- 6476- for (count = 0; m != NULL; m=m->next, count++); 6477- } 6478- else 6479- count = 1; 6480- 6481- for (; count > 0; count --) 6482- { 6483- sprintf(pacounter_buffer, "$%d", pacounter++); 6484- result = cat_str(3, result, mm_strdup(pacounter_buffer), make_str(" , ")); 6485- } 6486- 6487- /* removed the trailing " ," */ 6488- 6489- result[strlen(result)-3] = '\0'; 6490- return(result); 6491-} 6492- 6493-static char * 6494-adjust_outofscope_cursor_vars(struct cursor *cur) 6495-{ 6496- /* Informix accepts DECLARE with variables that are out of scope when OPEN is called. 6497- * For instance you can DECLARE a cursor in one function, and OPEN/FETCH/CLOSE 6498- * it in other functions. This is very useful for e.g. event-driver programming, 6499- * but may also lead to dangerous programming. The limitation when this is allowed 6500- * and doesn's cause problems have to be documented, like the allocated variables 6501- * must not be realloc()'ed. 6502- * 6503- * We have to change the variables to our own struct and just store the pointer 6504- * instead of the variable. Do it only for local variables, not for globals. 6505- */ 6506- 6507- char *result = make_str(""); 6508- int insert; 6509- 6510- for (insert = 1; insert >= 0; insert--) 6511- { 6512- struct arguments *list; 6513- struct arguments *ptr; 6514- struct arguments *newlist = NULL; 6515- struct variable *newvar, *newind; 6516- 6517- list = (insert ? cur->argsinsert : cur->argsresult); 6518- 6519- for (ptr = list; ptr != NULL; ptr = ptr->next) 6520- { 6521- char temp[20]; 6522- char *original_var; 6523- bool skip_set_var = false; 6524- 6525- /* change variable name to "ECPGget_var(<counter>)" */ 6526- original_var = ptr->variable->name; 6527- sprintf(temp, "%d))", ecpg_internal_var); 6528- 6529- /* Don't emit ECPGset_var() calls for global variables */ 6530- if (ptr->variable->brace_level == 0) 6531- { 6532- newvar = ptr->variable; 6533- skip_set_var = true; 6534- } 6535- else if ((ptr->variable->type->type == ECPGt_char_variable) && (!strncmp(ptr->variable->name, "ECPGprepared_statement", strlen("ECPGprepared_statement")))) 6536- { 6537- newvar = ptr->variable; 6538- skip_set_var = true; 6539- } 6540- else if ((ptr->variable->type->type != ECPGt_varchar && ptr->variable->type->type != ECPGt_char && ptr->variable->type->type != ECPGt_unsigned_char && ptr->variable->type->type != ECPGt_string) && atoi(ptr->variable->type->size) > 1) 6541- { 6542- newvar = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->variable->type->u.element->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_array_type(ECPGmake_simple_type(ptr->variable->type->u.element->type, make_str("1"), ptr->variable->type->u.element->counter), ptr->variable->type->size), 0); 6543- sprintf(temp, "%d, (", ecpg_internal_var++); 6544- } 6545- else if ((ptr->variable->type->type == ECPGt_varchar || ptr->variable->type->type == ECPGt_char || ptr->variable->type->type == ECPGt_unsigned_char || ptr->variable->type->type == ECPGt_string) && atoi(ptr->variable->type->size) > 1) 6546- { 6547- newvar = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->variable->type->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->variable->type->type, ptr->variable->type->size, ptr->variable->type->counter), 0); 6548- if (ptr->variable->type->type == ECPGt_varchar) 6549- sprintf(temp, "%d, &(", ecpg_internal_var++); 6550- else 6551- sprintf(temp, "%d, (", ecpg_internal_var++); 6552- } 6553- else if (ptr->variable->type->type == ECPGt_struct || ptr->variable->type->type == ECPGt_union) 6554- { 6555- sprintf(temp, "%d)))", ecpg_internal_var); 6556- newvar = new_variable(cat_str(4, make_str("(*("), mm_strdup(ptr->variable->type->type_name), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_struct_type(ptr->variable->type->u.members, ptr->variable->type->type, ptr->variable->type->type_name, ptr->variable->type->struct_sizeof), 0); 6557- sprintf(temp, "%d, &(", ecpg_internal_var++); 6558- } 6559- else if (ptr->variable->type->type == ECPGt_array) 6560- { 6561- if (ptr->variable->type->u.element->type == ECPGt_struct || ptr->variable->type->u.element->type == ECPGt_union) 6562- { 6563- sprintf(temp, "%d)))", ecpg_internal_var); 6564- newvar = new_variable(cat_str(4, make_str("(*("), mm_strdup(ptr->variable->type->u.element->type_name), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_struct_type(ptr->variable->type->u.element->u.members, ptr->variable->type->u.element->type, ptr->variable->type->u.element->type_name, ptr->variable->type->u.element->struct_sizeof), 0); 6565- sprintf(temp, "%d, (", ecpg_internal_var++); 6566- } 6567- else 6568- { 6569- newvar = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->variable->type->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_array_type(ECPGmake_simple_type(ptr->variable->type->u.element->type, ptr->variable->type->u.element->size, ptr->variable->type->u.element->counter), ptr->variable->type->size), 0); 6570- sprintf(temp, "%d, &(", ecpg_internal_var++); 6571- } 6572- } 6573- else 6574- { 6575- newvar = new_variable(cat_str(4, make_str("*("), mm_strdup(ecpg_type_name(ptr->variable->type->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->variable->type->type, ptr->variable->type->size, ptr->variable->type->counter), 0); 6576- sprintf(temp, "%d, &(", ecpg_internal_var++); 6577- } 6578- 6579- /* create call to "ECPGset_var(<counter>, <pointer>. <line number>)" */ 6580- if (!skip_set_var) 6581- result = cat_str(5, result, make_str("ECPGset_var("), mm_strdup(temp), mm_strdup(original_var), make_str("), __LINE__);\n")); 6582- 6583- /* now the indicator if there is one and it's not a global variable */ 6584- if ((ptr->indicator->type->type == ECPGt_NO_INDICATOR) || (ptr->indicator->brace_level == 0)) 6585- { 6586- newind = ptr->indicator; 6587- } 6588- else 6589- { 6590- /* change variable name to "ECPGget_var(<counter>)" */ 6591- original_var = ptr->indicator->name; 6592- sprintf(temp, "%d))", ecpg_internal_var); 6593- 6594- if (ptr->indicator->type->type == ECPGt_struct || ptr->indicator->type->type == ECPGt_union) 6595- { 6596- sprintf(temp, "%d)))", ecpg_internal_var); 6597- newind = new_variable(cat_str(4, make_str("(*("), mm_strdup(ptr->indicator->type->type_name), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_struct_type(ptr->indicator->type->u.members, ptr->indicator->type->type, ptr->indicator->type->type_name, ptr->indicator->type->struct_sizeof), 0); 6598- sprintf(temp, "%d, &(", ecpg_internal_var++); 6599- } 6600- else if (ptr->indicator->type->type == ECPGt_array) 6601- { 6602- if (ptr->indicator->type->u.element->type == ECPGt_struct || ptr->indicator->type->u.element->type == ECPGt_union) 6603- { 6604- sprintf(temp, "%d)))", ecpg_internal_var); 6605- newind = new_variable(cat_str(4, make_str("(*("), mm_strdup(ptr->indicator->type->u.element->type_name), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_struct_type(ptr->indicator->type->u.element->u.members, ptr->indicator->type->u.element->type, ptr->indicator->type->u.element->type_name, ptr->indicator->type->u.element->struct_sizeof), 0); 6606- sprintf(temp, "%d, (", ecpg_internal_var++); 6607- } 6608- else 6609- { 6610- newind = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->indicator->type->u.element->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_array_type(ECPGmake_simple_type(ptr->indicator->type->u.element->type, ptr->indicator->type->u.element->size, ptr->indicator->type->u.element->counter), ptr->indicator->type->size), 0); 6611- sprintf(temp, "%d, &(", ecpg_internal_var++); 6612- } 6613- } 6614- else if (atoi(ptr->indicator->type->size) > 1) 6615- { 6616- newind = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->indicator->type->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->indicator->type->type, ptr->indicator->type->size, ptr->variable->type->counter), 0); 6617- sprintf(temp, "%d, (", ecpg_internal_var++); 6618- } 6619- else 6620- { 6621- newind = new_variable(cat_str(4, make_str("*("), mm_strdup(ecpg_type_name(ptr->indicator->type->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->indicator->type->type, ptr->indicator->type->size, ptr->variable->type->counter), 0); 6622- sprintf(temp, "%d, &(", ecpg_internal_var++); 6623- } 6624- 6625- /* create call to "ECPGset_var(<counter>, <pointer>. <line number>)" */ 6626- result = cat_str(5, result, make_str("ECPGset_var("), mm_strdup(temp), mm_strdup(original_var), make_str("), __LINE__);\n")); 6627- } 6628- 6629- add_variable_to_tail(&newlist, newvar, newind); 6630- } 6631- 6632- if (insert) 6633- cur->argsinsert_oos = newlist; 6634- else 6635- cur->argsresult_oos = newlist; 6636- } 6637- 6638- return result; 6639-} 6640- 6641-/* This tests whether the cursor was declared and opened in the same function. */ 6642-#define SAMEFUNC(cur) \ 6643- ((cur->function == NULL) || \ 6644- (cur->function != NULL && !strcmp(cur->function, current_function))) 6645- 6646-static struct cursor * 6647-add_additional_variables(char *name, bool insert) 6648-{ 6649- struct cursor *ptr; 6650- struct arguments *p; 6651- 6652- for (ptr = cur; ptr != NULL; ptr=ptr->next) 6653- { 6654- if (strcmp(ptr->name, name) == 0) 6655- break; 6656- } 6657- 6658- if (ptr == NULL) 6659- { 6660- mmerror(PARSE_ERROR, ET_ERROR, "cursor \"%s\" does not exist", name); 6661- return NULL; 6662- } 6663- 6664- if (insert) 6665- { 6666- /* add all those input variables that were given earlier 6667- * note that we have to append here but have to keep the existing order */ 6668- for (p = (SAMEFUNC(ptr) ? ptr->argsinsert : ptr->argsinsert_oos); p; p = p->next) 6669- add_variable_to_tail(&argsinsert, p->variable, p->indicator); 6670- } 6671- 6672- /* add all those output variables that were given earlier */ 6673- for (p = (SAMEFUNC(ptr) ? ptr->argsresult : ptr->argsresult_oos); p; p = p->next) 6674- add_variable_to_tail(&argsresult, p->variable, p->indicator); 6675- 6676- return ptr; 6677-} 6678- 6679-static void 6680-add_typedef(char *name, char * dimension, char * length, enum ECPGttype type_enum, char *type_dimension, char *type_index, int initializer, int array) 6681-{ 6682- /* add entry to list */ 6683- struct typedefs *ptr, *this; 6684- 6685- if ((type_enum == ECPGt_struct || 6686- type_enum == ECPGt_union) && 6687- initializer == 1) 6688- mmerror(PARSE_ERROR, ET_ERROR, "initializer not allowed in type definition"); 6689- else if (INFORMIX_MODE && strcmp(name, "string") == 0) 6690- mmerror(PARSE_ERROR, ET_ERROR, "type name \"string\" is reserved in Informix mode"); 6691- else 6692- { 6693- for (ptr = types; ptr != NULL; ptr = ptr->next) 6694- { 6695- if (strcmp(name, ptr->name) == 0) 6696- /* re-definition is a bug */ 6697- mmerror(PARSE_ERROR, ET_ERROR, "type \"%s\" is already defined", name); 6698- } 6699- adjust_array(type_enum, &dimension, &length, type_dimension, type_index, array, true); 6700- 6701- this = (struct typedefs *) mm_alloc(sizeof(struct typedefs)); 6702- 6703- /* initial definition */ 6704- this->next = types; 6705- this->name = name; 6706- this->brace_level = braces_open; 6707- this->type = (struct this_type *) mm_alloc(sizeof(struct this_type)); 6708- this->type->type_enum = type_enum; 6709- this->type->type_str = mm_strdup(name); 6710- this->type->type_dimension = dimension; /* dimension of array */ 6711- this->type->type_index = length; /* length of string */ 6712- this->type->type_sizeof = ECPGstruct_sizeof; 6713- this->struct_member_list = (type_enum == ECPGt_struct || type_enum == ECPGt_union) ? 6714- ECPGstruct_member_dup(struct_member_list[struct_level]) : NULL; 6715- 6716- if (type_enum != ECPGt_varchar && 6717- type_enum != ECPGt_char && 6718- type_enum != ECPGt_unsigned_char && 6719- type_enum != ECPGt_string && 6720- atoi(this->type->type_index) >= 0) 6721- mmerror(PARSE_ERROR, ET_ERROR, "multidimensional arrays for simple data types are not supported"); 6722- 6723- types = this; 6724- } 6725-} 6726- 6727- 6728-/* Line 189 of yacc.c */ 6729-#line 544 "preproc.c" 6730- 6731-/* Enabling traces. */ 6732-#ifndef YYDEBUG 6733-# define YYDEBUG 0 6734-#endif 6735- 6736-/* Enabling verbose error messages. */ 6737-#ifdef YYERROR_VERBOSE 6738-# undef YYERROR_VERBOSE 6739-# define YYERROR_VERBOSE 1 6740-#else 6741-# define YYERROR_VERBOSE 0 6742-#endif 6743- 6744-/* Enabling the token table. */ 6745-#ifndef YYTOKEN_TABLE 6746-# define YYTOKEN_TABLE 0 6747-#endif 6748- 6749+#define yyparse base_yyparse 6750+#define yylex base_yylex 6751+#define yyerror base_yyerror 6752+#define yylval base_yylval 6753+#define yychar base_yychar 6754+#define yydebug base_yydebug 6755+#define yynerrs base_yynerrs 6756+#define yylloc base_yylloc 6757 6758 /* Tokens. */ 6759 #ifndef YYTOKENTYPE 6760@@ -1057,16 +564,985 @@ 6761 UMINUS = 745 6762 }; 6763 #endif 6764+/* Tokens. */ 6765+#define SQL_ALLOCATE 258 6766+#define SQL_AUTOCOMMIT 259 6767+#define SQL_BOOL 260 6768+#define SQL_BREAK 261 6769+#define SQL_CALL 262 6770+#define SQL_CARDINALITY 263 6771+#define SQL_CONNECT 264 6772+#define SQL_COUNT 265 6773+#define SQL_DATETIME_INTERVAL_CODE 266 6774+#define SQL_DATETIME_INTERVAL_PRECISION 267 6775+#define SQL_DESCRIBE 268 6776+#define SQL_DESCRIPTOR 269 6777+#define SQL_DISCONNECT 270 6778+#define SQL_FOUND 271 6779+#define SQL_FREE 272 6780+#define SQL_GET 273 6781+#define SQL_GO 274 6782+#define SQL_GOTO 275 6783+#define SQL_IDENTIFIED 276 6784+#define SQL_INDICATOR 277 6785+#define SQL_KEY_MEMBER 278 6786+#define SQL_LENGTH 279 6787+#define SQL_LONG 280 6788+#define SQL_NULLABLE 281 6789+#define SQL_OCTET_LENGTH 282 6790+#define SQL_OPEN 283 6791+#define SQL_OUTPUT 284 6792+#define SQL_REFERENCE 285 6793+#define SQL_RETURNED_LENGTH 286 6794+#define SQL_RETURNED_OCTET_LENGTH 287 6795+#define SQL_SCALE 288 6796+#define SQL_SECTION 289 6797+#define SQL_SHORT 290 6798+#define SQL_SIGNED 291 6799+#define SQL_SQL 292 6800+#define SQL_SQLERROR 293 6801+#define SQL_SQLPRINT 294 6802+#define SQL_SQLWARNING 295 6803+#define SQL_START 296 6804+#define SQL_STOP 297 6805+#define SQL_STRUCT 298 6806+#define SQL_UNSIGNED 299 6807+#define SQL_VAR 300 6808+#define SQL_WHENEVER 301 6809+#define S_ADD 302 6810+#define S_AND 303 6811+#define S_ANYTHING 304 6812+#define S_AUTO 305 6813+#define S_CONST 306 6814+#define S_DEC 307 6815+#define S_DIV 308 6816+#define S_DOTPOINT 309 6817+#define S_EQUAL 310 6818+#define S_EXTERN 311 6819+#define S_INC 312 6820+#define S_LSHIFT 313 6821+#define S_MEMPOINT 314 6822+#define S_MEMBER 315 6823+#define S_MOD 316 6824+#define S_MUL 317 6825+#define S_NEQUAL 318 6826+#define S_OR 319 6827+#define S_REGISTER 320 6828+#define S_RSHIFT 321 6829+#define S_STATIC 322 6830+#define S_SUB 323 6831+#define S_VOLATILE 324 6832+#define S_TYPEDEF 325 6833+#define CSTRING 326 6834+#define CVARIABLE 327 6835+#define CPP_LINE 328 6836+#define IP 329 6837+#define DOLCONST 330 6838+#define ECONST 331 6839+#define NCONST 332 6840+#define UCONST 333 6841+#define UIDENT 334 6842+#define IDENT 335 6843+#define FCONST 336 6844+#define SCONST 337 6845+#define BCONST 338 6846+#define XCONST 339 6847+#define Op 340 6848+#define ICONST 341 6849+#define PARAM 342 6850+#define TYPECAST 343 6851+#define DOT_DOT 344 6852+#define COLON_EQUALS 345 6853+#define ABORT_P 346 6854+#define ABSOLUTE_P 347 6855+#define ACCESS 348 6856+#define ACTION 349 6857+#define ADD_P 350 6858+#define ADMIN 351 6859+#define AFTER 352 6860+#define AGGREGATE 353 6861+#define ALL 354 6862+#define ALSO 355 6863+#define ALTER 356 6864+#define ALWAYS 357 6865+#define ANALYSE 358 6866+#define ANALYZE 359 6867+#define AND 360 6868+#define ANY 361 6869+#define ARRAY 362 6870+#define AS 363 6871+#define ASC 364 6872+#define ASSERTION 365 6873+#define ASSIGNMENT 366 6874+#define ASYMMETRIC 367 6875+#define AT 368 6876+#define AUTHORIZATION 369 6877+#define BACKWARD 370 6878+#define BEFORE 371 6879+#define BEGIN_P 372 6880+#define BETWEEN 373 6881+#define BIGINT 374 6882+#define BINARY 375 6883+#define BIT 376 6884+#define BOOLEAN_P 377 6885+#define BOTH 378 6886+#define BY 379 6887+#define CACHE 380 6888+#define CALLED 381 6889+#define CASCADE 382 6890+#define CASCADED 383 6891+#define CASE 384 6892+#define CAST 385 6893+#define CATALOG_P 386 6894+#define CHAIN 387 6895+#define CHAR_P 388 6896+#define CHARACTER 389 6897+#define CHARACTERISTICS 390 6898+#define CHECK 391 6899+#define CHECKPOINT 392 6900+#define CLASS 393 6901+#define CLOSE 394 6902+#define CLUSTER 395 6903+#define COALESCE 396 6904+#define COLLATE 397 6905+#define COLUMN 398 6906+#define COMMENT 399 6907+#define COMMENTS 400 6908+#define COMMIT 401 6909+#define COMMITTED 402 6910+#define CONCURRENTLY 403 6911+#define CONFIGURATION 404 6912+#define CONNECTION 405 6913+#define CONSTRAINT 406 6914+#define CONSTRAINTS 407 6915+#define CONTENT_P 408 6916+#define CONTINUE_P 409 6917+#define CONVERSION_P 410 6918+#define COPY 411 6919+#define COST 412 6920+#define CREATE 413 6921+#define CREATEDB 414 6922+#define CREATEROLE 415 6923+#define CREATEUSER 416 6924+#define CROSS 417 6925+#define CSV 418 6926+#define CURRENT_P 419 6927+#define CURRENT_CATALOG 420 6928+#define CURRENT_DATE 421 6929+#define CURRENT_ROLE 422 6930+#define CURRENT_SCHEMA 423 6931+#define CURRENT_TIME 424 6932+#define CURRENT_TIMESTAMP 425 6933+#define CURRENT_USER 426 6934+#define CURSOR 427 6935+#define CYCLE 428 6936+#define DATA_P 429 6937+#define DATABASE 430 6938+#define DAY_P 431 6939+#define DEALLOCATE 432 6940+#define DEC 433 6941+#define DECIMAL_P 434 6942+#define DECLARE 435 6943+#define DEFAULT 436 6944+#define DEFAULTS 437 6945+#define DEFERRABLE 438 6946+#define DEFERRED 439 6947+#define DEFINER 440 6948+#define DELETE_P 441 6949+#define DELIMITER 442 6950+#define DELIMITERS 443 6951+#define DESC 444 6952+#define DICTIONARY 445 6953+#define DISABLE_P 446 6954+#define DISCARD 447 6955+#define DISTINCT 448 6956+#define DO 449 6957+#define DOCUMENT_P 450 6958+#define DOMAIN_P 451 6959+#define DOUBLE_P 452 6960+#define DROP 453 6961+#define EACH 454 6962+#define ELSE 455 6963+#define ENABLE_P 456 6964+#define ENCODING 457 6965+#define ENCRYPTED 458 6966+#define END_P 459 6967+#define ENUM_P 460 6968+#define ESCAPE 461 6969+#define EXCEPT 462 6970+#define EXCLUDE 463 6971+#define EXCLUDING 464 6972+#define EXCLUSIVE 465 6973+#define EXECUTE 466 6974+#define EXISTS 467 6975+#define EXPLAIN 468 6976+#define EXTERNAL 469 6977+#define EXTRACT 470 6978+#define FALSE_P 471 6979+#define FAMILY 472 6980+#define FETCH 473 6981+#define FIRST_P 474 6982+#define FLOAT_P 475 6983+#define FOLLOWING 476 6984+#define FOR 477 6985+#define FORCE 478 6986+#define FOREIGN 479 6987+#define FORWARD 480 6988+#define FREEZE 481 6989+#define FROM 482 6990+#define FULL 483 6991+#define FUNCTION 484 6992+#define FUNCTIONS 485 6993+#define GLOBAL 486 6994+#define GRANT 487 6995+#define GRANTED 488 6996+#define GREATEST 489 6997+#define GROUP_P 490 6998+#define HANDLER 491 6999+#define HAVING 492 7000+#define HEADER_P 493 7001+#define HOLD 494 7002+#define HOUR_P 495 7003+#define IDENTITY_P 496 7004+#define IF_P 497 7005+#define ILIKE 498 7006+#define IMMEDIATE 499 7007+#define IMMUTABLE 500 7008+#define IMPLICIT_P 501 7009+#define IN_P 502 7010+#define INCLUDING 503 7011+#define INCREMENT 504 7012+#define INDEX 505 7013+#define INDEXES 506 7014+#define INHERIT 507 7015+#define INHERITS 508 7016+#define INITIALLY 509 7017+#define INLINE_P 510 7018+#define INNER_P 511 7019+#define INOUT 512 7020+#define INPUT_P 513 7021+#define INSENSITIVE 514 7022+#define INSERT 515 7023+#define INSTEAD 516 7024+#define INT_P 517 7025+#define INTEGER 518 7026+#define INTERSECT 519 7027+#define INTERVAL 520 7028+#define INTO 521 7029+#define INVOKER 522 7030+#define IS 523 7031+#define ISNULL 524 7032+#define ISOLATION 525 7033+#define JOIN 526 7034+#define KEY 527 7035+#define LANGUAGE 528 7036+#define LARGE_P 529 7037+#define LAST_P 530 7038+#define LC_COLLATE_P 531 7039+#define LC_CTYPE_P 532 7040+#define LEADING 533 7041+#define LEAST 534 7042+#define LEFT 535 7043+#define LEVEL 536 7044+#define LIKE 537 7045+#define LIMIT 538 7046+#define LISTEN 539 7047+#define LOAD 540 7048+#define LOCAL 541 7049+#define LOCALTIME 542 7050+#define LOCALTIMESTAMP 543 7051+#define LOCATION 544 7052+#define LOCK_P 545 7053+#define LOGIN_P 546 7054+#define MAPPING 547 7055+#define MATCH 548 7056+#define MAXVALUE 549 7057+#define MINUTE_P 550 7058+#define MINVALUE 551 7059+#define MODE 552 7060+#define MONTH_P 553 7061+#define MOVE 554 7062+#define NAME_P 555 7063+#define NAMES 556 7064+#define NATIONAL 557 7065+#define NATURAL 558 7066+#define NCHAR 559 7067+#define NEXT 560 7068+#define NO 561 7069+#define NOCREATEDB 562 7070+#define NOCREATEROLE 563 7071+#define NOCREATEUSER 564 7072+#define NOINHERIT 565 7073+#define NOLOGIN_P 566 7074+#define NONE 567 7075+#define NOSUPERUSER 568 7076+#define NOT 569 7077+#define NOTHING 570 7078+#define NOTIFY 571 7079+#define NOTNULL 572 7080+#define NOWAIT 573 7081+#define NULL_P 574 7082+#define NULLIF 575 7083+#define NULLS_P 576 7084+#define NUMERIC 577 7085+#define OBJECT_P 578 7086+#define OF 579 7087+#define OFF 580 7088+#define OFFSET 581 7089+#define OIDS 582 7090+#define ON 583 7091+#define ONLY 584 7092+#define OPERATOR 585 7093+#define OPTION 586 7094+#define OPTIONS 587 7095+#define OR 588 7096+#define ORDER 589 7097+#define OUT_P 590 7098+#define OUTER_P 591 7099+#define OVER 592 7100+#define OVERLAPS 593 7101+#define OVERLAY 594 7102+#define OWNED 595 7103+#define OWNER 596 7104+#define PARSER 597 7105+#define PARTIAL 598 7106+#define PARTITION 599 7107+#define PASSWORD 600 7108+#define PLACING 601 7109+#define PLANS 602 7110+#define POSITION 603 7111+#define PRECEDING 604 7112+#define PRECISION 605 7113+#define PRESERVE 606 7114+#define PREPARE 607 7115+#define PREPARED 608 7116+#define PRIMARY 609 7117+#define PRIOR 610 7118+#define PRIVILEGES 611 7119+#define PROCEDURAL 612 7120+#define PROCEDURE 613 7121+#define QUOTE 614 7122+#define RANGE 615 7123+#define READ 616 7124+#define REAL 617 7125+#define REASSIGN 618 7126+#define RECHECK 619 7127+#define RECURSIVE 620 7128+#define REFERENCES 621 7129+#define REINDEX 622 7130+#define RELATIVE_P 623 7131+#define RELEASE 624 7132+#define RENAME 625 7133+#define REPEATABLE 626 7134+#define REPLACE 627 7135+#define REPLICA 628 7136+#define RESET 629 7137+#define RESTART 630 7138+#define RESTRICT 631 7139+#define RETURNING 632 7140+#define RETURNS 633 7141+#define REVOKE 634 7142+#define RIGHT 635 7143+#define ROLE 636 7144+#define ROLLBACK 637 7145+#define ROW 638 7146+#define ROWS 639 7147+#define RULE 640 7148+#define SAVEPOINT 641 7149+#define SCHEMA 642 7150+#define SCROLL 643 7151+#define SEARCH 644 7152+#define SECOND_P 645 7153+#define SECURITY 646 7154+#define SELECT 647 7155+#define SEQUENCE 648 7156+#define SEQUENCES 649 7157+#define SERIALIZABLE 650 7158+#define SERVER 651 7159+#define SESSION 652 7160+#define SESSION_USER 653 7161+#define SET 654 7162+#define SETOF 655 7163+#define SHARE 656 7164+#define SHOW 657 7165+#define SIMILAR 658 7166+#define SIMPLE 659 7167+#define SMALLINT 660 7168+#define SOME 661 7169+#define STABLE 662 7170+#define STANDALONE_P 663 7171+#define START 664 7172+#define STATEMENT 665 7173+#define STATISTICS 666 7174+#define STDIN 667 7175+#define STDOUT 668 7176+#define STORAGE 669 7177+#define STRICT_P 670 7178+#define STRIP_P 671 7179+#define SUBSTRING 672 7180+#define SUPERUSER_P 673 7181+#define SYMMETRIC 674 7182+#define SYSID 675 7183+#define SYSTEM_P 676 7184+#define TABLE 677 7185+#define TABLES 678 7186+#define TABLESPACE 679 7187+#define TEMP 680 7188+#define TEMPLATE 681 7189+#define TEMPORARY 682 7190+#define TEXT_P 683 7191+#define THEN 684 7192+#define TIME 685 7193+#define TIMESTAMP 686 7194+#define TO 687 7195+#define TRAILING 688 7196+#define TRANSACTION 689 7197+#define TREAT 690 7198+#define TRIGGER 691 7199+#define TRIM 692 7200+#define TRUE_P 693 7201+#define TRUNCATE 694 7202+#define TRUSTED 695 7203+#define TYPE_P 696 7204+#define UNBOUNDED 697 7205+#define UNCOMMITTED 698 7206+#define UNENCRYPTED 699 7207+#define UNION 700 7208+#define UNIQUE 701 7209+#define UNKNOWN 702 7210+#define UNLISTEN 703 7211+#define UNTIL 704 7212+#define UPDATE 705 7213+#define USER 706 7214+#define USING 707 7215+#define VACUUM 708 7216+#define VALID 709 7217+#define VALIDATOR 710 7218+#define VALUE_P 711 7219+#define VALUES 712 7220+#define VARCHAR 713 7221+#define VARIADIC 714 7222+#define VARYING 715 7223+#define VERBOSE 716 7224+#define VERSION_P 717 7225+#define VIEW 718 7226+#define VOLATILE 719 7227+#define WHEN 720 7228+#define WHERE 721 7229+#define WHITESPACE_P 722 7230+#define WINDOW 723 7231+#define WITH 724 7232+#define WITHOUT 725 7233+#define WORK 726 7234+#define WRAPPER 727 7235+#define WRITE 728 7236+#define XML_P 729 7237+#define XMLATTRIBUTES 730 7238+#define XMLCONCAT 731 7239+#define XMLELEMENT 732 7240+#define XMLFOREST 733 7241+#define XMLPARSE 734 7242+#define XMLPI 735 7243+#define XMLROOT 736 7244+#define XMLSERIALIZE 737 7245+#define YEAR_P 738 7246+#define YES_P 739 7247+#define ZONE 740 7248+#define NULLS_FIRST 741 7249+#define NULLS_LAST 742 7250+#define WITH_TIME 743 7251+#define POSTFIXOP 744 7252+#define UMINUS 745 7253 7254 7255 7256-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 7257-typedef union YYSTYPE 7258+ 7259+/* Copy the first part of user declarations. */ 7260+#line 5 "preproc.y" 7261+ 7262+#include "postgres_fe.h" 7263+ 7264+#include "extern.h" 7265+#include "ecpg_config.h" 7266+#include <unistd.h> 7267+ 7268+/* Location tracking support --- simpler than bison's default */ 7269+#define YYLLOC_DEFAULT(Current, Rhs, N) \ 7270+ do { \ 7271+ if (N) \ 7272+ (Current) = (Rhs)[1]; \ 7273+ else \ 7274+ (Current) = (Rhs)[0]; \ 7275+ } while (0) 7276+ 7277+/* 7278+ * The %name-prefix option below will make bison call base_yylex, but we 7279+ * really want it to call filtered_base_yylex (see parser.c). 7280+ */ 7281+#define base_yylex filtered_base_yylex 7282+ 7283+/* 7284+ * This is only here so the string gets into the POT. Bison uses it 7285+ * internally. 7286+ */ 7287+#define bison_gettext_dummy gettext_noop("syntax error") 7288+ 7289+/* 7290+ * Variables containing simple states. 7291+ */ 7292+int struct_level = 0; 7293+int braces_open; /* brace level counter */ 7294+char *current_function; 7295+int ecpg_internal_var = 0; 7296+char *connection = NULL; 7297+char *input_filename = NULL; 7298+ 7299+static int FoundInto = 0; 7300+static int initializer = 0; 7301+static int pacounter = 1; 7302+static char pacounter_buffer[sizeof(int) * CHAR_BIT * 10 / 3]; /* a rough guess at the size we need */ 7303+static struct this_type actual_type[STRUCT_DEPTH]; 7304+static char *actual_startline[STRUCT_DEPTH]; 7305+static int varchar_counter = 1; 7306+ 7307+/* temporarily store struct members while creating the data structure */ 7308+struct ECPGstruct_member *struct_member_list[STRUCT_DEPTH] = { NULL }; 7309+ 7310+/* also store struct type so we can do a sizeof() later */ 7311+static char *ECPGstruct_sizeof = NULL; 7312+ 7313+/* for forward declarations we have to store some data as well */ 7314+static char *forward_name = NULL; 7315+ 7316+struct ECPGtype ecpg_no_indicator = {ECPGt_NO_INDICATOR, NULL, NULL, NULL, {NULL}, 0}; 7317+struct variable no_indicator = {"no_indicator", &ecpg_no_indicator, 0, NULL}; 7318+ 7319+struct ECPGtype ecpg_query = {ECPGt_char_variable, NULL, NULL, NULL, {NULL}, 0}; 7320+ 7321+/* 7322+ * Handle parsing errors and warnings 7323+ */ 7324+void 7325+mmerror(int error_code, enum errortype type, const char *error, ...) 7326 { 7327+ va_list ap; 7328 7329-/* Line 214 of yacc.c */ 7330-#line 471 "preproc.y" 7331+ /* internationalize the error message string */ 7332+ error = _(error); 7333+ 7334+ fprintf(stderr, "%s:%d: ", input_filename, yylineno); 7335+ 7336+ switch(type) 7337+ { 7338+ case ET_WARNING: 7339+ fprintf(stderr, _("WARNING: ")); 7340+ break; 7341+ case ET_ERROR: 7342+ case ET_FATAL: 7343+ fprintf(stderr, _("ERROR: ")); 7344+ break; 7345+ } 7346+ 7347+ va_start(ap, error); 7348+ vfprintf(stderr, error, ap); 7349+ va_end(ap); 7350+ 7351+ fprintf(stderr, "\n"); 7352+ 7353+ switch(type) 7354+ { 7355+ case ET_WARNING: 7356+ break; 7357+ case ET_ERROR: 7358+ ret_value = error_code; 7359+ break; 7360+ case ET_FATAL: 7361+ if (yyin) 7362+ fclose(yyin); 7363+ if (yyout) 7364+ fclose(yyout); 7365+ 7366+ if (strcmp(output_filename, "-") != 0 && unlink(output_filename) != 0) 7367+ fprintf(stderr, _("could not remove output file \"%s\"\n"), output_filename); 7368+ exit(error_code); 7369+ } 7370+} 7371+ 7372+/* 7373+ * string concatenation 7374+ */ 7375+ 7376+static char * 7377+cat2_str(char *str1, char *str2) 7378+{ 7379+ char * res_str = (char *)mm_alloc(strlen(str1) + strlen(str2) + 2); 7380+ 7381+ strcpy(res_str, str1); 7382+ if (strlen(str1) != 0 && strlen(str2) != 0) 7383+ strcat(res_str, " "); 7384+ strcat(res_str, str2); 7385+ free(str1); 7386+ free(str2); 7387+ return(res_str); 7388+} 7389+ 7390+static char * 7391+cat_str(int count, ...) 7392+{ 7393+ va_list args; 7394+ int i; 7395+ char *res_str; 7396+ 7397+ va_start(args, count); 7398+ 7399+ res_str = va_arg(args, char *); 7400+ 7401+ /* now add all other strings */ 7402+ for (i = 1; i < count; i++) 7403+ res_str = cat2_str(res_str, va_arg(args, char *)); 7404+ 7405+ va_end(args); 7406+ 7407+ return(res_str); 7408+} 7409+ 7410+char * 7411+make_str(const char *str) 7412+{ 7413+ char * res_str = (char *)mm_alloc(strlen(str) + 1); 7414+ 7415+ strcpy(res_str, str); 7416+ return res_str; 7417+} 7418+ 7419+static char * 7420+make2_str(char *str1, char *str2) 7421+{ 7422+ char * res_str = (char *)mm_alloc(strlen(str1) + strlen(str2) + 1); 7423+ 7424+ strcpy(res_str, str1); 7425+ strcat(res_str, str2); 7426+ free(str1); 7427+ free(str2); 7428+ return(res_str); 7429+} 7430+ 7431+static char * 7432+make3_str(char *str1, char *str2, char *str3) 7433+{ 7434+ char * res_str = (char *)mm_alloc(strlen(str1) + strlen(str2) +strlen(str3) + 1); 7435+ 7436+ strcpy(res_str, str1); 7437+ strcat(res_str, str2); 7438+ strcat(res_str, str3); 7439+ free(str1); 7440+ free(str2); 7441+ free(str3); 7442+ return(res_str); 7443+} 7444+ 7445+/* and the rest */ 7446+static char * 7447+make_name(void) 7448+{ 7449+ return mm_strdup(yytext); 7450+} 7451+ 7452+static char * 7453+create_questionmarks(char *name, bool array) 7454+{ 7455+ struct variable *p = find_variable(name); 7456+ int count; 7457+ char *result = EMPTY; 7458+ 7459+ /* In case we have a struct, we have to print as many "?" as there are attributes in the struct 7460+ * An array is only allowed together with an element argument 7461+ * This is essantially only used for inserts, but using a struct as input parameter is an error anywhere else 7462+ * so we don't have to worry here. */ 7463+ 7464+ if (p->type->type == ECPGt_struct || (array && p->type->type == ECPGt_array && p->type->u.element->type == ECPGt_struct)) 7465+ { 7466+ struct ECPGstruct_member *m; 7467+ 7468+ if (p->type->type == ECPGt_struct) 7469+ m = p->type->u.members; 7470+ else 7471+ m = p->type->u.element->u.members; 7472+ 7473+ for (count = 0; m != NULL; m=m->next, count++); 7474+ } 7475+ else 7476+ count = 1; 7477+ 7478+ for (; count > 0; count --) 7479+ { 7480+ sprintf(pacounter_buffer, "$%d", pacounter++); 7481+ result = cat_str(3, result, mm_strdup(pacounter_buffer), make_str(" , ")); 7482+ } 7483+ 7484+ /* removed the trailing " ," */ 7485+ 7486+ result[strlen(result)-3] = '\0'; 7487+ return(result); 7488+} 7489+ 7490+static char * 7491+adjust_outofscope_cursor_vars(struct cursor *cur) 7492+{ 7493+ /* Informix accepts DECLARE with variables that are out of scope when OPEN is called. 7494+ * For instance you can DECLARE a cursor in one function, and OPEN/FETCH/CLOSE 7495+ * it in other functions. This is very useful for e.g. event-driver programming, 7496+ * but may also lead to dangerous programming. The limitation when this is allowed 7497+ * and doesn's cause problems have to be documented, like the allocated variables 7498+ * must not be realloc()'ed. 7499+ * 7500+ * We have to change the variables to our own struct and just store the pointer 7501+ * instead of the variable. Do it only for local variables, not for globals. 7502+ */ 7503+ 7504+ char *result = make_str(""); 7505+ int insert; 7506+ 7507+ for (insert = 1; insert >= 0; insert--) 7508+ { 7509+ struct arguments *list; 7510+ struct arguments *ptr; 7511+ struct arguments *newlist = NULL; 7512+ struct variable *newvar, *newind; 7513+ 7514+ list = (insert ? cur->argsinsert : cur->argsresult); 7515+ 7516+ for (ptr = list; ptr != NULL; ptr = ptr->next) 7517+ { 7518+ char temp[20]; 7519+ char *original_var; 7520+ bool skip_set_var = false; 7521+ 7522+ /* change variable name to "ECPGget_var(<counter>)" */ 7523+ original_var = ptr->variable->name; 7524+ sprintf(temp, "%d))", ecpg_internal_var); 7525+ 7526+ /* Don't emit ECPGset_var() calls for global variables */ 7527+ if (ptr->variable->brace_level == 0) 7528+ { 7529+ newvar = ptr->variable; 7530+ skip_set_var = true; 7531+ } 7532+ else if ((ptr->variable->type->type == ECPGt_char_variable) && (!strncmp(ptr->variable->name, "ECPGprepared_statement", strlen("ECPGprepared_statement")))) 7533+ { 7534+ newvar = ptr->variable; 7535+ skip_set_var = true; 7536+ } 7537+ else if ((ptr->variable->type->type != ECPGt_varchar && ptr->variable->type->type != ECPGt_char && ptr->variable->type->type != ECPGt_unsigned_char && ptr->variable->type->type != ECPGt_string) && atoi(ptr->variable->type->size) > 1) 7538+ { 7539+ newvar = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->variable->type->u.element->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_array_type(ECPGmake_simple_type(ptr->variable->type->u.element->type, make_str("1"), ptr->variable->type->u.element->counter), ptr->variable->type->size), 0); 7540+ sprintf(temp, "%d, (", ecpg_internal_var++); 7541+ } 7542+ else if ((ptr->variable->type->type == ECPGt_varchar || ptr->variable->type->type == ECPGt_char || ptr->variable->type->type == ECPGt_unsigned_char || ptr->variable->type->type == ECPGt_string) && atoi(ptr->variable->type->size) > 1) 7543+ { 7544+ newvar = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->variable->type->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->variable->type->type, ptr->variable->type->size, ptr->variable->type->counter), 0); 7545+ if (ptr->variable->type->type == ECPGt_varchar) 7546+ sprintf(temp, "%d, &(", ecpg_internal_var++); 7547+ else 7548+ sprintf(temp, "%d, (", ecpg_internal_var++); 7549+ } 7550+ else if (ptr->variable->type->type == ECPGt_struct || ptr->variable->type->type == ECPGt_union) 7551+ { 7552+ sprintf(temp, "%d)))", ecpg_internal_var); 7553+ newvar = new_variable(cat_str(4, make_str("(*("), mm_strdup(ptr->variable->type->type_name), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_struct_type(ptr->variable->type->u.members, ptr->variable->type->type, ptr->variable->type->type_name, ptr->variable->type->struct_sizeof), 0); 7554+ sprintf(temp, "%d, &(", ecpg_internal_var++); 7555+ } 7556+ else if (ptr->variable->type->type == ECPGt_array) 7557+ { 7558+ if (ptr->variable->type->u.element->type == ECPGt_struct || ptr->variable->type->u.element->type == ECPGt_union) 7559+ { 7560+ sprintf(temp, "%d)))", ecpg_internal_var); 7561+ newvar = new_variable(cat_str(4, make_str("(*("), mm_strdup(ptr->variable->type->u.element->type_name), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_struct_type(ptr->variable->type->u.element->u.members, ptr->variable->type->u.element->type, ptr->variable->type->u.element->type_name, ptr->variable->type->u.element->struct_sizeof), 0); 7562+ sprintf(temp, "%d, (", ecpg_internal_var++); 7563+ } 7564+ else 7565+ { 7566+ newvar = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->variable->type->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_array_type(ECPGmake_simple_type(ptr->variable->type->u.element->type, ptr->variable->type->u.element->size, ptr->variable->type->u.element->counter), ptr->variable->type->size), 0); 7567+ sprintf(temp, "%d, &(", ecpg_internal_var++); 7568+ } 7569+ } 7570+ else 7571+ { 7572+ newvar = new_variable(cat_str(4, make_str("*("), mm_strdup(ecpg_type_name(ptr->variable->type->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->variable->type->type, ptr->variable->type->size, ptr->variable->type->counter), 0); 7573+ sprintf(temp, "%d, &(", ecpg_internal_var++); 7574+ } 7575+ 7576+ /* create call to "ECPGset_var(<counter>, <pointer>. <line number>)" */ 7577+ if (!skip_set_var) 7578+ result = cat_str(5, result, make_str("ECPGset_var("), mm_strdup(temp), mm_strdup(original_var), make_str("), __LINE__);\n")); 7579+ 7580+ /* now the indicator if there is one and it's not a global variable */ 7581+ if ((ptr->indicator->type->type == ECPGt_NO_INDICATOR) || (ptr->indicator->brace_level == 0)) 7582+ { 7583+ newind = ptr->indicator; 7584+ } 7585+ else 7586+ { 7587+ /* change variable name to "ECPGget_var(<counter>)" */ 7588+ original_var = ptr->indicator->name; 7589+ sprintf(temp, "%d))", ecpg_internal_var); 7590+ 7591+ if (ptr->indicator->type->type == ECPGt_struct || ptr->indicator->type->type == ECPGt_union) 7592+ { 7593+ sprintf(temp, "%d)))", ecpg_internal_var); 7594+ newind = new_variable(cat_str(4, make_str("(*("), mm_strdup(ptr->indicator->type->type_name), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_struct_type(ptr->indicator->type->u.members, ptr->indicator->type->type, ptr->indicator->type->type_name, ptr->indicator->type->struct_sizeof), 0); 7595+ sprintf(temp, "%d, &(", ecpg_internal_var++); 7596+ } 7597+ else if (ptr->indicator->type->type == ECPGt_array) 7598+ { 7599+ if (ptr->indicator->type->u.element->type == ECPGt_struct || ptr->indicator->type->u.element->type == ECPGt_union) 7600+ { 7601+ sprintf(temp, "%d)))", ecpg_internal_var); 7602+ newind = new_variable(cat_str(4, make_str("(*("), mm_strdup(ptr->indicator->type->u.element->type_name), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_struct_type(ptr->indicator->type->u.element->u.members, ptr->indicator->type->u.element->type, ptr->indicator->type->u.element->type_name, ptr->indicator->type->u.element->struct_sizeof), 0); 7603+ sprintf(temp, "%d, (", ecpg_internal_var++); 7604+ } 7605+ else 7606+ { 7607+ newind = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->indicator->type->u.element->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_array_type(ECPGmake_simple_type(ptr->indicator->type->u.element->type, ptr->indicator->type->u.element->size, ptr->indicator->type->u.element->counter), ptr->indicator->type->size), 0); 7608+ sprintf(temp, "%d, &(", ecpg_internal_var++); 7609+ } 7610+ } 7611+ else if (atoi(ptr->indicator->type->size) > 1) 7612+ { 7613+ newind = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->indicator->type->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->indicator->type->type, ptr->indicator->type->size, ptr->variable->type->counter), 0); 7614+ sprintf(temp, "%d, (", ecpg_internal_var++); 7615+ } 7616+ else 7617+ { 7618+ newind = new_variable(cat_str(4, make_str("*("), mm_strdup(ecpg_type_name(ptr->indicator->type->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->indicator->type->type, ptr->indicator->type->size, ptr->variable->type->counter), 0); 7619+ sprintf(temp, "%d, &(", ecpg_internal_var++); 7620+ } 7621+ 7622+ /* create call to "ECPGset_var(<counter>, <pointer>. <line number>)" */ 7623+ result = cat_str(5, result, make_str("ECPGset_var("), mm_strdup(temp), mm_strdup(original_var), make_str("), __LINE__);\n")); 7624+ } 7625+ 7626+ add_variable_to_tail(&newlist, newvar, newind); 7627+ } 7628+ 7629+ if (insert) 7630+ cur->argsinsert_oos = newlist; 7631+ else 7632+ cur->argsresult_oos = newlist; 7633+ } 7634+ 7635+ return result; 7636+} 7637+ 7638+/* This tests whether the cursor was declared and opened in the same function. */ 7639+#define SAMEFUNC(cur) \ 7640+ ((cur->function == NULL) || \ 7641+ (cur->function != NULL && !strcmp(cur->function, current_function))) 7642+ 7643+static struct cursor * 7644+add_additional_variables(char *name, bool insert) 7645+{ 7646+ struct cursor *ptr; 7647+ struct arguments *p; 7648 7649+ for (ptr = cur; ptr != NULL; ptr=ptr->next) 7650+ { 7651+ if (strcmp(ptr->name, name) == 0) 7652+ break; 7653+ } 7654+ 7655+ if (ptr == NULL) 7656+ { 7657+ mmerror(PARSE_ERROR, ET_ERROR, "cursor \"%s\" does not exist", name); 7658+ return NULL; 7659+ } 7660+ 7661+ if (insert) 7662+ { 7663+ /* add all those input variables that were given earlier 7664+ * note that we have to append here but have to keep the existing order */ 7665+ for (p = (SAMEFUNC(ptr) ? ptr->argsinsert : ptr->argsinsert_oos); p; p = p->next) 7666+ add_variable_to_tail(&argsinsert, p->variable, p->indicator); 7667+ } 7668+ 7669+ /* add all those output variables that were given earlier */ 7670+ for (p = (SAMEFUNC(ptr) ? ptr->argsresult : ptr->argsresult_oos); p; p = p->next) 7671+ add_variable_to_tail(&argsresult, p->variable, p->indicator); 7672+ 7673+ return ptr; 7674+} 7675+ 7676+static void 7677+add_typedef(char *name, char * dimension, char * length, enum ECPGttype type_enum, char *type_dimension, char *type_index, int initializer, int array) 7678+{ 7679+ /* add entry to list */ 7680+ struct typedefs *ptr, *this; 7681+ 7682+ if ((type_enum == ECPGt_struct || 7683+ type_enum == ECPGt_union) && 7684+ initializer == 1) 7685+ mmerror(PARSE_ERROR, ET_ERROR, "initializer not allowed in type definition"); 7686+ else if (INFORMIX_MODE && strcmp(name, "string") == 0) 7687+ mmerror(PARSE_ERROR, ET_ERROR, "type name \"string\" is reserved in Informix mode"); 7688+ else 7689+ { 7690+ for (ptr = types; ptr != NULL; ptr = ptr->next) 7691+ { 7692+ if (strcmp(name, ptr->name) == 0) 7693+ /* re-definition is a bug */ 7694+ mmerror(PARSE_ERROR, ET_ERROR, "type \"%s\" is already defined", name); 7695+ } 7696+ adjust_array(type_enum, &dimension, &length, type_dimension, type_index, array, true); 7697+ 7698+ this = (struct typedefs *) mm_alloc(sizeof(struct typedefs)); 7699+ 7700+ /* initial definition */ 7701+ this->next = types; 7702+ this->name = name; 7703+ this->brace_level = braces_open; 7704+ this->type = (struct this_type *) mm_alloc(sizeof(struct this_type)); 7705+ this->type->type_enum = type_enum; 7706+ this->type->type_str = mm_strdup(name); 7707+ this->type->type_dimension = dimension; /* dimension of array */ 7708+ this->type->type_index = length; /* length of string */ 7709+ this->type->type_sizeof = ECPGstruct_sizeof; 7710+ this->struct_member_list = (type_enum == ECPGt_struct || type_enum == ECPGt_union) ? 7711+ ECPGstruct_member_dup(struct_member_list[struct_level]) : NULL; 7712+ 7713+ if (type_enum != ECPGt_varchar && 7714+ type_enum != ECPGt_char && 7715+ type_enum != ECPGt_unsigned_char && 7716+ type_enum != ECPGt_string && 7717+ atoi(this->type->type_index) >= 0) 7718+ mmerror(PARSE_ERROR, ET_ERROR, "multidimensional arrays for simple data types are not supported"); 7719+ 7720+ types = this; 7721+ } 7722+} 7723+ 7724+ 7725+/* Enabling traces. */ 7726+#ifndef YYDEBUG 7727+# define YYDEBUG 0 7728+#endif 7729+ 7730+/* Enabling verbose error messages. */ 7731+#ifdef YYERROR_VERBOSE 7732+# undef YYERROR_VERBOSE 7733+# define YYERROR_VERBOSE 1 7734+#else 7735+# define YYERROR_VERBOSE 0 7736+#endif 7737+ 7738+/* Enabling the token table. */ 7739+#ifndef YYTOKEN_TABLE 7740+# define YYTOKEN_TABLE 0 7741+#endif 7742+ 7743+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 7744+typedef union YYSTYPE 7745+#line 471 "preproc.y" 7746+{ 7747 double dval; 7748 char *str; 7749 int ival; 7750@@ -1079,15 +1555,13 @@ 7751 struct fetch_desc descriptor; 7752 struct su_symbol struct_union; 7753 struct prep prep; 7754- 7755- 7756- 7757-/* Line 214 of yacc.c */ 7758-#line 1087 "preproc.c" 7759-} YYSTYPE; 7760-# define YYSTYPE_IS_TRIVIAL 1 7761+} 7762+/* Line 193 of yacc.c. */ 7763+#line 1561 "preproc" 7764+ YYSTYPE; 7765 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 7766 # define YYSTYPE_IS_DECLARED 1 7767+# define YYSTYPE_IS_TRIVIAL 1 7768 #endif 7769 7770 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED 7771@@ -1107,8 +1581,8 @@ 7772 /* Copy the second part of user declarations. */ 7773 7774 7775-/* Line 264 of yacc.c */ 7776-#line 1112 "preproc.c" 7777+/* Line 216 of yacc.c. */ 7778+#line 1586 "preproc" 7779 7780 #ifdef short 7781 # undef short 7782@@ -1158,7 +1632,7 @@ 7783 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 7784 7785 #ifndef YY_ 7786-# if YYENABLE_NLS 7787+# if defined YYENABLE_NLS && YYENABLE_NLS 7788 # if ENABLE_NLS 7789 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 7790 # define YY_(msgid) dgettext ("bison-runtime", msgid) 7791@@ -1183,14 +1657,14 @@ 7792 #if (defined __STDC__ || defined __C99__FUNC__ \ 7793 || defined __cplusplus || defined _MSC_VER) 7794 static int 7795-YYID (int yyi) 7796+YYID (int i) 7797 #else 7798 static int 7799-YYID (yyi) 7800- int yyi; 7801+YYID (i) 7802+ int i; 7803 #endif 7804 { 7805- return yyi; 7806+ return i; 7807 } 7808 #endif 7809 7810@@ -1272,9 +1746,9 @@ 7811 /* A type that is properly aligned for any stack member. */ 7812 union yyalloc 7813 { 7814- yytype_int16 yyss_alloc; 7815- YYSTYPE yyvs_alloc; 7816- YYLTYPE yyls_alloc; 7817+ yytype_int16 yyss; 7818+ YYSTYPE yyvs; 7819+ YYLTYPE yyls; 7820 }; 7821 7822 /* The size of the maximum gap between one aligned stack and the next. */ 7823@@ -1309,12 +1783,12 @@ 7824 elements in the stack, and YYPTR gives the new location of the 7825 stack. Advance YYPTR to a properly aligned location for the next 7826 stack. */ 7827-# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 7828+# define YYSTACK_RELOCATE(Stack) \ 7829 do \ 7830 { \ 7831 YYSIZE_T yynewbytes; \ 7832- YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 7833- Stack = &yyptr->Stack_alloc; \ 7834+ YYCOPY (&yyptr->Stack, Stack, yysize); \ 7835+ Stack = &yyptr->Stack; \ 7836 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 7837 yyptr += yynewbytes / sizeof (*yyptr); \ 7838 } \ 7839@@ -3001,24 +3475,23 @@ 7840 "attr_name", "index_name", "file_name", "func_name", "AexprConst", 7841 "Iconst", "RoleId", "SignedIconst", "unreserved_keyword", 7842 "col_name_keyword", "type_func_name_keyword", "reserved_keyword", 7843- "statements", "statement", "CreateAsStmt", "$@1", "at", "ECPGConnect", 7844+ "statements", "statement", "CreateAsStmt", "@1", "at", "ECPGConnect", 7845 "connection_target", "opt_database_name", "db_prefix", "server", 7846 "opt_server", "server_name", "opt_port", "opt_connection_name", 7847 "opt_user", "ora_user", "user_name", "char_variable", "opt_options", 7848 "connect_options", "opt_opt_value", "prepared_name", "ECPGCursorStmt", 7849 "ECPGExecuteImmediateStmt", "ECPGVarDeclaration", 7850 "single_vt_declaration", "precision", "opt_scale", "ecpg_interval", 7851- "ECPGDeclaration", "$@2", "sql_startdeclare", "sql_enddeclare", 7852+ "ECPGDeclaration", "@2", "sql_startdeclare", "sql_enddeclare", 7853 "var_type_declarations", "vt_declarations", "variable_declarations", 7854- "type_declaration", "$@3", "var_declaration", "$@4", "$@5", 7855- "opt_bit_field", "storage_declaration", "storage_clause", 7856- "storage_modifier", "var_type", "enum_type", "enum_definition", 7857- "struct_union_type_with_symbol", "$@6", "struct_union_type", "$@7", 7858- "s_struct_union_symbol", "s_struct_union", "simple_type", 7859- "unsigned_type", "signed_type", "opt_signed", "variable_list", 7860- "variable", "opt_initializer", "opt_pointer", "ECPGDeclare", 7861- "ECPGDisconnect", "dis_name", "connection_object", "execstring", 7862- "ECPGFree", "ECPGOpen", "opt_ecpg_using", "ecpg_using", 7863+ "type_declaration", "@3", "var_declaration", "@4", "@5", "opt_bit_field", 7864+ "storage_declaration", "storage_clause", "storage_modifier", "var_type", 7865+ "enum_type", "enum_definition", "struct_union_type_with_symbol", "@6", 7866+ "struct_union_type", "@7", "s_struct_union_symbol", "s_struct_union", 7867+ "simple_type", "unsigned_type", "signed_type", "opt_signed", 7868+ "variable_list", "variable", "opt_initializer", "opt_pointer", 7869+ "ECPGDeclare", "ECPGDisconnect", "dis_name", "connection_object", 7870+ "execstring", "ECPGFree", "ECPGOpen", "opt_ecpg_using", "ecpg_using", 7871 "using_descriptor", "into_descriptor", "into_sqlda", "using_list", 7872 "UsingValue", "UsingConst", "ECPGDescribe", "opt_output", 7873 "ECPGAllocateDescr", "ECPGDeallocateDescr", "ECPGGetDescriptorHeader", 7874@@ -3028,8 +3501,8 @@ 7875 "ECPGGetDescriptor", "ECPGGetDescItems", "ECPGGetDescItem", 7876 "ECPGSetDescriptor", "ECPGSetDescItems", "ECPGSetDescItem", 7877 "AllConstVar", "descriptor_item", "ECPGSetAutocommit", "on_off", 7878- "ECPGSetConnection", "ECPGTypedef", "$@8", "opt_reference", "ECPGVar", 7879- "$@9", "ECPGWhenever", "action", "ECPGKeywords", "ECPGKeywords_vanames", 7880+ "ECPGSetConnection", "ECPGTypedef", "@8", "opt_reference", "ECPGVar", 7881+ "@9", "ECPGWhenever", "action", "ECPGKeywords", "ECPGKeywords_vanames", 7882 "ECPGKeywords_rest", "ECPGTypeName", "symbol", "ECPGColId", "ColId", 7883 "type_function_name", "ColLabel", "ECPGColLabel", "ECPGColLabelCommon", 7884 "ECPGCKeywords", "all_unreserved_keyword", "ECPGunreserved_interval", 7885@@ -24198,7 +24671,7 @@ 7886 we won't break user code: when these are the locations we know. */ 7887 7888 #ifndef YY_LOCATION_PRINT 7889-# if YYLTYPE_IS_TRIVIAL 7890+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 7891 # define YY_LOCATION_PRINT(File, Loc) \ 7892 fprintf (File, "%d.%d-%d.%d", \ 7893 (Loc).first_line, (Loc).first_column, \ 7894@@ -24314,20 +24787,17 @@ 7895 #if (defined __STDC__ || defined __C99__FUNC__ \ 7896 || defined __cplusplus || defined _MSC_VER) 7897 static void 7898-yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 7899+yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) 7900 #else 7901 static void 7902-yy_stack_print (yybottom, yytop) 7903- yytype_int16 *yybottom; 7904- yytype_int16 *yytop; 7905+yy_stack_print (bottom, top) 7906+ yytype_int16 *bottom; 7907+ yytype_int16 *top; 7908 #endif 7909 { 7910 YYFPRINTF (stderr, "Stack now"); 7911- for (; yybottom <= yytop; yybottom++) 7912- { 7913- int yybot = *yybottom; 7914- YYFPRINTF (stderr, " %d", yybot); 7915- } 7916+ for (; bottom <= top; ++bottom) 7917+ YYFPRINTF (stderr, " %d", *bottom); 7918 YYFPRINTF (stderr, "\n"); 7919 } 7920 7921@@ -24362,11 +24832,11 @@ 7922 /* The symbols being reduced. */ 7923 for (yyi = 0; yyi < yynrhs; yyi++) 7924 { 7925- YYFPRINTF (stderr, " $%d = ", yyi + 1); 7926+ fprintf (stderr, " $%d = ", yyi + 1); 7927 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 7928 &(yyvsp[(yyi + 1) - (yynrhs)]) 7929 , &(yylsp[(yyi + 1) - (yynrhs)]) ); 7930- YYFPRINTF (stderr, "\n"); 7931+ fprintf (stderr, "\n"); 7932 } 7933 } 7934 7935@@ -24648,8 +25118,10 @@ 7936 break; 7937 } 7938 } 7939+ 7940 7941 /* Prevent warnings from -Wmissing-prototypes. */ 7942+ 7943 #ifdef YYPARSE_PARAM 7944 #if defined __STDC__ || defined __cplusplus 7945 int yyparse (void *YYPARSE_PARAM); 7946@@ -24665,23 +25137,23 @@ 7947 #endif /* ! YYPARSE_PARAM */ 7948 7949 7950-/* The lookahead symbol. */ 7951+ 7952+/* The look-ahead symbol. */ 7953 int yychar; 7954 7955-/* The semantic value of the lookahead symbol. */ 7956+/* The semantic value of the look-ahead symbol. */ 7957 YYSTYPE yylval; 7958 7959-/* Location data for the lookahead symbol. */ 7960-YYLTYPE yylloc; 7961- 7962 /* Number of syntax errors so far. */ 7963 int yynerrs; 7964+/* Location data for the look-ahead symbol. */ 7965+YYLTYPE yylloc; 7966 7967 7968 7969-/*-------------------------. 7970-| yyparse or yypush_parse. | 7971-`-------------------------*/ 7972+/*----------. 7973+| yyparse. | 7974+`----------*/ 7975 7976 #ifdef YYPARSE_PARAM 7977 #if (defined __STDC__ || defined __C99__FUNC__ \ 7978@@ -24705,49 +25177,14 @@ 7979 #endif 7980 #endif 7981 { 7982- 7983- 7984- int yystate; 7985- /* Number of tokens to shift before error messages enabled. */ 7986- int yyerrstatus; 7987- 7988- /* The stacks and their tools: 7989- `yyss': related to states. 7990- `yyvs': related to semantic values. 7991- `yyls': related to locations. 7992- 7993- Refer to the stacks thru separate pointers, to allow yyoverflow 7994- to reallocate them elsewhere. */ 7995- 7996- /* The state stack. */ 7997- yytype_int16 yyssa[YYINITDEPTH]; 7998- yytype_int16 *yyss; 7999- yytype_int16 *yyssp; 8000- 8001- /* The semantic value stack. */ 8002- YYSTYPE yyvsa[YYINITDEPTH]; 8003- YYSTYPE *yyvs; 8004- YYSTYPE *yyvsp; 8005- 8006- /* The location stack. */ 8007- YYLTYPE yylsa[YYINITDEPTH]; 8008- YYLTYPE *yyls; 8009- YYLTYPE *yylsp; 8010- 8011- /* The locations where the error started and ended. */ 8012- YYLTYPE yyerror_range[2]; 8013- 8014- YYSIZE_T yystacksize; 8015- 8016+ 8017+ int yystate; 8018 int yyn; 8019 int yyresult; 8020- /* Lookahead token as an internal (translated) token number. */ 8021- int yytoken; 8022- /* The variables used to return semantic value and location from the 8023- action routines. */ 8024- YYSTYPE yyval; 8025- YYLTYPE yyloc; 8026- 8027+ /* Number of tokens to shift before error messages enabled. */ 8028+ int yyerrstatus; 8029+ /* Look-ahead token as an internal (translated) token number. */ 8030+ int yytoken = 0; 8031 #if YYERROR_VERBOSE 8032 /* Buffer for error messages, and its allocated size. */ 8033 char yymsgbuf[128]; 8034@@ -24755,37 +25192,63 @@ 8035 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 8036 #endif 8037 8038+ /* Three stacks and their tools: 8039+ `yyss': related to states, 8040+ `yyvs': related to semantic values, 8041+ `yyls': related to locations. 8042+ 8043+ Refer to the stacks thru separate pointers, to allow yyoverflow 8044+ to reallocate them elsewhere. */ 8045+ 8046+ /* The state stack. */ 8047+ yytype_int16 yyssa[YYINITDEPTH]; 8048+ yytype_int16 *yyss = yyssa; 8049+ yytype_int16 *yyssp; 8050+ 8051+ /* The semantic value stack. */ 8052+ YYSTYPE yyvsa[YYINITDEPTH]; 8053+ YYSTYPE *yyvs = yyvsa; 8054+ YYSTYPE *yyvsp; 8055+ 8056+ /* The location stack. */ 8057+ YYLTYPE yylsa[YYINITDEPTH]; 8058+ YYLTYPE *yyls = yylsa; 8059+ YYLTYPE *yylsp; 8060+ /* The locations where the error started and ended. */ 8061+ YYLTYPE yyerror_range[2]; 8062+ 8063 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) 8064 8065+ YYSIZE_T yystacksize = YYINITDEPTH; 8066+ 8067+ /* The variables used to return semantic value and location from the 8068+ action routines. */ 8069+ YYSTYPE yyval; 8070+ YYLTYPE yyloc; 8071+ 8072 /* The number of symbols on the RHS of the reduced rule. 8073 Keep to zero when no symbol should be popped. */ 8074 int yylen = 0; 8075 8076- yytoken = 0; 8077- yyss = yyssa; 8078- yyvs = yyvsa; 8079- yyls = yylsa; 8080- yystacksize = YYINITDEPTH; 8081- 8082 YYDPRINTF ((stderr, "Starting parse\n")); 8083 8084 yystate = 0; 8085 yyerrstatus = 0; 8086 yynerrs = 0; 8087- yychar = YYEMPTY; /* Cause a token to be read. */ 8088+ yychar = YYEMPTY; /* Cause a token to be read. */ 8089 8090 /* Initialize stack pointers. 8091 Waste one element of value and location stack 8092 so that they stay on the same level as the state stack. 8093 The wasted elements are never initialized. */ 8094+ 8095 yyssp = yyss; 8096 yyvsp = yyvs; 8097 yylsp = yyls; 8098- 8099-#if YYLTYPE_IS_TRIVIAL 8100+#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 8101 /* Initialize the default location before parsing starts. */ 8102 yylloc.first_line = yylloc.last_line = 1; 8103- yylloc.first_column = yylloc.last_column = 1; 8104+ yylloc.first_column = yylloc.last_column = 0; 8105 #endif 8106 8107 goto yysetstate; 8108@@ -24824,7 +25287,6 @@ 8109 &yyvs1, yysize * sizeof (*yyvsp), 8110 &yyls1, yysize * sizeof (*yylsp), 8111 &yystacksize); 8112- 8113 yyls = yyls1; 8114 yyss = yyss1; 8115 yyvs = yyvs1; 8116@@ -24846,9 +25308,9 @@ 8117 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 8118 if (! yyptr) 8119 goto yyexhaustedlab; 8120- YYSTACK_RELOCATE (yyss_alloc, yyss); 8121- YYSTACK_RELOCATE (yyvs_alloc, yyvs); 8122- YYSTACK_RELOCATE (yyls_alloc, yyls); 8123+ YYSTACK_RELOCATE (yyss); 8124+ YYSTACK_RELOCATE (yyvs); 8125+ YYSTACK_RELOCATE (yyls); 8126 # undef YYSTACK_RELOCATE 8127 if (yyss1 != yyssa) 8128 YYSTACK_FREE (yyss1); 8129@@ -24869,9 +25331,6 @@ 8130 8131 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 8132 8133- if (yystate == YYFINAL) 8134- YYACCEPT; 8135- 8136 goto yybackup; 8137 8138 /*-----------. 8139@@ -24880,16 +25339,16 @@ 8140 yybackup: 8141 8142 /* Do appropriate processing given the current state. Read a 8143- lookahead token if we need one and don't already have one. */ 8144+ look-ahead token if we need one and don't already have one. */ 8145 8146- /* First try to decide what to do without reference to lookahead token. */ 8147+ /* First try to decide what to do without reference to look-ahead token. */ 8148 yyn = yypact[yystate]; 8149 if (yyn == YYPACT_NINF) 8150 goto yydefault; 8151 8152- /* Not known => get a lookahead token if don't already have one. */ 8153+ /* Not known => get a look-ahead token if don't already have one. */ 8154 8155- /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 8156+ /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 8157 if (yychar == YYEMPTY) 8158 { 8159 YYDPRINTF ((stderr, "Reading a token: ")); 8160@@ -24921,16 +25380,20 @@ 8161 goto yyreduce; 8162 } 8163 8164+ if (yyn == YYFINAL) 8165+ YYACCEPT; 8166+ 8167 /* Count tokens shifted since error; after three, turn off error 8168 status. */ 8169 if (yyerrstatus) 8170 yyerrstatus--; 8171 8172- /* Shift the lookahead token. */ 8173+ /* Shift the look-ahead token. */ 8174 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 8175 8176- /* Discard the shifted token. */ 8177- yychar = YYEMPTY; 8178+ /* Discard the shifted token unless it is eof. */ 8179+ if (yychar != YYEOF) 8180+ yychar = YYEMPTY; 8181 8182 yystate = yyn; 8183 *++yyvsp = yylval; 8184@@ -24971,155 +25434,111 @@ 8185 switch (yyn) 8186 { 8187 case 3: 8188- 8189-/* Line 1455 of yacc.c */ 8190 #line 1344 "preproc.y" 8191 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8192 break; 8193 8194 case 4: 8195- 8196-/* Line 1455 of yacc.c */ 8197 #line 1346 "preproc.y" 8198 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8199 break; 8200 8201 case 5: 8202- 8203-/* Line 1455 of yacc.c */ 8204 #line 1348 "preproc.y" 8205 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8206 break; 8207 8208 case 6: 8209- 8210-/* Line 1455 of yacc.c */ 8211 #line 1350 "preproc.y" 8212 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8213 break; 8214 8215 case 7: 8216- 8217-/* Line 1455 of yacc.c */ 8218 #line 1352 "preproc.y" 8219 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8220 break; 8221 8222 case 8: 8223- 8224-/* Line 1455 of yacc.c */ 8225 #line 1354 "preproc.y" 8226 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8227 break; 8228 8229 case 9: 8230- 8231-/* Line 1455 of yacc.c */ 8232 #line 1356 "preproc.y" 8233 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8234 break; 8235 8236 case 10: 8237- 8238-/* Line 1455 of yacc.c */ 8239 #line 1358 "preproc.y" 8240 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8241 break; 8242 8243 case 11: 8244- 8245-/* Line 1455 of yacc.c */ 8246 #line 1360 "preproc.y" 8247 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8248 break; 8249 8250 case 12: 8251- 8252-/* Line 1455 of yacc.c */ 8253 #line 1362 "preproc.y" 8254 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8255 break; 8256 8257 case 13: 8258- 8259-/* Line 1455 of yacc.c */ 8260 #line 1364 "preproc.y" 8261 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8262 break; 8263 8264 case 14: 8265- 8266-/* Line 1455 of yacc.c */ 8267 #line 1366 "preproc.y" 8268 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8269 break; 8270 8271 case 15: 8272- 8273-/* Line 1455 of yacc.c */ 8274 #line 1368 "preproc.y" 8275 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8276 break; 8277 8278 case 16: 8279- 8280-/* Line 1455 of yacc.c */ 8281 #line 1370 "preproc.y" 8282 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8283 break; 8284 8285 case 17: 8286- 8287-/* Line 1455 of yacc.c */ 8288 #line 1372 "preproc.y" 8289 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8290 break; 8291 8292 case 18: 8293- 8294-/* Line 1455 of yacc.c */ 8295 #line 1374 "preproc.y" 8296 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8297 break; 8298 8299 case 19: 8300- 8301-/* Line 1455 of yacc.c */ 8302 #line 1376 "preproc.y" 8303 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8304 break; 8305 8306 case 20: 8307- 8308-/* Line 1455 of yacc.c */ 8309 #line 1378 "preproc.y" 8310 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8311 break; 8312 8313 case 21: 8314- 8315-/* Line 1455 of yacc.c */ 8316 #line 1380 "preproc.y" 8317 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8318 break; 8319 8320 case 22: 8321- 8322-/* Line 1455 of yacc.c */ 8323 #line 1382 "preproc.y" 8324 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8325 break; 8326 8327 case 23: 8328- 8329-/* Line 1455 of yacc.c */ 8330 #line 1384 "preproc.y" 8331 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8332 break; 8333 8334 case 24: 8335- 8336-/* Line 1455 of yacc.c */ 8337 #line 1386 "preproc.y" 8338 { 8339 if (INFORMIX_MODE) 8340@@ -25141,190 +25560,136 @@ 8341 break; 8342 8343 case 25: 8344- 8345-/* Line 1455 of yacc.c */ 8346 #line 1404 "preproc.y" 8347 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8348 break; 8349 8350 case 26: 8351- 8352-/* Line 1455 of yacc.c */ 8353 #line 1406 "preproc.y" 8354 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8355 break; 8356 8357 case 27: 8358- 8359-/* Line 1455 of yacc.c */ 8360 #line 1408 "preproc.y" 8361 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8362 break; 8363 8364 case 28: 8365- 8366-/* Line 1455 of yacc.c */ 8367 #line 1410 "preproc.y" 8368 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8369 break; 8370 8371 case 29: 8372- 8373-/* Line 1455 of yacc.c */ 8374 #line 1412 "preproc.y" 8375 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8376 break; 8377 8378 case 30: 8379- 8380-/* Line 1455 of yacc.c */ 8381 #line 1414 "preproc.y" 8382 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8383 break; 8384 8385 case 31: 8386- 8387-/* Line 1455 of yacc.c */ 8388 #line 1416 "preproc.y" 8389 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8390 break; 8391 8392 case 32: 8393- 8394-/* Line 1455 of yacc.c */ 8395 #line 1418 "preproc.y" 8396 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8397 break; 8398 8399 case 33: 8400- 8401-/* Line 1455 of yacc.c */ 8402 #line 1420 "preproc.y" 8403 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8404 break; 8405 8406 case 34: 8407- 8408-/* Line 1455 of yacc.c */ 8409 #line 1422 "preproc.y" 8410 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8411 break; 8412 8413 case 35: 8414- 8415-/* Line 1455 of yacc.c */ 8416 #line 1424 "preproc.y" 8417 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8418 break; 8419 8420 case 36: 8421- 8422-/* Line 1455 of yacc.c */ 8423 #line 1426 "preproc.y" 8424 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8425 break; 8426 8427 case 37: 8428- 8429-/* Line 1455 of yacc.c */ 8430 #line 1428 "preproc.y" 8431 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8432 break; 8433 8434 case 38: 8435- 8436-/* Line 1455 of yacc.c */ 8437 #line 1430 "preproc.y" 8438 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8439 break; 8440 8441 case 39: 8442- 8443-/* Line 1455 of yacc.c */ 8444 #line 1432 "preproc.y" 8445 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8446 break; 8447 8448 case 40: 8449- 8450-/* Line 1455 of yacc.c */ 8451 #line 1434 "preproc.y" 8452 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8453 break; 8454 8455 case 41: 8456- 8457-/* Line 1455 of yacc.c */ 8458 #line 1436 "preproc.y" 8459 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8460 break; 8461 8462 case 42: 8463- 8464-/* Line 1455 of yacc.c */ 8465 #line 1438 "preproc.y" 8466 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8467 break; 8468 8469 case 43: 8470- 8471-/* Line 1455 of yacc.c */ 8472 #line 1440 "preproc.y" 8473 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8474 break; 8475 8476 case 44: 8477- 8478-/* Line 1455 of yacc.c */ 8479 #line 1442 "preproc.y" 8480 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8481 break; 8482 8483 case 45: 8484- 8485-/* Line 1455 of yacc.c */ 8486 #line 1444 "preproc.y" 8487 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8488 break; 8489 8490 case 46: 8491- 8492-/* Line 1455 of yacc.c */ 8493 #line 1446 "preproc.y" 8494 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8495 break; 8496 8497 case 47: 8498- 8499-/* Line 1455 of yacc.c */ 8500 #line 1448 "preproc.y" 8501 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8502 break; 8503 8504 case 48: 8505- 8506-/* Line 1455 of yacc.c */ 8507 #line 1450 "preproc.y" 8508 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8509 break; 8510 8511 case 49: 8512- 8513-/* Line 1455 of yacc.c */ 8514 #line 1452 "preproc.y" 8515 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8516 break; 8517 8518 case 50: 8519- 8520-/* Line 1455 of yacc.c */ 8521 #line 1454 "preproc.y" 8522 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8523 break; 8524 8525 case 51: 8526- 8527-/* Line 1455 of yacc.c */ 8528 #line 1456 "preproc.y" 8529 { 8530 output_deallocate_prepare_statement((yyvsp[(1) - (1)].str)); 8531@@ -25332,239 +25697,171 @@ 8532 break; 8533 8534 case 52: 8535- 8536-/* Line 1455 of yacc.c */ 8537 #line 1460 "preproc.y" 8538 { output_simple_statement((yyvsp[(1) - (1)].str)); ;} 8539 break; 8540 8541 case 53: 8542- 8543-/* Line 1455 of yacc.c */ 8544 #line 1462 "preproc.y" 8545 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8546 break; 8547 8548 case 54: 8549- 8550-/* Line 1455 of yacc.c */ 8551 #line 1464 "preproc.y" 8552 { output_statement((yyvsp[(1) - (1)].str), 1, ECPGst_prepnormal); ;} 8553 break; 8554 8555 case 55: 8556- 8557-/* Line 1455 of yacc.c */ 8558 #line 1466 "preproc.y" 8559 { output_statement((yyvsp[(1) - (1)].str), 1, ECPGst_normal); ;} 8560 break; 8561 8562 case 56: 8563- 8564-/* Line 1455 of yacc.c */ 8565 #line 1468 "preproc.y" 8566 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8567 break; 8568 8569 case 57: 8570- 8571-/* Line 1455 of yacc.c */ 8572 #line 1470 "preproc.y" 8573 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8574 break; 8575 8576 case 58: 8577- 8578-/* Line 1455 of yacc.c */ 8579 #line 1472 "preproc.y" 8580 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8581 break; 8582 8583 case 59: 8584- 8585-/* Line 1455 of yacc.c */ 8586 #line 1474 "preproc.y" 8587 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8588 break; 8589 8590 case 60: 8591- 8592-/* Line 1455 of yacc.c */ 8593 #line 1476 "preproc.y" 8594 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8595 break; 8596 8597 case 61: 8598- 8599-/* Line 1455 of yacc.c */ 8600 #line 1478 "preproc.y" 8601 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8602 break; 8603 8604 case 62: 8605- 8606-/* Line 1455 of yacc.c */ 8607 #line 1480 "preproc.y" 8608 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8609 break; 8610 8611 case 63: 8612- 8613-/* Line 1455 of yacc.c */ 8614 #line 1482 "preproc.y" 8615 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8616 break; 8617 8618 case 64: 8619- 8620-/* Line 1455 of yacc.c */ 8621 #line 1484 "preproc.y" 8622 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8623 break; 8624 8625 case 65: 8626- 8627-/* Line 1455 of yacc.c */ 8628 #line 1486 "preproc.y" 8629 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8630 break; 8631 8632 case 66: 8633- 8634-/* Line 1455 of yacc.c */ 8635 #line 1488 "preproc.y" 8636 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8637 break; 8638 8639 case 67: 8640- 8641-/* Line 1455 of yacc.c */ 8642 #line 1490 "preproc.y" 8643 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8644 break; 8645 8646 case 68: 8647- 8648-/* Line 1455 of yacc.c */ 8649 #line 1492 "preproc.y" 8650 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8651 break; 8652 8653 case 69: 8654- 8655-/* Line 1455 of yacc.c */ 8656 #line 1494 "preproc.y" 8657 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8658 break; 8659 8660 case 70: 8661- 8662-/* Line 1455 of yacc.c */ 8663 #line 1496 "preproc.y" 8664 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8665 break; 8666 8667 case 71: 8668- 8669-/* Line 1455 of yacc.c */ 8670 #line 1498 "preproc.y" 8671 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8672 break; 8673 8674 case 72: 8675- 8676-/* Line 1455 of yacc.c */ 8677 #line 1500 "preproc.y" 8678 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8679 break; 8680 8681 case 73: 8682- 8683-/* Line 1455 of yacc.c */ 8684 #line 1502 "preproc.y" 8685 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8686 break; 8687 8688 case 74: 8689- 8690-/* Line 1455 of yacc.c */ 8691 #line 1504 "preproc.y" 8692 { output_statement((yyvsp[(1) - (1)].str), 1, ECPGst_execute); ;} 8693 break; 8694 8695 case 75: 8696- 8697-/* Line 1455 of yacc.c */ 8698 #line 1506 "preproc.y" 8699 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8700 break; 8701 8702 case 76: 8703- 8704-/* Line 1455 of yacc.c */ 8705 #line 1508 "preproc.y" 8706 { output_statement((yyvsp[(1) - (1)].str), 1, ECPGst_normal); ;} 8707 break; 8708 8709 case 77: 8710- 8711-/* Line 1455 of yacc.c */ 8712 #line 1510 "preproc.y" 8713 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8714 break; 8715 8716 case 78: 8717- 8718-/* Line 1455 of yacc.c */ 8719 #line 1512 "preproc.y" 8720 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8721 break; 8722 8723 case 79: 8724- 8725-/* Line 1455 of yacc.c */ 8726 #line 1514 "preproc.y" 8727 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8728 break; 8729 8730 case 80: 8731- 8732-/* Line 1455 of yacc.c */ 8733 #line 1516 "preproc.y" 8734 { output_statement((yyvsp[(1) - (1)].str), 1, ECPGst_prepnormal); ;} 8735 break; 8736 8737 case 81: 8738- 8739-/* Line 1455 of yacc.c */ 8740 #line 1518 "preproc.y" 8741 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8742 break; 8743 8744 case 82: 8745- 8746-/* Line 1455 of yacc.c */ 8747 #line 1520 "preproc.y" 8748 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8749 break; 8750 8751 case 83: 8752- 8753-/* Line 1455 of yacc.c */ 8754 #line 1522 "preproc.y" 8755 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8756 break; 8757 8758 case 84: 8759- 8760-/* Line 1455 of yacc.c */ 8761 #line 1524 "preproc.y" 8762 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8763 break; 8764 8765 case 85: 8766- 8767-/* Line 1455 of yacc.c */ 8768 #line 1526 "preproc.y" 8769 { 8770 if ((yyvsp[(1) - (1)].prep).type == NULL || strlen((yyvsp[(1) - (1)].prep).type) == 0) 8771@@ -25575,78 +25872,56 @@ 8772 break; 8773 8774 case 86: 8775- 8776-/* Line 1455 of yacc.c */ 8777 #line 1533 "preproc.y" 8778 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8779 break; 8780 8781 case 87: 8782- 8783-/* Line 1455 of yacc.c */ 8784 #line 1535 "preproc.y" 8785 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8786 break; 8787 8788 case 88: 8789- 8790-/* Line 1455 of yacc.c */ 8791 #line 1537 "preproc.y" 8792 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8793 break; 8794 8795 case 89: 8796- 8797-/* Line 1455 of yacc.c */ 8798 #line 1539 "preproc.y" 8799 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8800 break; 8801 8802 case 90: 8803- 8804-/* Line 1455 of yacc.c */ 8805 #line 1541 "preproc.y" 8806 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8807 break; 8808 8809 case 91: 8810- 8811-/* Line 1455 of yacc.c */ 8812 #line 1543 "preproc.y" 8813 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8814 break; 8815 8816 case 92: 8817- 8818-/* Line 1455 of yacc.c */ 8819 #line 1545 "preproc.y" 8820 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8821 break; 8822 8823 case 93: 8824- 8825-/* Line 1455 of yacc.c */ 8826 #line 1547 "preproc.y" 8827 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8828 break; 8829 8830 case 94: 8831- 8832-/* Line 1455 of yacc.c */ 8833 #line 1549 "preproc.y" 8834 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8835 break; 8836 8837 case 95: 8838- 8839-/* Line 1455 of yacc.c */ 8840 #line 1551 "preproc.y" 8841 { output_statement((yyvsp[(1) - (1)].str), 1, ECPGst_prepnormal); ;} 8842 break; 8843 8844 case 96: 8845- 8846-/* Line 1455 of yacc.c */ 8847 #line 1553 "preproc.y" 8848 { 8849 fprintf(yyout, "{ ECPGtrans(__LINE__, %s, \"%s\");", connection ? connection : "NULL", (yyvsp[(1) - (1)].str)); 8850@@ -25656,64 +25931,46 @@ 8851 break; 8852 8853 case 97: 8854- 8855-/* Line 1455 of yacc.c */ 8856 #line 1559 "preproc.y" 8857 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8858 break; 8859 8860 case 98: 8861- 8862-/* Line 1455 of yacc.c */ 8863 #line 1561 "preproc.y" 8864 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8865 break; 8866 8867 case 99: 8868- 8869-/* Line 1455 of yacc.c */ 8870 #line 1563 "preproc.y" 8871 { output_statement((yyvsp[(1) - (1)].str), 1, ECPGst_prepnormal); ;} 8872 break; 8873 8874 case 100: 8875- 8876-/* Line 1455 of yacc.c */ 8877 #line 1565 "preproc.y" 8878 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8879 break; 8880 8881 case 101: 8882- 8883-/* Line 1455 of yacc.c */ 8884 #line 1567 "preproc.y" 8885 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8886 break; 8887 8888 case 102: 8889- 8890-/* Line 1455 of yacc.c */ 8891 #line 1569 "preproc.y" 8892 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8893 break; 8894 8895 case 103: 8896- 8897-/* Line 1455 of yacc.c */ 8898 #line 1571 "preproc.y" 8899 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8900 break; 8901 8902 case 104: 8903- 8904-/* Line 1455 of yacc.c */ 8905 #line 1573 "preproc.y" 8906 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;} 8907 break; 8908 8909 case 105: 8910- 8911-/* Line 1455 of yacc.c */ 8912 #line 1575 "preproc.y" 8913 { 8914 fprintf(yyout,"ECPGallocate_desc(__LINE__, %s);",(yyvsp[(1) - (1)].str)); 8915@@ -25723,8 +25980,6 @@ 8916 break; 8917 8918 case 106: 8919- 8920-/* Line 1455 of yacc.c */ 8921 #line 1581 "preproc.y" 8922 { 8923 if (connection) 8924@@ -25738,8 +25993,6 @@ 8925 break; 8926 8927 case 107: 8928- 8929-/* Line 1455 of yacc.c */ 8930 #line 1591 "preproc.y" 8931 { 8932 output_simple_statement((yyvsp[(1) - (1)].str)); 8933@@ -25747,8 +26000,6 @@ 8934 break; 8935 8936 case 108: 8937- 8938-/* Line 1455 of yacc.c */ 8939 #line 1595 "preproc.y" 8940 { 8941 fprintf(yyout,"ECPGdeallocate_desc(__LINE__, %s);",(yyvsp[(1) - (1)].str)); 8942@@ -25758,8 +26009,6 @@ 8943 break; 8944 8945 case 109: 8946- 8947-/* Line 1455 of yacc.c */ 8948 #line 1601 "preproc.y" 8949 { 8950 output_simple_statement((yyvsp[(1) - (1)].str)); 8951@@ -25767,8 +26016,6 @@ 8952 break; 8953 8954 case 110: 8955- 8956-/* Line 1455 of yacc.c */ 8957 #line 1605 "preproc.y" 8958 { 8959 fprintf(yyout, "{ ECPGdescribe(__LINE__, %d, %s,", compat, (yyvsp[(1) - (1)].str)); 8960@@ -25782,8 +26029,6 @@ 8961 break; 8962 8963 case 111: 8964- 8965-/* Line 1455 of yacc.c */ 8966 #line 1615 "preproc.y" 8967 { 8968 if (connection) 8969@@ -25797,15 +26042,11 @@ 8970 break; 8971 8972 case 112: 8973- 8974-/* Line 1455 of yacc.c */ 8975 #line 1624 "preproc.y" 8976 { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_exec_immediate); ;} 8977 break; 8978 8979 case 113: 8980- 8981-/* Line 1455 of yacc.c */ 8982 #line 1626 "preproc.y" 8983 { 8984 const char *con = connection ? connection : "NULL"; 8985@@ -25823,8 +26064,6 @@ 8986 break; 8987 8988 case 114: 8989- 8990-/* Line 1455 of yacc.c */ 8991 #line 1640 "preproc.y" 8992 { 8993 lookup_descriptor((yyvsp[(1) - (1)].descriptor).name, connection); 8994@@ -25835,8 +26074,6 @@ 8995 break; 8996 8997 case 115: 8998- 8999-/* Line 1455 of yacc.c */ 9000 #line 1647 "preproc.y" 9001 { 9002 lookup_descriptor((yyvsp[(1) - (1)].str), connection); 9003@@ -25846,8 +26083,6 @@ 9004 break; 9005 9006 case 116: 9007- 9008-/* Line 1455 of yacc.c */ 9009 #line 1653 "preproc.y" 9010 { 9011 struct cursor *ptr; 9012@@ -25862,8 +26097,6 @@ 9013 break; 9014 9015 case 117: 9016- 9017-/* Line 1455 of yacc.c */ 9018 #line 1664 "preproc.y" 9019 { 9020 fprintf(yyout, "{ ECPGsetcommit(__LINE__, \"%s\", %s);", (yyvsp[(1) - (1)].str), connection ? connection : "NULL"); 9021@@ -25873,8 +26106,6 @@ 9022 break; 9023 9024 case 118: 9025- 9026-/* Line 1455 of yacc.c */ 9027 #line 1670 "preproc.y" 9028 { 9029 if (connection) 9030@@ -25887,8 +26118,6 @@ 9031 break; 9032 9033 case 119: 9034- 9035-/* Line 1455 of yacc.c */ 9036 #line 1679 "preproc.y" 9037 { 9038 lookup_descriptor((yyvsp[(1) - (1)].descriptor).name, connection); 9039@@ -25899,8 +26128,6 @@ 9040 break; 9041 9042 case 120: 9043- 9044-/* Line 1455 of yacc.c */ 9045 #line 1686 "preproc.y" 9046 { 9047 lookup_descriptor((yyvsp[(1) - (1)].str), connection); 9048@@ -25910,8 +26137,6 @@ 9049 break; 9050 9051 case 121: 9052- 9053-/* Line 1455 of yacc.c */ 9054 #line 1692 "preproc.y" 9055 { 9056 if (connection) 9057@@ -25924,8 +26149,6 @@ 9058 break; 9059 9060 case 122: 9061- 9062-/* Line 1455 of yacc.c */ 9063 #line 1701 "preproc.y" 9064 { 9065 if (connection) 9066@@ -25936,8 +26159,6 @@ 9067 break; 9068 9069 case 123: 9070- 9071-/* Line 1455 of yacc.c */ 9072 #line 1708 "preproc.y" 9073 { 9074 if (connection) 9075@@ -25948,15 +26169,11 @@ 9076 break; 9077 9078 case 124: 9079- 9080-/* Line 1455 of yacc.c */ 9081 #line 1715 "preproc.y" 9082 { (yyval.str) = NULL; ;} 9083 break; 9084 9085 case 125: 9086- 9087-/* Line 1455 of yacc.c */ 9088 #line 1721 "preproc.y" 9089 { 9090 (yyval.str) = cat_str(4,make_str("create role"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 9091@@ -25964,8 +26181,6 @@ 9092 break; 9093 9094 case 126: 9095- 9096-/* Line 1455 of yacc.c */ 9097 #line 1729 "preproc.y" 9098 { 9099 (yyval.str) = make_str("with"); 9100@@ -25973,16 +26188,12 @@ 9101 break; 9102 9103 case 127: 9104- 9105-/* Line 1455 of yacc.c */ 9106 #line 1733 "preproc.y" 9107 { 9108 (yyval.str)=EMPTY; ;} 9109 break; 9110 9111 case 128: 9112- 9113-/* Line 1455 of yacc.c */ 9114 #line 1740 "preproc.y" 9115 { 9116 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 9117@@ -25990,16 +26201,12 @@ 9118 break; 9119 9120 case 129: 9121- 9122-/* Line 1455 of yacc.c */ 9123 #line 1744 "preproc.y" 9124 { 9125 (yyval.str)=EMPTY; ;} 9126 break; 9127 9128 case 130: 9129- 9130-/* Line 1455 of yacc.c */ 9131 #line 1751 "preproc.y" 9132 { 9133 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 9134@@ -26007,16 +26214,12 @@ 9135 break; 9136 9137 case 131: 9138- 9139-/* Line 1455 of yacc.c */ 9140 #line 1755 "preproc.y" 9141 { 9142 (yyval.str)=EMPTY; ;} 9143 break; 9144 9145 case 132: 9146- 9147-/* Line 1455 of yacc.c */ 9148 #line 1762 "preproc.y" 9149 { 9150 (yyval.str) = cat_str(2,make_str("password"),(yyvsp[(2) - (2)].str)); 9151@@ -26024,8 +26227,6 @@ 9152 break; 9153 9154 case 133: 9155- 9156-/* Line 1455 of yacc.c */ 9157 #line 1766 "preproc.y" 9158 { 9159 (yyval.str) = make_str("password null"); 9160@@ -26033,8 +26234,6 @@ 9161 break; 9162 9163 case 134: 9164- 9165-/* Line 1455 of yacc.c */ 9166 #line 1770 "preproc.y" 9167 { 9168 (yyval.str) = cat_str(2,make_str("encrypted password"),(yyvsp[(3) - (3)].str)); 9169@@ -26042,8 +26241,6 @@ 9170 break; 9171 9172 case 135: 9173- 9174-/* Line 1455 of yacc.c */ 9175 #line 1774 "preproc.y" 9176 { 9177 (yyval.str) = cat_str(2,make_str("unencrypted password"),(yyvsp[(3) - (3)].str)); 9178@@ -26051,8 +26248,6 @@ 9179 break; 9180 9181 case 136: 9182- 9183-/* Line 1455 of yacc.c */ 9184 #line 1778 "preproc.y" 9185 { 9186 (yyval.str) = make_str("superuser"); 9187@@ -26060,8 +26255,6 @@ 9188 break; 9189 9190 case 137: 9191- 9192-/* Line 1455 of yacc.c */ 9193 #line 1782 "preproc.y" 9194 { 9195 (yyval.str) = make_str("nosuperuser"); 9196@@ -26069,8 +26262,6 @@ 9197 break; 9198 9199 case 138: 9200- 9201-/* Line 1455 of yacc.c */ 9202 #line 1786 "preproc.y" 9203 { 9204 (yyval.str) = make_str("inherit"); 9205@@ -26078,8 +26269,6 @@ 9206 break; 9207 9208 case 139: 9209- 9210-/* Line 1455 of yacc.c */ 9211 #line 1790 "preproc.y" 9212 { 9213 (yyval.str) = make_str("noinherit"); 9214@@ -26087,8 +26276,6 @@ 9215 break; 9216 9217 case 140: 9218- 9219-/* Line 1455 of yacc.c */ 9220 #line 1794 "preproc.y" 9221 { 9222 (yyval.str) = make_str("createdb"); 9223@@ -26096,8 +26283,6 @@ 9224 break; 9225 9226 case 141: 9227- 9228-/* Line 1455 of yacc.c */ 9229 #line 1798 "preproc.y" 9230 { 9231 (yyval.str) = make_str("nocreatedb"); 9232@@ -26105,8 +26290,6 @@ 9233 break; 9234 9235 case 142: 9236- 9237-/* Line 1455 of yacc.c */ 9238 #line 1802 "preproc.y" 9239 { 9240 (yyval.str) = make_str("createrole"); 9241@@ -26114,8 +26297,6 @@ 9242 break; 9243 9244 case 143: 9245- 9246-/* Line 1455 of yacc.c */ 9247 #line 1806 "preproc.y" 9248 { 9249 (yyval.str) = make_str("nocreaterole"); 9250@@ -26123,8 +26304,6 @@ 9251 break; 9252 9253 case 144: 9254- 9255-/* Line 1455 of yacc.c */ 9256 #line 1810 "preproc.y" 9257 { 9258 (yyval.str) = make_str("createuser"); 9259@@ -26132,8 +26311,6 @@ 9260 break; 9261 9262 case 145: 9263- 9264-/* Line 1455 of yacc.c */ 9265 #line 1814 "preproc.y" 9266 { 9267 (yyval.str) = make_str("nocreateuser"); 9268@@ -26141,8 +26318,6 @@ 9269 break; 9270 9271 case 146: 9272- 9273-/* Line 1455 of yacc.c */ 9274 #line 1818 "preproc.y" 9275 { 9276 (yyval.str) = make_str("login"); 9277@@ -26150,8 +26325,6 @@ 9278 break; 9279 9280 case 147: 9281- 9282-/* Line 1455 of yacc.c */ 9283 #line 1822 "preproc.y" 9284 { 9285 (yyval.str) = make_str("nologin"); 9286@@ -26159,8 +26332,6 @@ 9287 break; 9288 9289 case 148: 9290- 9291-/* Line 1455 of yacc.c */ 9292 #line 1826 "preproc.y" 9293 { 9294 (yyval.str) = cat_str(2,make_str("connection limit"),(yyvsp[(3) - (3)].str)); 9295@@ -26168,8 +26339,6 @@ 9296 break; 9297 9298 case 149: 9299- 9300-/* Line 1455 of yacc.c */ 9301 #line 1830 "preproc.y" 9302 { 9303 (yyval.str) = cat_str(2,make_str("valid until"),(yyvsp[(3) - (3)].str)); 9304@@ -26177,8 +26346,6 @@ 9305 break; 9306 9307 case 150: 9308- 9309-/* Line 1455 of yacc.c */ 9310 #line 1834 "preproc.y" 9311 { 9312 (yyval.str) = cat_str(2,make_str("user"),(yyvsp[(2) - (2)].str)); 9313@@ -26186,8 +26353,6 @@ 9314 break; 9315 9316 case 151: 9317- 9318-/* Line 1455 of yacc.c */ 9319 #line 1842 "preproc.y" 9320 { 9321 (yyval.str) = (yyvsp[(1) - (1)].str); 9322@@ -26195,8 +26360,6 @@ 9323 break; 9324 9325 case 152: 9326- 9327-/* Line 1455 of yacc.c */ 9328 #line 1846 "preproc.y" 9329 { 9330 (yyval.str) = cat_str(2,make_str("sysid"),(yyvsp[(2) - (2)].str)); 9331@@ -26204,8 +26367,6 @@ 9332 break; 9333 9334 case 153: 9335- 9336-/* Line 1455 of yacc.c */ 9337 #line 1850 "preproc.y" 9338 { 9339 (yyval.str) = cat_str(2,make_str("admin"),(yyvsp[(2) - (2)].str)); 9340@@ -26213,8 +26374,6 @@ 9341 break; 9342 9343 case 154: 9344- 9345-/* Line 1455 of yacc.c */ 9346 #line 1854 "preproc.y" 9347 { 9348 (yyval.str) = cat_str(2,make_str("role"),(yyvsp[(2) - (2)].str)); 9349@@ -26222,8 +26381,6 @@ 9350 break; 9351 9352 case 155: 9353- 9354-/* Line 1455 of yacc.c */ 9355 #line 1858 "preproc.y" 9356 { 9357 (yyval.str) = cat_str(2,make_str("in role"),(yyvsp[(3) - (3)].str)); 9358@@ -26231,8 +26388,6 @@ 9359 break; 9360 9361 case 156: 9362- 9363-/* Line 1455 of yacc.c */ 9364 #line 1862 "preproc.y" 9365 { 9366 (yyval.str) = cat_str(2,make_str("in group"),(yyvsp[(3) - (3)].str)); 9367@@ -26240,8 +26395,6 @@ 9368 break; 9369 9370 case 157: 9371- 9372-/* Line 1455 of yacc.c */ 9373 #line 1870 "preproc.y" 9374 { 9375 (yyval.str) = cat_str(4,make_str("create user"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 9376@@ -26249,8 +26402,6 @@ 9377 break; 9378 9379 case 158: 9380- 9381-/* Line 1455 of yacc.c */ 9382 #line 1878 "preproc.y" 9383 { 9384 (yyval.str) = cat_str(4,make_str("alter role"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 9385@@ -26258,16 +26409,12 @@ 9386 break; 9387 9388 case 159: 9389- 9390-/* Line 1455 of yacc.c */ 9391 #line 1886 "preproc.y" 9392 { 9393 (yyval.str)=EMPTY; ;} 9394 break; 9395 9396 case 160: 9397- 9398-/* Line 1455 of yacc.c */ 9399 #line 1889 "preproc.y" 9400 { 9401 (yyval.str) = cat_str(2,make_str("in database"),(yyvsp[(3) - (3)].str)); 9402@@ -26275,8 +26422,6 @@ 9403 break; 9404 9405 case 161: 9406- 9407-/* Line 1455 of yacc.c */ 9408 #line 1897 "preproc.y" 9409 { 9410 (yyval.str) = cat_str(4,make_str("alter role"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 9411@@ -26284,8 +26429,6 @@ 9412 break; 9413 9414 case 162: 9415- 9416-/* Line 1455 of yacc.c */ 9417 #line 1905 "preproc.y" 9418 { 9419 (yyval.str) = cat_str(4,make_str("alter user"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 9420@@ -26293,8 +26436,6 @@ 9421 break; 9422 9423 case 163: 9424- 9425-/* Line 1455 of yacc.c */ 9426 #line 1913 "preproc.y" 9427 { 9428 (yyval.str) = cat_str(3,make_str("alter user"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 9429@@ -26302,8 +26443,6 @@ 9430 break; 9431 9432 case 164: 9433- 9434-/* Line 1455 of yacc.c */ 9435 #line 1921 "preproc.y" 9436 { 9437 (yyval.str) = cat_str(2,make_str("drop role"),(yyvsp[(3) - (3)].str)); 9438@@ -26311,8 +26450,6 @@ 9439 break; 9440 9441 case 165: 9442- 9443-/* Line 1455 of yacc.c */ 9444 #line 1925 "preproc.y" 9445 { 9446 (yyval.str) = cat_str(2,make_str("drop role if exists"),(yyvsp[(5) - (5)].str)); 9447@@ -26320,8 +26457,6 @@ 9448 break; 9449 9450 case 166: 9451- 9452-/* Line 1455 of yacc.c */ 9453 #line 1933 "preproc.y" 9454 { 9455 (yyval.str) = cat_str(2,make_str("drop user"),(yyvsp[(3) - (3)].str)); 9456@@ -26329,8 +26464,6 @@ 9457 break; 9458 9459 case 167: 9460- 9461-/* Line 1455 of yacc.c */ 9462 #line 1937 "preproc.y" 9463 { 9464 (yyval.str) = cat_str(2,make_str("drop user if exists"),(yyvsp[(5) - (5)].str)); 9465@@ -26338,8 +26471,6 @@ 9466 break; 9467 9468 case 168: 9469- 9470-/* Line 1455 of yacc.c */ 9471 #line 1945 "preproc.y" 9472 { 9473 (yyval.str) = cat_str(4,make_str("create group"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 9474@@ -26347,8 +26478,6 @@ 9475 break; 9476 9477 case 169: 9478- 9479-/* Line 1455 of yacc.c */ 9480 #line 1953 "preproc.y" 9481 { 9482 (yyval.str) = cat_str(5,make_str("alter group"),(yyvsp[(3) - (6)].str),(yyvsp[(4) - (6)].str),make_str("user"),(yyvsp[(6) - (6)].str)); 9483@@ -26356,8 +26485,6 @@ 9484 break; 9485 9486 case 170: 9487- 9488-/* Line 1455 of yacc.c */ 9489 #line 1961 "preproc.y" 9490 { 9491 (yyval.str) = make_str("add"); 9492@@ -26365,8 +26492,6 @@ 9493 break; 9494 9495 case 171: 9496- 9497-/* Line 1455 of yacc.c */ 9498 #line 1965 "preproc.y" 9499 { 9500 (yyval.str) = make_str("drop"); 9501@@ -26374,8 +26499,6 @@ 9502 break; 9503 9504 case 172: 9505- 9506-/* Line 1455 of yacc.c */ 9507 #line 1973 "preproc.y" 9508 { 9509 (yyval.str) = cat_str(2,make_str("drop group"),(yyvsp[(3) - (3)].str)); 9510@@ -26383,8 +26506,6 @@ 9511 break; 9512 9513 case 173: 9514- 9515-/* Line 1455 of yacc.c */ 9516 #line 1977 "preproc.y" 9517 { 9518 (yyval.str) = cat_str(2,make_str("drop group if exists"),(yyvsp[(5) - (5)].str)); 9519@@ -26392,8 +26513,6 @@ 9520 break; 9521 9522 case 174: 9523- 9524-/* Line 1455 of yacc.c */ 9525 #line 1985 "preproc.y" 9526 { 9527 (yyval.str) = cat_str(5,make_str("create schema"),(yyvsp[(3) - (6)].str),make_str("authorization"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 9528@@ -26401,8 +26520,6 @@ 9529 break; 9530 9531 case 175: 9532- 9533-/* Line 1455 of yacc.c */ 9534 #line 1989 "preproc.y" 9535 { 9536 (yyval.str) = cat_str(3,make_str("create schema"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 9537@@ -26410,8 +26527,6 @@ 9538 break; 9539 9540 case 176: 9541- 9542-/* Line 1455 of yacc.c */ 9543 #line 1997 "preproc.y" 9544 { 9545 (yyval.str) = (yyvsp[(1) - (1)].str); 9546@@ -26419,16 +26534,12 @@ 9547 break; 9548 9549 case 177: 9550- 9551-/* Line 1455 of yacc.c */ 9552 #line 2001 "preproc.y" 9553 { 9554 (yyval.str)=EMPTY; ;} 9555 break; 9556 9557 case 178: 9558- 9559-/* Line 1455 of yacc.c */ 9560 #line 2008 "preproc.y" 9561 { 9562 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 9563@@ -26436,16 +26547,12 @@ 9564 break; 9565 9566 case 179: 9567- 9568-/* Line 1455 of yacc.c */ 9569 #line 2012 "preproc.y" 9570 { 9571 (yyval.str)=EMPTY; ;} 9572 break; 9573 9574 case 180: 9575- 9576-/* Line 1455 of yacc.c */ 9577 #line 2019 "preproc.y" 9578 { 9579 (yyval.str) = (yyvsp[(1) - (1)].str); 9580@@ -26453,8 +26560,6 @@ 9581 break; 9582 9583 case 181: 9584- 9585-/* Line 1455 of yacc.c */ 9586 #line 2023 "preproc.y" 9587 { 9588 (yyval.str) = (yyvsp[(1) - (1)].str); 9589@@ -26462,8 +26567,6 @@ 9590 break; 9591 9592 case 182: 9593- 9594-/* Line 1455 of yacc.c */ 9595 #line 2027 "preproc.y" 9596 { 9597 (yyval.str) = (yyvsp[(1) - (1)].str); 9598@@ -26471,8 +26574,6 @@ 9599 break; 9600 9601 case 183: 9602- 9603-/* Line 1455 of yacc.c */ 9604 #line 2031 "preproc.y" 9605 { 9606 (yyval.str) = (yyvsp[(1) - (1)].str); 9607@@ -26480,8 +26581,6 @@ 9608 break; 9609 9610 case 184: 9611- 9612-/* Line 1455 of yacc.c */ 9613 #line 2035 "preproc.y" 9614 { 9615 (yyval.str) = (yyvsp[(1) - (1)].str); 9616@@ -26489,8 +26588,6 @@ 9617 break; 9618 9619 case 185: 9620- 9621-/* Line 1455 of yacc.c */ 9622 #line 2039 "preproc.y" 9623 { 9624 (yyval.str) = (yyvsp[(1) - (1)].str); 9625@@ -26498,8 +26595,6 @@ 9626 break; 9627 9628 case 186: 9629- 9630-/* Line 1455 of yacc.c */ 9631 #line 2047 "preproc.y" 9632 { 9633 (yyval.str) = cat_str(2,make_str("set"),(yyvsp[(2) - (2)].str)); 9634@@ -26507,8 +26602,6 @@ 9635 break; 9636 9637 case 187: 9638- 9639-/* Line 1455 of yacc.c */ 9640 #line 2051 "preproc.y" 9641 { 9642 (yyval.str) = cat_str(2,make_str("set local"),(yyvsp[(3) - (3)].str)); 9643@@ -26516,8 +26609,6 @@ 9644 break; 9645 9646 case 188: 9647- 9648-/* Line 1455 of yacc.c */ 9649 #line 2055 "preproc.y" 9650 { 9651 (yyval.str) = cat_str(2,make_str("set session"),(yyvsp[(3) - (3)].str)); 9652@@ -26525,8 +26616,6 @@ 9653 break; 9654 9655 case 189: 9656- 9657-/* Line 1455 of yacc.c */ 9658 #line 2063 "preproc.y" 9659 { 9660 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("to"),(yyvsp[(3) - (3)].str)); 9661@@ -26534,8 +26623,6 @@ 9662 break; 9663 9664 case 190: 9665- 9666-/* Line 1455 of yacc.c */ 9667 #line 2067 "preproc.y" 9668 { 9669 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("="),(yyvsp[(3) - (3)].str)); 9670@@ -26543,8 +26630,6 @@ 9671 break; 9672 9673 case 191: 9674- 9675-/* Line 1455 of yacc.c */ 9676 #line 2071 "preproc.y" 9677 { 9678 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("to default")); 9679@@ -26552,8 +26637,6 @@ 9680 break; 9681 9682 case 192: 9683- 9684-/* Line 1455 of yacc.c */ 9685 #line 2075 "preproc.y" 9686 { 9687 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("= default")); 9688@@ -26561,8 +26644,6 @@ 9689 break; 9690 9691 case 193: 9692- 9693-/* Line 1455 of yacc.c */ 9694 #line 2079 "preproc.y" 9695 { 9696 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("from current")); 9697@@ -26570,8 +26651,6 @@ 9698 break; 9699 9700 case 194: 9701- 9702-/* Line 1455 of yacc.c */ 9703 #line 2083 "preproc.y" 9704 { 9705 (yyval.str) = cat_str(2,make_str("time zone"),(yyvsp[(3) - (3)].str)); 9706@@ -26579,8 +26658,6 @@ 9707 break; 9708 9709 case 195: 9710- 9711-/* Line 1455 of yacc.c */ 9712 #line 2087 "preproc.y" 9713 { 9714 (yyval.str) = cat_str(2,make_str("transaction"),(yyvsp[(2) - (2)].str)); 9715@@ -26588,8 +26665,6 @@ 9716 break; 9717 9718 case 196: 9719- 9720-/* Line 1455 of yacc.c */ 9721 #line 2091 "preproc.y" 9722 { 9723 (yyval.str) = cat_str(2,make_str("session characteristics as transaction"),(yyvsp[(5) - (5)].str)); 9724@@ -26597,8 +26672,6 @@ 9725 break; 9726 9727 case 197: 9728- 9729-/* Line 1455 of yacc.c */ 9730 #line 2095 "preproc.y" 9731 { 9732 mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server"); 9733@@ -26607,8 +26680,6 @@ 9734 break; 9735 9736 case 198: 9737- 9738-/* Line 1455 of yacc.c */ 9739 #line 2100 "preproc.y" 9740 { 9741 (yyval.str) = cat_str(2,make_str("schema"),(yyvsp[(2) - (2)].str)); 9742@@ -26616,8 +26687,6 @@ 9743 break; 9744 9745 case 199: 9746- 9747-/* Line 1455 of yacc.c */ 9748 #line 2104 "preproc.y" 9749 { 9750 (yyval.str) = cat_str(2,make_str("names"),(yyvsp[(2) - (2)].str)); 9751@@ -26625,8 +26694,6 @@ 9752 break; 9753 9754 case 200: 9755- 9756-/* Line 1455 of yacc.c */ 9757 #line 2108 "preproc.y" 9758 { 9759 (yyval.str) = cat_str(2,make_str("role"),(yyvsp[(2) - (2)].str)); 9760@@ -26634,8 +26701,6 @@ 9761 break; 9762 9763 case 201: 9764- 9765-/* Line 1455 of yacc.c */ 9766 #line 2112 "preproc.y" 9767 { 9768 (yyval.str) = cat_str(2,make_str("session authorization"),(yyvsp[(3) - (3)].str)); 9769@@ -26643,8 +26708,6 @@ 9770 break; 9771 9772 case 202: 9773- 9774-/* Line 1455 of yacc.c */ 9775 #line 2116 "preproc.y" 9776 { 9777 (yyval.str) = make_str("session authorization default"); 9778@@ -26652,8 +26715,6 @@ 9779 break; 9780 9781 case 203: 9782- 9783-/* Line 1455 of yacc.c */ 9784 #line 2120 "preproc.y" 9785 { 9786 (yyval.str) = cat_str(2,make_str("xml option"),(yyvsp[(3) - (3)].str)); 9787@@ -26661,8 +26722,6 @@ 9788 break; 9789 9790 case 204: 9791- 9792-/* Line 1455 of yacc.c */ 9793 #line 2128 "preproc.y" 9794 { 9795 (yyval.str) = (yyvsp[(1) - (1)].str); 9796@@ -26670,8 +26729,6 @@ 9797 break; 9798 9799 case 205: 9800- 9801-/* Line 1455 of yacc.c */ 9802 #line 2132 "preproc.y" 9803 { 9804 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("."),(yyvsp[(3) - (3)].str)); 9805@@ -26679,8 +26736,6 @@ 9806 break; 9807 9808 case 206: 9809- 9810-/* Line 1455 of yacc.c */ 9811 #line 2140 "preproc.y" 9812 { 9813 (yyval.str) = (yyvsp[(1) - (1)].str); 9814@@ -26688,8 +26743,6 @@ 9815 break; 9816 9817 case 207: 9818- 9819-/* Line 1455 of yacc.c */ 9820 #line 2144 "preproc.y" 9821 { 9822 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 9823@@ -26697,8 +26750,6 @@ 9824 break; 9825 9826 case 208: 9827- 9828-/* Line 1455 of yacc.c */ 9829 #line 2152 "preproc.y" 9830 { 9831 (yyval.str) = (yyvsp[(1) - (1)].str); 9832@@ -26706,8 +26757,6 @@ 9833 break; 9834 9835 case 209: 9836- 9837-/* Line 1455 of yacc.c */ 9838 #line 2156 "preproc.y" 9839 { 9840 if ((yyvsp[(1) - (1)].str)[0] == '$') 9841@@ -26721,8 +26770,6 @@ 9842 break; 9843 9844 case 210: 9845- 9846-/* Line 1455 of yacc.c */ 9847 #line 2170 "preproc.y" 9848 { 9849 (yyval.str) = make_str("read uncommitted"); 9850@@ -26730,8 +26777,6 @@ 9851 break; 9852 9853 case 211: 9854- 9855-/* Line 1455 of yacc.c */ 9856 #line 2174 "preproc.y" 9857 { 9858 (yyval.str) = make_str("read committed"); 9859@@ -26739,8 +26784,6 @@ 9860 break; 9861 9862 case 212: 9863- 9864-/* Line 1455 of yacc.c */ 9865 #line 2178 "preproc.y" 9866 { 9867 (yyval.str) = make_str("repeatable read"); 9868@@ -26748,8 +26791,6 @@ 9869 break; 9870 9871 case 213: 9872- 9873-/* Line 1455 of yacc.c */ 9874 #line 2182 "preproc.y" 9875 { 9876 (yyval.str) = make_str("serializable"); 9877@@ -26757,8 +26798,6 @@ 9878 break; 9879 9880 case 214: 9881- 9882-/* Line 1455 of yacc.c */ 9883 #line 2190 "preproc.y" 9884 { 9885 (yyval.str) = make_str("true"); 9886@@ -26766,8 +26805,6 @@ 9887 break; 9888 9889 case 215: 9890- 9891-/* Line 1455 of yacc.c */ 9892 #line 2194 "preproc.y" 9893 { 9894 (yyval.str) = make_str("false"); 9895@@ -26775,8 +26812,6 @@ 9896 break; 9897 9898 case 216: 9899- 9900-/* Line 1455 of yacc.c */ 9901 #line 2198 "preproc.y" 9902 { 9903 (yyval.str) = make_str("on"); 9904@@ -26784,8 +26819,6 @@ 9905 break; 9906 9907 case 217: 9908- 9909-/* Line 1455 of yacc.c */ 9910 #line 2202 "preproc.y" 9911 { 9912 (yyval.str) = (yyvsp[(1) - (1)].str); 9913@@ -26793,8 +26826,6 @@ 9914 break; 9915 9916 case 218: 9917- 9918-/* Line 1455 of yacc.c */ 9919 #line 2210 "preproc.y" 9920 { 9921 (yyval.str) = (yyvsp[(1) - (1)].str); 9922@@ -26802,8 +26833,6 @@ 9923 break; 9924 9925 case 219: 9926- 9927-/* Line 1455 of yacc.c */ 9928 #line 2214 "preproc.y" 9929 { 9930 (yyval.str) = (yyvsp[(1) - (1)].str); 9931@@ -26811,8 +26840,6 @@ 9932 break; 9933 9934 case 220: 9935- 9936-/* Line 1455 of yacc.c */ 9937 #line 2218 "preproc.y" 9938 { 9939 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 9940@@ -26820,8 +26847,6 @@ 9941 break; 9942 9943 case 221: 9944- 9945-/* Line 1455 of yacc.c */ 9946 #line 2222 "preproc.y" 9947 { 9948 (yyval.str) = cat_str(6,(yyvsp[(1) - (6)].str),make_str("("),(yyvsp[(3) - (6)].str),make_str(")"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 9949@@ -26829,8 +26854,6 @@ 9950 break; 9951 9952 case 222: 9953- 9954-/* Line 1455 of yacc.c */ 9955 #line 2226 "preproc.y" 9956 { 9957 (yyval.str) = (yyvsp[(1) - (1)].str); 9958@@ -26838,8 +26861,6 @@ 9959 break; 9960 9961 case 223: 9962- 9963-/* Line 1455 of yacc.c */ 9964 #line 2230 "preproc.y" 9965 { 9966 (yyval.str) = make_str("default"); 9967@@ -26847,8 +26868,6 @@ 9968 break; 9969 9970 case 224: 9971- 9972-/* Line 1455 of yacc.c */ 9973 #line 2234 "preproc.y" 9974 { 9975 (yyval.str) = make_str("local"); 9976@@ -26856,8 +26875,6 @@ 9977 break; 9978 9979 case 225: 9980- 9981-/* Line 1455 of yacc.c */ 9982 #line 2242 "preproc.y" 9983 { 9984 (yyval.str) = (yyvsp[(1) - (1)].str); 9985@@ -26865,8 +26882,6 @@ 9986 break; 9987 9988 case 226: 9989- 9990-/* Line 1455 of yacc.c */ 9991 #line 2246 "preproc.y" 9992 { 9993 (yyval.str) = make_str("default"); 9994@@ -26874,16 +26889,12 @@ 9995 break; 9996 9997 case 227: 9998- 9999-/* Line 1455 of yacc.c */ 10000 #line 2250 "preproc.y" 10001 { 10002 (yyval.str)=EMPTY; ;} 10003 break; 10004 10005 case 228: 10006- 10007-/* Line 1455 of yacc.c */ 10008 #line 2257 "preproc.y" 10009 { 10010 (yyval.str) = (yyvsp[(1) - (1)].str); 10011@@ -26891,8 +26902,6 @@ 10012 break; 10013 10014 case 229: 10015- 10016-/* Line 1455 of yacc.c */ 10017 #line 2261 "preproc.y" 10018 { 10019 (yyval.str) = (yyvsp[(1) - (1)].str); 10020@@ -26900,8 +26909,6 @@ 10021 break; 10022 10023 case 230: 10024- 10025-/* Line 1455 of yacc.c */ 10026 #line 2269 "preproc.y" 10027 { 10028 (yyval.str) = cat_str(2,make_str("reset"),(yyvsp[(2) - (2)].str)); 10029@@ -26909,8 +26916,6 @@ 10030 break; 10031 10032 case 231: 10033- 10034-/* Line 1455 of yacc.c */ 10035 #line 2273 "preproc.y" 10036 { 10037 (yyval.str) = make_str("reset time zone"); 10038@@ -26918,8 +26923,6 @@ 10039 break; 10040 10041 case 232: 10042- 10043-/* Line 1455 of yacc.c */ 10044 #line 2277 "preproc.y" 10045 { 10046 (yyval.str) = make_str("reset transaction isolation level"); 10047@@ -26927,8 +26930,6 @@ 10048 break; 10049 10050 case 233: 10051- 10052-/* Line 1455 of yacc.c */ 10053 #line 2281 "preproc.y" 10054 { 10055 (yyval.str) = make_str("reset session authorization"); 10056@@ -26936,8 +26937,6 @@ 10057 break; 10058 10059 case 234: 10060- 10061-/* Line 1455 of yacc.c */ 10062 #line 2285 "preproc.y" 10063 { 10064 (yyval.str) = make_str("reset all"); 10065@@ -26945,8 +26944,6 @@ 10066 break; 10067 10068 case 235: 10069- 10070-/* Line 1455 of yacc.c */ 10071 #line 2293 "preproc.y" 10072 { 10073 (yyval.str) = cat_str(2,make_str("set"),(yyvsp[(2) - (2)].str)); 10074@@ -26954,8 +26951,6 @@ 10075 break; 10076 10077 case 236: 10078- 10079-/* Line 1455 of yacc.c */ 10080 #line 2297 "preproc.y" 10081 { 10082 (yyval.str) = (yyvsp[(1) - (1)].str); 10083@@ -26963,8 +26958,6 @@ 10084 break; 10085 10086 case 237: 10087- 10088-/* Line 1455 of yacc.c */ 10089 #line 2305 "preproc.y" 10090 { 10091 (yyval.str) = cat_str(2,make_str("show"),(yyvsp[(2) - (3)].str)); 10092@@ -26972,8 +26965,6 @@ 10093 break; 10094 10095 case 238: 10096- 10097-/* Line 1455 of yacc.c */ 10098 #line 2309 "preproc.y" 10099 { 10100 (yyval.str) = make_str("show time zone"); 10101@@ -26981,8 +26972,6 @@ 10102 break; 10103 10104 case 239: 10105- 10106-/* Line 1455 of yacc.c */ 10107 #line 2313 "preproc.y" 10108 { 10109 (yyval.str) = make_str("show transaction isolation level"); 10110@@ -26990,8 +26979,6 @@ 10111 break; 10112 10113 case 240: 10114- 10115-/* Line 1455 of yacc.c */ 10116 #line 2317 "preproc.y" 10117 { 10118 (yyval.str) = make_str("show session authorization"); 10119@@ -26999,8 +26986,6 @@ 10120 break; 10121 10122 case 241: 10123- 10124-/* Line 1455 of yacc.c */ 10125 #line 2321 "preproc.y" 10126 { 10127 mmerror(PARSE_ERROR, ET_ERROR, "SHOW ALL is not implemented"); 10128@@ -27009,8 +26994,6 @@ 10129 break; 10130 10131 case 242: 10132- 10133-/* Line 1455 of yacc.c */ 10134 #line 2330 "preproc.y" 10135 { 10136 (yyval.str) = cat_str(3,make_str("set constraints"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 10137@@ -27018,8 +27001,6 @@ 10138 break; 10139 10140 case 243: 10141- 10142-/* Line 1455 of yacc.c */ 10143 #line 2338 "preproc.y" 10144 { 10145 (yyval.str) = make_str("all"); 10146@@ -27027,8 +27008,6 @@ 10147 break; 10148 10149 case 244: 10150- 10151-/* Line 1455 of yacc.c */ 10152 #line 2342 "preproc.y" 10153 { 10154 (yyval.str) = (yyvsp[(1) - (1)].str); 10155@@ -27036,8 +27015,6 @@ 10156 break; 10157 10158 case 245: 10159- 10160-/* Line 1455 of yacc.c */ 10161 #line 2350 "preproc.y" 10162 { 10163 (yyval.str) = make_str("deferred"); 10164@@ -27045,8 +27022,6 @@ 10165 break; 10166 10167 case 246: 10168- 10169-/* Line 1455 of yacc.c */ 10170 #line 2354 "preproc.y" 10171 { 10172 (yyval.str) = make_str("immediate"); 10173@@ -27054,8 +27029,6 @@ 10174 break; 10175 10176 case 247: 10177- 10178-/* Line 1455 of yacc.c */ 10179 #line 2362 "preproc.y" 10180 { 10181 (yyval.str) = make_str("checkpoint"); 10182@@ -27063,8 +27036,6 @@ 10183 break; 10184 10185 case 248: 10186- 10187-/* Line 1455 of yacc.c */ 10188 #line 2370 "preproc.y" 10189 { 10190 (yyval.str) = make_str("discard all"); 10191@@ -27072,8 +27043,6 @@ 10192 break; 10193 10194 case 249: 10195- 10196-/* Line 1455 of yacc.c */ 10197 #line 2374 "preproc.y" 10198 { 10199 (yyval.str) = make_str("discard temp"); 10200@@ -27081,8 +27050,6 @@ 10201 break; 10202 10203 case 250: 10204- 10205-/* Line 1455 of yacc.c */ 10206 #line 2378 "preproc.y" 10207 { 10208 (yyval.str) = make_str("discard temporary"); 10209@@ -27090,8 +27057,6 @@ 10210 break; 10211 10212 case 251: 10213- 10214-/* Line 1455 of yacc.c */ 10215 #line 2382 "preproc.y" 10216 { 10217 (yyval.str) = make_str("discard plans"); 10218@@ -27099,8 +27064,6 @@ 10219 break; 10220 10221 case 252: 10222- 10223-/* Line 1455 of yacc.c */ 10224 #line 2390 "preproc.y" 10225 { 10226 (yyval.str) = cat_str(3,make_str("alter table"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 10227@@ -27108,8 +27071,6 @@ 10228 break; 10229 10230 case 253: 10231- 10232-/* Line 1455 of yacc.c */ 10233 #line 2394 "preproc.y" 10234 { 10235 (yyval.str) = cat_str(3,make_str("alter index"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 10236@@ -27117,8 +27078,6 @@ 10237 break; 10238 10239 case 254: 10240- 10241-/* Line 1455 of yacc.c */ 10242 #line 2398 "preproc.y" 10243 { 10244 (yyval.str) = cat_str(3,make_str("alter sequence"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 10245@@ -27126,8 +27085,6 @@ 10246 break; 10247 10248 case 255: 10249- 10250-/* Line 1455 of yacc.c */ 10251 #line 2402 "preproc.y" 10252 { 10253 (yyval.str) = cat_str(3,make_str("alter view"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 10254@@ -27135,8 +27092,6 @@ 10255 break; 10256 10257 case 256: 10258- 10259-/* Line 1455 of yacc.c */ 10260 #line 2410 "preproc.y" 10261 { 10262 (yyval.str) = (yyvsp[(1) - (1)].str); 10263@@ -27144,8 +27099,6 @@ 10264 break; 10265 10266 case 257: 10267- 10268-/* Line 1455 of yacc.c */ 10269 #line 2414 "preproc.y" 10270 { 10271 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 10272@@ -27153,8 +27106,6 @@ 10273 break; 10274 10275 case 258: 10276- 10277-/* Line 1455 of yacc.c */ 10278 #line 2422 "preproc.y" 10279 { 10280 (yyval.str) = cat_str(2,make_str("add"),(yyvsp[(2) - (2)].str)); 10281@@ -27162,8 +27113,6 @@ 10282 break; 10283 10284 case 259: 10285- 10286-/* Line 1455 of yacc.c */ 10287 #line 2426 "preproc.y" 10288 { 10289 (yyval.str) = cat_str(2,make_str("add column"),(yyvsp[(3) - (3)].str)); 10290@@ -27171,8 +27120,6 @@ 10291 break; 10292 10293 case 260: 10294- 10295-/* Line 1455 of yacc.c */ 10296 #line 2430 "preproc.y" 10297 { 10298 (yyval.str) = cat_str(4,make_str("alter"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 10299@@ -27180,8 +27127,6 @@ 10300 break; 10301 10302 case 261: 10303- 10304-/* Line 1455 of yacc.c */ 10305 #line 2434 "preproc.y" 10306 { 10307 (yyval.str) = cat_str(4,make_str("alter"),(yyvsp[(2) - (6)].str),(yyvsp[(3) - (6)].str),make_str("drop not null")); 10308@@ -27189,8 +27134,6 @@ 10309 break; 10310 10311 case 262: 10312- 10313-/* Line 1455 of yacc.c */ 10314 #line 2438 "preproc.y" 10315 { 10316 (yyval.str) = cat_str(4,make_str("alter"),(yyvsp[(2) - (6)].str),(yyvsp[(3) - (6)].str),make_str("set not null")); 10317@@ -27198,8 +27141,6 @@ 10318 break; 10319 10320 case 263: 10321- 10322-/* Line 1455 of yacc.c */ 10323 #line 2442 "preproc.y" 10324 { 10325 (yyval.str) = cat_str(5,make_str("alter"),(yyvsp[(2) - (6)].str),(yyvsp[(3) - (6)].str),make_str("set statistics"),(yyvsp[(6) - (6)].str)); 10326@@ -27207,8 +27148,6 @@ 10327 break; 10328 10329 case 264: 10330- 10331-/* Line 1455 of yacc.c */ 10332 #line 2446 "preproc.y" 10333 { 10334 (yyval.str) = cat_str(5,make_str("alter"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),make_str("set"),(yyvsp[(5) - (5)].str)); 10335@@ -27216,8 +27155,6 @@ 10336 break; 10337 10338 case 265: 10339- 10340-/* Line 1455 of yacc.c */ 10341 #line 2450 "preproc.y" 10342 { 10343 (yyval.str) = cat_str(5,make_str("alter"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),make_str("reset"),(yyvsp[(5) - (5)].str)); 10344@@ -27225,8 +27162,6 @@ 10345 break; 10346 10347 case 266: 10348- 10349-/* Line 1455 of yacc.c */ 10350 #line 2454 "preproc.y" 10351 { 10352 (yyval.str) = cat_str(5,make_str("alter"),(yyvsp[(2) - (6)].str),(yyvsp[(3) - (6)].str),make_str("set storage"),(yyvsp[(6) - (6)].str)); 10353@@ -27234,8 +27169,6 @@ 10354 break; 10355 10356 case 267: 10357- 10358-/* Line 1455 of yacc.c */ 10359 #line 2458 "preproc.y" 10360 { 10361 (yyval.str) = cat_str(5,make_str("drop"),(yyvsp[(2) - (6)].str),make_str("if exists"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 10362@@ -27243,8 +27176,6 @@ 10363 break; 10364 10365 case 268: 10366- 10367-/* Line 1455 of yacc.c */ 10368 #line 2462 "preproc.y" 10369 { 10370 (yyval.str) = cat_str(4,make_str("drop"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 10371@@ -27252,8 +27183,6 @@ 10372 break; 10373 10374 case 269: 10375- 10376-/* Line 1455 of yacc.c */ 10377 #line 2466 "preproc.y" 10378 { 10379 (yyval.str) = cat_str(7,make_str("alter"),(yyvsp[(2) - (7)].str),(yyvsp[(3) - (7)].str),(yyvsp[(4) - (7)].str),make_str("type"),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 10380@@ -27261,8 +27190,6 @@ 10381 break; 10382 10383 case 270: 10384- 10385-/* Line 1455 of yacc.c */ 10386 #line 2470 "preproc.y" 10387 { 10388 (yyval.str) = cat_str(2,make_str("add"),(yyvsp[(2) - (2)].str)); 10389@@ -27270,8 +27197,6 @@ 10390 break; 10391 10392 case 271: 10393- 10394-/* Line 1455 of yacc.c */ 10395 #line 2474 "preproc.y" 10396 { 10397 (yyval.str) = cat_str(3,make_str("drop constraint if exists"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 10398@@ -27279,8 +27204,6 @@ 10399 break; 10400 10401 case 272: 10402- 10403-/* Line 1455 of yacc.c */ 10404 #line 2478 "preproc.y" 10405 { 10406 (yyval.str) = cat_str(3,make_str("drop constraint"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 10407@@ -27288,8 +27211,6 @@ 10408 break; 10409 10410 case 273: 10411- 10412-/* Line 1455 of yacc.c */ 10413 #line 2482 "preproc.y" 10414 { 10415 (yyval.str) = make_str("set with oids"); 10416@@ -27297,8 +27218,6 @@ 10417 break; 10418 10419 case 274: 10420- 10421-/* Line 1455 of yacc.c */ 10422 #line 2486 "preproc.y" 10423 { 10424 (yyval.str) = make_str("set without oids"); 10425@@ -27306,8 +27225,6 @@ 10426 break; 10427 10428 case 275: 10429- 10430-/* Line 1455 of yacc.c */ 10431 #line 2490 "preproc.y" 10432 { 10433 (yyval.str) = cat_str(2,make_str("cluster on"),(yyvsp[(3) - (3)].str)); 10434@@ -27315,8 +27232,6 @@ 10435 break; 10436 10437 case 276: 10438- 10439-/* Line 1455 of yacc.c */ 10440 #line 2494 "preproc.y" 10441 { 10442 (yyval.str) = make_str("set without cluster"); 10443@@ -27324,8 +27239,6 @@ 10444 break; 10445 10446 case 277: 10447- 10448-/* Line 1455 of yacc.c */ 10449 #line 2498 "preproc.y" 10450 { 10451 (yyval.str) = cat_str(2,make_str("enable trigger"),(yyvsp[(3) - (3)].str)); 10452@@ -27333,8 +27246,6 @@ 10453 break; 10454 10455 case 278: 10456- 10457-/* Line 1455 of yacc.c */ 10458 #line 2502 "preproc.y" 10459 { 10460 (yyval.str) = cat_str(2,make_str("enable always trigger"),(yyvsp[(4) - (4)].str)); 10461@@ -27342,8 +27253,6 @@ 10462 break; 10463 10464 case 279: 10465- 10466-/* Line 1455 of yacc.c */ 10467 #line 2506 "preproc.y" 10468 { 10469 (yyval.str) = cat_str(2,make_str("enable replica trigger"),(yyvsp[(4) - (4)].str)); 10470@@ -27351,8 +27260,6 @@ 10471 break; 10472 10473 case 280: 10474- 10475-/* Line 1455 of yacc.c */ 10476 #line 2510 "preproc.y" 10477 { 10478 (yyval.str) = make_str("enable trigger all"); 10479@@ -27360,8 +27267,6 @@ 10480 break; 10481 10482 case 281: 10483- 10484-/* Line 1455 of yacc.c */ 10485 #line 2514 "preproc.y" 10486 { 10487 (yyval.str) = make_str("enable trigger user"); 10488@@ -27369,8 +27274,6 @@ 10489 break; 10490 10491 case 282: 10492- 10493-/* Line 1455 of yacc.c */ 10494 #line 2518 "preproc.y" 10495 { 10496 (yyval.str) = cat_str(2,make_str("disable trigger"),(yyvsp[(3) - (3)].str)); 10497@@ -27378,8 +27281,6 @@ 10498 break; 10499 10500 case 283: 10501- 10502-/* Line 1455 of yacc.c */ 10503 #line 2522 "preproc.y" 10504 { 10505 (yyval.str) = make_str("disable trigger all"); 10506@@ -27387,8 +27288,6 @@ 10507 break; 10508 10509 case 284: 10510- 10511-/* Line 1455 of yacc.c */ 10512 #line 2526 "preproc.y" 10513 { 10514 (yyval.str) = make_str("disable trigger user"); 10515@@ -27396,8 +27295,6 @@ 10516 break; 10517 10518 case 285: 10519- 10520-/* Line 1455 of yacc.c */ 10521 #line 2530 "preproc.y" 10522 { 10523 (yyval.str) = cat_str(2,make_str("enable rule"),(yyvsp[(3) - (3)].str)); 10524@@ -27405,8 +27302,6 @@ 10525 break; 10526 10527 case 286: 10528- 10529-/* Line 1455 of yacc.c */ 10530 #line 2534 "preproc.y" 10531 { 10532 (yyval.str) = cat_str(2,make_str("enable always rule"),(yyvsp[(4) - (4)].str)); 10533@@ -27414,8 +27309,6 @@ 10534 break; 10535 10536 case 287: 10537- 10538-/* Line 1455 of yacc.c */ 10539 #line 2538 "preproc.y" 10540 { 10541 (yyval.str) = cat_str(2,make_str("enable replica rule"),(yyvsp[(4) - (4)].str)); 10542@@ -27423,8 +27316,6 @@ 10543 break; 10544 10545 case 288: 10546- 10547-/* Line 1455 of yacc.c */ 10548 #line 2542 "preproc.y" 10549 { 10550 (yyval.str) = cat_str(2,make_str("disable rule"),(yyvsp[(3) - (3)].str)); 10551@@ -27432,8 +27323,6 @@ 10552 break; 10553 10554 case 289: 10555- 10556-/* Line 1455 of yacc.c */ 10557 #line 2546 "preproc.y" 10558 { 10559 (yyval.str) = cat_str(2,make_str("inherit"),(yyvsp[(2) - (2)].str)); 10560@@ -27441,8 +27330,6 @@ 10561 break; 10562 10563 case 290: 10564- 10565-/* Line 1455 of yacc.c */ 10566 #line 2550 "preproc.y" 10567 { 10568 (yyval.str) = cat_str(2,make_str("no inherit"),(yyvsp[(3) - (3)].str)); 10569@@ -27450,8 +27337,6 @@ 10570 break; 10571 10572 case 291: 10573- 10574-/* Line 1455 of yacc.c */ 10575 #line 2554 "preproc.y" 10576 { 10577 (yyval.str) = cat_str(2,make_str("owner to"),(yyvsp[(3) - (3)].str)); 10578@@ -27459,8 +27344,6 @@ 10579 break; 10580 10581 case 292: 10582- 10583-/* Line 1455 of yacc.c */ 10584 #line 2558 "preproc.y" 10585 { 10586 (yyval.str) = cat_str(2,make_str("set tablespace"),(yyvsp[(3) - (3)].str)); 10587@@ -27468,8 +27351,6 @@ 10588 break; 10589 10590 case 293: 10591- 10592-/* Line 1455 of yacc.c */ 10593 #line 2562 "preproc.y" 10594 { 10595 (yyval.str) = cat_str(2,make_str("set"),(yyvsp[(2) - (2)].str)); 10596@@ -27477,8 +27358,6 @@ 10597 break; 10598 10599 case 294: 10600- 10601-/* Line 1455 of yacc.c */ 10602 #line 2566 "preproc.y" 10603 { 10604 (yyval.str) = cat_str(2,make_str("reset"),(yyvsp[(2) - (2)].str)); 10605@@ -27486,8 +27365,6 @@ 10606 break; 10607 10608 case 295: 10609- 10610-/* Line 1455 of yacc.c */ 10611 #line 2574 "preproc.y" 10612 { 10613 (yyval.str) = cat_str(2,make_str("set default"),(yyvsp[(3) - (3)].str)); 10614@@ -27495,8 +27372,6 @@ 10615 break; 10616 10617 case 296: 10618- 10619-/* Line 1455 of yacc.c */ 10620 #line 2578 "preproc.y" 10621 { 10622 (yyval.str) = make_str("drop default"); 10623@@ -27504,8 +27379,6 @@ 10624 break; 10625 10626 case 297: 10627- 10628-/* Line 1455 of yacc.c */ 10629 #line 2586 "preproc.y" 10630 { 10631 (yyval.str) = make_str("cascade"); 10632@@ -27513,8 +27386,6 @@ 10633 break; 10634 10635 case 298: 10636- 10637-/* Line 1455 of yacc.c */ 10638 #line 2590 "preproc.y" 10639 { 10640 (yyval.str) = make_str("restrict"); 10641@@ -27522,16 +27393,12 @@ 10642 break; 10643 10644 case 299: 10645- 10646-/* Line 1455 of yacc.c */ 10647 #line 2594 "preproc.y" 10648 { 10649 (yyval.str)=EMPTY; ;} 10650 break; 10651 10652 case 300: 10653- 10654-/* Line 1455 of yacc.c */ 10655 #line 2601 "preproc.y" 10656 { 10657 (yyval.str) = cat_str(2,make_str("using"),(yyvsp[(2) - (2)].str)); 10658@@ -27539,16 +27406,12 @@ 10659 break; 10660 10661 case 301: 10662- 10663-/* Line 1455 of yacc.c */ 10664 #line 2605 "preproc.y" 10665 { 10666 (yyval.str)=EMPTY; ;} 10667 break; 10668 10669 case 302: 10670- 10671-/* Line 1455 of yacc.c */ 10672 #line 2612 "preproc.y" 10673 { 10674 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 10675@@ -27556,8 +27419,6 @@ 10676 break; 10677 10678 case 303: 10679- 10680-/* Line 1455 of yacc.c */ 10681 #line 2620 "preproc.y" 10682 { 10683 (yyval.str) = cat_str(2,make_str("with"),(yyvsp[(2) - (2)].str)); 10684@@ -27565,16 +27426,12 @@ 10685 break; 10686 10687 case 304: 10688- 10689-/* Line 1455 of yacc.c */ 10690 #line 2624 "preproc.y" 10691 { 10692 (yyval.str)=EMPTY; ;} 10693 break; 10694 10695 case 305: 10696- 10697-/* Line 1455 of yacc.c */ 10698 #line 2631 "preproc.y" 10699 { 10700 (yyval.str) = (yyvsp[(1) - (1)].str); 10701@@ -27582,8 +27439,6 @@ 10702 break; 10703 10704 case 306: 10705- 10706-/* Line 1455 of yacc.c */ 10707 #line 2635 "preproc.y" 10708 { 10709 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 10710@@ -27591,8 +27446,6 @@ 10711 break; 10712 10713 case 307: 10714- 10715-/* Line 1455 of yacc.c */ 10716 #line 2643 "preproc.y" 10717 { 10718 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("="),(yyvsp[(3) - (3)].str)); 10719@@ -27600,8 +27453,6 @@ 10720 break; 10721 10722 case 308: 10723- 10724-/* Line 1455 of yacc.c */ 10725 #line 2647 "preproc.y" 10726 { 10727 (yyval.str) = (yyvsp[(1) - (1)].str); 10728@@ -27609,8 +27460,6 @@ 10729 break; 10730 10731 case 309: 10732- 10733-/* Line 1455 of yacc.c */ 10734 #line 2651 "preproc.y" 10735 { 10736 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),make_str("."),(yyvsp[(3) - (5)].str),make_str("="),(yyvsp[(5) - (5)].str)); 10737@@ -27618,8 +27467,6 @@ 10738 break; 10739 10740 case 310: 10741- 10742-/* Line 1455 of yacc.c */ 10743 #line 2655 "preproc.y" 10744 { 10745 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("."),(yyvsp[(3) - (3)].str)); 10746@@ -27627,8 +27474,6 @@ 10747 break; 10748 10749 case 311: 10750- 10751-/* Line 1455 of yacc.c */ 10752 #line 2663 "preproc.y" 10753 { 10754 char *cursor_marker = (yyvsp[(2) - (2)].str)[0] == ':' ? make_str("$0") : (yyvsp[(2) - (2)].str); 10755@@ -27637,8 +27482,6 @@ 10756 break; 10757 10758 case 312: 10759- 10760-/* Line 1455 of yacc.c */ 10761 #line 2668 "preproc.y" 10762 { 10763 (yyval.str) = make_str("close all"); 10764@@ -27646,8 +27489,6 @@ 10765 break; 10766 10767 case 313: 10768- 10769-/* Line 1455 of yacc.c */ 10770 #line 2676 "preproc.y" 10771 { 10772 if (strcmp((yyvsp[(6) - (10)].str), "to") == 0 && strcmp((yyvsp[(7) - (10)].str), "stdin") == 0) 10773@@ -27662,8 +27503,6 @@ 10774 break; 10775 10776 case 314: 10777- 10778-/* Line 1455 of yacc.c */ 10779 #line 2687 "preproc.y" 10780 { 10781 if (strcmp((yyvsp[(4) - (6)].str), "stdin") == 0) 10782@@ -27674,8 +27513,6 @@ 10783 break; 10784 10785 case 315: 10786- 10787-/* Line 1455 of yacc.c */ 10788 #line 2698 "preproc.y" 10789 { 10790 (yyval.str) = make_str("from"); 10791@@ -27683,8 +27520,6 @@ 10792 break; 10793 10794 case 316: 10795- 10796-/* Line 1455 of yacc.c */ 10797 #line 2702 "preproc.y" 10798 { 10799 (yyval.str) = make_str("to"); 10800@@ -27692,8 +27527,6 @@ 10801 break; 10802 10803 case 317: 10804- 10805-/* Line 1455 of yacc.c */ 10806 #line 2710 "preproc.y" 10807 { 10808 (yyval.str) = (yyvsp[(1) - (1)].str); 10809@@ -27701,8 +27534,6 @@ 10810 break; 10811 10812 case 318: 10813- 10814-/* Line 1455 of yacc.c */ 10815 #line 2714 "preproc.y" 10816 { 10817 (yyval.str) = make_str("stdin"); 10818@@ -27710,8 +27541,6 @@ 10819 break; 10820 10821 case 319: 10822- 10823-/* Line 1455 of yacc.c */ 10824 #line 2718 "preproc.y" 10825 { 10826 (yyval.str) = make_str("stdout"); 10827@@ -27719,8 +27548,6 @@ 10828 break; 10829 10830 case 320: 10831- 10832-/* Line 1455 of yacc.c */ 10833 #line 2726 "preproc.y" 10834 { 10835 (yyval.str) = (yyvsp[(1) - (1)].str); 10836@@ -27728,8 +27555,6 @@ 10837 break; 10838 10839 case 321: 10840- 10841-/* Line 1455 of yacc.c */ 10842 #line 2730 "preproc.y" 10843 { 10844 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 10845@@ -27737,8 +27562,6 @@ 10846 break; 10847 10848 case 322: 10849- 10850-/* Line 1455 of yacc.c */ 10851 #line 2738 "preproc.y" 10852 { 10853 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 10854@@ -27746,16 +27569,12 @@ 10855 break; 10856 10857 case 323: 10858- 10859-/* Line 1455 of yacc.c */ 10860 #line 2742 "preproc.y" 10861 { 10862 (yyval.str)=EMPTY; ;} 10863 break; 10864 10865 case 324: 10866- 10867-/* Line 1455 of yacc.c */ 10868 #line 2749 "preproc.y" 10869 { 10870 (yyval.str) = make_str("binary"); 10871@@ -27763,8 +27582,6 @@ 10872 break; 10873 10874 case 325: 10875- 10876-/* Line 1455 of yacc.c */ 10877 #line 2753 "preproc.y" 10878 { 10879 (yyval.str) = make_str("oids"); 10880@@ -27772,8 +27589,6 @@ 10881 break; 10882 10883 case 326: 10884- 10885-/* Line 1455 of yacc.c */ 10886 #line 2757 "preproc.y" 10887 { 10888 (yyval.str) = cat_str(3,make_str("delimiter"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 10889@@ -27781,8 +27596,6 @@ 10890 break; 10891 10892 case 327: 10893- 10894-/* Line 1455 of yacc.c */ 10895 #line 2761 "preproc.y" 10896 { 10897 (yyval.str) = cat_str(3,make_str("null"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 10898@@ -27790,8 +27603,6 @@ 10899 break; 10900 10901 case 328: 10902- 10903-/* Line 1455 of yacc.c */ 10904 #line 2765 "preproc.y" 10905 { 10906 (yyval.str) = make_str("csv"); 10907@@ -27799,8 +27610,6 @@ 10908 break; 10909 10910 case 329: 10911- 10912-/* Line 1455 of yacc.c */ 10913 #line 2769 "preproc.y" 10914 { 10915 (yyval.str) = make_str("header"); 10916@@ -27808,8 +27617,6 @@ 10917 break; 10918 10919 case 330: 10920- 10921-/* Line 1455 of yacc.c */ 10922 #line 2773 "preproc.y" 10923 { 10924 (yyval.str) = cat_str(3,make_str("quote"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 10925@@ -27817,8 +27624,6 @@ 10926 break; 10927 10928 case 331: 10929- 10930-/* Line 1455 of yacc.c */ 10931 #line 2777 "preproc.y" 10932 { 10933 (yyval.str) = cat_str(3,make_str("escape"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 10934@@ -27826,8 +27631,6 @@ 10935 break; 10936 10937 case 332: 10938- 10939-/* Line 1455 of yacc.c */ 10940 #line 2781 "preproc.y" 10941 { 10942 (yyval.str) = cat_str(2,make_str("force quote"),(yyvsp[(3) - (3)].str)); 10943@@ -27835,8 +27638,6 @@ 10944 break; 10945 10946 case 333: 10947- 10948-/* Line 1455 of yacc.c */ 10949 #line 2785 "preproc.y" 10950 { 10951 (yyval.str) = make_str("force quote *"); 10952@@ -27844,8 +27645,6 @@ 10953 break; 10954 10955 case 334: 10956- 10957-/* Line 1455 of yacc.c */ 10958 #line 2789 "preproc.y" 10959 { 10960 (yyval.str) = cat_str(2,make_str("force not null"),(yyvsp[(4) - (4)].str)); 10961@@ -27853,8 +27652,6 @@ 10962 break; 10963 10964 case 335: 10965- 10966-/* Line 1455 of yacc.c */ 10967 #line 2797 "preproc.y" 10968 { 10969 (yyval.str) = make_str("binary"); 10970@@ -27862,16 +27659,12 @@ 10971 break; 10972 10973 case 336: 10974- 10975-/* Line 1455 of yacc.c */ 10976 #line 2801 "preproc.y" 10977 { 10978 (yyval.str)=EMPTY; ;} 10979 break; 10980 10981 case 337: 10982- 10983-/* Line 1455 of yacc.c */ 10984 #line 2808 "preproc.y" 10985 { 10986 (yyval.str) = make_str("with oids"); 10987@@ -27879,16 +27672,12 @@ 10988 break; 10989 10990 case 338: 10991- 10992-/* Line 1455 of yacc.c */ 10993 #line 2812 "preproc.y" 10994 { 10995 (yyval.str)=EMPTY; ;} 10996 break; 10997 10998 case 339: 10999- 11000-/* Line 1455 of yacc.c */ 11001 #line 2819 "preproc.y" 11002 { 11003 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("delimiters"),(yyvsp[(3) - (3)].str)); 11004@@ -27896,16 +27685,12 @@ 11005 break; 11006 11007 case 340: 11008- 11009-/* Line 1455 of yacc.c */ 11010 #line 2823 "preproc.y" 11011 { 11012 (yyval.str)=EMPTY; ;} 11013 break; 11014 11015 case 341: 11016- 11017-/* Line 1455 of yacc.c */ 11018 #line 2830 "preproc.y" 11019 { 11020 (yyval.str) = make_str("using"); 11021@@ -27913,16 +27698,12 @@ 11022 break; 11023 11024 case 342: 11025- 11026-/* Line 1455 of yacc.c */ 11027 #line 2834 "preproc.y" 11028 { 11029 (yyval.str)=EMPTY; ;} 11030 break; 11031 11032 case 343: 11033- 11034-/* Line 1455 of yacc.c */ 11035 #line 2841 "preproc.y" 11036 { 11037 (yyval.str) = (yyvsp[(1) - (1)].str); 11038@@ -27930,8 +27711,6 @@ 11039 break; 11040 11041 case 344: 11042- 11043-/* Line 1455 of yacc.c */ 11044 #line 2845 "preproc.y" 11045 { 11046 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 11047@@ -27939,8 +27718,6 @@ 11048 break; 11049 11050 case 345: 11051- 11052-/* Line 1455 of yacc.c */ 11053 #line 2853 "preproc.y" 11054 { 11055 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 11056@@ -27948,8 +27725,6 @@ 11057 break; 11058 11059 case 346: 11060- 11061-/* Line 1455 of yacc.c */ 11062 #line 2861 "preproc.y" 11063 { 11064 (yyval.str) = (yyvsp[(1) - (1)].str); 11065@@ -27957,8 +27732,6 @@ 11066 break; 11067 11068 case 347: 11069- 11070-/* Line 1455 of yacc.c */ 11071 #line 2865 "preproc.y" 11072 { 11073 (yyval.str) = (yyvsp[(1) - (1)].str); 11074@@ -27966,8 +27739,6 @@ 11075 break; 11076 11077 case 348: 11078- 11079-/* Line 1455 of yacc.c */ 11080 #line 2869 "preproc.y" 11081 { 11082 (yyval.str) = make_str("*"); 11083@@ -27975,8 +27746,6 @@ 11084 break; 11085 11086 case 349: 11087- 11088-/* Line 1455 of yacc.c */ 11089 #line 2873 "preproc.y" 11090 { 11091 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 11092@@ -27984,16 +27753,12 @@ 11093 break; 11094 11095 case 350: 11096- 11097-/* Line 1455 of yacc.c */ 11098 #line 2877 "preproc.y" 11099 { 11100 (yyval.str)=EMPTY; ;} 11101 break; 11102 11103 case 351: 11104- 11105-/* Line 1455 of yacc.c */ 11106 #line 2884 "preproc.y" 11107 { 11108 (yyval.str) = (yyvsp[(1) - (1)].str); 11109@@ -28001,8 +27766,6 @@ 11110 break; 11111 11112 case 352: 11113- 11114-/* Line 1455 of yacc.c */ 11115 #line 2888 "preproc.y" 11116 { 11117 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 11118@@ -28010,8 +27773,6 @@ 11119 break; 11120 11121 case 353: 11122- 11123-/* Line 1455 of yacc.c */ 11124 #line 2896 "preproc.y" 11125 { 11126 (yyval.str) = (yyvsp[(1) - (1)].str); 11127@@ -28019,8 +27780,6 @@ 11128 break; 11129 11130 case 354: 11131- 11132-/* Line 1455 of yacc.c */ 11133 #line 2904 "preproc.y" 11134 { 11135 (yyval.str) = cat_str(11,make_str("create"),(yyvsp[(2) - (11)].str),make_str("table"),(yyvsp[(4) - (11)].str),make_str("("),(yyvsp[(6) - (11)].str),make_str(")"),(yyvsp[(8) - (11)].str),(yyvsp[(9) - (11)].str),(yyvsp[(10) - (11)].str),(yyvsp[(11) - (11)].str)); 11136@@ -28028,8 +27787,6 @@ 11137 break; 11138 11139 case 355: 11140- 11141-/* Line 1455 of yacc.c */ 11142 #line 2908 "preproc.y" 11143 { 11144 (yyval.str) = cat_str(10,make_str("create"),(yyvsp[(2) - (10)].str),make_str("table"),(yyvsp[(4) - (10)].str),make_str("of"),(yyvsp[(6) - (10)].str),(yyvsp[(7) - (10)].str),(yyvsp[(8) - (10)].str),(yyvsp[(9) - (10)].str),(yyvsp[(10) - (10)].str)); 11145@@ -28037,8 +27794,6 @@ 11146 break; 11147 11148 case 356: 11149- 11150-/* Line 1455 of yacc.c */ 11151 #line 2916 "preproc.y" 11152 { 11153 (yyval.str) = make_str("temporary"); 11154@@ -28046,8 +27801,6 @@ 11155 break; 11156 11157 case 357: 11158- 11159-/* Line 1455 of yacc.c */ 11160 #line 2920 "preproc.y" 11161 { 11162 (yyval.str) = make_str("temp"); 11163@@ -28055,8 +27808,6 @@ 11164 break; 11165 11166 case 358: 11167- 11168-/* Line 1455 of yacc.c */ 11169 #line 2924 "preproc.y" 11170 { 11171 (yyval.str) = make_str("local temporary"); 11172@@ -28064,8 +27815,6 @@ 11173 break; 11174 11175 case 359: 11176- 11177-/* Line 1455 of yacc.c */ 11178 #line 2928 "preproc.y" 11179 { 11180 (yyval.str) = make_str("local temp"); 11181@@ -28073,8 +27822,6 @@ 11182 break; 11183 11184 case 360: 11185- 11186-/* Line 1455 of yacc.c */ 11187 #line 2932 "preproc.y" 11188 { 11189 (yyval.str) = make_str("global temporary"); 11190@@ -28082,8 +27829,6 @@ 11191 break; 11192 11193 case 361: 11194- 11195-/* Line 1455 of yacc.c */ 11196 #line 2936 "preproc.y" 11197 { 11198 (yyval.str) = make_str("global temp"); 11199@@ -28091,16 +27836,12 @@ 11200 break; 11201 11202 case 362: 11203- 11204-/* Line 1455 of yacc.c */ 11205 #line 2940 "preproc.y" 11206 { 11207 (yyval.str)=EMPTY; ;} 11208 break; 11209 11210 case 363: 11211- 11212-/* Line 1455 of yacc.c */ 11213 #line 2947 "preproc.y" 11214 { 11215 (yyval.str) = (yyvsp[(1) - (1)].str); 11216@@ -28108,16 +27849,12 @@ 11217 break; 11218 11219 case 364: 11220- 11221-/* Line 1455 of yacc.c */ 11222 #line 2951 "preproc.y" 11223 { 11224 (yyval.str)=EMPTY; ;} 11225 break; 11226 11227 case 365: 11228- 11229-/* Line 1455 of yacc.c */ 11230 #line 2958 "preproc.y" 11231 { 11232 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 11233@@ -28125,16 +27862,12 @@ 11234 break; 11235 11236 case 366: 11237- 11238-/* Line 1455 of yacc.c */ 11239 #line 2962 "preproc.y" 11240 { 11241 (yyval.str)=EMPTY; ;} 11242 break; 11243 11244 case 367: 11245- 11246-/* Line 1455 of yacc.c */ 11247 #line 2969 "preproc.y" 11248 { 11249 (yyval.str) = (yyvsp[(1) - (1)].str); 11250@@ -28142,8 +27875,6 @@ 11251 break; 11252 11253 case 368: 11254- 11255-/* Line 1455 of yacc.c */ 11256 #line 2973 "preproc.y" 11257 { 11258 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 11259@@ -28151,8 +27882,6 @@ 11260 break; 11261 11262 case 369: 11263- 11264-/* Line 1455 of yacc.c */ 11265 #line 2981 "preproc.y" 11266 { 11267 (yyval.str) = (yyvsp[(1) - (1)].str); 11268@@ -28160,8 +27889,6 @@ 11269 break; 11270 11271 case 370: 11272- 11273-/* Line 1455 of yacc.c */ 11274 #line 2985 "preproc.y" 11275 { 11276 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 11277@@ -28169,8 +27896,6 @@ 11278 break; 11279 11280 case 371: 11281- 11282-/* Line 1455 of yacc.c */ 11283 #line 2993 "preproc.y" 11284 { 11285 (yyval.str) = (yyvsp[(1) - (1)].str); 11286@@ -28178,8 +27903,6 @@ 11287 break; 11288 11289 case 372: 11290- 11291-/* Line 1455 of yacc.c */ 11292 #line 2997 "preproc.y" 11293 { 11294 (yyval.str) = (yyvsp[(1) - (1)].str); 11295@@ -28187,8 +27910,6 @@ 11296 break; 11297 11298 case 373: 11299- 11300-/* Line 1455 of yacc.c */ 11301 #line 3001 "preproc.y" 11302 { 11303 (yyval.str) = (yyvsp[(1) - (1)].str); 11304@@ -28196,8 +27917,6 @@ 11305 break; 11306 11307 case 374: 11308- 11309-/* Line 1455 of yacc.c */ 11310 #line 3009 "preproc.y" 11311 { 11312 (yyval.str) = (yyvsp[(1) - (1)].str); 11313@@ -28205,8 +27924,6 @@ 11314 break; 11315 11316 case 375: 11317- 11318-/* Line 1455 of yacc.c */ 11319 #line 3013 "preproc.y" 11320 { 11321 (yyval.str) = (yyvsp[(1) - (1)].str); 11322@@ -28214,8 +27931,6 @@ 11323 break; 11324 11325 case 376: 11326- 11327-/* Line 1455 of yacc.c */ 11328 #line 3021 "preproc.y" 11329 { 11330 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 11331@@ -28223,8 +27938,6 @@ 11332 break; 11333 11334 case 377: 11335- 11336-/* Line 1455 of yacc.c */ 11337 #line 3029 "preproc.y" 11338 { 11339 (yyval.str) = cat_str(3,(yyvsp[(1) - (4)].str),make_str("with options"),(yyvsp[(4) - (4)].str)); 11340@@ -28232,8 +27945,6 @@ 11341 break; 11342 11343 case 378: 11344- 11345-/* Line 1455 of yacc.c */ 11346 #line 3037 "preproc.y" 11347 { 11348 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 11349@@ -28241,16 +27952,12 @@ 11350 break; 11351 11352 case 379: 11353- 11354-/* Line 1455 of yacc.c */ 11355 #line 3041 "preproc.y" 11356 { 11357 (yyval.str)=EMPTY; ;} 11358 break; 11359 11360 case 380: 11361- 11362-/* Line 1455 of yacc.c */ 11363 #line 3048 "preproc.y" 11364 { 11365 (yyval.str) = cat_str(3,make_str("constraint"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 11366@@ -28258,8 +27965,6 @@ 11367 break; 11368 11369 case 381: 11370- 11371-/* Line 1455 of yacc.c */ 11372 #line 3052 "preproc.y" 11373 { 11374 (yyval.str) = (yyvsp[(1) - (1)].str); 11375@@ -28267,8 +27972,6 @@ 11376 break; 11377 11378 case 382: 11379- 11380-/* Line 1455 of yacc.c */ 11381 #line 3056 "preproc.y" 11382 { 11383 (yyval.str) = (yyvsp[(1) - (1)].str); 11384@@ -28276,8 +27979,6 @@ 11385 break; 11386 11387 case 383: 11388- 11389-/* Line 1455 of yacc.c */ 11390 #line 3064 "preproc.y" 11391 { 11392 (yyval.str) = make_str("not null"); 11393@@ -28285,8 +27986,6 @@ 11394 break; 11395 11396 case 384: 11397- 11398-/* Line 1455 of yacc.c */ 11399 #line 3068 "preproc.y" 11400 { 11401 (yyval.str) = make_str("null"); 11402@@ -28294,8 +27993,6 @@ 11403 break; 11404 11405 case 385: 11406- 11407-/* Line 1455 of yacc.c */ 11408 #line 3072 "preproc.y" 11409 { 11410 (yyval.str) = cat_str(3,make_str("unique"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 11411@@ -28303,8 +28000,6 @@ 11412 break; 11413 11414 case 386: 11415- 11416-/* Line 1455 of yacc.c */ 11417 #line 3076 "preproc.y" 11418 { 11419 (yyval.str) = cat_str(3,make_str("primary key"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 11420@@ -28312,8 +28007,6 @@ 11421 break; 11422 11423 case 387: 11424- 11425-/* Line 1455 of yacc.c */ 11426 #line 3080 "preproc.y" 11427 { 11428 (yyval.str) = cat_str(3,make_str("check ("),(yyvsp[(3) - (4)].str),make_str(")")); 11429@@ -28321,8 +28014,6 @@ 11430 break; 11431 11432 case 388: 11433- 11434-/* Line 1455 of yacc.c */ 11435 #line 3084 "preproc.y" 11436 { 11437 (yyval.str) = cat_str(2,make_str("default"),(yyvsp[(2) - (2)].str)); 11438@@ -28330,8 +28021,6 @@ 11439 break; 11440 11441 case 389: 11442- 11443-/* Line 1455 of yacc.c */ 11444 #line 3088 "preproc.y" 11445 { 11446 (yyval.str) = cat_str(5,make_str("references"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 11447@@ -28339,8 +28028,6 @@ 11448 break; 11449 11450 case 390: 11451- 11452-/* Line 1455 of yacc.c */ 11453 #line 3096 "preproc.y" 11454 { 11455 (yyval.str) = make_str("deferrable"); 11456@@ -28348,8 +28035,6 @@ 11457 break; 11458 11459 case 391: 11460- 11461-/* Line 1455 of yacc.c */ 11462 #line 3100 "preproc.y" 11463 { 11464 (yyval.str) = make_str("not deferrable"); 11465@@ -28357,8 +28042,6 @@ 11466 break; 11467 11468 case 392: 11469- 11470-/* Line 1455 of yacc.c */ 11471 #line 3104 "preproc.y" 11472 { 11473 (yyval.str) = make_str("initially deferred"); 11474@@ -28366,8 +28049,6 @@ 11475 break; 11476 11477 case 393: 11478- 11479-/* Line 1455 of yacc.c */ 11480 #line 3108 "preproc.y" 11481 { 11482 (yyval.str) = make_str("initially immediate"); 11483@@ -28375,8 +28056,6 @@ 11484 break; 11485 11486 case 394: 11487- 11488-/* Line 1455 of yacc.c */ 11489 #line 3116 "preproc.y" 11490 { 11491 (yyval.str) = cat_str(3,make_str("like"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 11492@@ -28384,8 +28063,6 @@ 11493 break; 11494 11495 case 395: 11496- 11497-/* Line 1455 of yacc.c */ 11498 #line 3124 "preproc.y" 11499 { 11500 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("including"),(yyvsp[(3) - (3)].str)); 11501@@ -28393,8 +28070,6 @@ 11502 break; 11503 11504 case 396: 11505- 11506-/* Line 1455 of yacc.c */ 11507 #line 3128 "preproc.y" 11508 { 11509 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("excluding"),(yyvsp[(3) - (3)].str)); 11510@@ -28402,16 +28077,12 @@ 11511 break; 11512 11513 case 397: 11514- 11515-/* Line 1455 of yacc.c */ 11516 #line 3132 "preproc.y" 11517 { 11518 (yyval.str)=EMPTY; ;} 11519 break; 11520 11521 case 398: 11522- 11523-/* Line 1455 of yacc.c */ 11524 #line 3139 "preproc.y" 11525 { 11526 (yyval.str) = make_str("defaults"); 11527@@ -28419,8 +28090,6 @@ 11528 break; 11529 11530 case 399: 11531- 11532-/* Line 1455 of yacc.c */ 11533 #line 3143 "preproc.y" 11534 { 11535 (yyval.str) = make_str("constraints"); 11536@@ -28428,8 +28097,6 @@ 11537 break; 11538 11539 case 400: 11540- 11541-/* Line 1455 of yacc.c */ 11542 #line 3147 "preproc.y" 11543 { 11544 (yyval.str) = make_str("indexes"); 11545@@ -28437,8 +28104,6 @@ 11546 break; 11547 11548 case 401: 11549- 11550-/* Line 1455 of yacc.c */ 11551 #line 3151 "preproc.y" 11552 { 11553 (yyval.str) = make_str("storage"); 11554@@ -28446,8 +28111,6 @@ 11555 break; 11556 11557 case 402: 11558- 11559-/* Line 1455 of yacc.c */ 11560 #line 3155 "preproc.y" 11561 { 11562 (yyval.str) = make_str("comments"); 11563@@ -28455,8 +28118,6 @@ 11564 break; 11565 11566 case 403: 11567- 11568-/* Line 1455 of yacc.c */ 11569 #line 3159 "preproc.y" 11570 { 11571 (yyval.str) = make_str("all"); 11572@@ -28464,8 +28125,6 @@ 11573 break; 11574 11575 case 404: 11576- 11577-/* Line 1455 of yacc.c */ 11578 #line 3167 "preproc.y" 11579 { 11580 (yyval.str) = cat_str(3,make_str("constraint"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 11581@@ -28473,8 +28132,6 @@ 11582 break; 11583 11584 case 405: 11585- 11586-/* Line 1455 of yacc.c */ 11587 #line 3171 "preproc.y" 11588 { 11589 (yyval.str) = (yyvsp[(1) - (1)].str); 11590@@ -28482,8 +28139,6 @@ 11591 break; 11592 11593 case 406: 11594- 11595-/* Line 1455 of yacc.c */ 11596 #line 3179 "preproc.y" 11597 { 11598 mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server"); 11599@@ -28492,8 +28147,6 @@ 11600 break; 11601 11602 case 407: 11603- 11604-/* Line 1455 of yacc.c */ 11605 #line 3184 "preproc.y" 11606 { 11607 (yyval.str) = cat_str(6,make_str("unique ("),(yyvsp[(3) - (7)].str),make_str(")"),(yyvsp[(5) - (7)].str),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 11608@@ -28501,8 +28154,6 @@ 11609 break; 11610 11611 case 408: 11612- 11613-/* Line 1455 of yacc.c */ 11614 #line 3188 "preproc.y" 11615 { 11616 (yyval.str) = cat_str(6,make_str("primary key ("),(yyvsp[(4) - (8)].str),make_str(")"),(yyvsp[(6) - (8)].str),(yyvsp[(7) - (8)].str),(yyvsp[(8) - (8)].str)); 11617@@ -28510,8 +28161,6 @@ 11618 break; 11619 11620 case 409: 11621- 11622-/* Line 1455 of yacc.c */ 11623 #line 3192 "preproc.y" 11624 { 11625 (yyval.str) = cat_str(9,make_str("exclude"),(yyvsp[(2) - (9)].str),make_str("("),(yyvsp[(4) - (9)].str),make_str(")"),(yyvsp[(6) - (9)].str),(yyvsp[(7) - (9)].str),(yyvsp[(8) - (9)].str),(yyvsp[(9) - (9)].str)); 11626@@ -28519,8 +28168,6 @@ 11627 break; 11628 11629 case 410: 11630- 11631-/* Line 1455 of yacc.c */ 11632 #line 3196 "preproc.y" 11633 { 11634 (yyval.str) = cat_str(8,make_str("foreign key ("),(yyvsp[(4) - (11)].str),make_str(") references"),(yyvsp[(7) - (11)].str),(yyvsp[(8) - (11)].str),(yyvsp[(9) - (11)].str),(yyvsp[(10) - (11)].str),(yyvsp[(11) - (11)].str)); 11635@@ -28528,8 +28175,6 @@ 11636 break; 11637 11638 case 411: 11639- 11640-/* Line 1455 of yacc.c */ 11641 #line 3204 "preproc.y" 11642 { 11643 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 11644@@ -28537,16 +28182,12 @@ 11645 break; 11646 11647 case 412: 11648- 11649-/* Line 1455 of yacc.c */ 11650 #line 3208 "preproc.y" 11651 { 11652 (yyval.str)=EMPTY; ;} 11653 break; 11654 11655 case 413: 11656- 11657-/* Line 1455 of yacc.c */ 11658 #line 3215 "preproc.y" 11659 { 11660 (yyval.str) = (yyvsp[(1) - (1)].str); 11661@@ -28554,8 +28195,6 @@ 11662 break; 11663 11664 case 414: 11665- 11666-/* Line 1455 of yacc.c */ 11667 #line 3219 "preproc.y" 11668 { 11669 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 11670@@ -28563,8 +28202,6 @@ 11671 break; 11672 11673 case 415: 11674- 11675-/* Line 1455 of yacc.c */ 11676 #line 3227 "preproc.y" 11677 { 11678 (yyval.str) = (yyvsp[(1) - (1)].str); 11679@@ -28572,8 +28209,6 @@ 11680 break; 11681 11682 case 416: 11683- 11684-/* Line 1455 of yacc.c */ 11685 #line 3235 "preproc.y" 11686 { 11687 (yyval.str) = make_str("match full"); 11688@@ -28581,8 +28216,6 @@ 11689 break; 11690 11691 case 417: 11692- 11693-/* Line 1455 of yacc.c */ 11694 #line 3239 "preproc.y" 11695 { 11696 mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server"); 11697@@ -28591,8 +28224,6 @@ 11698 break; 11699 11700 case 418: 11701- 11702-/* Line 1455 of yacc.c */ 11703 #line 3244 "preproc.y" 11704 { 11705 (yyval.str) = make_str("match simple"); 11706@@ -28600,16 +28231,12 @@ 11707 break; 11708 11709 case 419: 11710- 11711-/* Line 1455 of yacc.c */ 11712 #line 3248 "preproc.y" 11713 { 11714 (yyval.str)=EMPTY; ;} 11715 break; 11716 11717 case 420: 11718- 11719-/* Line 1455 of yacc.c */ 11720 #line 3255 "preproc.y" 11721 { 11722 (yyval.str) = (yyvsp[(1) - (1)].str); 11723@@ -28617,8 +28244,6 @@ 11724 break; 11725 11726 case 421: 11727- 11728-/* Line 1455 of yacc.c */ 11729 #line 3259 "preproc.y" 11730 { 11731 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 11732@@ -28626,8 +28251,6 @@ 11733 break; 11734 11735 case 422: 11736- 11737-/* Line 1455 of yacc.c */ 11738 #line 3267 "preproc.y" 11739 { 11740 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("with"),(yyvsp[(3) - (3)].str)); 11741@@ -28635,8 +28258,6 @@ 11742 break; 11743 11744 case 423: 11745- 11746-/* Line 1455 of yacc.c */ 11747 #line 3271 "preproc.y" 11748 { 11749 (yyval.str) = cat_str(4,(yyvsp[(1) - (6)].str),make_str("with operator ("),(yyvsp[(5) - (6)].str),make_str(")")); 11750@@ -28644,8 +28265,6 @@ 11751 break; 11752 11753 case 424: 11754- 11755-/* Line 1455 of yacc.c */ 11756 #line 3279 "preproc.y" 11757 { 11758 (yyval.str) = cat_str(3,make_str("where ("),(yyvsp[(3) - (4)].str),make_str(")")); 11759@@ -28653,16 +28272,12 @@ 11760 break; 11761 11762 case 425: 11763- 11764-/* Line 1455 of yacc.c */ 11765 #line 3283 "preproc.y" 11766 { 11767 (yyval.str)=EMPTY; ;} 11768 break; 11769 11770 case 426: 11771- 11772-/* Line 1455 of yacc.c */ 11773 #line 3290 "preproc.y" 11774 { 11775 (yyval.str) = (yyvsp[(1) - (1)].str); 11776@@ -28670,8 +28285,6 @@ 11777 break; 11778 11779 case 427: 11780- 11781-/* Line 1455 of yacc.c */ 11782 #line 3294 "preproc.y" 11783 { 11784 (yyval.str) = (yyvsp[(1) - (1)].str); 11785@@ -28679,8 +28292,6 @@ 11786 break; 11787 11788 case 428: 11789- 11790-/* Line 1455 of yacc.c */ 11791 #line 3298 "preproc.y" 11792 { 11793 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 11794@@ -28688,8 +28299,6 @@ 11795 break; 11796 11797 case 429: 11798- 11799-/* Line 1455 of yacc.c */ 11800 #line 3302 "preproc.y" 11801 { 11802 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 11803@@ -28697,16 +28306,12 @@ 11804 break; 11805 11806 case 430: 11807- 11808-/* Line 1455 of yacc.c */ 11809 #line 3306 "preproc.y" 11810 { 11811 (yyval.str)=EMPTY; ;} 11812 break; 11813 11814 case 431: 11815- 11816-/* Line 1455 of yacc.c */ 11817 #line 3313 "preproc.y" 11818 { 11819 (yyval.str) = cat_str(2,make_str("on update"),(yyvsp[(3) - (3)].str)); 11820@@ -28714,8 +28319,6 @@ 11821 break; 11822 11823 case 432: 11824- 11825-/* Line 1455 of yacc.c */ 11826 #line 3321 "preproc.y" 11827 { 11828 (yyval.str) = cat_str(2,make_str("on delete"),(yyvsp[(3) - (3)].str)); 11829@@ -28723,8 +28326,6 @@ 11830 break; 11831 11832 case 433: 11833- 11834-/* Line 1455 of yacc.c */ 11835 #line 3329 "preproc.y" 11836 { 11837 (yyval.str) = make_str("no action"); 11838@@ -28732,8 +28333,6 @@ 11839 break; 11840 11841 case 434: 11842- 11843-/* Line 1455 of yacc.c */ 11844 #line 3333 "preproc.y" 11845 { 11846 (yyval.str) = make_str("restrict"); 11847@@ -28741,8 +28340,6 @@ 11848 break; 11849 11850 case 435: 11851- 11852-/* Line 1455 of yacc.c */ 11853 #line 3337 "preproc.y" 11854 { 11855 (yyval.str) = make_str("cascade"); 11856@@ -28750,8 +28347,6 @@ 11857 break; 11858 11859 case 436: 11860- 11861-/* Line 1455 of yacc.c */ 11862 #line 3341 "preproc.y" 11863 { 11864 (yyval.str) = make_str("set null"); 11865@@ -28759,8 +28354,6 @@ 11866 break; 11867 11868 case 437: 11869- 11870-/* Line 1455 of yacc.c */ 11871 #line 3345 "preproc.y" 11872 { 11873 (yyval.str) = make_str("set default"); 11874@@ -28768,8 +28361,6 @@ 11875 break; 11876 11877 case 438: 11878- 11879-/* Line 1455 of yacc.c */ 11880 #line 3353 "preproc.y" 11881 { 11882 (yyval.str) = cat_str(3,make_str("inherits ("),(yyvsp[(3) - (4)].str),make_str(")")); 11883@@ -28777,16 +28368,12 @@ 11884 break; 11885 11886 case 439: 11887- 11888-/* Line 1455 of yacc.c */ 11889 #line 3357 "preproc.y" 11890 { 11891 (yyval.str)=EMPTY; ;} 11892 break; 11893 11894 case 440: 11895- 11896-/* Line 1455 of yacc.c */ 11897 #line 3364 "preproc.y" 11898 { 11899 (yyval.str) = cat_str(2,make_str("with"),(yyvsp[(2) - (2)].str)); 11900@@ -28794,8 +28381,6 @@ 11901 break; 11902 11903 case 441: 11904- 11905-/* Line 1455 of yacc.c */ 11906 #line 3368 "preproc.y" 11907 { 11908 (yyval.str) = make_str("with oids"); 11909@@ -28803,8 +28388,6 @@ 11910 break; 11911 11912 case 442: 11913- 11914-/* Line 1455 of yacc.c */ 11915 #line 3372 "preproc.y" 11916 { 11917 (yyval.str) = make_str("without oids"); 11918@@ -28812,16 +28395,12 @@ 11919 break; 11920 11921 case 443: 11922- 11923-/* Line 1455 of yacc.c */ 11924 #line 3376 "preproc.y" 11925 { 11926 (yyval.str)=EMPTY; ;} 11927 break; 11928 11929 case 444: 11930- 11931-/* Line 1455 of yacc.c */ 11932 #line 3383 "preproc.y" 11933 { 11934 (yyval.str) = make_str("on commit drop"); 11935@@ -28829,8 +28408,6 @@ 11936 break; 11937 11938 case 445: 11939- 11940-/* Line 1455 of yacc.c */ 11941 #line 3387 "preproc.y" 11942 { 11943 (yyval.str) = make_str("on commit delete rows"); 11944@@ -28838,8 +28415,6 @@ 11945 break; 11946 11947 case 446: 11948- 11949-/* Line 1455 of yacc.c */ 11950 #line 3391 "preproc.y" 11951 { 11952 (yyval.str) = make_str("on commit preserve rows"); 11953@@ -28847,16 +28422,12 @@ 11954 break; 11955 11956 case 447: 11957- 11958-/* Line 1455 of yacc.c */ 11959 #line 3395 "preproc.y" 11960 { 11961 (yyval.str)=EMPTY; ;} 11962 break; 11963 11964 case 448: 11965- 11966-/* Line 1455 of yacc.c */ 11967 #line 3402 "preproc.y" 11968 { 11969 (yyval.str) = cat_str(2,make_str("tablespace"),(yyvsp[(2) - (2)].str)); 11970@@ -28864,16 +28435,12 @@ 11971 break; 11972 11973 case 449: 11974- 11975-/* Line 1455 of yacc.c */ 11976 #line 3406 "preproc.y" 11977 { 11978 (yyval.str)=EMPTY; ;} 11979 break; 11980 11981 case 450: 11982- 11983-/* Line 1455 of yacc.c */ 11984 #line 3413 "preproc.y" 11985 { 11986 (yyval.str) = cat_str(2,make_str("using index tablespace"),(yyvsp[(4) - (4)].str)); 11987@@ -28881,16 +28448,12 @@ 11988 break; 11989 11990 case 451: 11991- 11992-/* Line 1455 of yacc.c */ 11993 #line 3417 "preproc.y" 11994 { 11995 (yyval.str)=EMPTY; ;} 11996 break; 11997 11998 case 452: 11999- 12000-/* Line 1455 of yacc.c */ 12001 #line 3424 "preproc.y" 12002 { 12003 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 12004@@ -28898,8 +28461,6 @@ 12005 break; 12006 12007 case 453: 12008- 12009-/* Line 1455 of yacc.c */ 12010 #line 3432 "preproc.y" 12011 { 12012 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 12013@@ -28907,16 +28468,12 @@ 12014 break; 12015 12016 case 454: 12017- 12018-/* Line 1455 of yacc.c */ 12019 #line 3436 "preproc.y" 12020 { 12021 (yyval.str)=EMPTY; ;} 12022 break; 12023 12024 case 455: 12025- 12026-/* Line 1455 of yacc.c */ 12027 #line 3443 "preproc.y" 12028 { 12029 (yyval.str) = (yyvsp[(1) - (1)].str); 12030@@ -28924,8 +28481,6 @@ 12031 break; 12032 12033 case 456: 12034- 12035-/* Line 1455 of yacc.c */ 12036 #line 3447 "preproc.y" 12037 { 12038 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 12039@@ -28933,8 +28488,6 @@ 12040 break; 12041 12042 case 457: 12043- 12044-/* Line 1455 of yacc.c */ 12045 #line 3455 "preproc.y" 12046 { 12047 (yyval.str) = (yyvsp[(1) - (1)].str); 12048@@ -28942,8 +28495,6 @@ 12049 break; 12050 12051 case 458: 12052- 12053-/* Line 1455 of yacc.c */ 12054 #line 3463 "preproc.y" 12055 { 12056 (yyval.str) = make_str("with data"); 12057@@ -28951,8 +28502,6 @@ 12058 break; 12059 12060 case 459: 12061- 12062-/* Line 1455 of yacc.c */ 12063 #line 3467 "preproc.y" 12064 { 12065 (yyval.str) = make_str("with no data"); 12066@@ -28960,16 +28509,12 @@ 12067 break; 12068 12069 case 460: 12070- 12071-/* Line 1455 of yacc.c */ 12072 #line 3471 "preproc.y" 12073 { 12074 (yyval.str)=EMPTY; ;} 12075 break; 12076 12077 case 461: 12078- 12079-/* Line 1455 of yacc.c */ 12080 #line 3478 "preproc.y" 12081 { 12082 (yyval.str) = cat_str(5,make_str("create"),(yyvsp[(2) - (5)].str),make_str("sequence"),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 12083@@ -28977,8 +28522,6 @@ 12084 break; 12085 12086 case 462: 12087- 12088-/* Line 1455 of yacc.c */ 12089 #line 3486 "preproc.y" 12090 { 12091 (yyval.str) = cat_str(3,make_str("alter sequence"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 12092@@ -28986,8 +28529,6 @@ 12093 break; 12094 12095 case 463: 12096- 12097-/* Line 1455 of yacc.c */ 12098 #line 3494 "preproc.y" 12099 { 12100 (yyval.str) = (yyvsp[(1) - (1)].str); 12101@@ -28995,16 +28536,12 @@ 12102 break; 12103 12104 case 464: 12105- 12106-/* Line 1455 of yacc.c */ 12107 #line 3498 "preproc.y" 12108 { 12109 (yyval.str)=EMPTY; ;} 12110 break; 12111 12112 case 465: 12113- 12114-/* Line 1455 of yacc.c */ 12115 #line 3505 "preproc.y" 12116 { 12117 (yyval.str) = (yyvsp[(1) - (1)].str); 12118@@ -29012,8 +28549,6 @@ 12119 break; 12120 12121 case 466: 12122- 12123-/* Line 1455 of yacc.c */ 12124 #line 3509 "preproc.y" 12125 { 12126 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 12127@@ -29021,8 +28556,6 @@ 12128 break; 12129 12130 case 467: 12131- 12132-/* Line 1455 of yacc.c */ 12133 #line 3517 "preproc.y" 12134 { 12135 (yyval.str) = cat_str(2,make_str("cache"),(yyvsp[(2) - (2)].str)); 12136@@ -29030,8 +28563,6 @@ 12137 break; 12138 12139 case 468: 12140- 12141-/* Line 1455 of yacc.c */ 12142 #line 3521 "preproc.y" 12143 { 12144 (yyval.str) = make_str("cycle"); 12145@@ -29039,8 +28570,6 @@ 12146 break; 12147 12148 case 469: 12149- 12150-/* Line 1455 of yacc.c */ 12151 #line 3525 "preproc.y" 12152 { 12153 (yyval.str) = make_str("no cycle"); 12154@@ -29048,8 +28577,6 @@ 12155 break; 12156 12157 case 470: 12158- 12159-/* Line 1455 of yacc.c */ 12160 #line 3529 "preproc.y" 12161 { 12162 (yyval.str) = cat_str(3,make_str("increment"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 12163@@ -29057,8 +28584,6 @@ 12164 break; 12165 12166 case 471: 12167- 12168-/* Line 1455 of yacc.c */ 12169 #line 3533 "preproc.y" 12170 { 12171 (yyval.str) = cat_str(2,make_str("maxvalue"),(yyvsp[(2) - (2)].str)); 12172@@ -29066,8 +28591,6 @@ 12173 break; 12174 12175 case 472: 12176- 12177-/* Line 1455 of yacc.c */ 12178 #line 3537 "preproc.y" 12179 { 12180 (yyval.str) = cat_str(2,make_str("minvalue"),(yyvsp[(2) - (2)].str)); 12181@@ -29075,8 +28598,6 @@ 12182 break; 12183 12184 case 473: 12185- 12186-/* Line 1455 of yacc.c */ 12187 #line 3541 "preproc.y" 12188 { 12189 (yyval.str) = make_str("no maxvalue"); 12190@@ -29084,8 +28605,6 @@ 12191 break; 12192 12193 case 474: 12194- 12195-/* Line 1455 of yacc.c */ 12196 #line 3545 "preproc.y" 12197 { 12198 (yyval.str) = make_str("no minvalue"); 12199@@ -29093,8 +28612,6 @@ 12200 break; 12201 12202 case 475: 12203- 12204-/* Line 1455 of yacc.c */ 12205 #line 3549 "preproc.y" 12206 { 12207 (yyval.str) = cat_str(2,make_str("owned by"),(yyvsp[(3) - (3)].str)); 12208@@ -29102,8 +28619,6 @@ 12209 break; 12210 12211 case 476: 12212- 12213-/* Line 1455 of yacc.c */ 12214 #line 3553 "preproc.y" 12215 { 12216 (yyval.str) = cat_str(3,make_str("start"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 12217@@ -29111,8 +28626,6 @@ 12218 break; 12219 12220 case 477: 12221- 12222-/* Line 1455 of yacc.c */ 12223 #line 3557 "preproc.y" 12224 { 12225 (yyval.str) = make_str("restart"); 12226@@ -29120,8 +28633,6 @@ 12227 break; 12228 12229 case 478: 12230- 12231-/* Line 1455 of yacc.c */ 12232 #line 3561 "preproc.y" 12233 { 12234 (yyval.str) = cat_str(3,make_str("restart"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 12235@@ -29129,8 +28640,6 @@ 12236 break; 12237 12238 case 479: 12239- 12240-/* Line 1455 of yacc.c */ 12241 #line 3569 "preproc.y" 12242 { 12243 (yyval.str) = make_str("by"); 12244@@ -29138,16 +28647,12 @@ 12245 break; 12246 12247 case 480: 12248- 12249-/* Line 1455 of yacc.c */ 12250 #line 3573 "preproc.y" 12251 { 12252 (yyval.str)=EMPTY; ;} 12253 break; 12254 12255 case 481: 12256- 12257-/* Line 1455 of yacc.c */ 12258 #line 3580 "preproc.y" 12259 { 12260 (yyval.str) = (yyvsp[(1) - (1)].str); 12261@@ -29155,8 +28660,6 @@ 12262 break; 12263 12264 case 482: 12265- 12266-/* Line 1455 of yacc.c */ 12267 #line 3584 "preproc.y" 12268 { 12269 (yyval.str) = cat_str(2,make_str("-"),(yyvsp[(2) - (2)].str)); 12270@@ -29164,8 +28667,6 @@ 12271 break; 12272 12273 case 483: 12274- 12275-/* Line 1455 of yacc.c */ 12276 #line 3588 "preproc.y" 12277 { 12278 (yyval.str) = (yyvsp[(1) - (1)].str); 12279@@ -29173,8 +28674,6 @@ 12280 break; 12281 12282 case 484: 12283- 12284-/* Line 1455 of yacc.c */ 12285 #line 3596 "preproc.y" 12286 { 12287 (yyval.str) = (yyvsp[(1) - (1)].str); 12288@@ -29182,8 +28681,6 @@ 12289 break; 12290 12291 case 485: 12292- 12293-/* Line 1455 of yacc.c */ 12294 #line 3600 "preproc.y" 12295 { 12296 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 12297@@ -29191,8 +28688,6 @@ 12298 break; 12299 12300 case 486: 12301- 12302-/* Line 1455 of yacc.c */ 12303 #line 3608 "preproc.y" 12304 { 12305 (yyval.str) = cat_str(6,make_str("create"),(yyvsp[(2) - (6)].str),(yyvsp[(3) - (6)].str),(yyvsp[(4) - (6)].str),make_str("language"),(yyvsp[(6) - (6)].str)); 12306@@ -29200,8 +28695,6 @@ 12307 break; 12308 12309 case 487: 12310- 12311-/* Line 1455 of yacc.c */ 12312 #line 3612 "preproc.y" 12313 { 12314 (yyval.str) = cat_str(10,make_str("create"),(yyvsp[(2) - (10)].str),(yyvsp[(3) - (10)].str),(yyvsp[(4) - (10)].str),make_str("language"),(yyvsp[(6) - (10)].str),make_str("handler"),(yyvsp[(8) - (10)].str),(yyvsp[(9) - (10)].str),(yyvsp[(10) - (10)].str)); 12315@@ -29209,8 +28702,6 @@ 12316 break; 12317 12318 case 488: 12319- 12320-/* Line 1455 of yacc.c */ 12321 #line 3620 "preproc.y" 12322 { 12323 (yyval.str) = make_str("trusted"); 12324@@ -29218,16 +28709,12 @@ 12325 break; 12326 12327 case 489: 12328- 12329-/* Line 1455 of yacc.c */ 12330 #line 3624 "preproc.y" 12331 { 12332 (yyval.str)=EMPTY; ;} 12333 break; 12334 12335 case 490: 12336- 12337-/* Line 1455 of yacc.c */ 12338 #line 3631 "preproc.y" 12339 { 12340 (yyval.str) = (yyvsp[(1) - (1)].str); 12341@@ -29235,8 +28722,6 @@ 12342 break; 12343 12344 case 491: 12345- 12346-/* Line 1455 of yacc.c */ 12347 #line 3635 "preproc.y" 12348 { 12349 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 12350@@ -29244,8 +28729,6 @@ 12351 break; 12352 12353 case 492: 12354- 12355-/* Line 1455 of yacc.c */ 12356 #line 3643 "preproc.y" 12357 { 12358 (yyval.str) = cat_str(2,make_str("inline"),(yyvsp[(2) - (2)].str)); 12359@@ -29253,16 +28736,12 @@ 12360 break; 12361 12362 case 493: 12363- 12364-/* Line 1455 of yacc.c */ 12365 #line 3647 "preproc.y" 12366 { 12367 (yyval.str)=EMPTY; ;} 12368 break; 12369 12370 case 494: 12371- 12372-/* Line 1455 of yacc.c */ 12373 #line 3654 "preproc.y" 12374 { 12375 (yyval.str) = cat_str(2,make_str("validator"),(yyvsp[(2) - (2)].str)); 12376@@ -29270,8 +28749,6 @@ 12377 break; 12378 12379 case 495: 12380- 12381-/* Line 1455 of yacc.c */ 12382 #line 3658 "preproc.y" 12383 { 12384 (yyval.str) = make_str("no validator"); 12385@@ -29279,8 +28756,6 @@ 12386 break; 12387 12388 case 496: 12389- 12390-/* Line 1455 of yacc.c */ 12391 #line 3666 "preproc.y" 12392 { 12393 (yyval.str) = (yyvsp[(1) - (1)].str); 12394@@ -29288,16 +28763,12 @@ 12395 break; 12396 12397 case 497: 12398- 12399-/* Line 1455 of yacc.c */ 12400 #line 3670 "preproc.y" 12401 { 12402 (yyval.str)=EMPTY; ;} 12403 break; 12404 12405 case 498: 12406- 12407-/* Line 1455 of yacc.c */ 12408 #line 3677 "preproc.y" 12409 { 12410 (yyval.str) = cat_str(5,make_str("drop"),(yyvsp[(2) - (5)].str),make_str("language"),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 12411@@ -29305,8 +28776,6 @@ 12412 break; 12413 12414 case 499: 12415- 12416-/* Line 1455 of yacc.c */ 12417 #line 3681 "preproc.y" 12418 { 12419 (yyval.str) = cat_str(5,make_str("drop"),(yyvsp[(2) - (7)].str),make_str("language if exists"),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 12420@@ -29314,8 +28783,6 @@ 12421 break; 12422 12423 case 500: 12424- 12425-/* Line 1455 of yacc.c */ 12426 #line 3689 "preproc.y" 12427 { 12428 (yyval.str) = make_str("procedural"); 12429@@ -29323,16 +28790,12 @@ 12430 break; 12431 12432 case 501: 12433- 12434-/* Line 1455 of yacc.c */ 12435 #line 3693 "preproc.y" 12436 { 12437 (yyval.str)=EMPTY; ;} 12438 break; 12439 12440 case 502: 12441- 12442-/* Line 1455 of yacc.c */ 12443 #line 3700 "preproc.y" 12444 { 12445 (yyval.str) = cat_str(5,make_str("create tablespace"),(yyvsp[(3) - (6)].str),(yyvsp[(4) - (6)].str),make_str("location"),(yyvsp[(6) - (6)].str)); 12446@@ -29340,8 +28803,6 @@ 12447 break; 12448 12449 case 503: 12450- 12451-/* Line 1455 of yacc.c */ 12452 #line 3708 "preproc.y" 12453 { 12454 (yyval.str) = cat_str(2,make_str("owner"),(yyvsp[(2) - (2)].str)); 12455@@ -29349,16 +28810,12 @@ 12456 break; 12457 12458 case 504: 12459- 12460-/* Line 1455 of yacc.c */ 12461 #line 3712 "preproc.y" 12462 { 12463 (yyval.str)=EMPTY; ;} 12464 break; 12465 12466 case 505: 12467- 12468-/* Line 1455 of yacc.c */ 12469 #line 3719 "preproc.y" 12470 { 12471 (yyval.str) = cat_str(2,make_str("drop tablespace"),(yyvsp[(3) - (3)].str)); 12472@@ -29366,8 +28823,6 @@ 12473 break; 12474 12475 case 506: 12476- 12477-/* Line 1455 of yacc.c */ 12478 #line 3723 "preproc.y" 12479 { 12480 (yyval.str) = cat_str(2,make_str("drop tablespace if exists"),(yyvsp[(5) - (5)].str)); 12481@@ -29375,8 +28830,6 @@ 12482 break; 12483 12484 case 507: 12485- 12486-/* Line 1455 of yacc.c */ 12487 #line 3731 "preproc.y" 12488 { 12489 (yyval.str) = cat_str(4,make_str("create foreign data wrapper"),(yyvsp[(5) - (7)].str),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 12490@@ -29384,8 +28837,6 @@ 12491 break; 12492 12493 case 508: 12494- 12495-/* Line 1455 of yacc.c */ 12496 #line 3739 "preproc.y" 12497 { 12498 (yyval.str) = cat_str(3,make_str("drop foreign data wrapper"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 12499@@ -29393,8 +28844,6 @@ 12500 break; 12501 12502 case 509: 12503- 12504-/* Line 1455 of yacc.c */ 12505 #line 3743 "preproc.y" 12506 { 12507 (yyval.str) = cat_str(3,make_str("drop foreign data wrapper if exists"),(yyvsp[(7) - (8)].str),(yyvsp[(8) - (8)].str)); 12508@@ -29402,8 +28851,6 @@ 12509 break; 12510 12511 case 510: 12512- 12513-/* Line 1455 of yacc.c */ 12514 #line 3751 "preproc.y" 12515 { 12516 (yyval.str) = cat_str(4,make_str("alter foreign data wrapper"),(yyvsp[(5) - (7)].str),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 12517@@ -29411,8 +28858,6 @@ 12518 break; 12519 12520 case 511: 12521- 12522-/* Line 1455 of yacc.c */ 12523 #line 3755 "preproc.y" 12524 { 12525 (yyval.str) = cat_str(3,make_str("alter foreign data wrapper"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 12526@@ -29420,8 +28865,6 @@ 12527 break; 12528 12529 case 512: 12530- 12531-/* Line 1455 of yacc.c */ 12532 #line 3759 "preproc.y" 12533 { 12534 (yyval.str) = cat_str(3,make_str("alter foreign data wrapper"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 12535@@ -29429,8 +28872,6 @@ 12536 break; 12537 12538 case 513: 12539- 12540-/* Line 1455 of yacc.c */ 12541 #line 3767 "preproc.y" 12542 { 12543 (yyval.str) = cat_str(3,make_str("options ("),(yyvsp[(3) - (4)].str),make_str(")")); 12544@@ -29438,16 +28879,12 @@ 12545 break; 12546 12547 case 514: 12548- 12549-/* Line 1455 of yacc.c */ 12550 #line 3771 "preproc.y" 12551 { 12552 (yyval.str)=EMPTY; ;} 12553 break; 12554 12555 case 515: 12556- 12557-/* Line 1455 of yacc.c */ 12558 #line 3778 "preproc.y" 12559 { 12560 (yyval.str) = (yyvsp[(1) - (1)].str); 12561@@ -29455,8 +28892,6 @@ 12562 break; 12563 12564 case 516: 12565- 12566-/* Line 1455 of yacc.c */ 12567 #line 3782 "preproc.y" 12568 { 12569 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 12570@@ -29464,8 +28899,6 @@ 12571 break; 12572 12573 case 517: 12574- 12575-/* Line 1455 of yacc.c */ 12576 #line 3790 "preproc.y" 12577 { 12578 (yyval.str) = cat_str(3,make_str("options ("),(yyvsp[(3) - (4)].str),make_str(")")); 12579@@ -29473,8 +28906,6 @@ 12580 break; 12581 12582 case 518: 12583- 12584-/* Line 1455 of yacc.c */ 12585 #line 3798 "preproc.y" 12586 { 12587 (yyval.str) = (yyvsp[(1) - (1)].str); 12588@@ -29482,8 +28913,6 @@ 12589 break; 12590 12591 case 519: 12592- 12593-/* Line 1455 of yacc.c */ 12594 #line 3802 "preproc.y" 12595 { 12596 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 12597@@ -29491,8 +28920,6 @@ 12598 break; 12599 12600 case 520: 12601- 12602-/* Line 1455 of yacc.c */ 12603 #line 3810 "preproc.y" 12604 { 12605 (yyval.str) = (yyvsp[(1) - (1)].str); 12606@@ -29500,8 +28927,6 @@ 12607 break; 12608 12609 case 521: 12610- 12611-/* Line 1455 of yacc.c */ 12612 #line 3814 "preproc.y" 12613 { 12614 (yyval.str) = cat_str(2,make_str("set"),(yyvsp[(2) - (2)].str)); 12615@@ -29509,8 +28934,6 @@ 12616 break; 12617 12618 case 522: 12619- 12620-/* Line 1455 of yacc.c */ 12621 #line 3818 "preproc.y" 12622 { 12623 (yyval.str) = cat_str(2,make_str("add"),(yyvsp[(2) - (2)].str)); 12624@@ -29518,8 +28941,6 @@ 12625 break; 12626 12627 case 523: 12628- 12629-/* Line 1455 of yacc.c */ 12630 #line 3822 "preproc.y" 12631 { 12632 (yyval.str) = cat_str(2,make_str("drop"),(yyvsp[(2) - (2)].str)); 12633@@ -29527,8 +28948,6 @@ 12634 break; 12635 12636 case 524: 12637- 12638-/* Line 1455 of yacc.c */ 12639 #line 3830 "preproc.y" 12640 { 12641 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 12642@@ -29536,8 +28955,6 @@ 12643 break; 12644 12645 case 525: 12646- 12647-/* Line 1455 of yacc.c */ 12648 #line 3838 "preproc.y" 12649 { 12650 (yyval.str) = (yyvsp[(1) - (1)].str); 12651@@ -29545,8 +28962,6 @@ 12652 break; 12653 12654 case 526: 12655- 12656-/* Line 1455 of yacc.c */ 12657 #line 3846 "preproc.y" 12658 { 12659 (yyval.str) = (yyvsp[(1) - (1)].str); 12660@@ -29554,8 +28969,6 @@ 12661 break; 12662 12663 case 527: 12664- 12665-/* Line 1455 of yacc.c */ 12666 #line 3854 "preproc.y" 12667 { 12668 (yyval.str) = cat_str(7,make_str("create server"),(yyvsp[(3) - (10)].str),(yyvsp[(4) - (10)].str),(yyvsp[(5) - (10)].str),make_str("foreign data wrapper"),(yyvsp[(9) - (10)].str),(yyvsp[(10) - (10)].str)); 12669@@ -29563,8 +28976,6 @@ 12670 break; 12671 12672 case 528: 12673- 12674-/* Line 1455 of yacc.c */ 12675 #line 3862 "preproc.y" 12676 { 12677 (yyval.str) = cat_str(2,make_str("type"),(yyvsp[(2) - (2)].str)); 12678@@ -29572,16 +28983,12 @@ 12679 break; 12680 12681 case 529: 12682- 12683-/* Line 1455 of yacc.c */ 12684 #line 3866 "preproc.y" 12685 { 12686 (yyval.str)=EMPTY; ;} 12687 break; 12688 12689 case 530: 12690- 12691-/* Line 1455 of yacc.c */ 12692 #line 3873 "preproc.y" 12693 { 12694 (yyval.str) = cat_str(2,make_str("version"),(yyvsp[(2) - (2)].str)); 12695@@ -29589,8 +28996,6 @@ 12696 break; 12697 12698 case 531: 12699- 12700-/* Line 1455 of yacc.c */ 12701 #line 3877 "preproc.y" 12702 { 12703 (yyval.str) = make_str("version null"); 12704@@ -29598,8 +29003,6 @@ 12705 break; 12706 12707 case 532: 12708- 12709-/* Line 1455 of yacc.c */ 12710 #line 3885 "preproc.y" 12711 { 12712 (yyval.str) = (yyvsp[(1) - (1)].str); 12713@@ -29607,16 +29010,12 @@ 12714 break; 12715 12716 case 533: 12717- 12718-/* Line 1455 of yacc.c */ 12719 #line 3889 "preproc.y" 12720 { 12721 (yyval.str)=EMPTY; ;} 12722 break; 12723 12724 case 534: 12725- 12726-/* Line 1455 of yacc.c */ 12727 #line 3896 "preproc.y" 12728 { 12729 (yyval.str) = cat_str(3,make_str("drop server"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 12730@@ -29624,8 +29023,6 @@ 12731 break; 12732 12733 case 535: 12734- 12735-/* Line 1455 of yacc.c */ 12736 #line 3900 "preproc.y" 12737 { 12738 (yyval.str) = cat_str(3,make_str("drop server if exists"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 12739@@ -29633,8 +29030,6 @@ 12740 break; 12741 12742 case 536: 12743- 12744-/* Line 1455 of yacc.c */ 12745 #line 3908 "preproc.y" 12746 { 12747 (yyval.str) = cat_str(4,make_str("alter server"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 12748@@ -29642,8 +29037,6 @@ 12749 break; 12750 12751 case 537: 12752- 12753-/* Line 1455 of yacc.c */ 12754 #line 3912 "preproc.y" 12755 { 12756 (yyval.str) = cat_str(3,make_str("alter server"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 12757@@ -29651,8 +29044,6 @@ 12758 break; 12759 12760 case 538: 12761- 12762-/* Line 1455 of yacc.c */ 12763 #line 3916 "preproc.y" 12764 { 12765 (yyval.str) = cat_str(3,make_str("alter server"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 12766@@ -29660,8 +29051,6 @@ 12767 break; 12768 12769 case 539: 12770- 12771-/* Line 1455 of yacc.c */ 12772 #line 3924 "preproc.y" 12773 { 12774 (yyval.str) = cat_str(5,make_str("create user mapping for"),(yyvsp[(5) - (8)].str),make_str("server"),(yyvsp[(7) - (8)].str),(yyvsp[(8) - (8)].str)); 12775@@ -29669,8 +29058,6 @@ 12776 break; 12777 12778 case 540: 12779- 12780-/* Line 1455 of yacc.c */ 12781 #line 3932 "preproc.y" 12782 { 12783 (yyval.str) = make_str("current_user"); 12784@@ -29678,8 +29065,6 @@ 12785 break; 12786 12787 case 541: 12788- 12789-/* Line 1455 of yacc.c */ 12790 #line 3936 "preproc.y" 12791 { 12792 (yyval.str) = make_str("user"); 12793@@ -29687,8 +29072,6 @@ 12794 break; 12795 12796 case 542: 12797- 12798-/* Line 1455 of yacc.c */ 12799 #line 3940 "preproc.y" 12800 { 12801 (yyval.str) = (yyvsp[(1) - (1)].str); 12802@@ -29696,8 +29079,6 @@ 12803 break; 12804 12805 case 543: 12806- 12807-/* Line 1455 of yacc.c */ 12808 #line 3948 "preproc.y" 12809 { 12810 (yyval.str) = cat_str(4,make_str("drop user mapping for"),(yyvsp[(5) - (7)].str),make_str("server"),(yyvsp[(7) - (7)].str)); 12811@@ -29705,8 +29086,6 @@ 12812 break; 12813 12814 case 544: 12815- 12816-/* Line 1455 of yacc.c */ 12817 #line 3952 "preproc.y" 12818 { 12819 (yyval.str) = cat_str(4,make_str("drop user mapping if exists for"),(yyvsp[(7) - (9)].str),make_str("server"),(yyvsp[(9) - (9)].str)); 12820@@ -29714,8 +29093,6 @@ 12821 break; 12822 12823 case 545: 12824- 12825-/* Line 1455 of yacc.c */ 12826 #line 3960 "preproc.y" 12827 { 12828 (yyval.str) = cat_str(5,make_str("alter user mapping for"),(yyvsp[(5) - (8)].str),make_str("server"),(yyvsp[(7) - (8)].str),(yyvsp[(8) - (8)].str)); 12829@@ -29723,8 +29100,6 @@ 12830 break; 12831 12832 case 546: 12833- 12834-/* Line 1455 of yacc.c */ 12835 #line 3968 "preproc.y" 12836 { 12837 (yyval.str) = cat_str(13,make_str("create trigger"),(yyvsp[(3) - (15)].str),(yyvsp[(4) - (15)].str),(yyvsp[(5) - (15)].str),make_str("on"),(yyvsp[(7) - (15)].str),(yyvsp[(8) - (15)].str),(yyvsp[(9) - (15)].str),make_str("execute procedure"),(yyvsp[(12) - (15)].str),make_str("("),(yyvsp[(14) - (15)].str),make_str(")")); 12838@@ -29732,8 +29107,6 @@ 12839 break; 12840 12841 case 547: 12842- 12843-/* Line 1455 of yacc.c */ 12844 #line 3972 "preproc.y" 12845 { 12846 (yyval.str) = cat_str(15,make_str("create constraint trigger"),(yyvsp[(4) - (20)].str),make_str("after"),(yyvsp[(6) - (20)].str),make_str("on"),(yyvsp[(8) - (20)].str),(yyvsp[(9) - (20)].str),(yyvsp[(10) - (20)].str),make_str("for each row"),(yyvsp[(14) - (20)].str),make_str("execute procedure"),(yyvsp[(17) - (20)].str),make_str("("),(yyvsp[(19) - (20)].str),make_str(")")); 12847@@ -29741,8 +29114,6 @@ 12848 break; 12849 12850 case 548: 12851- 12852-/* Line 1455 of yacc.c */ 12853 #line 3980 "preproc.y" 12854 { 12855 (yyval.str) = make_str("before"); 12856@@ -29750,8 +29121,6 @@ 12857 break; 12858 12859 case 549: 12860- 12861-/* Line 1455 of yacc.c */ 12862 #line 3984 "preproc.y" 12863 { 12864 (yyval.str) = make_str("after"); 12865@@ -29759,8 +29128,6 @@ 12866 break; 12867 12868 case 550: 12869- 12870-/* Line 1455 of yacc.c */ 12871 #line 3992 "preproc.y" 12872 { 12873 (yyval.str) = (yyvsp[(1) - (1)].str); 12874@@ -29768,8 +29135,6 @@ 12875 break; 12876 12877 case 551: 12878- 12879-/* Line 1455 of yacc.c */ 12880 #line 3996 "preproc.y" 12881 { 12882 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("or"),(yyvsp[(3) - (3)].str)); 12883@@ -29777,8 +29142,6 @@ 12884 break; 12885 12886 case 552: 12887- 12888-/* Line 1455 of yacc.c */ 12889 #line 4004 "preproc.y" 12890 { 12891 (yyval.str) = make_str("insert"); 12892@@ -29786,8 +29149,6 @@ 12893 break; 12894 12895 case 553: 12896- 12897-/* Line 1455 of yacc.c */ 12898 #line 4008 "preproc.y" 12899 { 12900 (yyval.str) = make_str("delete"); 12901@@ -29795,8 +29156,6 @@ 12902 break; 12903 12904 case 554: 12905- 12906-/* Line 1455 of yacc.c */ 12907 #line 4012 "preproc.y" 12908 { 12909 (yyval.str) = make_str("update"); 12910@@ -29804,8 +29163,6 @@ 12911 break; 12912 12913 case 555: 12914- 12915-/* Line 1455 of yacc.c */ 12916 #line 4016 "preproc.y" 12917 { 12918 (yyval.str) = cat_str(2,make_str("update of"),(yyvsp[(3) - (3)].str)); 12919@@ -29813,8 +29170,6 @@ 12920 break; 12921 12922 case 556: 12923- 12924-/* Line 1455 of yacc.c */ 12925 #line 4020 "preproc.y" 12926 { 12927 (yyval.str) = make_str("truncate"); 12928@@ -29822,8 +29177,6 @@ 12929 break; 12930 12931 case 557: 12932- 12933-/* Line 1455 of yacc.c */ 12934 #line 4028 "preproc.y" 12935 { 12936 (yyval.str) = cat_str(3,make_str("for"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 12937@@ -29831,16 +29184,12 @@ 12938 break; 12939 12940 case 558: 12941- 12942-/* Line 1455 of yacc.c */ 12943 #line 4032 "preproc.y" 12944 { 12945 (yyval.str)=EMPTY; ;} 12946 break; 12947 12948 case 559: 12949- 12950-/* Line 1455 of yacc.c */ 12951 #line 4039 "preproc.y" 12952 { 12953 (yyval.str) = make_str("each"); 12954@@ -29848,16 +29197,12 @@ 12955 break; 12956 12957 case 560: 12958- 12959-/* Line 1455 of yacc.c */ 12960 #line 4043 "preproc.y" 12961 { 12962 (yyval.str)=EMPTY; ;} 12963 break; 12964 12965 case 561: 12966- 12967-/* Line 1455 of yacc.c */ 12968 #line 4050 "preproc.y" 12969 { 12970 (yyval.str) = make_str("row"); 12971@@ -29865,8 +29210,6 @@ 12972 break; 12973 12974 case 562: 12975- 12976-/* Line 1455 of yacc.c */ 12977 #line 4054 "preproc.y" 12978 { 12979 (yyval.str) = make_str("statement"); 12980@@ -29874,8 +29217,6 @@ 12981 break; 12982 12983 case 563: 12984- 12985-/* Line 1455 of yacc.c */ 12986 #line 4062 "preproc.y" 12987 { 12988 (yyval.str) = cat_str(3,make_str("when ("),(yyvsp[(3) - (4)].str),make_str(")")); 12989@@ -29883,16 +29224,12 @@ 12990 break; 12991 12992 case 564: 12993- 12994-/* Line 1455 of yacc.c */ 12995 #line 4066 "preproc.y" 12996 { 12997 (yyval.str)=EMPTY; ;} 12998 break; 12999 13000 case 565: 13001- 13002-/* Line 1455 of yacc.c */ 13003 #line 4073 "preproc.y" 13004 { 13005 (yyval.str) = (yyvsp[(1) - (1)].str); 13006@@ -29900,8 +29237,6 @@ 13007 break; 13008 13009 case 566: 13010- 13011-/* Line 1455 of yacc.c */ 13012 #line 4077 "preproc.y" 13013 { 13014 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 13015@@ -29909,16 +29244,12 @@ 13016 break; 13017 13018 case 567: 13019- 13020-/* Line 1455 of yacc.c */ 13021 #line 4081 "preproc.y" 13022 { 13023 (yyval.str)=EMPTY; ;} 13024 break; 13025 13026 case 568: 13027- 13028-/* Line 1455 of yacc.c */ 13029 #line 4088 "preproc.y" 13030 { 13031 (yyval.str) = (yyvsp[(1) - (1)].str); 13032@@ -29926,8 +29257,6 @@ 13033 break; 13034 13035 case 569: 13036- 13037-/* Line 1455 of yacc.c */ 13038 #line 4092 "preproc.y" 13039 { 13040 (yyval.str) = (yyvsp[(1) - (1)].str); 13041@@ -29935,8 +29264,6 @@ 13042 break; 13043 13044 case 570: 13045- 13046-/* Line 1455 of yacc.c */ 13047 #line 4096 "preproc.y" 13048 { 13049 (yyval.str) = (yyvsp[(1) - (1)].str); 13050@@ -29944,8 +29271,6 @@ 13051 break; 13052 13053 case 571: 13054- 13055-/* Line 1455 of yacc.c */ 13056 #line 4100 "preproc.y" 13057 { 13058 (yyval.str) = (yyvsp[(1) - (1)].str); 13059@@ -29953,8 +29278,6 @@ 13060 break; 13061 13062 case 572: 13063- 13064-/* Line 1455 of yacc.c */ 13065 #line 4104 "preproc.y" 13066 { 13067 (yyval.str) = make_str("xconst"); 13068@@ -29962,8 +29285,6 @@ 13069 break; 13070 13071 case 573: 13072- 13073-/* Line 1455 of yacc.c */ 13074 #line 4108 "preproc.y" 13075 { 13076 (yyval.str) = (yyvsp[(1) - (1)].str); 13077@@ -29971,8 +29292,6 @@ 13078 break; 13079 13080 case 574: 13081- 13082-/* Line 1455 of yacc.c */ 13083 #line 4116 "preproc.y" 13084 { 13085 (yyval.str) = cat_str(2,make_str("from"),(yyvsp[(2) - (2)].str)); 13086@@ -29980,16 +29299,12 @@ 13087 break; 13088 13089 case 575: 13090- 13091-/* Line 1455 of yacc.c */ 13092 #line 4120 "preproc.y" 13093 { 13094 (yyval.str)=EMPTY; ;} 13095 break; 13096 13097 case 576: 13098- 13099-/* Line 1455 of yacc.c */ 13100 #line 4127 "preproc.y" 13101 { 13102 (yyval.str) = (yyvsp[(1) - (1)].str); 13103@@ -29997,8 +29312,6 @@ 13104 break; 13105 13106 case 577: 13107- 13108-/* Line 1455 of yacc.c */ 13109 #line 4131 "preproc.y" 13110 { 13111 if (strcmp((yyvsp[(1) - (2)].str), "deferrable") != 0 && strcmp((yyvsp[(2) - (2)].str), "initially deferrable") == 0 ) 13112@@ -30009,8 +29322,6 @@ 13113 break; 13114 13115 case 578: 13116- 13117-/* Line 1455 of yacc.c */ 13118 #line 4138 "preproc.y" 13119 { 13120 (yyval.str) = (yyvsp[(1) - (1)].str); 13121@@ -30018,8 +29329,6 @@ 13122 break; 13123 13124 case 579: 13125- 13126-/* Line 1455 of yacc.c */ 13127 #line 4142 "preproc.y" 13128 { 13129 if (strcmp((yyvsp[(2) - (2)].str), "deferrable") != 0 && strcmp((yyvsp[(1) - (2)].str), "initially deferrable") == 0 ) 13130@@ -30030,16 +29339,12 @@ 13131 break; 13132 13133 case 580: 13134- 13135-/* Line 1455 of yacc.c */ 13136 #line 4149 "preproc.y" 13137 { 13138 (yyval.str)=EMPTY; ;} 13139 break; 13140 13141 case 581: 13142- 13143-/* Line 1455 of yacc.c */ 13144 #line 4156 "preproc.y" 13145 { 13146 (yyval.str) = make_str("not deferrable"); 13147@@ -30047,8 +29352,6 @@ 13148 break; 13149 13150 case 582: 13151- 13152-/* Line 1455 of yacc.c */ 13153 #line 4160 "preproc.y" 13154 { 13155 (yyval.str) = make_str("deferrable"); 13156@@ -30056,8 +29359,6 @@ 13157 break; 13158 13159 case 583: 13160- 13161-/* Line 1455 of yacc.c */ 13162 #line 4168 "preproc.y" 13163 { 13164 (yyval.str) = make_str("initially immediate"); 13165@@ -30065,8 +29366,6 @@ 13166 break; 13167 13168 case 584: 13169- 13170-/* Line 1455 of yacc.c */ 13171 #line 4172 "preproc.y" 13172 { 13173 (yyval.str) = make_str("initially deferred"); 13174@@ -30074,8 +29373,6 @@ 13175 break; 13176 13177 case 585: 13178- 13179-/* Line 1455 of yacc.c */ 13180 #line 4180 "preproc.y" 13181 { 13182 (yyval.str) = cat_str(5,make_str("drop trigger"),(yyvsp[(3) - (6)].str),make_str("on"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 13183@@ -30083,8 +29380,6 @@ 13184 break; 13185 13186 case 586: 13187- 13188-/* Line 1455 of yacc.c */ 13189 #line 4184 "preproc.y" 13190 { 13191 (yyval.str) = cat_str(5,make_str("drop trigger if exists"),(yyvsp[(5) - (8)].str),make_str("on"),(yyvsp[(7) - (8)].str),(yyvsp[(8) - (8)].str)); 13192@@ -30092,8 +29387,6 @@ 13193 break; 13194 13195 case 587: 13196- 13197-/* Line 1455 of yacc.c */ 13198 #line 4192 "preproc.y" 13199 { 13200 mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server"); 13201@@ -30102,8 +29395,6 @@ 13202 break; 13203 13204 case 588: 13205- 13206-/* Line 1455 of yacc.c */ 13207 #line 4201 "preproc.y" 13208 { 13209 mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server"); 13210@@ -30112,8 +29403,6 @@ 13211 break; 13212 13213 case 589: 13214- 13215-/* Line 1455 of yacc.c */ 13216 #line 4210 "preproc.y" 13217 { 13218 (yyval.str) = cat_str(4,make_str("create aggregate"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 13219@@ -30121,8 +29410,6 @@ 13220 break; 13221 13222 case 590: 13223- 13224-/* Line 1455 of yacc.c */ 13225 #line 4214 "preproc.y" 13226 { 13227 (yyval.str) = cat_str(3,make_str("create aggregate"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 13228@@ -30130,8 +29417,6 @@ 13229 break; 13230 13231 case 591: 13232- 13233-/* Line 1455 of yacc.c */ 13234 #line 4218 "preproc.y" 13235 { 13236 (yyval.str) = cat_str(3,make_str("create operator"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 13237@@ -30139,8 +29424,6 @@ 13238 break; 13239 13240 case 592: 13241- 13242-/* Line 1455 of yacc.c */ 13243 #line 4222 "preproc.y" 13244 { 13245 (yyval.str) = cat_str(3,make_str("create type"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 13246@@ -30148,8 +29431,6 @@ 13247 break; 13248 13249 case 593: 13250- 13251-/* Line 1455 of yacc.c */ 13252 #line 4226 "preproc.y" 13253 { 13254 (yyval.str) = cat_str(2,make_str("create type"),(yyvsp[(3) - (3)].str)); 13255@@ -30157,8 +29438,6 @@ 13256 break; 13257 13258 case 594: 13259- 13260-/* Line 1455 of yacc.c */ 13261 #line 4230 "preproc.y" 13262 { 13263 (yyval.str) = cat_str(5,make_str("create type"),(yyvsp[(3) - (7)].str),make_str("as ("),(yyvsp[(6) - (7)].str),make_str(")")); 13264@@ -30166,8 +29445,6 @@ 13265 break; 13266 13267 case 595: 13268- 13269-/* Line 1455 of yacc.c */ 13270 #line 4234 "preproc.y" 13271 { 13272 (yyval.str) = cat_str(5,make_str("create type"),(yyvsp[(3) - (8)].str),make_str("as enum ("),(yyvsp[(7) - (8)].str),make_str(")")); 13273@@ -30175,8 +29452,6 @@ 13274 break; 13275 13276 case 596: 13277- 13278-/* Line 1455 of yacc.c */ 13279 #line 4238 "preproc.y" 13280 { 13281 (yyval.str) = cat_str(3,make_str("create text search parser"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 13282@@ -30184,8 +29459,6 @@ 13283 break; 13284 13285 case 597: 13286- 13287-/* Line 1455 of yacc.c */ 13288 #line 4242 "preproc.y" 13289 { 13290 (yyval.str) = cat_str(3,make_str("create text search dictionary"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 13291@@ -30193,8 +29466,6 @@ 13292 break; 13293 13294 case 598: 13295- 13296-/* Line 1455 of yacc.c */ 13297 #line 4246 "preproc.y" 13298 { 13299 (yyval.str) = cat_str(3,make_str("create text search template"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 13300@@ -30202,8 +29473,6 @@ 13301 break; 13302 13303 case 599: 13304- 13305-/* Line 1455 of yacc.c */ 13306 #line 4250 "preproc.y" 13307 { 13308 (yyval.str) = cat_str(3,make_str("create text search configuration"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 13309@@ -30211,8 +29480,6 @@ 13310 break; 13311 13312 case 600: 13313- 13314-/* Line 1455 of yacc.c */ 13315 #line 4258 "preproc.y" 13316 { 13317 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 13318@@ -30220,8 +29487,6 @@ 13319 break; 13320 13321 case 601: 13322- 13323-/* Line 1455 of yacc.c */ 13324 #line 4266 "preproc.y" 13325 { 13326 (yyval.str) = (yyvsp[(1) - (1)].str); 13327@@ -30229,8 +29494,6 @@ 13328 break; 13329 13330 case 602: 13331- 13332-/* Line 1455 of yacc.c */ 13333 #line 4270 "preproc.y" 13334 { 13335 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 13336@@ -30238,8 +29501,6 @@ 13337 break; 13338 13339 case 603: 13340- 13341-/* Line 1455 of yacc.c */ 13342 #line 4278 "preproc.y" 13343 { 13344 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("="),(yyvsp[(3) - (3)].str)); 13345@@ -30247,8 +29508,6 @@ 13346 break; 13347 13348 case 604: 13349- 13350-/* Line 1455 of yacc.c */ 13351 #line 4282 "preproc.y" 13352 { 13353 (yyval.str) = (yyvsp[(1) - (1)].str); 13354@@ -30256,8 +29515,6 @@ 13355 break; 13356 13357 case 605: 13358- 13359-/* Line 1455 of yacc.c */ 13360 #line 4290 "preproc.y" 13361 { 13362 (yyval.str) = (yyvsp[(1) - (1)].str); 13363@@ -30265,8 +29522,6 @@ 13364 break; 13365 13366 case 606: 13367- 13368-/* Line 1455 of yacc.c */ 13369 #line 4294 "preproc.y" 13370 { 13371 (yyval.str) = (yyvsp[(1) - (1)].str); 13372@@ -30274,8 +29529,6 @@ 13373 break; 13374 13375 case 607: 13376- 13377-/* Line 1455 of yacc.c */ 13378 #line 4298 "preproc.y" 13379 { 13380 (yyval.str) = (yyvsp[(1) - (1)].str); 13381@@ -30283,8 +29536,6 @@ 13382 break; 13383 13384 case 608: 13385- 13386-/* Line 1455 of yacc.c */ 13387 #line 4302 "preproc.y" 13388 { 13389 (yyval.str) = (yyvsp[(1) - (1)].str); 13390@@ -30292,8 +29543,6 @@ 13391 break; 13392 13393 case 609: 13394- 13395-/* Line 1455 of yacc.c */ 13396 #line 4306 "preproc.y" 13397 { 13398 (yyval.str) = (yyvsp[(1) - (1)].str); 13399@@ -30301,8 +29550,6 @@ 13400 break; 13401 13402 case 610: 13403- 13404-/* Line 1455 of yacc.c */ 13405 #line 4314 "preproc.y" 13406 { 13407 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 13408@@ -30310,8 +29557,6 @@ 13409 break; 13410 13411 case 611: 13412- 13413-/* Line 1455 of yacc.c */ 13414 #line 4318 "preproc.y" 13415 { 13416 (yyval.str) = make_str("( * )"); 13417@@ -30319,8 +29564,6 @@ 13418 break; 13419 13420 case 612: 13421- 13422-/* Line 1455 of yacc.c */ 13423 #line 4326 "preproc.y" 13424 { 13425 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 13426@@ -30328,8 +29571,6 @@ 13427 break; 13428 13429 case 613: 13430- 13431-/* Line 1455 of yacc.c */ 13432 #line 4334 "preproc.y" 13433 { 13434 (yyval.str) = (yyvsp[(1) - (1)].str); 13435@@ -30337,8 +29578,6 @@ 13436 break; 13437 13438 case 614: 13439- 13440-/* Line 1455 of yacc.c */ 13441 #line 4338 "preproc.y" 13442 { 13443 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 13444@@ -30346,8 +29585,6 @@ 13445 break; 13446 13447 case 615: 13448- 13449-/* Line 1455 of yacc.c */ 13450 #line 4346 "preproc.y" 13451 { 13452 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("="),(yyvsp[(3) - (3)].str)); 13453@@ -30355,8 +29592,6 @@ 13454 break; 13455 13456 case 616: 13457- 13458-/* Line 1455 of yacc.c */ 13459 #line 4354 "preproc.y" 13460 { 13461 (yyval.str) = (yyvsp[(1) - (1)].str); 13462@@ -30364,16 +29599,12 @@ 13463 break; 13464 13465 case 617: 13466- 13467-/* Line 1455 of yacc.c */ 13468 #line 4358 "preproc.y" 13469 { 13470 (yyval.str)=EMPTY; ;} 13471 break; 13472 13473 case 618: 13474- 13475-/* Line 1455 of yacc.c */ 13476 #line 4365 "preproc.y" 13477 { 13478 (yyval.str) = (yyvsp[(1) - (1)].str); 13479@@ -30381,8 +29612,6 @@ 13480 break; 13481 13482 case 619: 13483- 13484-/* Line 1455 of yacc.c */ 13485 #line 4369 "preproc.y" 13486 { 13487 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 13488@@ -30390,8 +29619,6 @@ 13489 break; 13490 13491 case 620: 13492- 13493-/* Line 1455 of yacc.c */ 13494 #line 4377 "preproc.y" 13495 { 13496 (yyval.str) = cat_str(10,make_str("create operator class"),(yyvsp[(4) - (13)].str),(yyvsp[(5) - (13)].str),make_str("for type"),(yyvsp[(8) - (13)].str),make_str("using"),(yyvsp[(10) - (13)].str),(yyvsp[(11) - (13)].str),make_str("as"),(yyvsp[(13) - (13)].str)); 13497@@ -30399,8 +29626,6 @@ 13498 break; 13499 13500 case 621: 13501- 13502-/* Line 1455 of yacc.c */ 13503 #line 4385 "preproc.y" 13504 { 13505 (yyval.str) = (yyvsp[(1) - (1)].str); 13506@@ -30408,8 +29633,6 @@ 13507 break; 13508 13509 case 622: 13510- 13511-/* Line 1455 of yacc.c */ 13512 #line 4389 "preproc.y" 13513 { 13514 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 13515@@ -30417,8 +29640,6 @@ 13516 break; 13517 13518 case 623: 13519- 13520-/* Line 1455 of yacc.c */ 13521 #line 4397 "preproc.y" 13522 { 13523 (yyval.str) = cat_str(4,make_str("operator"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 13524@@ -30426,8 +29647,6 @@ 13525 break; 13526 13527 case 624: 13528- 13529-/* Line 1455 of yacc.c */ 13530 #line 4401 "preproc.y" 13531 { 13532 (yyval.str) = cat_str(5,make_str("operator"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 13533@@ -30435,8 +29654,6 @@ 13534 break; 13535 13536 case 625: 13537- 13538-/* Line 1455 of yacc.c */ 13539 #line 4405 "preproc.y" 13540 { 13541 (yyval.str) = cat_str(4,make_str("function"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 13542@@ -30444,8 +29661,6 @@ 13543 break; 13544 13545 case 626: 13546- 13547-/* Line 1455 of yacc.c */ 13548 #line 4409 "preproc.y" 13549 { 13550 (yyval.str) = cat_str(7,make_str("function"),(yyvsp[(2) - (7)].str),make_str("("),(yyvsp[(4) - (7)].str),make_str(")"),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 13551@@ -30453,8 +29668,6 @@ 13552 break; 13553 13554 case 627: 13555- 13556-/* Line 1455 of yacc.c */ 13557 #line 4413 "preproc.y" 13558 { 13559 (yyval.str) = cat_str(2,make_str("storage"),(yyvsp[(2) - (2)].str)); 13560@@ -30462,8 +29675,6 @@ 13561 break; 13562 13563 case 628: 13564- 13565-/* Line 1455 of yacc.c */ 13566 #line 4421 "preproc.y" 13567 { 13568 (yyval.str) = make_str("default"); 13569@@ -30471,16 +29682,12 @@ 13570 break; 13571 13572 case 629: 13573- 13574-/* Line 1455 of yacc.c */ 13575 #line 4425 "preproc.y" 13576 { 13577 (yyval.str)=EMPTY; ;} 13578 break; 13579 13580 case 630: 13581- 13582-/* Line 1455 of yacc.c */ 13583 #line 4432 "preproc.y" 13584 { 13585 (yyval.str) = cat_str(2,make_str("family"),(yyvsp[(2) - (2)].str)); 13586@@ -30488,16 +29695,12 @@ 13587 break; 13588 13589 case 631: 13590- 13591-/* Line 1455 of yacc.c */ 13592 #line 4436 "preproc.y" 13593 { 13594 (yyval.str)=EMPTY; ;} 13595 break; 13596 13597 case 632: 13598- 13599-/* Line 1455 of yacc.c */ 13600 #line 4443 "preproc.y" 13601 { 13602 mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server"); 13603@@ -30506,16 +29709,12 @@ 13604 break; 13605 13606 case 633: 13607- 13608-/* Line 1455 of yacc.c */ 13609 #line 4448 "preproc.y" 13610 { 13611 (yyval.str)=EMPTY; ;} 13612 break; 13613 13614 case 634: 13615- 13616-/* Line 1455 of yacc.c */ 13617 #line 4455 "preproc.y" 13618 { 13619 (yyval.str) = cat_str(4,make_str("create operator family"),(yyvsp[(4) - (6)].str),make_str("using"),(yyvsp[(6) - (6)].str)); 13620@@ -30523,8 +29722,6 @@ 13621 break; 13622 13623 case 635: 13624- 13625-/* Line 1455 of yacc.c */ 13626 #line 4463 "preproc.y" 13627 { 13628 (yyval.str) = cat_str(6,make_str("alter operator family"),(yyvsp[(4) - (8)].str),make_str("using"),(yyvsp[(6) - (8)].str),make_str("add"),(yyvsp[(8) - (8)].str)); 13629@@ -30532,8 +29729,6 @@ 13630 break; 13631 13632 case 636: 13633- 13634-/* Line 1455 of yacc.c */ 13635 #line 4467 "preproc.y" 13636 { 13637 (yyval.str) = cat_str(6,make_str("alter operator family"),(yyvsp[(4) - (8)].str),make_str("using"),(yyvsp[(6) - (8)].str),make_str("drop"),(yyvsp[(8) - (8)].str)); 13638@@ -30541,8 +29736,6 @@ 13639 break; 13640 13641 case 637: 13642- 13643-/* Line 1455 of yacc.c */ 13644 #line 4475 "preproc.y" 13645 { 13646 (yyval.str) = (yyvsp[(1) - (1)].str); 13647@@ -30550,8 +29743,6 @@ 13648 break; 13649 13650 case 638: 13651- 13652-/* Line 1455 of yacc.c */ 13653 #line 4479 "preproc.y" 13654 { 13655 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 13656@@ -30559,8 +29750,6 @@ 13657 break; 13658 13659 case 639: 13660- 13661-/* Line 1455 of yacc.c */ 13662 #line 4487 "preproc.y" 13663 { 13664 (yyval.str) = cat_str(5,make_str("operator"),(yyvsp[(2) - (5)].str),make_str("("),(yyvsp[(4) - (5)].str),make_str(")")); 13665@@ -30568,8 +29757,6 @@ 13666 break; 13667 13668 case 640: 13669- 13670-/* Line 1455 of yacc.c */ 13671 #line 4491 "preproc.y" 13672 { 13673 (yyval.str) = cat_str(5,make_str("function"),(yyvsp[(2) - (5)].str),make_str("("),(yyvsp[(4) - (5)].str),make_str(")")); 13674@@ -30577,8 +29764,6 @@ 13675 break; 13676 13677 case 641: 13678- 13679-/* Line 1455 of yacc.c */ 13680 #line 4499 "preproc.y" 13681 { 13682 (yyval.str) = cat_str(5,make_str("drop operator class"),(yyvsp[(4) - (7)].str),make_str("using"),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 13683@@ -30586,8 +29771,6 @@ 13684 break; 13685 13686 case 642: 13687- 13688-/* Line 1455 of yacc.c */ 13689 #line 4503 "preproc.y" 13690 { 13691 (yyval.str) = cat_str(5,make_str("drop operator class if exists"),(yyvsp[(6) - (9)].str),make_str("using"),(yyvsp[(8) - (9)].str),(yyvsp[(9) - (9)].str)); 13692@@ -30595,8 +29778,6 @@ 13693 break; 13694 13695 case 643: 13696- 13697-/* Line 1455 of yacc.c */ 13698 #line 4511 "preproc.y" 13699 { 13700 (yyval.str) = cat_str(5,make_str("drop operator family"),(yyvsp[(4) - (7)].str),make_str("using"),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 13701@@ -30604,8 +29785,6 @@ 13702 break; 13703 13704 case 644: 13705- 13706-/* Line 1455 of yacc.c */ 13707 #line 4515 "preproc.y" 13708 { 13709 (yyval.str) = cat_str(5,make_str("drop operator family if exists"),(yyvsp[(6) - (9)].str),make_str("using"),(yyvsp[(8) - (9)].str),(yyvsp[(9) - (9)].str)); 13710@@ -30613,8 +29792,6 @@ 13711 break; 13712 13713 case 645: 13714- 13715-/* Line 1455 of yacc.c */ 13716 #line 4523 "preproc.y" 13717 { 13718 (yyval.str) = cat_str(3,make_str("drop owned by"),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 13719@@ -30622,8 +29799,6 @@ 13720 break; 13721 13722 case 646: 13723- 13724-/* Line 1455 of yacc.c */ 13725 #line 4531 "preproc.y" 13726 { 13727 (yyval.str) = cat_str(4,make_str("reassign owned by"),(yyvsp[(4) - (6)].str),make_str("to"),(yyvsp[(6) - (6)].str)); 13728@@ -30631,8 +29806,6 @@ 13729 break; 13730 13731 case 647: 13732- 13733-/* Line 1455 of yacc.c */ 13734 #line 4539 "preproc.y" 13735 { 13736 (yyval.str) = cat_str(5,make_str("drop"),(yyvsp[(2) - (6)].str),make_str("if exists"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 13737@@ -30640,8 +29813,6 @@ 13738 break; 13739 13740 case 648: 13741- 13742-/* Line 1455 of yacc.c */ 13743 #line 4543 "preproc.y" 13744 { 13745 (yyval.str) = cat_str(4,make_str("drop"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 13746@@ -30649,8 +29820,6 @@ 13747 break; 13748 13749 case 649: 13750- 13751-/* Line 1455 of yacc.c */ 13752 #line 4551 "preproc.y" 13753 { 13754 (yyval.str) = make_str("table"); 13755@@ -30658,8 +29827,6 @@ 13756 break; 13757 13758 case 650: 13759- 13760-/* Line 1455 of yacc.c */ 13761 #line 4555 "preproc.y" 13762 { 13763 (yyval.str) = make_str("sequence"); 13764@@ -30667,8 +29834,6 @@ 13765 break; 13766 13767 case 651: 13768- 13769-/* Line 1455 of yacc.c */ 13770 #line 4559 "preproc.y" 13771 { 13772 (yyval.str) = make_str("view"); 13773@@ -30676,8 +29841,6 @@ 13774 break; 13775 13776 case 652: 13777- 13778-/* Line 1455 of yacc.c */ 13779 #line 4563 "preproc.y" 13780 { 13781 (yyval.str) = make_str("index"); 13782@@ -30685,8 +29848,6 @@ 13783 break; 13784 13785 case 653: 13786- 13787-/* Line 1455 of yacc.c */ 13788 #line 4567 "preproc.y" 13789 { 13790 (yyval.str) = make_str("type"); 13791@@ -30694,8 +29855,6 @@ 13792 break; 13793 13794 case 654: 13795- 13796-/* Line 1455 of yacc.c */ 13797 #line 4571 "preproc.y" 13798 { 13799 (yyval.str) = make_str("domain"); 13800@@ -30703,8 +29862,6 @@ 13801 break; 13802 13803 case 655: 13804- 13805-/* Line 1455 of yacc.c */ 13806 #line 4575 "preproc.y" 13807 { 13808 (yyval.str) = make_str("conversion"); 13809@@ -30712,8 +29869,6 @@ 13810 break; 13811 13812 case 656: 13813- 13814-/* Line 1455 of yacc.c */ 13815 #line 4579 "preproc.y" 13816 { 13817 (yyval.str) = make_str("schema"); 13818@@ -30721,8 +29876,6 @@ 13819 break; 13820 13821 case 657: 13822- 13823-/* Line 1455 of yacc.c */ 13824 #line 4583 "preproc.y" 13825 { 13826 (yyval.str) = make_str("text search parser"); 13827@@ -30730,8 +29883,6 @@ 13828 break; 13829 13830 case 658: 13831- 13832-/* Line 1455 of yacc.c */ 13833 #line 4587 "preproc.y" 13834 { 13835 (yyval.str) = make_str("text search dictionary"); 13836@@ -30739,8 +29890,6 @@ 13837 break; 13838 13839 case 659: 13840- 13841-/* Line 1455 of yacc.c */ 13842 #line 4591 "preproc.y" 13843 { 13844 (yyval.str) = make_str("text search template"); 13845@@ -30748,8 +29897,6 @@ 13846 break; 13847 13848 case 660: 13849- 13850-/* Line 1455 of yacc.c */ 13851 #line 4595 "preproc.y" 13852 { 13853 (yyval.str) = make_str("text search configuration"); 13854@@ -30757,8 +29904,6 @@ 13855 break; 13856 13857 case 661: 13858- 13859-/* Line 1455 of yacc.c */ 13860 #line 4603 "preproc.y" 13861 { 13862 (yyval.str) = (yyvsp[(1) - (1)].str); 13863@@ -30766,8 +29911,6 @@ 13864 break; 13865 13866 case 662: 13867- 13868-/* Line 1455 of yacc.c */ 13869 #line 4607 "preproc.y" 13870 { 13871 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 13872@@ -30775,8 +29918,6 @@ 13873 break; 13874 13875 case 663: 13876- 13877-/* Line 1455 of yacc.c */ 13878 #line 4615 "preproc.y" 13879 { 13880 (yyval.str) = (yyvsp[(1) - (1)].str); 13881@@ -30784,8 +29925,6 @@ 13882 break; 13883 13884 case 664: 13885- 13886-/* Line 1455 of yacc.c */ 13887 #line 4619 "preproc.y" 13888 { 13889 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 13890@@ -30793,8 +29932,6 @@ 13891 break; 13892 13893 case 665: 13894- 13895-/* Line 1455 of yacc.c */ 13896 #line 4627 "preproc.y" 13897 { 13898 (yyval.str) = cat_str(2,make_str("."),(yyvsp[(2) - (2)].str)); 13899@@ -30802,8 +29939,6 @@ 13900 break; 13901 13902 case 666: 13903- 13904-/* Line 1455 of yacc.c */ 13905 #line 4631 "preproc.y" 13906 { 13907 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("."),(yyvsp[(3) - (3)].str)); 13908@@ -30811,8 +29946,6 @@ 13909 break; 13910 13911 case 667: 13912- 13913-/* Line 1455 of yacc.c */ 13914 #line 4639 "preproc.y" 13915 { 13916 (yyval.str) = cat_str(5,make_str("truncate"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 13917@@ -30820,8 +29953,6 @@ 13918 break; 13919 13920 case 668: 13921- 13922-/* Line 1455 of yacc.c */ 13923 #line 4647 "preproc.y" 13924 { 13925 (yyval.str) = make_str("continue identity"); 13926@@ -30829,8 +29960,6 @@ 13927 break; 13928 13929 case 669: 13930- 13931-/* Line 1455 of yacc.c */ 13932 #line 4651 "preproc.y" 13933 { 13934 (yyval.str) = make_str("restart identity"); 13935@@ -30838,16 +29967,12 @@ 13936 break; 13937 13938 case 670: 13939- 13940-/* Line 1455 of yacc.c */ 13941 #line 4655 "preproc.y" 13942 { 13943 (yyval.str)=EMPTY; ;} 13944 break; 13945 13946 case 671: 13947- 13948-/* Line 1455 of yacc.c */ 13949 #line 4662 "preproc.y" 13950 { 13951 (yyval.str) = cat_str(5,make_str("comment on"),(yyvsp[(3) - (6)].str),(yyvsp[(4) - (6)].str),make_str("is"),(yyvsp[(6) - (6)].str)); 13952@@ -30855,8 +29980,6 @@ 13953 break; 13954 13955 case 672: 13956- 13957-/* Line 1455 of yacc.c */ 13958 #line 4666 "preproc.y" 13959 { 13960 (yyval.str) = cat_str(5,make_str("comment on aggregate"),(yyvsp[(4) - (7)].str),(yyvsp[(5) - (7)].str),make_str("is"),(yyvsp[(7) - (7)].str)); 13961@@ -30864,8 +29987,6 @@ 13962 break; 13963 13964 case 673: 13965- 13966-/* Line 1455 of yacc.c */ 13967 #line 4670 "preproc.y" 13968 { 13969 (yyval.str) = cat_str(5,make_str("comment on function"),(yyvsp[(4) - (7)].str),(yyvsp[(5) - (7)].str),make_str("is"),(yyvsp[(7) - (7)].str)); 13970@@ -30873,8 +29994,6 @@ 13971 break; 13972 13973 case 674: 13974- 13975-/* Line 1455 of yacc.c */ 13976 #line 4674 "preproc.y" 13977 { 13978 (yyval.str) = cat_str(5,make_str("comment on operator"),(yyvsp[(4) - (7)].str),(yyvsp[(5) - (7)].str),make_str("is"),(yyvsp[(7) - (7)].str)); 13979@@ -30882,8 +30001,6 @@ 13980 break; 13981 13982 case 675: 13983- 13984-/* Line 1455 of yacc.c */ 13985 #line 4678 "preproc.y" 13986 { 13987 (yyval.str) = cat_str(6,make_str("comment on constraint"),(yyvsp[(4) - (8)].str),make_str("on"),(yyvsp[(6) - (8)].str),make_str("is"),(yyvsp[(8) - (8)].str)); 13988@@ -30891,8 +30008,6 @@ 13989 break; 13990 13991 case 676: 13992- 13993-/* Line 1455 of yacc.c */ 13994 #line 4682 "preproc.y" 13995 { 13996 (yyval.str) = cat_str(6,make_str("comment on rule"),(yyvsp[(4) - (8)].str),make_str("on"),(yyvsp[(6) - (8)].str),make_str("is"),(yyvsp[(8) - (8)].str)); 13997@@ -30900,8 +30015,6 @@ 13998 break; 13999 14000 case 677: 14001- 14002-/* Line 1455 of yacc.c */ 14003 #line 4686 "preproc.y" 14004 { 14005 (yyval.str) = cat_str(4,make_str("comment on rule"),(yyvsp[(4) - (6)].str),make_str("is"),(yyvsp[(6) - (6)].str)); 14006@@ -30909,8 +30022,6 @@ 14007 break; 14008 14009 case 678: 14010- 14011-/* Line 1455 of yacc.c */ 14012 #line 4690 "preproc.y" 14013 { 14014 (yyval.str) = cat_str(6,make_str("comment on trigger"),(yyvsp[(4) - (8)].str),make_str("on"),(yyvsp[(6) - (8)].str),make_str("is"),(yyvsp[(8) - (8)].str)); 14015@@ -30918,8 +30029,6 @@ 14016 break; 14017 14018 case 679: 14019- 14020-/* Line 1455 of yacc.c */ 14021 #line 4694 "preproc.y" 14022 { 14023 (yyval.str) = cat_str(6,make_str("comment on operator class"),(yyvsp[(5) - (9)].str),make_str("using"),(yyvsp[(7) - (9)].str),make_str("is"),(yyvsp[(9) - (9)].str)); 14024@@ -30927,8 +30036,6 @@ 14025 break; 14026 14027 case 680: 14028- 14029-/* Line 1455 of yacc.c */ 14030 #line 4698 "preproc.y" 14031 { 14032 (yyval.str) = cat_str(6,make_str("comment on operator family"),(yyvsp[(5) - (9)].str),make_str("using"),(yyvsp[(7) - (9)].str),make_str("is"),(yyvsp[(9) - (9)].str)); 14033@@ -30936,8 +30043,6 @@ 14034 break; 14035 14036 case 681: 14037- 14038-/* Line 1455 of yacc.c */ 14039 #line 4702 "preproc.y" 14040 { 14041 (yyval.str) = cat_str(4,make_str("comment on large object"),(yyvsp[(5) - (7)].str),make_str("is"),(yyvsp[(7) - (7)].str)); 14042@@ -30945,8 +30050,6 @@ 14043 break; 14044 14045 case 682: 14046- 14047-/* Line 1455 of yacc.c */ 14048 #line 4706 "preproc.y" 14049 { 14050 (yyval.str) = cat_str(6,make_str("comment on cast ("),(yyvsp[(5) - (10)].str),make_str("as"),(yyvsp[(7) - (10)].str),make_str(") is"),(yyvsp[(10) - (10)].str)); 14051@@ -30954,8 +30057,6 @@ 14052 break; 14053 14054 case 683: 14055- 14056-/* Line 1455 of yacc.c */ 14057 #line 4710 "preproc.y" 14058 { 14059 (yyval.str) = cat_str(6,make_str("comment on"),(yyvsp[(3) - (7)].str),make_str("language"),(yyvsp[(5) - (7)].str),make_str("is"),(yyvsp[(7) - (7)].str)); 14060@@ -30963,8 +30064,6 @@ 14061 break; 14062 14063 case 684: 14064- 14065-/* Line 1455 of yacc.c */ 14066 #line 4714 "preproc.y" 14067 { 14068 (yyval.str) = cat_str(4,make_str("comment on text search parser"),(yyvsp[(6) - (8)].str),make_str("is"),(yyvsp[(8) - (8)].str)); 14069@@ -30972,8 +30071,6 @@ 14070 break; 14071 14072 case 685: 14073- 14074-/* Line 1455 of yacc.c */ 14075 #line 4718 "preproc.y" 14076 { 14077 (yyval.str) = cat_str(4,make_str("comment on text search dictionary"),(yyvsp[(6) - (8)].str),make_str("is"),(yyvsp[(8) - (8)].str)); 14078@@ -30981,8 +30078,6 @@ 14079 break; 14080 14081 case 686: 14082- 14083-/* Line 1455 of yacc.c */ 14084 #line 4722 "preproc.y" 14085 { 14086 (yyval.str) = cat_str(4,make_str("comment on text search template"),(yyvsp[(6) - (8)].str),make_str("is"),(yyvsp[(8) - (8)].str)); 14087@@ -30990,8 +30085,6 @@ 14088 break; 14089 14090 case 687: 14091- 14092-/* Line 1455 of yacc.c */ 14093 #line 4726 "preproc.y" 14094 { 14095 (yyval.str) = cat_str(4,make_str("comment on text search configuration"),(yyvsp[(6) - (8)].str),make_str("is"),(yyvsp[(8) - (8)].str)); 14096@@ -30999,8 +30092,6 @@ 14097 break; 14098 14099 case 688: 14100- 14101-/* Line 1455 of yacc.c */ 14102 #line 4734 "preproc.y" 14103 { 14104 (yyval.str) = make_str("column"); 14105@@ -31008,8 +30099,6 @@ 14106 break; 14107 14108 case 689: 14109- 14110-/* Line 1455 of yacc.c */ 14111 #line 4738 "preproc.y" 14112 { 14113 (yyval.str) = make_str("database"); 14114@@ -31017,8 +30106,6 @@ 14115 break; 14116 14117 case 690: 14118- 14119-/* Line 1455 of yacc.c */ 14120 #line 4742 "preproc.y" 14121 { 14122 (yyval.str) = make_str("schema"); 14123@@ -31026,8 +30113,6 @@ 14124 break; 14125 14126 case 691: 14127- 14128-/* Line 1455 of yacc.c */ 14129 #line 4746 "preproc.y" 14130 { 14131 (yyval.str) = make_str("index"); 14132@@ -31035,8 +30120,6 @@ 14133 break; 14134 14135 case 692: 14136- 14137-/* Line 1455 of yacc.c */ 14138 #line 4750 "preproc.y" 14139 { 14140 (yyval.str) = make_str("sequence"); 14141@@ -31044,8 +30127,6 @@ 14142 break; 14143 14144 case 693: 14145- 14146-/* Line 1455 of yacc.c */ 14147 #line 4754 "preproc.y" 14148 { 14149 (yyval.str) = make_str("table"); 14150@@ -31053,8 +30134,6 @@ 14151 break; 14152 14153 case 694: 14154- 14155-/* Line 1455 of yacc.c */ 14156 #line 4758 "preproc.y" 14157 { 14158 (yyval.str) = make_str("domain"); 14159@@ -31062,8 +30141,6 @@ 14160 break; 14161 14162 case 695: 14163- 14164-/* Line 1455 of yacc.c */ 14165 #line 4762 "preproc.y" 14166 { 14167 (yyval.str) = make_str("type"); 14168@@ -31071,8 +30148,6 @@ 14169 break; 14170 14171 case 696: 14172- 14173-/* Line 1455 of yacc.c */ 14174 #line 4766 "preproc.y" 14175 { 14176 (yyval.str) = make_str("view"); 14177@@ -31080,8 +30155,6 @@ 14178 break; 14179 14180 case 697: 14181- 14182-/* Line 1455 of yacc.c */ 14183 #line 4770 "preproc.y" 14184 { 14185 (yyval.str) = make_str("conversion"); 14186@@ -31089,8 +30162,6 @@ 14187 break; 14188 14189 case 698: 14190- 14191-/* Line 1455 of yacc.c */ 14192 #line 4774 "preproc.y" 14193 { 14194 (yyval.str) = make_str("tablespace"); 14195@@ -31098,8 +30169,6 @@ 14196 break; 14197 14198 case 699: 14199- 14200-/* Line 1455 of yacc.c */ 14201 #line 4778 "preproc.y" 14202 { 14203 (yyval.str) = make_str("role"); 14204@@ -31107,8 +30176,6 @@ 14205 break; 14206 14207 case 700: 14208- 14209-/* Line 1455 of yacc.c */ 14210 #line 4786 "preproc.y" 14211 { 14212 (yyval.str) = (yyvsp[(1) - (1)].str); 14213@@ -31116,8 +30183,6 @@ 14214 break; 14215 14216 case 701: 14217- 14218-/* Line 1455 of yacc.c */ 14219 #line 4790 "preproc.y" 14220 { 14221 (yyval.str) = make_str("null"); 14222@@ -31125,8 +30190,6 @@ 14223 break; 14224 14225 case 702: 14226- 14227-/* Line 1455 of yacc.c */ 14228 #line 4798 "preproc.y" 14229 { 14230 (yyval.str) = cat_str(2,make_str("fetch"),(yyvsp[(2) - (2)].str)); 14231@@ -31134,8 +30197,6 @@ 14232 break; 14233 14234 case 703: 14235- 14236-/* Line 1455 of yacc.c */ 14237 #line 4802 "preproc.y" 14238 { 14239 (yyval.str) = cat_str(2,make_str("move"),(yyvsp[(2) - (2)].str)); 14240@@ -31143,8 +30204,6 @@ 14241 break; 14242 14243 case 704: 14244- 14245-/* Line 1455 of yacc.c */ 14246 #line 4806 "preproc.y" 14247 { 14248 (yyval.str) = cat2_str(make_str("fetch"), (yyvsp[(2) - (3)].str)); 14249@@ -31152,8 +30211,6 @@ 14250 break; 14251 14252 case 705: 14253- 14254-/* Line 1455 of yacc.c */ 14255 #line 4810 "preproc.y" 14256 { 14257 char *cursor_marker = (yyvsp[(3) - (4)].str)[0] == ':' ? make_str("$0") : (yyvsp[(3) - (4)].str); 14258@@ -31163,8 +30220,6 @@ 14259 break; 14260 14261 case 706: 14262- 14263-/* Line 1455 of yacc.c */ 14264 #line 4816 "preproc.y" 14265 { 14266 char *cursor_marker = (yyvsp[(4) - (5)].str)[0] == ':' ? make_str("$0") : (yyvsp[(4) - (5)].str); 14267@@ -31174,8 +30229,6 @@ 14268 break; 14269 14270 case 707: 14271- 14272-/* Line 1455 of yacc.c */ 14273 #line 4822 "preproc.y" 14274 { 14275 char *cursor_marker = (yyvsp[(3) - (4)].str)[0] == ':' ? make_str("$0") : (yyvsp[(3) - (4)].str); 14276@@ -31185,8 +30238,6 @@ 14277 break; 14278 14279 case 708: 14280- 14281-/* Line 1455 of yacc.c */ 14282 #line 4828 "preproc.y" 14283 { 14284 char *cursor_marker = (yyvsp[(4) - (5)].str)[0] == ':' ? make_str("$0") : (yyvsp[(4) - (5)].str); 14285@@ -31196,8 +30247,6 @@ 14286 break; 14287 14288 case 709: 14289- 14290-/* Line 1455 of yacc.c */ 14291 #line 4834 "preproc.y" 14292 { 14293 char *cursor_marker = (yyvsp[(3) - (3)].str)[0] == ':' ? make_str("$0") : (yyvsp[(3) - (3)].str); 14294@@ -31207,8 +30256,6 @@ 14295 break; 14296 14297 case 710: 14298- 14299-/* Line 1455 of yacc.c */ 14300 #line 4840 "preproc.y" 14301 { 14302 char *cursor_marker = (yyvsp[(4) - (4)].str)[0] == ':' ? make_str("$0") : (yyvsp[(4) - (4)].str); 14303@@ -31218,8 +30265,6 @@ 14304 break; 14305 14306 case 711: 14307- 14308-/* Line 1455 of yacc.c */ 14309 #line 4846 "preproc.y" 14310 { 14311 char *cursor_marker = (yyvsp[(3) - (3)].str)[0] == ':' ? make_str("$0") : (yyvsp[(3) - (3)].str); 14312@@ -31229,8 +30274,6 @@ 14313 break; 14314 14315 case 712: 14316- 14317-/* Line 1455 of yacc.c */ 14318 #line 4852 "preproc.y" 14319 { 14320 char *cursor_marker = (yyvsp[(4) - (4)].str)[0] == ':' ? make_str("$0") : (yyvsp[(4) - (4)].str); 14321@@ -31240,8 +30283,6 @@ 14322 break; 14323 14324 case 713: 14325- 14326-/* Line 1455 of yacc.c */ 14327 #line 4862 "preproc.y" 14328 { 14329 add_additional_variables((yyvsp[(1) - (1)].str), false); 14330@@ -31256,8 +30297,6 @@ 14331 break; 14332 14333 case 714: 14334- 14335-/* Line 1455 of yacc.c */ 14336 #line 4873 "preproc.y" 14337 { 14338 add_additional_variables((yyvsp[(2) - (2)].str), false); 14339@@ -31272,8 +30311,6 @@ 14340 break; 14341 14342 case 715: 14343- 14344-/* Line 1455 of yacc.c */ 14345 #line 4884 "preproc.y" 14346 { 14347 add_additional_variables((yyvsp[(3) - (3)].str), false); 14348@@ -31288,8 +30325,6 @@ 14349 break; 14350 14351 case 716: 14352- 14353-/* Line 1455 of yacc.c */ 14354 #line 4895 "preproc.y" 14355 { 14356 add_additional_variables((yyvsp[(3) - (3)].str), false); 14357@@ -31304,8 +30339,6 @@ 14358 break; 14359 14360 case 717: 14361- 14362-/* Line 1455 of yacc.c */ 14363 #line 4906 "preproc.y" 14364 { 14365 add_additional_variables((yyvsp[(3) - (3)].str), false); 14366@@ -31320,8 +30353,6 @@ 14367 break; 14368 14369 case 718: 14370- 14371-/* Line 1455 of yacc.c */ 14372 #line 4917 "preproc.y" 14373 { 14374 add_additional_variables((yyvsp[(3) - (3)].str), false); 14375@@ -31336,8 +30367,6 @@ 14376 break; 14377 14378 case 719: 14379- 14380-/* Line 1455 of yacc.c */ 14381 #line 4928 "preproc.y" 14382 { 14383 add_additional_variables((yyvsp[(4) - (4)].str), false); 14384@@ -31357,8 +30386,6 @@ 14385 break; 14386 14387 case 720: 14388- 14389-/* Line 1455 of yacc.c */ 14390 #line 4944 "preproc.y" 14391 { 14392 add_additional_variables((yyvsp[(4) - (4)].str), false); 14393@@ -31378,8 +30405,6 @@ 14394 break; 14395 14396 case 721: 14397- 14398-/* Line 1455 of yacc.c */ 14399 #line 4960 "preproc.y" 14400 { 14401 add_additional_variables((yyvsp[(3) - (3)].str), false); 14402@@ -31399,8 +30424,6 @@ 14403 break; 14404 14405 case 722: 14406- 14407-/* Line 1455 of yacc.c */ 14408 #line 4976 "preproc.y" 14409 { 14410 add_additional_variables((yyvsp[(3) - (3)].str), false); 14411@@ -31415,8 +30438,6 @@ 14412 break; 14413 14414 case 723: 14415- 14416-/* Line 1455 of yacc.c */ 14417 #line 4987 "preproc.y" 14418 { 14419 add_additional_variables((yyvsp[(4) - (4)].str), false); 14420@@ -31436,8 +30457,6 @@ 14421 break; 14422 14423 case 724: 14424- 14425-/* Line 1455 of yacc.c */ 14426 #line 5003 "preproc.y" 14427 { 14428 add_additional_variables((yyvsp[(4) - (4)].str), false); 14429@@ -31452,8 +30471,6 @@ 14430 break; 14431 14432 case 725: 14433- 14434-/* Line 1455 of yacc.c */ 14435 #line 5014 "preproc.y" 14436 { 14437 add_additional_variables((yyvsp[(4) - (4)].str), false); 14438@@ -31473,8 +30490,6 @@ 14439 break; 14440 14441 case 726: 14442- 14443-/* Line 1455 of yacc.c */ 14444 #line 5030 "preproc.y" 14445 { 14446 add_additional_variables((yyvsp[(4) - (4)].str), false); 14447@@ -31489,8 +30504,6 @@ 14448 break; 14449 14450 case 727: 14451- 14452-/* Line 1455 of yacc.c */ 14453 #line 5045 "preproc.y" 14454 { 14455 (yyval.str) = make_str("from"); 14456@@ -31498,8 +30511,6 @@ 14457 break; 14458 14459 case 728: 14460- 14461-/* Line 1455 of yacc.c */ 14462 #line 5049 "preproc.y" 14463 { 14464 (yyval.str) = make_str("in"); 14465@@ -31507,8 +30518,6 @@ 14466 break; 14467 14468 case 729: 14469- 14470-/* Line 1455 of yacc.c */ 14471 #line 5057 "preproc.y" 14472 { 14473 (yyval.str) = (yyvsp[(1) - (1)].str); 14474@@ -31516,16 +30525,12 @@ 14475 break; 14476 14477 case 730: 14478- 14479-/* Line 1455 of yacc.c */ 14480 #line 5061 "preproc.y" 14481 { 14482 (yyval.str)=EMPTY; ;} 14483 break; 14484 14485 case 731: 14486- 14487-/* Line 1455 of yacc.c */ 14488 #line 5068 "preproc.y" 14489 { 14490 (yyval.str) = cat_str(7,make_str("grant"),(yyvsp[(2) - (7)].str),make_str("on"),(yyvsp[(4) - (7)].str),make_str("to"),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 14491@@ -31533,8 +30538,6 @@ 14492 break; 14493 14494 case 732: 14495- 14496-/* Line 1455 of yacc.c */ 14497 #line 5076 "preproc.y" 14498 { 14499 (yyval.str) = cat_str(7,make_str("revoke"),(yyvsp[(2) - (7)].str),make_str("on"),(yyvsp[(4) - (7)].str),make_str("from"),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 14500@@ -31542,8 +30545,6 @@ 14501 break; 14502 14503 case 733: 14504- 14505-/* Line 1455 of yacc.c */ 14506 #line 5080 "preproc.y" 14507 { 14508 (yyval.str) = cat_str(7,make_str("revoke grant option for"),(yyvsp[(5) - (10)].str),make_str("on"),(yyvsp[(7) - (10)].str),make_str("from"),(yyvsp[(9) - (10)].str),(yyvsp[(10) - (10)].str)); 14509@@ -31551,8 +30552,6 @@ 14510 break; 14511 14512 case 734: 14513- 14514-/* Line 1455 of yacc.c */ 14515 #line 5088 "preproc.y" 14516 { 14517 (yyval.str) = (yyvsp[(1) - (1)].str); 14518@@ -31560,8 +30559,6 @@ 14519 break; 14520 14521 case 735: 14522- 14523-/* Line 1455 of yacc.c */ 14524 #line 5092 "preproc.y" 14525 { 14526 (yyval.str) = make_str("all"); 14527@@ -31569,8 +30566,6 @@ 14528 break; 14529 14530 case 736: 14531- 14532-/* Line 1455 of yacc.c */ 14533 #line 5096 "preproc.y" 14534 { 14535 (yyval.str) = make_str("all privileges"); 14536@@ -31578,8 +30573,6 @@ 14537 break; 14538 14539 case 737: 14540- 14541-/* Line 1455 of yacc.c */ 14542 #line 5100 "preproc.y" 14543 { 14544 (yyval.str) = cat_str(3,make_str("all ("),(yyvsp[(3) - (4)].str),make_str(")")); 14545@@ -31587,8 +30580,6 @@ 14546 break; 14547 14548 case 738: 14549- 14550-/* Line 1455 of yacc.c */ 14551 #line 5104 "preproc.y" 14552 { 14553 (yyval.str) = cat_str(3,make_str("all privileges ("),(yyvsp[(4) - (5)].str),make_str(")")); 14554@@ -31596,8 +30587,6 @@ 14555 break; 14556 14557 case 739: 14558- 14559-/* Line 1455 of yacc.c */ 14560 #line 5112 "preproc.y" 14561 { 14562 (yyval.str) = (yyvsp[(1) - (1)].str); 14563@@ -31605,8 +30594,6 @@ 14564 break; 14565 14566 case 740: 14567- 14568-/* Line 1455 of yacc.c */ 14569 #line 5116 "preproc.y" 14570 { 14571 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 14572@@ -31614,8 +30601,6 @@ 14573 break; 14574 14575 case 741: 14576- 14577-/* Line 1455 of yacc.c */ 14578 #line 5124 "preproc.y" 14579 { 14580 (yyval.str) = cat_str(2,make_str("select"),(yyvsp[(2) - (2)].str)); 14581@@ -31623,8 +30608,6 @@ 14582 break; 14583 14584 case 742: 14585- 14586-/* Line 1455 of yacc.c */ 14587 #line 5128 "preproc.y" 14588 { 14589 (yyval.str) = cat_str(2,make_str("references"),(yyvsp[(2) - (2)].str)); 14590@@ -31632,8 +30615,6 @@ 14591 break; 14592 14593 case 743: 14594- 14595-/* Line 1455 of yacc.c */ 14596 #line 5132 "preproc.y" 14597 { 14598 (yyval.str) = cat_str(2,make_str("create"),(yyvsp[(2) - (2)].str)); 14599@@ -31641,8 +30622,6 @@ 14600 break; 14601 14602 case 744: 14603- 14604-/* Line 1455 of yacc.c */ 14605 #line 5136 "preproc.y" 14606 { 14607 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 14608@@ -31650,8 +30629,6 @@ 14609 break; 14610 14611 case 745: 14612- 14613-/* Line 1455 of yacc.c */ 14614 #line 5144 "preproc.y" 14615 { 14616 (yyval.str) = (yyvsp[(1) - (1)].str); 14617@@ -31659,8 +30636,6 @@ 14618 break; 14619 14620 case 746: 14621- 14622-/* Line 1455 of yacc.c */ 14623 #line 5148 "preproc.y" 14624 { 14625 (yyval.str) = cat_str(2,make_str("table"),(yyvsp[(2) - (2)].str)); 14626@@ -31668,8 +30643,6 @@ 14627 break; 14628 14629 case 747: 14630- 14631-/* Line 1455 of yacc.c */ 14632 #line 5152 "preproc.y" 14633 { 14634 (yyval.str) = cat_str(2,make_str("sequence"),(yyvsp[(2) - (2)].str)); 14635@@ -31677,8 +30650,6 @@ 14636 break; 14637 14638 case 748: 14639- 14640-/* Line 1455 of yacc.c */ 14641 #line 5156 "preproc.y" 14642 { 14643 (yyval.str) = cat_str(2,make_str("foreign data wrapper"),(yyvsp[(4) - (4)].str)); 14644@@ -31686,8 +30657,6 @@ 14645 break; 14646 14647 case 749: 14648- 14649-/* Line 1455 of yacc.c */ 14650 #line 5160 "preproc.y" 14651 { 14652 (yyval.str) = cat_str(2,make_str("foreign server"),(yyvsp[(3) - (3)].str)); 14653@@ -31695,8 +30664,6 @@ 14654 break; 14655 14656 case 750: 14657- 14658-/* Line 1455 of yacc.c */ 14659 #line 5164 "preproc.y" 14660 { 14661 (yyval.str) = cat_str(2,make_str("function"),(yyvsp[(2) - (2)].str)); 14662@@ -31704,8 +30671,6 @@ 14663 break; 14664 14665 case 751: 14666- 14667-/* Line 1455 of yacc.c */ 14668 #line 5168 "preproc.y" 14669 { 14670 (yyval.str) = cat_str(2,make_str("database"),(yyvsp[(2) - (2)].str)); 14671@@ -31713,8 +30678,6 @@ 14672 break; 14673 14674 case 752: 14675- 14676-/* Line 1455 of yacc.c */ 14677 #line 5172 "preproc.y" 14678 { 14679 (yyval.str) = cat_str(2,make_str("language"),(yyvsp[(2) - (2)].str)); 14680@@ -31722,8 +30685,6 @@ 14681 break; 14682 14683 case 753: 14684- 14685-/* Line 1455 of yacc.c */ 14686 #line 5176 "preproc.y" 14687 { 14688 (yyval.str) = cat_str(2,make_str("large object"),(yyvsp[(3) - (3)].str)); 14689@@ -31731,8 +30692,6 @@ 14690 break; 14691 14692 case 754: 14693- 14694-/* Line 1455 of yacc.c */ 14695 #line 5180 "preproc.y" 14696 { 14697 (yyval.str) = cat_str(2,make_str("schema"),(yyvsp[(2) - (2)].str)); 14698@@ -31740,8 +30699,6 @@ 14699 break; 14700 14701 case 755: 14702- 14703-/* Line 1455 of yacc.c */ 14704 #line 5184 "preproc.y" 14705 { 14706 (yyval.str) = cat_str(2,make_str("tablespace"),(yyvsp[(2) - (2)].str)); 14707@@ -31749,8 +30706,6 @@ 14708 break; 14709 14710 case 756: 14711- 14712-/* Line 1455 of yacc.c */ 14713 #line 5188 "preproc.y" 14714 { 14715 (yyval.str) = cat_str(2,make_str("all tables in schema"),(yyvsp[(5) - (5)].str)); 14716@@ -31758,8 +30713,6 @@ 14717 break; 14718 14719 case 757: 14720- 14721-/* Line 1455 of yacc.c */ 14722 #line 5192 "preproc.y" 14723 { 14724 (yyval.str) = cat_str(2,make_str("all sequences in schema"),(yyvsp[(5) - (5)].str)); 14725@@ -31767,8 +30720,6 @@ 14726 break; 14727 14728 case 758: 14729- 14730-/* Line 1455 of yacc.c */ 14731 #line 5196 "preproc.y" 14732 { 14733 (yyval.str) = cat_str(2,make_str("all functions in schema"),(yyvsp[(5) - (5)].str)); 14734@@ -31776,8 +30727,6 @@ 14735 break; 14736 14737 case 759: 14738- 14739-/* Line 1455 of yacc.c */ 14740 #line 5204 "preproc.y" 14741 { 14742 (yyval.str) = (yyvsp[(1) - (1)].str); 14743@@ -31785,8 +30734,6 @@ 14744 break; 14745 14746 case 760: 14747- 14748-/* Line 1455 of yacc.c */ 14749 #line 5208 "preproc.y" 14750 { 14751 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 14752@@ -31794,8 +30741,6 @@ 14753 break; 14754 14755 case 761: 14756- 14757-/* Line 1455 of yacc.c */ 14758 #line 5216 "preproc.y" 14759 { 14760 (yyval.str) = (yyvsp[(1) - (1)].str); 14761@@ -31803,8 +30748,6 @@ 14762 break; 14763 14764 case 762: 14765- 14766-/* Line 1455 of yacc.c */ 14767 #line 5220 "preproc.y" 14768 { 14769 (yyval.str) = cat_str(2,make_str("group"),(yyvsp[(2) - (2)].str)); 14770@@ -31812,8 +30755,6 @@ 14771 break; 14772 14773 case 763: 14774- 14775-/* Line 1455 of yacc.c */ 14776 #line 5228 "preproc.y" 14777 { 14778 (yyval.str) = make_str("with grant option"); 14779@@ -31821,16 +30762,12 @@ 14780 break; 14781 14782 case 764: 14783- 14784-/* Line 1455 of yacc.c */ 14785 #line 5232 "preproc.y" 14786 { 14787 (yyval.str)=EMPTY; ;} 14788 break; 14789 14790 case 765: 14791- 14792-/* Line 1455 of yacc.c */ 14793 #line 5239 "preproc.y" 14794 { 14795 (yyval.str) = (yyvsp[(1) - (1)].str); 14796@@ -31838,8 +30775,6 @@ 14797 break; 14798 14799 case 766: 14800- 14801-/* Line 1455 of yacc.c */ 14802 #line 5243 "preproc.y" 14803 { 14804 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 14805@@ -31847,8 +30782,6 @@ 14806 break; 14807 14808 case 767: 14809- 14810-/* Line 1455 of yacc.c */ 14811 #line 5251 "preproc.y" 14812 { 14813 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 14814@@ -31856,8 +30789,6 @@ 14815 break; 14816 14817 case 768: 14818- 14819-/* Line 1455 of yacc.c */ 14820 #line 5259 "preproc.y" 14821 { 14822 (yyval.str) = cat_str(6,make_str("grant"),(yyvsp[(2) - (6)].str),make_str("to"),(yyvsp[(4) - (6)].str),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 14823@@ -31865,8 +30796,6 @@ 14824 break; 14825 14826 case 769: 14827- 14828-/* Line 1455 of yacc.c */ 14829 #line 5267 "preproc.y" 14830 { 14831 (yyval.str) = cat_str(6,make_str("revoke"),(yyvsp[(2) - (6)].str),make_str("from"),(yyvsp[(4) - (6)].str),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 14832@@ -31874,8 +30803,6 @@ 14833 break; 14834 14835 case 770: 14836- 14837-/* Line 1455 of yacc.c */ 14838 #line 5271 "preproc.y" 14839 { 14840 (yyval.str) = cat_str(6,make_str("revoke admin option for"),(yyvsp[(5) - (9)].str),make_str("from"),(yyvsp[(7) - (9)].str),(yyvsp[(8) - (9)].str),(yyvsp[(9) - (9)].str)); 14841@@ -31883,8 +30810,6 @@ 14842 break; 14843 14844 case 771: 14845- 14846-/* Line 1455 of yacc.c */ 14847 #line 5279 "preproc.y" 14848 { 14849 (yyval.str) = make_str("with admin option"); 14850@@ -31892,16 +30817,12 @@ 14851 break; 14852 14853 case 772: 14854- 14855-/* Line 1455 of yacc.c */ 14856 #line 5283 "preproc.y" 14857 { 14858 (yyval.str)=EMPTY; ;} 14859 break; 14860 14861 case 773: 14862- 14863-/* Line 1455 of yacc.c */ 14864 #line 5290 "preproc.y" 14865 { 14866 (yyval.str) = cat_str(2,make_str("granted by"),(yyvsp[(3) - (3)].str)); 14867@@ -31909,16 +30830,12 @@ 14868 break; 14869 14870 case 774: 14871- 14872-/* Line 1455 of yacc.c */ 14873 #line 5294 "preproc.y" 14874 { 14875 (yyval.str)=EMPTY; ;} 14876 break; 14877 14878 case 775: 14879- 14880-/* Line 1455 of yacc.c */ 14881 #line 5301 "preproc.y" 14882 { 14883 (yyval.str) = cat_str(3,make_str("alter default privileges"),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 14884@@ -31926,8 +30843,6 @@ 14885 break; 14886 14887 case 776: 14888- 14889-/* Line 1455 of yacc.c */ 14890 #line 5309 "preproc.y" 14891 { 14892 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 14893@@ -31935,16 +30850,12 @@ 14894 break; 14895 14896 case 777: 14897- 14898-/* Line 1455 of yacc.c */ 14899 #line 5313 "preproc.y" 14900 { 14901 (yyval.str)=EMPTY; ;} 14902 break; 14903 14904 case 778: 14905- 14906-/* Line 1455 of yacc.c */ 14907 #line 5320 "preproc.y" 14908 { 14909 (yyval.str) = cat_str(2,make_str("in schema"),(yyvsp[(3) - (3)].str)); 14910@@ -31952,8 +30863,6 @@ 14911 break; 14912 14913 case 779: 14914- 14915-/* Line 1455 of yacc.c */ 14916 #line 5324 "preproc.y" 14917 { 14918 (yyval.str) = cat_str(2,make_str("for role"),(yyvsp[(3) - (3)].str)); 14919@@ -31961,8 +30870,6 @@ 14920 break; 14921 14922 case 780: 14923- 14924-/* Line 1455 of yacc.c */ 14925 #line 5328 "preproc.y" 14926 { 14927 (yyval.str) = cat_str(2,make_str("for user"),(yyvsp[(3) - (3)].str)); 14928@@ -31970,8 +30877,6 @@ 14929 break; 14930 14931 case 781: 14932- 14933-/* Line 1455 of yacc.c */ 14934 #line 5336 "preproc.y" 14935 { 14936 (yyval.str) = cat_str(7,make_str("grant"),(yyvsp[(2) - (7)].str),make_str("on"),(yyvsp[(4) - (7)].str),make_str("to"),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 14937@@ -31979,8 +30884,6 @@ 14938 break; 14939 14940 case 782: 14941- 14942-/* Line 1455 of yacc.c */ 14943 #line 5340 "preproc.y" 14944 { 14945 (yyval.str) = cat_str(7,make_str("revoke"),(yyvsp[(2) - (7)].str),make_str("on"),(yyvsp[(4) - (7)].str),make_str("from"),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 14946@@ -31988,8 +30891,6 @@ 14947 break; 14948 14949 case 783: 14950- 14951-/* Line 1455 of yacc.c */ 14952 #line 5344 "preproc.y" 14953 { 14954 (yyval.str) = cat_str(7,make_str("revoke grant option for"),(yyvsp[(5) - (10)].str),make_str("on"),(yyvsp[(7) - (10)].str),make_str("from"),(yyvsp[(9) - (10)].str),(yyvsp[(10) - (10)].str)); 14955@@ -31997,8 +30898,6 @@ 14956 break; 14957 14958 case 784: 14959- 14960-/* Line 1455 of yacc.c */ 14961 #line 5352 "preproc.y" 14962 { 14963 (yyval.str) = make_str("tables"); 14964@@ -32006,8 +30905,6 @@ 14965 break; 14966 14967 case 785: 14968- 14969-/* Line 1455 of yacc.c */ 14970 #line 5356 "preproc.y" 14971 { 14972 (yyval.str) = make_str("functions"); 14973@@ -32015,8 +30912,6 @@ 14974 break; 14975 14976 case 786: 14977- 14978-/* Line 1455 of yacc.c */ 14979 #line 5360 "preproc.y" 14980 { 14981 (yyval.str) = make_str("sequences"); 14982@@ -32024,8 +30919,6 @@ 14983 break; 14984 14985 case 787: 14986- 14987-/* Line 1455 of yacc.c */ 14988 #line 5368 "preproc.y" 14989 { 14990 (yyval.str) = cat_str(14,make_str("create"),(yyvsp[(2) - (14)].str),make_str("index"),(yyvsp[(4) - (14)].str),(yyvsp[(5) - (14)].str),make_str("on"),(yyvsp[(7) - (14)].str),(yyvsp[(8) - (14)].str),make_str("("),(yyvsp[(10) - (14)].str),make_str(")"),(yyvsp[(12) - (14)].str),(yyvsp[(13) - (14)].str),(yyvsp[(14) - (14)].str)); 14991@@ -32033,8 +30926,6 @@ 14992 break; 14993 14994 case 788: 14995- 14996-/* Line 1455 of yacc.c */ 14997 #line 5376 "preproc.y" 14998 { 14999 (yyval.str) = make_str("unique"); 15000@@ -32042,16 +30933,12 @@ 15001 break; 15002 15003 case 789: 15004- 15005-/* Line 1455 of yacc.c */ 15006 #line 5380 "preproc.y" 15007 { 15008 (yyval.str)=EMPTY; ;} 15009 break; 15010 15011 case 790: 15012- 15013-/* Line 1455 of yacc.c */ 15014 #line 5387 "preproc.y" 15015 { 15016 (yyval.str) = make_str("concurrently"); 15017@@ -32059,16 +30946,12 @@ 15018 break; 15019 15020 case 791: 15021- 15022-/* Line 1455 of yacc.c */ 15023 #line 5391 "preproc.y" 15024 { 15025 (yyval.str)=EMPTY; ;} 15026 break; 15027 15028 case 792: 15029- 15030-/* Line 1455 of yacc.c */ 15031 #line 5398 "preproc.y" 15032 { 15033 (yyval.str) = (yyvsp[(1) - (1)].str); 15034@@ -32076,16 +30959,12 @@ 15035 break; 15036 15037 case 793: 15038- 15039-/* Line 1455 of yacc.c */ 15040 #line 5402 "preproc.y" 15041 { 15042 (yyval.str)=EMPTY; ;} 15043 break; 15044 15045 case 794: 15046- 15047-/* Line 1455 of yacc.c */ 15048 #line 5409 "preproc.y" 15049 { 15050 (yyval.str) = cat_str(2,make_str("using"),(yyvsp[(2) - (2)].str)); 15051@@ -32093,16 +30972,12 @@ 15052 break; 15053 15054 case 795: 15055- 15056-/* Line 1455 of yacc.c */ 15057 #line 5413 "preproc.y" 15058 { 15059 (yyval.str)=EMPTY; ;} 15060 break; 15061 15062 case 796: 15063- 15064-/* Line 1455 of yacc.c */ 15065 #line 5420 "preproc.y" 15066 { 15067 (yyval.str) = (yyvsp[(1) - (1)].str); 15068@@ -32110,8 +30985,6 @@ 15069 break; 15070 15071 case 797: 15072- 15073-/* Line 1455 of yacc.c */ 15074 #line 5424 "preproc.y" 15075 { 15076 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 15077@@ -32119,8 +30992,6 @@ 15078 break; 15079 15080 case 798: 15081- 15082-/* Line 1455 of yacc.c */ 15083 #line 5432 "preproc.y" 15084 { 15085 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 15086@@ -32128,8 +30999,6 @@ 15087 break; 15088 15089 case 799: 15090- 15091-/* Line 1455 of yacc.c */ 15092 #line 5436 "preproc.y" 15093 { 15094 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 15095@@ -32137,8 +31006,6 @@ 15096 break; 15097 15098 case 800: 15099- 15100-/* Line 1455 of yacc.c */ 15101 #line 5440 "preproc.y" 15102 { 15103 (yyval.str) = cat_str(6,make_str("("),(yyvsp[(2) - (6)].str),make_str(")"),(yyvsp[(4) - (6)].str),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 15104@@ -32146,8 +31013,6 @@ 15105 break; 15106 15107 case 801: 15108- 15109-/* Line 1455 of yacc.c */ 15110 #line 5448 "preproc.y" 15111 { 15112 (yyval.str) = (yyvsp[(1) - (1)].str); 15113@@ -32155,8 +31020,6 @@ 15114 break; 15115 15116 case 802: 15117- 15118-/* Line 1455 of yacc.c */ 15119 #line 5452 "preproc.y" 15120 { 15121 (yyval.str) = cat_str(2,make_str("using"),(yyvsp[(2) - (2)].str)); 15122@@ -32164,16 +31027,12 @@ 15123 break; 15124 15125 case 803: 15126- 15127-/* Line 1455 of yacc.c */ 15128 #line 5456 "preproc.y" 15129 { 15130 (yyval.str)=EMPTY; ;} 15131 break; 15132 15133 case 804: 15134- 15135-/* Line 1455 of yacc.c */ 15136 #line 5463 "preproc.y" 15137 { 15138 (yyval.str) = make_str("asc"); 15139@@ -32181,8 +31040,6 @@ 15140 break; 15141 15142 case 805: 15143- 15144-/* Line 1455 of yacc.c */ 15145 #line 5467 "preproc.y" 15146 { 15147 (yyval.str) = make_str("desc"); 15148@@ -32190,16 +31047,12 @@ 15149 break; 15150 15151 case 806: 15152- 15153-/* Line 1455 of yacc.c */ 15154 #line 5471 "preproc.y" 15155 { 15156 (yyval.str)=EMPTY; ;} 15157 break; 15158 15159 case 807: 15160- 15161-/* Line 1455 of yacc.c */ 15162 #line 5478 "preproc.y" 15163 { 15164 (yyval.str) = make_str("nulls first"); 15165@@ -32207,8 +31060,6 @@ 15166 break; 15167 15168 case 808: 15169- 15170-/* Line 1455 of yacc.c */ 15171 #line 5482 "preproc.y" 15172 { 15173 (yyval.str) = make_str("nulls last"); 15174@@ -32216,16 +31067,12 @@ 15175 break; 15176 15177 case 809: 15178- 15179-/* Line 1455 of yacc.c */ 15180 #line 5486 "preproc.y" 15181 { 15182 (yyval.str)=EMPTY; ;} 15183 break; 15184 15185 case 810: 15186- 15187-/* Line 1455 of yacc.c */ 15188 #line 5493 "preproc.y" 15189 { 15190 (yyval.str) = cat_str(9,make_str("create"),(yyvsp[(2) - (9)].str),make_str("function"),(yyvsp[(4) - (9)].str),(yyvsp[(5) - (9)].str),make_str("returns"),(yyvsp[(7) - (9)].str),(yyvsp[(8) - (9)].str),(yyvsp[(9) - (9)].str)); 15191@@ -32233,8 +31080,6 @@ 15192 break; 15193 15194 case 811: 15195- 15196-/* Line 1455 of yacc.c */ 15197 #line 5497 "preproc.y" 15198 { 15199 (yyval.str) = cat_str(10,make_str("create"),(yyvsp[(2) - (12)].str),make_str("function"),(yyvsp[(4) - (12)].str),(yyvsp[(5) - (12)].str),make_str("returns table ("),(yyvsp[(9) - (12)].str),make_str(")"),(yyvsp[(11) - (12)].str),(yyvsp[(12) - (12)].str)); 15200@@ -32242,8 +31087,6 @@ 15201 break; 15202 15203 case 812: 15204- 15205-/* Line 1455 of yacc.c */ 15206 #line 5501 "preproc.y" 15207 { 15208 (yyval.str) = cat_str(7,make_str("create"),(yyvsp[(2) - (7)].str),make_str("function"),(yyvsp[(4) - (7)].str),(yyvsp[(5) - (7)].str),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 15209@@ -32251,8 +31094,6 @@ 15210 break; 15211 15212 case 813: 15213- 15214-/* Line 1455 of yacc.c */ 15215 #line 5509 "preproc.y" 15216 { 15217 (yyval.str) = make_str("or replace"); 15218@@ -32260,16 +31101,12 @@ 15219 break; 15220 15221 case 814: 15222- 15223-/* Line 1455 of yacc.c */ 15224 #line 5513 "preproc.y" 15225 { 15226 (yyval.str)=EMPTY; ;} 15227 break; 15228 15229 case 815: 15230- 15231-/* Line 1455 of yacc.c */ 15232 #line 5520 "preproc.y" 15233 { 15234 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 15235@@ -32277,8 +31114,6 @@ 15236 break; 15237 15238 case 816: 15239- 15240-/* Line 1455 of yacc.c */ 15241 #line 5524 "preproc.y" 15242 { 15243 (yyval.str) = make_str("( )"); 15244@@ -32286,8 +31121,6 @@ 15245 break; 15246 15247 case 817: 15248- 15249-/* Line 1455 of yacc.c */ 15250 #line 5532 "preproc.y" 15251 { 15252 (yyval.str) = (yyvsp[(1) - (1)].str); 15253@@ -32295,8 +31128,6 @@ 15254 break; 15255 15256 case 818: 15257- 15258-/* Line 1455 of yacc.c */ 15259 #line 5536 "preproc.y" 15260 { 15261 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 15262@@ -32304,8 +31135,6 @@ 15263 break; 15264 15265 case 819: 15266- 15267-/* Line 1455 of yacc.c */ 15268 #line 5544 "preproc.y" 15269 { 15270 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 15271@@ -32313,8 +31142,6 @@ 15272 break; 15273 15274 case 820: 15275- 15276-/* Line 1455 of yacc.c */ 15277 #line 5548 "preproc.y" 15278 { 15279 (yyval.str) = make_str("( )"); 15280@@ -32322,8 +31149,6 @@ 15281 break; 15282 15283 case 821: 15284- 15285-/* Line 1455 of yacc.c */ 15286 #line 5556 "preproc.y" 15287 { 15288 (yyval.str) = (yyvsp[(1) - (1)].str); 15289@@ -32331,8 +31156,6 @@ 15290 break; 15291 15292 case 822: 15293- 15294-/* Line 1455 of yacc.c */ 15295 #line 5560 "preproc.y" 15296 { 15297 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 15298@@ -32340,8 +31163,6 @@ 15299 break; 15300 15301 case 823: 15302- 15303-/* Line 1455 of yacc.c */ 15304 #line 5568 "preproc.y" 15305 { 15306 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 15307@@ -32349,8 +31170,6 @@ 15308 break; 15309 15310 case 824: 15311- 15312-/* Line 1455 of yacc.c */ 15313 #line 5572 "preproc.y" 15314 { 15315 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 15316@@ -32358,8 +31177,6 @@ 15317 break; 15318 15319 case 825: 15320- 15321-/* Line 1455 of yacc.c */ 15322 #line 5576 "preproc.y" 15323 { 15324 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 15325@@ -32367,8 +31184,6 @@ 15326 break; 15327 15328 case 826: 15329- 15330-/* Line 1455 of yacc.c */ 15331 #line 5580 "preproc.y" 15332 { 15333 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 15334@@ -32376,8 +31191,6 @@ 15335 break; 15336 15337 case 827: 15338- 15339-/* Line 1455 of yacc.c */ 15340 #line 5584 "preproc.y" 15341 { 15342 (yyval.str) = (yyvsp[(1) - (1)].str); 15343@@ -32385,8 +31198,6 @@ 15344 break; 15345 15346 case 828: 15347- 15348-/* Line 1455 of yacc.c */ 15349 #line 5592 "preproc.y" 15350 { 15351 (yyval.str) = make_str("in"); 15352@@ -32394,8 +31205,6 @@ 15353 break; 15354 15355 case 829: 15356- 15357-/* Line 1455 of yacc.c */ 15358 #line 5596 "preproc.y" 15359 { 15360 (yyval.str) = make_str("out"); 15361@@ -32403,8 +31212,6 @@ 15362 break; 15363 15364 case 830: 15365- 15366-/* Line 1455 of yacc.c */ 15367 #line 5600 "preproc.y" 15368 { 15369 (yyval.str) = make_str("inout"); 15370@@ -32412,8 +31219,6 @@ 15371 break; 15372 15373 case 831: 15374- 15375-/* Line 1455 of yacc.c */ 15376 #line 5604 "preproc.y" 15377 { 15378 (yyval.str) = make_str("in out"); 15379@@ -32421,8 +31226,6 @@ 15380 break; 15381 15382 case 832: 15383- 15384-/* Line 1455 of yacc.c */ 15385 #line 5608 "preproc.y" 15386 { 15387 (yyval.str) = make_str("variadic"); 15388@@ -32430,8 +31233,6 @@ 15389 break; 15390 15391 case 833: 15392- 15393-/* Line 1455 of yacc.c */ 15394 #line 5616 "preproc.y" 15395 { 15396 (yyval.str) = (yyvsp[(1) - (1)].str); 15397@@ -32439,8 +31240,6 @@ 15398 break; 15399 15400 case 834: 15401- 15402-/* Line 1455 of yacc.c */ 15403 #line 5624 "preproc.y" 15404 { 15405 (yyval.str) = (yyvsp[(1) - (1)].str); 15406@@ -32448,8 +31247,6 @@ 15407 break; 15408 15409 case 835: 15410- 15411-/* Line 1455 of yacc.c */ 15412 #line 5632 "preproc.y" 15413 { 15414 (yyval.str) = (yyvsp[(1) - (1)].str); 15415@@ -32457,8 +31254,6 @@ 15416 break; 15417 15418 case 836: 15419- 15420-/* Line 1455 of yacc.c */ 15421 #line 5636 "preproc.y" 15422 { 15423 (yyval.str) = cat_str(3,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),make_str("% type")); 15424@@ -32466,8 +31261,6 @@ 15425 break; 15426 15427 case 837: 15428- 15429-/* Line 1455 of yacc.c */ 15430 #line 5640 "preproc.y" 15431 { 15432 (yyval.str) = cat_str(4,make_str("setof"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),make_str("% type")); 15433@@ -32475,8 +31268,6 @@ 15434 break; 15435 15436 case 838: 15437- 15438-/* Line 1455 of yacc.c */ 15439 #line 5648 "preproc.y" 15440 { 15441 (yyval.str) = (yyvsp[(1) - (1)].str); 15442@@ -32484,8 +31275,6 @@ 15443 break; 15444 15445 case 839: 15446- 15447-/* Line 1455 of yacc.c */ 15448 #line 5652 "preproc.y" 15449 { 15450 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("default"),(yyvsp[(3) - (3)].str)); 15451@@ -32493,8 +31282,6 @@ 15452 break; 15453 15454 case 840: 15455- 15456-/* Line 1455 of yacc.c */ 15457 #line 5656 "preproc.y" 15458 { 15459 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("="),(yyvsp[(3) - (3)].str)); 15460@@ -32502,8 +31289,6 @@ 15461 break; 15462 15463 case 841: 15464- 15465-/* Line 1455 of yacc.c */ 15466 #line 5664 "preproc.y" 15467 { 15468 (yyval.str) = (yyvsp[(1) - (1)].str); 15469@@ -32511,8 +31296,6 @@ 15470 break; 15471 15472 case 842: 15473- 15474-/* Line 1455 of yacc.c */ 15475 #line 5668 "preproc.y" 15476 { 15477 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 15478@@ -32520,8 +31303,6 @@ 15479 break; 15480 15481 case 843: 15482- 15483-/* Line 1455 of yacc.c */ 15484 #line 5676 "preproc.y" 15485 { 15486 (yyval.str) = make_str("called on null input"); 15487@@ -32529,8 +31310,6 @@ 15488 break; 15489 15490 case 844: 15491- 15492-/* Line 1455 of yacc.c */ 15493 #line 5680 "preproc.y" 15494 { 15495 (yyval.str) = make_str("returns null on null input"); 15496@@ -32538,8 +31317,6 @@ 15497 break; 15498 15499 case 845: 15500- 15501-/* Line 1455 of yacc.c */ 15502 #line 5684 "preproc.y" 15503 { 15504 (yyval.str) = make_str("strict"); 15505@@ -32547,8 +31324,6 @@ 15506 break; 15507 15508 case 846: 15509- 15510-/* Line 1455 of yacc.c */ 15511 #line 5688 "preproc.y" 15512 { 15513 (yyval.str) = make_str("immutable"); 15514@@ -32556,8 +31331,6 @@ 15515 break; 15516 15517 case 847: 15518- 15519-/* Line 1455 of yacc.c */ 15520 #line 5692 "preproc.y" 15521 { 15522 (yyval.str) = make_str("stable"); 15523@@ -32565,8 +31338,6 @@ 15524 break; 15525 15526 case 848: 15527- 15528-/* Line 1455 of yacc.c */ 15529 #line 5696 "preproc.y" 15530 { 15531 (yyval.str) = make_str("volatile"); 15532@@ -32574,8 +31345,6 @@ 15533 break; 15534 15535 case 849: 15536- 15537-/* Line 1455 of yacc.c */ 15538 #line 5700 "preproc.y" 15539 { 15540 (yyval.str) = make_str("external security definer"); 15541@@ -32583,8 +31352,6 @@ 15542 break; 15543 15544 case 850: 15545- 15546-/* Line 1455 of yacc.c */ 15547 #line 5704 "preproc.y" 15548 { 15549 (yyval.str) = make_str("external security invoker"); 15550@@ -32592,8 +31359,6 @@ 15551 break; 15552 15553 case 851: 15554- 15555-/* Line 1455 of yacc.c */ 15556 #line 5708 "preproc.y" 15557 { 15558 (yyval.str) = make_str("security definer"); 15559@@ -32601,8 +31366,6 @@ 15560 break; 15561 15562 case 852: 15563- 15564-/* Line 1455 of yacc.c */ 15565 #line 5712 "preproc.y" 15566 { 15567 (yyval.str) = make_str("security invoker"); 15568@@ -32610,8 +31373,6 @@ 15569 break; 15570 15571 case 853: 15572- 15573-/* Line 1455 of yacc.c */ 15574 #line 5716 "preproc.y" 15575 { 15576 (yyval.str) = cat_str(2,make_str("cost"),(yyvsp[(2) - (2)].str)); 15577@@ -32619,8 +31380,6 @@ 15578 break; 15579 15580 case 854: 15581- 15582-/* Line 1455 of yacc.c */ 15583 #line 5720 "preproc.y" 15584 { 15585 (yyval.str) = cat_str(2,make_str("rows"),(yyvsp[(2) - (2)].str)); 15586@@ -32628,8 +31387,6 @@ 15587 break; 15588 15589 case 855: 15590- 15591-/* Line 1455 of yacc.c */ 15592 #line 5724 "preproc.y" 15593 { 15594 (yyval.str) = (yyvsp[(1) - (1)].str); 15595@@ -32637,8 +31394,6 @@ 15596 break; 15597 15598 case 856: 15599- 15600-/* Line 1455 of yacc.c */ 15601 #line 5732 "preproc.y" 15602 { 15603 (yyval.str) = cat_str(2,make_str("as"),(yyvsp[(2) - (2)].str)); 15604@@ -32646,8 +31401,6 @@ 15605 break; 15606 15607 case 857: 15608- 15609-/* Line 1455 of yacc.c */ 15610 #line 5736 "preproc.y" 15611 { 15612 (yyval.str) = cat_str(2,make_str("language"),(yyvsp[(2) - (2)].str)); 15613@@ -32655,8 +31408,6 @@ 15614 break; 15615 15616 case 858: 15617- 15618-/* Line 1455 of yacc.c */ 15619 #line 5740 "preproc.y" 15620 { 15621 (yyval.str) = make_str("window"); 15622@@ -32664,8 +31415,6 @@ 15623 break; 15624 15625 case 859: 15626- 15627-/* Line 1455 of yacc.c */ 15628 #line 5744 "preproc.y" 15629 { 15630 (yyval.str) = (yyvsp[(1) - (1)].str); 15631@@ -32673,8 +31422,6 @@ 15632 break; 15633 15634 case 860: 15635- 15636-/* Line 1455 of yacc.c */ 15637 #line 5752 "preproc.y" 15638 { 15639 (yyval.str) = (yyvsp[(1) - (1)].str); 15640@@ -32682,8 +31429,6 @@ 15641 break; 15642 15643 case 861: 15644- 15645-/* Line 1455 of yacc.c */ 15646 #line 5756 "preproc.y" 15647 { 15648 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 15649@@ -32691,8 +31436,6 @@ 15650 break; 15651 15652 case 862: 15653- 15654-/* Line 1455 of yacc.c */ 15655 #line 5764 "preproc.y" 15656 { 15657 (yyval.str) = cat_str(2,make_str("with"),(yyvsp[(2) - (2)].str)); 15658@@ -32700,16 +31443,12 @@ 15659 break; 15660 15661 case 863: 15662- 15663-/* Line 1455 of yacc.c */ 15664 #line 5768 "preproc.y" 15665 { 15666 (yyval.str)=EMPTY; ;} 15667 break; 15668 15669 case 864: 15670- 15671-/* Line 1455 of yacc.c */ 15672 #line 5775 "preproc.y" 15673 { 15674 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 15675@@ -32717,8 +31456,6 @@ 15676 break; 15677 15678 case 865: 15679- 15680-/* Line 1455 of yacc.c */ 15681 #line 5783 "preproc.y" 15682 { 15683 (yyval.str) = (yyvsp[(1) - (1)].str); 15684@@ -32726,8 +31463,6 @@ 15685 break; 15686 15687 case 866: 15688- 15689-/* Line 1455 of yacc.c */ 15690 #line 5787 "preproc.y" 15691 { 15692 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 15693@@ -32735,8 +31470,6 @@ 15694 break; 15695 15696 case 867: 15697- 15698-/* Line 1455 of yacc.c */ 15699 #line 5795 "preproc.y" 15700 { 15701 (yyval.str) = cat_str(4,make_str("alter function"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 15702@@ -32744,8 +31477,6 @@ 15703 break; 15704 15705 case 868: 15706- 15707-/* Line 1455 of yacc.c */ 15708 #line 5803 "preproc.y" 15709 { 15710 (yyval.str) = (yyvsp[(1) - (1)].str); 15711@@ -32753,8 +31484,6 @@ 15712 break; 15713 15714 case 869: 15715- 15716-/* Line 1455 of yacc.c */ 15717 #line 5807 "preproc.y" 15718 { 15719 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 15720@@ -32762,8 +31491,6 @@ 15721 break; 15722 15723 case 870: 15724- 15725-/* Line 1455 of yacc.c */ 15726 #line 5815 "preproc.y" 15727 { 15728 (yyval.str) = make_str("restrict"); 15729@@ -32771,16 +31498,12 @@ 15730 break; 15731 15732 case 871: 15733- 15734-/* Line 1455 of yacc.c */ 15735 #line 5819 "preproc.y" 15736 { 15737 (yyval.str)=EMPTY; ;} 15738 break; 15739 15740 case 872: 15741- 15742-/* Line 1455 of yacc.c */ 15743 #line 5826 "preproc.y" 15744 { 15745 (yyval.str) = cat_str(4,make_str("drop function"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 15746@@ -32788,8 +31511,6 @@ 15747 break; 15748 15749 case 873: 15750- 15751-/* Line 1455 of yacc.c */ 15752 #line 5830 "preproc.y" 15753 { 15754 (yyval.str) = cat_str(4,make_str("drop function if exists"),(yyvsp[(5) - (7)].str),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 15755@@ -32797,8 +31518,6 @@ 15756 break; 15757 15758 case 874: 15759- 15760-/* Line 1455 of yacc.c */ 15761 #line 5838 "preproc.y" 15762 { 15763 (yyval.str) = cat_str(4,make_str("drop aggregate"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 15764@@ -32806,8 +31525,6 @@ 15765 break; 15766 15767 case 875: 15768- 15769-/* Line 1455 of yacc.c */ 15770 #line 5842 "preproc.y" 15771 { 15772 (yyval.str) = cat_str(4,make_str("drop aggregate if exists"),(yyvsp[(5) - (7)].str),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 15773@@ -32815,8 +31532,6 @@ 15774 break; 15775 15776 case 876: 15777- 15778-/* Line 1455 of yacc.c */ 15779 #line 5850 "preproc.y" 15780 { 15781 (yyval.str) = cat_str(4,make_str("drop operator"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 15782@@ -32824,8 +31539,6 @@ 15783 break; 15784 15785 case 877: 15786- 15787-/* Line 1455 of yacc.c */ 15788 #line 5854 "preproc.y" 15789 { 15790 (yyval.str) = cat_str(4,make_str("drop operator if exists"),(yyvsp[(5) - (7)].str),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 15791@@ -32833,8 +31546,6 @@ 15792 break; 15793 15794 case 878: 15795- 15796-/* Line 1455 of yacc.c */ 15797 #line 5862 "preproc.y" 15798 { 15799 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 15800@@ -32842,8 +31553,6 @@ 15801 break; 15802 15803 case 879: 15804- 15805-/* Line 1455 of yacc.c */ 15806 #line 5866 "preproc.y" 15807 { 15808 (yyval.str) = cat_str(5,make_str("("),(yyvsp[(2) - (5)].str),make_str(","),(yyvsp[(4) - (5)].str),make_str(")")); 15809@@ -32851,8 +31560,6 @@ 15810 break; 15811 15812 case 880: 15813- 15814-/* Line 1455 of yacc.c */ 15815 #line 5870 "preproc.y" 15816 { 15817 (yyval.str) = cat_str(3,make_str("( none ,"),(yyvsp[(4) - (5)].str),make_str(")")); 15818@@ -32860,8 +31567,6 @@ 15819 break; 15820 15821 case 881: 15822- 15823-/* Line 1455 of yacc.c */ 15824 #line 5874 "preproc.y" 15825 { 15826 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (5)].str),make_str(", none )")); 15827@@ -32869,8 +31574,6 @@ 15828 break; 15829 15830 case 882: 15831- 15832-/* Line 1455 of yacc.c */ 15833 #line 5882 "preproc.y" 15834 { 15835 (yyval.str) = (yyvsp[(1) - (1)].str); 15836@@ -32878,8 +31581,6 @@ 15837 break; 15838 15839 case 883: 15840- 15841-/* Line 1455 of yacc.c */ 15842 #line 5886 "preproc.y" 15843 { 15844 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("."),(yyvsp[(3) - (3)].str)); 15845@@ -32887,8 +31588,6 @@ 15846 break; 15847 15848 case 884: 15849- 15850-/* Line 1455 of yacc.c */ 15851 #line 5894 "preproc.y" 15852 { 15853 (yyval.str) = cat_str(2,make_str("do"),(yyvsp[(2) - (2)].str)); 15854@@ -32896,8 +31595,6 @@ 15855 break; 15856 15857 case 885: 15858- 15859-/* Line 1455 of yacc.c */ 15860 #line 5902 "preproc.y" 15861 { 15862 (yyval.str) = (yyvsp[(1) - (1)].str); 15863@@ -32905,8 +31602,6 @@ 15864 break; 15865 15866 case 886: 15867- 15868-/* Line 1455 of yacc.c */ 15869 #line 5906 "preproc.y" 15870 { 15871 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 15872@@ -32914,8 +31609,6 @@ 15873 break; 15874 15875 case 887: 15876- 15877-/* Line 1455 of yacc.c */ 15878 #line 5914 "preproc.y" 15879 { 15880 (yyval.str) = (yyvsp[(1) - (1)].str); 15881@@ -32923,8 +31616,6 @@ 15882 break; 15883 15884 case 888: 15885- 15886-/* Line 1455 of yacc.c */ 15887 #line 5918 "preproc.y" 15888 { 15889 (yyval.str) = cat_str(2,make_str("language"),(yyvsp[(2) - (2)].str)); 15890@@ -32932,8 +31623,6 @@ 15891 break; 15892 15893 case 889: 15894- 15895-/* Line 1455 of yacc.c */ 15896 #line 5926 "preproc.y" 15897 { 15898 (yyval.str) = cat_str(7,make_str("create cast ("),(yyvsp[(4) - (11)].str),make_str("as"),(yyvsp[(6) - (11)].str),make_str(") with function"),(yyvsp[(10) - (11)].str),(yyvsp[(11) - (11)].str)); 15899@@ -32941,8 +31630,6 @@ 15900 break; 15901 15902 case 890: 15903- 15904-/* Line 1455 of yacc.c */ 15905 #line 5930 "preproc.y" 15906 { 15907 (yyval.str) = cat_str(6,make_str("create cast ("),(yyvsp[(4) - (10)].str),make_str("as"),(yyvsp[(6) - (10)].str),make_str(") without function"),(yyvsp[(10) - (10)].str)); 15908@@ -32950,8 +31637,6 @@ 15909 break; 15910 15911 case 891: 15912- 15913-/* Line 1455 of yacc.c */ 15914 #line 5934 "preproc.y" 15915 { 15916 (yyval.str) = cat_str(6,make_str("create cast ("),(yyvsp[(4) - (10)].str),make_str("as"),(yyvsp[(6) - (10)].str),make_str(") with inout"),(yyvsp[(10) - (10)].str)); 15917@@ -32959,8 +31644,6 @@ 15918 break; 15919 15920 case 892: 15921- 15922-/* Line 1455 of yacc.c */ 15923 #line 5942 "preproc.y" 15924 { 15925 (yyval.str) = make_str("as implicit"); 15926@@ -32968,8 +31651,6 @@ 15927 break; 15928 15929 case 893: 15930- 15931-/* Line 1455 of yacc.c */ 15932 #line 5946 "preproc.y" 15933 { 15934 (yyval.str) = make_str("as assignment"); 15935@@ -32977,16 +31658,12 @@ 15936 break; 15937 15938 case 894: 15939- 15940-/* Line 1455 of yacc.c */ 15941 #line 5950 "preproc.y" 15942 { 15943 (yyval.str)=EMPTY; ;} 15944 break; 15945 15946 case 895: 15947- 15948-/* Line 1455 of yacc.c */ 15949 #line 5957 "preproc.y" 15950 { 15951 (yyval.str) = cat_str(8,make_str("drop cast"),(yyvsp[(3) - (9)].str),make_str("("),(yyvsp[(5) - (9)].str),make_str("as"),(yyvsp[(7) - (9)].str),make_str(")"),(yyvsp[(9) - (9)].str)); 15952@@ -32994,8 +31671,6 @@ 15953 break; 15954 15955 case 896: 15956- 15957-/* Line 1455 of yacc.c */ 15958 #line 5965 "preproc.y" 15959 { 15960 (yyval.str) = make_str("if exists"); 15961@@ -33003,16 +31678,12 @@ 15962 break; 15963 15964 case 897: 15965- 15966-/* Line 1455 of yacc.c */ 15967 #line 5969 "preproc.y" 15968 { 15969 (yyval.str)=EMPTY; ;} 15970 break; 15971 15972 case 898: 15973- 15974-/* Line 1455 of yacc.c */ 15975 #line 5976 "preproc.y" 15976 { 15977 (yyval.str) = cat_str(4,make_str("reindex"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 15978@@ -33020,8 +31691,6 @@ 15979 break; 15980 15981 case 899: 15982- 15983-/* Line 1455 of yacc.c */ 15984 #line 5980 "preproc.y" 15985 { 15986 (yyval.str) = cat_str(3,make_str("reindex system"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 15987@@ -33029,8 +31698,6 @@ 15988 break; 15989 15990 case 900: 15991- 15992-/* Line 1455 of yacc.c */ 15993 #line 5984 "preproc.y" 15994 { 15995 (yyval.str) = cat_str(3,make_str("reindex database"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 15996@@ -33038,8 +31705,6 @@ 15997 break; 15998 15999 case 901: 16000- 16001-/* Line 1455 of yacc.c */ 16002 #line 5992 "preproc.y" 16003 { 16004 (yyval.str) = make_str("index"); 16005@@ -33047,8 +31712,6 @@ 16006 break; 16007 16008 case 902: 16009- 16010-/* Line 1455 of yacc.c */ 16011 #line 5996 "preproc.y" 16012 { 16013 (yyval.str) = make_str("table"); 16014@@ -33056,8 +31719,6 @@ 16015 break; 16016 16017 case 903: 16018- 16019-/* Line 1455 of yacc.c */ 16020 #line 6004 "preproc.y" 16021 { 16022 (yyval.str) = make_str("force"); 16023@@ -33065,16 +31726,12 @@ 16024 break; 16025 16026 case 904: 16027- 16028-/* Line 1455 of yacc.c */ 16029 #line 6008 "preproc.y" 16030 { 16031 (yyval.str)=EMPTY; ;} 16032 break; 16033 16034 case 905: 16035- 16036-/* Line 1455 of yacc.c */ 16037 #line 6015 "preproc.y" 16038 { 16039 (yyval.str) = cat_str(5,make_str("alter aggregate"),(yyvsp[(3) - (7)].str),(yyvsp[(4) - (7)].str),make_str("rename to"),(yyvsp[(7) - (7)].str)); 16040@@ -33082,8 +31739,6 @@ 16041 break; 16042 16043 case 906: 16044- 16045-/* Line 1455 of yacc.c */ 16046 #line 6019 "preproc.y" 16047 { 16048 (yyval.str) = cat_str(4,make_str("alter conversion"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str)); 16049@@ -33091,8 +31746,6 @@ 16050 break; 16051 16052 case 907: 16053- 16054-/* Line 1455 of yacc.c */ 16055 #line 6023 "preproc.y" 16056 { 16057 (yyval.str) = cat_str(4,make_str("alter database"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str)); 16058@@ -33100,8 +31753,6 @@ 16059 break; 16060 16061 case 908: 16062- 16063-/* Line 1455 of yacc.c */ 16064 #line 6027 "preproc.y" 16065 { 16066 (yyval.str) = cat_str(4,make_str("alter function"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str)); 16067@@ -33109,8 +31760,6 @@ 16068 break; 16069 16070 case 909: 16071- 16072-/* Line 1455 of yacc.c */ 16073 #line 6031 "preproc.y" 16074 { 16075 (yyval.str) = cat_str(4,make_str("alter group"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str)); 16076@@ -33118,8 +31767,6 @@ 16077 break; 16078 16079 case 910: 16080- 16081-/* Line 1455 of yacc.c */ 16082 #line 6035 "preproc.y" 16083 { 16084 (yyval.str) = cat_str(6,make_str("alter"),(yyvsp[(2) - (7)].str),make_str("language"),(yyvsp[(4) - (7)].str),make_str("rename to"),(yyvsp[(7) - (7)].str)); 16085@@ -33127,8 +31774,6 @@ 16086 break; 16087 16088 case 911: 16089- 16090-/* Line 1455 of yacc.c */ 16091 #line 6039 "preproc.y" 16092 { 16093 (yyval.str) = cat_str(6,make_str("alter operator class"),(yyvsp[(4) - (9)].str),make_str("using"),(yyvsp[(6) - (9)].str),make_str("rename to"),(yyvsp[(9) - (9)].str)); 16094@@ -33136,8 +31781,6 @@ 16095 break; 16096 16097 case 912: 16098- 16099-/* Line 1455 of yacc.c */ 16100 #line 6043 "preproc.y" 16101 { 16102 (yyval.str) = cat_str(6,make_str("alter operator family"),(yyvsp[(4) - (9)].str),make_str("using"),(yyvsp[(6) - (9)].str),make_str("rename to"),(yyvsp[(9) - (9)].str)); 16103@@ -33145,8 +31788,6 @@ 16104 break; 16105 16106 case 913: 16107- 16108-/* Line 1455 of yacc.c */ 16109 #line 6047 "preproc.y" 16110 { 16111 (yyval.str) = cat_str(4,make_str("alter schema"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str)); 16112@@ -33154,8 +31795,6 @@ 16113 break; 16114 16115 case 914: 16116- 16117-/* Line 1455 of yacc.c */ 16118 #line 6051 "preproc.y" 16119 { 16120 (yyval.str) = cat_str(4,make_str("alter table"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str)); 16121@@ -33163,8 +31802,6 @@ 16122 break; 16123 16124 case 915: 16125- 16126-/* Line 1455 of yacc.c */ 16127 #line 6055 "preproc.y" 16128 { 16129 (yyval.str) = cat_str(4,make_str("alter sequence"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str)); 16130@@ -33172,8 +31809,6 @@ 16131 break; 16132 16133 case 916: 16134- 16135-/* Line 1455 of yacc.c */ 16136 #line 6059 "preproc.y" 16137 { 16138 (yyval.str) = cat_str(4,make_str("alter view"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str)); 16139@@ -33181,8 +31816,6 @@ 16140 break; 16141 16142 case 917: 16143- 16144-/* Line 1455 of yacc.c */ 16145 #line 6063 "preproc.y" 16146 { 16147 (yyval.str) = cat_str(4,make_str("alter index"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str)); 16148@@ -33190,8 +31823,6 @@ 16149 break; 16150 16151 case 918: 16152- 16153-/* Line 1455 of yacc.c */ 16154 #line 6067 "preproc.y" 16155 { 16156 (yyval.str) = cat_str(7,make_str("alter table"),(yyvsp[(3) - (8)].str),make_str("rename"),(yyvsp[(5) - (8)].str),(yyvsp[(6) - (8)].str),make_str("to"),(yyvsp[(8) - (8)].str)); 16157@@ -33199,8 +31830,6 @@ 16158 break; 16159 16160 case 919: 16161- 16162-/* Line 1455 of yacc.c */ 16163 #line 6071 "preproc.y" 16164 { 16165 (yyval.str) = cat_str(6,make_str("alter trigger"),(yyvsp[(3) - (8)].str),make_str("on"),(yyvsp[(5) - (8)].str),make_str("rename to"),(yyvsp[(8) - (8)].str)); 16166@@ -33208,8 +31837,6 @@ 16167 break; 16168 16169 case 920: 16170- 16171-/* Line 1455 of yacc.c */ 16172 #line 6075 "preproc.y" 16173 { 16174 (yyval.str) = cat_str(4,make_str("alter role"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str)); 16175@@ -33217,8 +31844,6 @@ 16176 break; 16177 16178 case 921: 16179- 16180-/* Line 1455 of yacc.c */ 16181 #line 6079 "preproc.y" 16182 { 16183 (yyval.str) = cat_str(4,make_str("alter user"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str)); 16184@@ -33226,8 +31851,6 @@ 16185 break; 16186 16187 case 922: 16188- 16189-/* Line 1455 of yacc.c */ 16190 #line 6083 "preproc.y" 16191 { 16192 (yyval.str) = cat_str(4,make_str("alter tablespace"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str)); 16193@@ -33235,8 +31858,6 @@ 16194 break; 16195 16196 case 923: 16197- 16198-/* Line 1455 of yacc.c */ 16199 #line 6087 "preproc.y" 16200 { 16201 (yyval.str) = cat_str(4,make_str("alter tablespace"),(yyvsp[(3) - (5)].str),make_str("set"),(yyvsp[(5) - (5)].str)); 16202@@ -33244,8 +31865,6 @@ 16203 break; 16204 16205 case 924: 16206- 16207-/* Line 1455 of yacc.c */ 16208 #line 6091 "preproc.y" 16209 { 16210 (yyval.str) = cat_str(4,make_str("alter tablespace"),(yyvsp[(3) - (5)].str),make_str("reset"),(yyvsp[(5) - (5)].str)); 16211@@ -33253,8 +31872,6 @@ 16212 break; 16213 16214 case 925: 16215- 16216-/* Line 1455 of yacc.c */ 16217 #line 6095 "preproc.y" 16218 { 16219 (yyval.str) = cat_str(4,make_str("alter text search parser"),(yyvsp[(5) - (8)].str),make_str("rename to"),(yyvsp[(8) - (8)].str)); 16220@@ -33262,8 +31879,6 @@ 16221 break; 16222 16223 case 926: 16224- 16225-/* Line 1455 of yacc.c */ 16226 #line 6099 "preproc.y" 16227 { 16228 (yyval.str) = cat_str(4,make_str("alter text search dictionary"),(yyvsp[(5) - (8)].str),make_str("rename to"),(yyvsp[(8) - (8)].str)); 16229@@ -33271,8 +31886,6 @@ 16230 break; 16231 16232 case 927: 16233- 16234-/* Line 1455 of yacc.c */ 16235 #line 6103 "preproc.y" 16236 { 16237 (yyval.str) = cat_str(4,make_str("alter text search template"),(yyvsp[(5) - (8)].str),make_str("rename to"),(yyvsp[(8) - (8)].str)); 16238@@ -33280,8 +31893,6 @@ 16239 break; 16240 16241 case 928: 16242- 16243-/* Line 1455 of yacc.c */ 16244 #line 6107 "preproc.y" 16245 { 16246 (yyval.str) = cat_str(4,make_str("alter text search configuration"),(yyvsp[(5) - (8)].str),make_str("rename to"),(yyvsp[(8) - (8)].str)); 16247@@ -33289,8 +31900,6 @@ 16248 break; 16249 16250 case 929: 16251- 16252-/* Line 1455 of yacc.c */ 16253 #line 6111 "preproc.y" 16254 { 16255 (yyval.str) = cat_str(4,make_str("alter type"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str)); 16256@@ -33298,8 +31907,6 @@ 16257 break; 16258 16259 case 930: 16260- 16261-/* Line 1455 of yacc.c */ 16262 #line 6119 "preproc.y" 16263 { 16264 (yyval.str) = make_str("column"); 16265@@ -33307,16 +31914,12 @@ 16266 break; 16267 16268 case 931: 16269- 16270-/* Line 1455 of yacc.c */ 16271 #line 6123 "preproc.y" 16272 { 16273 (yyval.str)=EMPTY; ;} 16274 break; 16275 16276 case 932: 16277- 16278-/* Line 1455 of yacc.c */ 16279 #line 6130 "preproc.y" 16280 { 16281 (yyval.str) = make_str("set data"); 16282@@ -33324,16 +31927,12 @@ 16283 break; 16284 16285 case 933: 16286- 16287-/* Line 1455 of yacc.c */ 16288 #line 6134 "preproc.y" 16289 { 16290 (yyval.str)=EMPTY; ;} 16291 break; 16292 16293 case 934: 16294- 16295-/* Line 1455 of yacc.c */ 16296 #line 6141 "preproc.y" 16297 { 16298 (yyval.str) = cat_str(5,make_str("alter aggregate"),(yyvsp[(3) - (7)].str),(yyvsp[(4) - (7)].str),make_str("set schema"),(yyvsp[(7) - (7)].str)); 16299@@ -33341,8 +31940,6 @@ 16300 break; 16301 16302 case 935: 16303- 16304-/* Line 1455 of yacc.c */ 16305 #line 6145 "preproc.y" 16306 { 16307 (yyval.str) = cat_str(4,make_str("alter domain"),(yyvsp[(3) - (6)].str),make_str("set schema"),(yyvsp[(6) - (6)].str)); 16308@@ -33350,8 +31947,6 @@ 16309 break; 16310 16311 case 936: 16312- 16313-/* Line 1455 of yacc.c */ 16314 #line 6149 "preproc.y" 16315 { 16316 (yyval.str) = cat_str(4,make_str("alter function"),(yyvsp[(3) - (6)].str),make_str("set schema"),(yyvsp[(6) - (6)].str)); 16317@@ -33359,8 +31954,6 @@ 16318 break; 16319 16320 case 937: 16321- 16322-/* Line 1455 of yacc.c */ 16323 #line 6153 "preproc.y" 16324 { 16325 (yyval.str) = cat_str(4,make_str("alter table"),(yyvsp[(3) - (6)].str),make_str("set schema"),(yyvsp[(6) - (6)].str)); 16326@@ -33368,8 +31961,6 @@ 16327 break; 16328 16329 case 938: 16330- 16331-/* Line 1455 of yacc.c */ 16332 #line 6157 "preproc.y" 16333 { 16334 (yyval.str) = cat_str(4,make_str("alter sequence"),(yyvsp[(3) - (6)].str),make_str("set schema"),(yyvsp[(6) - (6)].str)); 16335@@ -33377,8 +31968,6 @@ 16336 break; 16337 16338 case 939: 16339- 16340-/* Line 1455 of yacc.c */ 16341 #line 6161 "preproc.y" 16342 { 16343 (yyval.str) = cat_str(4,make_str("alter view"),(yyvsp[(3) - (6)].str),make_str("set schema"),(yyvsp[(6) - (6)].str)); 16344@@ -33386,8 +31975,6 @@ 16345 break; 16346 16347 case 940: 16348- 16349-/* Line 1455 of yacc.c */ 16350 #line 6165 "preproc.y" 16351 { 16352 (yyval.str) = cat_str(4,make_str("alter type"),(yyvsp[(3) - (6)].str),make_str("set schema"),(yyvsp[(6) - (6)].str)); 16353@@ -33395,8 +31982,6 @@ 16354 break; 16355 16356 case 941: 16357- 16358-/* Line 1455 of yacc.c */ 16359 #line 6173 "preproc.y" 16360 { 16361 (yyval.str) = cat_str(5,make_str("alter aggregate"),(yyvsp[(3) - (7)].str),(yyvsp[(4) - (7)].str),make_str("owner to"),(yyvsp[(7) - (7)].str)); 16362@@ -33404,8 +31989,6 @@ 16363 break; 16364 16365 case 942: 16366- 16367-/* Line 1455 of yacc.c */ 16368 #line 6177 "preproc.y" 16369 { 16370 (yyval.str) = cat_str(4,make_str("alter conversion"),(yyvsp[(3) - (6)].str),make_str("owner to"),(yyvsp[(6) - (6)].str)); 16371@@ -33413,8 +31996,6 @@ 16372 break; 16373 16374 case 943: 16375- 16376-/* Line 1455 of yacc.c */ 16377 #line 6181 "preproc.y" 16378 { 16379 (yyval.str) = cat_str(4,make_str("alter database"),(yyvsp[(3) - (6)].str),make_str("owner to"),(yyvsp[(6) - (6)].str)); 16380@@ -33422,8 +32003,6 @@ 16381 break; 16382 16383 case 944: 16384- 16385-/* Line 1455 of yacc.c */ 16386 #line 6185 "preproc.y" 16387 { 16388 (yyval.str) = cat_str(4,make_str("alter domain"),(yyvsp[(3) - (6)].str),make_str("owner to"),(yyvsp[(6) - (6)].str)); 16389@@ -33431,8 +32010,6 @@ 16390 break; 16391 16392 case 945: 16393- 16394-/* Line 1455 of yacc.c */ 16395 #line 6189 "preproc.y" 16396 { 16397 (yyval.str) = cat_str(4,make_str("alter function"),(yyvsp[(3) - (6)].str),make_str("owner to"),(yyvsp[(6) - (6)].str)); 16398@@ -33440,8 +32017,6 @@ 16399 break; 16400 16401 case 946: 16402- 16403-/* Line 1455 of yacc.c */ 16404 #line 6193 "preproc.y" 16405 { 16406 (yyval.str) = cat_str(6,make_str("alter"),(yyvsp[(2) - (7)].str),make_str("language"),(yyvsp[(4) - (7)].str),make_str("owner to"),(yyvsp[(7) - (7)].str)); 16407@@ -33449,8 +32024,6 @@ 16408 break; 16409 16410 case 947: 16411- 16412-/* Line 1455 of yacc.c */ 16413 #line 6197 "preproc.y" 16414 { 16415 (yyval.str) = cat_str(4,make_str("alter large object"),(yyvsp[(4) - (7)].str),make_str("owner to"),(yyvsp[(7) - (7)].str)); 16416@@ -33458,8 +32031,6 @@ 16417 break; 16418 16419 case 948: 16420- 16421-/* Line 1455 of yacc.c */ 16422 #line 6201 "preproc.y" 16423 { 16424 (yyval.str) = cat_str(5,make_str("alter operator"),(yyvsp[(3) - (7)].str),(yyvsp[(4) - (7)].str),make_str("owner to"),(yyvsp[(7) - (7)].str)); 16425@@ -33467,8 +32038,6 @@ 16426 break; 16427 16428 case 949: 16429- 16430-/* Line 1455 of yacc.c */ 16431 #line 6205 "preproc.y" 16432 { 16433 (yyval.str) = cat_str(6,make_str("alter operator class"),(yyvsp[(4) - (9)].str),make_str("using"),(yyvsp[(6) - (9)].str),make_str("owner to"),(yyvsp[(9) - (9)].str)); 16434@@ -33476,8 +32045,6 @@ 16435 break; 16436 16437 case 950: 16438- 16439-/* Line 1455 of yacc.c */ 16440 #line 6209 "preproc.y" 16441 { 16442 (yyval.str) = cat_str(6,make_str("alter operator family"),(yyvsp[(4) - (9)].str),make_str("using"),(yyvsp[(6) - (9)].str),make_str("owner to"),(yyvsp[(9) - (9)].str)); 16443@@ -33485,8 +32052,6 @@ 16444 break; 16445 16446 case 951: 16447- 16448-/* Line 1455 of yacc.c */ 16449 #line 6213 "preproc.y" 16450 { 16451 (yyval.str) = cat_str(4,make_str("alter schema"),(yyvsp[(3) - (6)].str),make_str("owner to"),(yyvsp[(6) - (6)].str)); 16452@@ -33494,8 +32059,6 @@ 16453 break; 16454 16455 case 952: 16456- 16457-/* Line 1455 of yacc.c */ 16458 #line 6217 "preproc.y" 16459 { 16460 (yyval.str) = cat_str(4,make_str("alter type"),(yyvsp[(3) - (6)].str),make_str("owner to"),(yyvsp[(6) - (6)].str)); 16461@@ -33503,8 +32066,6 @@ 16462 break; 16463 16464 case 953: 16465- 16466-/* Line 1455 of yacc.c */ 16467 #line 6221 "preproc.y" 16468 { 16469 (yyval.str) = cat_str(4,make_str("alter tablespace"),(yyvsp[(3) - (6)].str),make_str("owner to"),(yyvsp[(6) - (6)].str)); 16470@@ -33512,8 +32073,6 @@ 16471 break; 16472 16473 case 954: 16474- 16475-/* Line 1455 of yacc.c */ 16476 #line 6225 "preproc.y" 16477 { 16478 (yyval.str) = cat_str(4,make_str("alter text search dictionary"),(yyvsp[(5) - (8)].str),make_str("owner to"),(yyvsp[(8) - (8)].str)); 16479@@ -33521,8 +32080,6 @@ 16480 break; 16481 16482 case 955: 16483- 16484-/* Line 1455 of yacc.c */ 16485 #line 6229 "preproc.y" 16486 { 16487 (yyval.str) = cat_str(4,make_str("alter text search configuration"),(yyvsp[(5) - (8)].str),make_str("owner to"),(yyvsp[(8) - (8)].str)); 16488@@ -33530,8 +32087,6 @@ 16489 break; 16490 16491 case 956: 16492- 16493-/* Line 1455 of yacc.c */ 16494 #line 6233 "preproc.y" 16495 { 16496 (yyval.str) = cat_str(4,make_str("alter foreign data wrapper"),(yyvsp[(5) - (8)].str),make_str("owner to"),(yyvsp[(8) - (8)].str)); 16497@@ -33539,8 +32094,6 @@ 16498 break; 16499 16500 case 957: 16501- 16502-/* Line 1455 of yacc.c */ 16503 #line 6237 "preproc.y" 16504 { 16505 (yyval.str) = cat_str(4,make_str("alter server"),(yyvsp[(3) - (6)].str),make_str("owner to"),(yyvsp[(6) - (6)].str)); 16506@@ -33548,8 +32101,6 @@ 16507 break; 16508 16509 case 958: 16510- 16511-/* Line 1455 of yacc.c */ 16512 #line 6245 "preproc.y" 16513 { 16514 (yyval.str) = cat_str(12,make_str("create"),(yyvsp[(2) - (13)].str),make_str("rule"),(yyvsp[(4) - (13)].str),make_str("as on"),(yyvsp[(7) - (13)].str),make_str("to"),(yyvsp[(9) - (13)].str),(yyvsp[(10) - (13)].str),make_str("do"),(yyvsp[(12) - (13)].str),(yyvsp[(13) - (13)].str)); 16515@@ -33557,8 +32108,6 @@ 16516 break; 16517 16518 case 959: 16519- 16520-/* Line 1455 of yacc.c */ 16521 #line 6253 "preproc.y" 16522 { 16523 (yyval.str) = make_str("nothing"); 16524@@ -33566,8 +32115,6 @@ 16525 break; 16526 16527 case 960: 16528- 16529-/* Line 1455 of yacc.c */ 16530 #line 6257 "preproc.y" 16531 { 16532 (yyval.str) = (yyvsp[(1) - (1)].str); 16533@@ -33575,8 +32122,6 @@ 16534 break; 16535 16536 case 961: 16537- 16538-/* Line 1455 of yacc.c */ 16539 #line 6261 "preproc.y" 16540 { 16541 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 16542@@ -33584,8 +32129,6 @@ 16543 break; 16544 16545 case 962: 16546- 16547-/* Line 1455 of yacc.c */ 16548 #line 6269 "preproc.y" 16549 { 16550 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(";"),(yyvsp[(3) - (3)].str)); 16551@@ -33593,8 +32136,6 @@ 16552 break; 16553 16554 case 963: 16555- 16556-/* Line 1455 of yacc.c */ 16557 #line 6273 "preproc.y" 16558 { 16559 (yyval.str) = (yyvsp[(1) - (1)].str); 16560@@ -33602,8 +32143,6 @@ 16561 break; 16562 16563 case 964: 16564- 16565-/* Line 1455 of yacc.c */ 16566 #line 6281 "preproc.y" 16567 { 16568 (yyval.str) = (yyvsp[(1) - (1)].str); 16569@@ -33611,8 +32150,6 @@ 16570 break; 16571 16572 case 965: 16573- 16574-/* Line 1455 of yacc.c */ 16575 #line 6285 "preproc.y" 16576 { 16577 (yyval.str) = (yyvsp[(1) - (1)].str); 16578@@ -33620,8 +32157,6 @@ 16579 break; 16580 16581 case 966: 16582- 16583-/* Line 1455 of yacc.c */ 16584 #line 6289 "preproc.y" 16585 { 16586 (yyval.str) = (yyvsp[(1) - (1)].str); 16587@@ -33629,8 +32164,6 @@ 16588 break; 16589 16590 case 967: 16591- 16592-/* Line 1455 of yacc.c */ 16593 #line 6293 "preproc.y" 16594 { 16595 (yyval.str) = (yyvsp[(1) - (1)].str); 16596@@ -33638,8 +32171,6 @@ 16597 break; 16598 16599 case 968: 16600- 16601-/* Line 1455 of yacc.c */ 16602 #line 6297 "preproc.y" 16603 { 16604 (yyval.str) = (yyvsp[(1) - (1)].str); 16605@@ -33647,8 +32178,6 @@ 16606 break; 16607 16608 case 969: 16609- 16610-/* Line 1455 of yacc.c */ 16611 #line 6305 "preproc.y" 16612 { 16613 (yyval.str) = (yyvsp[(1) - (1)].str); 16614@@ -33656,16 +32185,12 @@ 16615 break; 16616 16617 case 970: 16618- 16619-/* Line 1455 of yacc.c */ 16620 #line 6309 "preproc.y" 16621 { 16622 (yyval.str)=EMPTY; ;} 16623 break; 16624 16625 case 971: 16626- 16627-/* Line 1455 of yacc.c */ 16628 #line 6316 "preproc.y" 16629 { 16630 (yyval.str) = make_str("select"); 16631@@ -33673,8 +32198,6 @@ 16632 break; 16633 16634 case 972: 16635- 16636-/* Line 1455 of yacc.c */ 16637 #line 6320 "preproc.y" 16638 { 16639 (yyval.str) = make_str("update"); 16640@@ -33682,8 +32205,6 @@ 16641 break; 16642 16643 case 973: 16644- 16645-/* Line 1455 of yacc.c */ 16646 #line 6324 "preproc.y" 16647 { 16648 (yyval.str) = make_str("delete"); 16649@@ -33691,8 +32212,6 @@ 16650 break; 16651 16652 case 974: 16653- 16654-/* Line 1455 of yacc.c */ 16655 #line 6328 "preproc.y" 16656 { 16657 (yyval.str) = make_str("insert"); 16658@@ -33700,8 +32219,6 @@ 16659 break; 16660 16661 case 975: 16662- 16663-/* Line 1455 of yacc.c */ 16664 #line 6336 "preproc.y" 16665 { 16666 (yyval.str) = make_str("instead"); 16667@@ -33709,8 +32226,6 @@ 16668 break; 16669 16670 case 976: 16671- 16672-/* Line 1455 of yacc.c */ 16673 #line 6340 "preproc.y" 16674 { 16675 (yyval.str) = make_str("also"); 16676@@ -33718,16 +32233,12 @@ 16677 break; 16678 16679 case 977: 16680- 16681-/* Line 1455 of yacc.c */ 16682 #line 6344 "preproc.y" 16683 { 16684 (yyval.str)=EMPTY; ;} 16685 break; 16686 16687 case 978: 16688- 16689-/* Line 1455 of yacc.c */ 16690 #line 6351 "preproc.y" 16691 { 16692 (yyval.str) = cat_str(5,make_str("drop rule"),(yyvsp[(3) - (6)].str),make_str("on"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 16693@@ -33735,8 +32246,6 @@ 16694 break; 16695 16696 case 979: 16697- 16698-/* Line 1455 of yacc.c */ 16699 #line 6355 "preproc.y" 16700 { 16701 (yyval.str) = cat_str(5,make_str("drop rule if exists"),(yyvsp[(5) - (8)].str),make_str("on"),(yyvsp[(7) - (8)].str),(yyvsp[(8) - (8)].str)); 16702@@ -33744,8 +32253,6 @@ 16703 break; 16704 16705 case 980: 16706- 16707-/* Line 1455 of yacc.c */ 16708 #line 6363 "preproc.y" 16709 { 16710 (yyval.str) = cat_str(3,make_str("notify"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 16711@@ -33753,8 +32260,6 @@ 16712 break; 16713 16714 case 981: 16715- 16716-/* Line 1455 of yacc.c */ 16717 #line 6371 "preproc.y" 16718 { 16719 (yyval.str) = cat_str(2,make_str(","),(yyvsp[(2) - (2)].str)); 16720@@ -33762,16 +32267,12 @@ 16721 break; 16722 16723 case 982: 16724- 16725-/* Line 1455 of yacc.c */ 16726 #line 6375 "preproc.y" 16727 { 16728 (yyval.str)=EMPTY; ;} 16729 break; 16730 16731 case 983: 16732- 16733-/* Line 1455 of yacc.c */ 16734 #line 6382 "preproc.y" 16735 { 16736 (yyval.str) = cat_str(2,make_str("listen"),(yyvsp[(2) - (2)].str)); 16737@@ -33779,8 +32280,6 @@ 16738 break; 16739 16740 case 984: 16741- 16742-/* Line 1455 of yacc.c */ 16743 #line 6390 "preproc.y" 16744 { 16745 (yyval.str) = cat_str(2,make_str("unlisten"),(yyvsp[(2) - (2)].str)); 16746@@ -33788,8 +32287,6 @@ 16747 break; 16748 16749 case 985: 16750- 16751-/* Line 1455 of yacc.c */ 16752 #line 6394 "preproc.y" 16753 { 16754 (yyval.str) = make_str("unlisten *"); 16755@@ -33797,8 +32294,6 @@ 16756 break; 16757 16758 case 986: 16759- 16760-/* Line 1455 of yacc.c */ 16761 #line 6402 "preproc.y" 16762 { 16763 (yyval.str) = cat_str(2,make_str("abort"),(yyvsp[(2) - (2)].str)); 16764@@ -33806,8 +32301,6 @@ 16765 break; 16766 16767 case 987: 16768- 16769-/* Line 1455 of yacc.c */ 16770 #line 6406 "preproc.y" 16771 { 16772 (yyval.str) = cat_str(3,make_str("begin"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 16773@@ -33815,8 +32308,6 @@ 16774 break; 16775 16776 case 988: 16777- 16778-/* Line 1455 of yacc.c */ 16779 #line 6410 "preproc.y" 16780 { 16781 (yyval.str) = cat_str(2,make_str("start transaction"),(yyvsp[(3) - (3)].str)); 16782@@ -33824,8 +32315,6 @@ 16783 break; 16784 16785 case 989: 16786- 16787-/* Line 1455 of yacc.c */ 16788 #line 6414 "preproc.y" 16789 { 16790 (yyval.str) = cat_str(2,make_str("commit"),(yyvsp[(2) - (2)].str)); 16791@@ -33833,8 +32322,6 @@ 16792 break; 16793 16794 case 990: 16795- 16796-/* Line 1455 of yacc.c */ 16797 #line 6418 "preproc.y" 16798 { 16799 (yyval.str) = cat_str(2,make_str("end"),(yyvsp[(2) - (2)].str)); 16800@@ -33842,8 +32329,6 @@ 16801 break; 16802 16803 case 991: 16804- 16805-/* Line 1455 of yacc.c */ 16806 #line 6422 "preproc.y" 16807 { 16808 (yyval.str) = cat_str(2,make_str("rollback"),(yyvsp[(2) - (2)].str)); 16809@@ -33851,8 +32336,6 @@ 16810 break; 16811 16812 case 992: 16813- 16814-/* Line 1455 of yacc.c */ 16815 #line 6426 "preproc.y" 16816 { 16817 (yyval.str) = cat_str(2,make_str("savepoint"),(yyvsp[(2) - (2)].str)); 16818@@ -33860,8 +32343,6 @@ 16819 break; 16820 16821 case 993: 16822- 16823-/* Line 1455 of yacc.c */ 16824 #line 6430 "preproc.y" 16825 { 16826 (yyval.str) = cat_str(2,make_str("release savepoint"),(yyvsp[(3) - (3)].str)); 16827@@ -33869,8 +32350,6 @@ 16828 break; 16829 16830 case 994: 16831- 16832-/* Line 1455 of yacc.c */ 16833 #line 6434 "preproc.y" 16834 { 16835 (yyval.str) = cat_str(2,make_str("release"),(yyvsp[(2) - (2)].str)); 16836@@ -33878,8 +32357,6 @@ 16837 break; 16838 16839 case 995: 16840- 16841-/* Line 1455 of yacc.c */ 16842 #line 6438 "preproc.y" 16843 { 16844 (yyval.str) = cat_str(4,make_str("rollback"),(yyvsp[(2) - (5)].str),make_str("to savepoint"),(yyvsp[(5) - (5)].str)); 16845@@ -33887,8 +32364,6 @@ 16846 break; 16847 16848 case 996: 16849- 16850-/* Line 1455 of yacc.c */ 16851 #line 6442 "preproc.y" 16852 { 16853 (yyval.str) = cat_str(4,make_str("rollback"),(yyvsp[(2) - (4)].str),make_str("to"),(yyvsp[(4) - (4)].str)); 16854@@ -33896,8 +32371,6 @@ 16855 break; 16856 16857 case 997: 16858- 16859-/* Line 1455 of yacc.c */ 16860 #line 6446 "preproc.y" 16861 { 16862 (yyval.str) = cat_str(2,make_str("prepare transaction"),(yyvsp[(3) - (3)].str)); 16863@@ -33905,8 +32378,6 @@ 16864 break; 16865 16866 case 998: 16867- 16868-/* Line 1455 of yacc.c */ 16869 #line 6450 "preproc.y" 16870 { 16871 (yyval.str) = cat_str(2,make_str("commit prepared"),(yyvsp[(3) - (3)].str)); 16872@@ -33914,8 +32385,6 @@ 16873 break; 16874 16875 case 999: 16876- 16877-/* Line 1455 of yacc.c */ 16878 #line 6454 "preproc.y" 16879 { 16880 (yyval.str) = cat_str(2,make_str("rollback prepared"),(yyvsp[(3) - (3)].str)); 16881@@ -33923,8 +32392,6 @@ 16882 break; 16883 16884 case 1000: 16885- 16886-/* Line 1455 of yacc.c */ 16887 #line 6462 "preproc.y" 16888 { 16889 (yyval.str) = make_str("work"); 16890@@ -33932,8 +32399,6 @@ 16891 break; 16892 16893 case 1001: 16894- 16895-/* Line 1455 of yacc.c */ 16896 #line 6466 "preproc.y" 16897 { 16898 (yyval.str) = make_str("transaction"); 16899@@ -33941,16 +32406,12 @@ 16900 break; 16901 16902 case 1002: 16903- 16904-/* Line 1455 of yacc.c */ 16905 #line 6470 "preproc.y" 16906 { 16907 (yyval.str)=EMPTY; ;} 16908 break; 16909 16910 case 1003: 16911- 16912-/* Line 1455 of yacc.c */ 16913 #line 6477 "preproc.y" 16914 { 16915 (yyval.str) = cat_str(2,make_str("isolation level"),(yyvsp[(3) - (3)].str)); 16916@@ -33958,8 +32419,6 @@ 16917 break; 16918 16919 case 1004: 16920- 16921-/* Line 1455 of yacc.c */ 16922 #line 6481 "preproc.y" 16923 { 16924 (yyval.str) = make_str("read only"); 16925@@ -33967,8 +32426,6 @@ 16926 break; 16927 16928 case 1005: 16929- 16930-/* Line 1455 of yacc.c */ 16931 #line 6485 "preproc.y" 16932 { 16933 (yyval.str) = make_str("read write"); 16934@@ -33976,8 +32433,6 @@ 16935 break; 16936 16937 case 1006: 16938- 16939-/* Line 1455 of yacc.c */ 16940 #line 6493 "preproc.y" 16941 { 16942 (yyval.str) = (yyvsp[(1) - (1)].str); 16943@@ -33985,8 +32440,6 @@ 16944 break; 16945 16946 case 1007: 16947- 16948-/* Line 1455 of yacc.c */ 16949 #line 6497 "preproc.y" 16950 { 16951 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 16952@@ -33994,8 +32447,6 @@ 16953 break; 16954 16955 case 1008: 16956- 16957-/* Line 1455 of yacc.c */ 16958 #line 6501 "preproc.y" 16959 { 16960 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 16961@@ -34003,8 +32454,6 @@ 16962 break; 16963 16964 case 1009: 16965- 16966-/* Line 1455 of yacc.c */ 16967 #line 6509 "preproc.y" 16968 { 16969 (yyval.str) = (yyvsp[(1) - (1)].str); 16970@@ -34012,16 +32461,12 @@ 16971 break; 16972 16973 case 1010: 16974- 16975-/* Line 1455 of yacc.c */ 16976 #line 6513 "preproc.y" 16977 { 16978 (yyval.str)=EMPTY; ;} 16979 break; 16980 16981 case 1011: 16982- 16983-/* Line 1455 of yacc.c */ 16984 #line 6520 "preproc.y" 16985 { 16986 (yyval.str) = cat_str(8,make_str("create"),(yyvsp[(2) - (8)].str),make_str("view"),(yyvsp[(4) - (8)].str),(yyvsp[(5) - (8)].str),make_str("as"),(yyvsp[(7) - (8)].str),(yyvsp[(8) - (8)].str)); 16987@@ -34029,8 +32474,6 @@ 16988 break; 16989 16990 case 1012: 16991- 16992-/* Line 1455 of yacc.c */ 16993 #line 6524 "preproc.y" 16994 { 16995 (yyval.str) = cat_str(8,make_str("create or replace"),(yyvsp[(4) - (10)].str),make_str("view"),(yyvsp[(6) - (10)].str),(yyvsp[(7) - (10)].str),make_str("as"),(yyvsp[(9) - (10)].str),(yyvsp[(10) - (10)].str)); 16996@@ -34038,8 +32481,6 @@ 16997 break; 16998 16999 case 1013: 17000- 17001-/* Line 1455 of yacc.c */ 17002 #line 6532 "preproc.y" 17003 { 17004 mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server"); 17005@@ -34048,8 +32489,6 @@ 17006 break; 17007 17008 case 1014: 17009- 17010-/* Line 1455 of yacc.c */ 17011 #line 6537 "preproc.y" 17012 { 17013 mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server"); 17014@@ -34058,8 +32497,6 @@ 17015 break; 17016 17017 case 1015: 17018- 17019-/* Line 1455 of yacc.c */ 17020 #line 6542 "preproc.y" 17021 { 17022 mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server"); 17023@@ -34068,16 +32505,12 @@ 17024 break; 17025 17026 case 1016: 17027- 17028-/* Line 1455 of yacc.c */ 17029 #line 6547 "preproc.y" 17030 { 17031 (yyval.str)=EMPTY; ;} 17032 break; 17033 17034 case 1017: 17035- 17036-/* Line 1455 of yacc.c */ 17037 #line 6554 "preproc.y" 17038 { 17039 (yyval.str) = cat_str(2,make_str("load"),(yyvsp[(2) - (2)].str)); 17040@@ -34085,8 +32518,6 @@ 17041 break; 17042 17043 case 1018: 17044- 17045-/* Line 1455 of yacc.c */ 17046 #line 6562 "preproc.y" 17047 { 17048 (yyval.str) = cat_str(4,make_str("create database"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 17049@@ -34094,8 +32525,6 @@ 17050 break; 17051 17052 case 1019: 17053- 17054-/* Line 1455 of yacc.c */ 17055 #line 6570 "preproc.y" 17056 { 17057 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 17058@@ -34103,16 +32532,12 @@ 17059 break; 17060 17061 case 1020: 17062- 17063-/* Line 1455 of yacc.c */ 17064 #line 6574 "preproc.y" 17065 { 17066 (yyval.str)=EMPTY; ;} 17067 break; 17068 17069 case 1021: 17070- 17071-/* Line 1455 of yacc.c */ 17072 #line 6581 "preproc.y" 17073 { 17074 (yyval.str) = cat_str(3,make_str("tablespace"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 17075@@ -34120,8 +32545,6 @@ 17076 break; 17077 17078 case 1022: 17079- 17080-/* Line 1455 of yacc.c */ 17081 #line 6585 "preproc.y" 17082 { 17083 (yyval.str) = cat_str(3,make_str("tablespace"),(yyvsp[(2) - (3)].str),make_str("default")); 17084@@ -34129,8 +32552,6 @@ 17085 break; 17086 17087 case 1023: 17088- 17089-/* Line 1455 of yacc.c */ 17090 #line 6589 "preproc.y" 17091 { 17092 (yyval.str) = cat_str(3,make_str("location"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 17093@@ -34138,8 +32559,6 @@ 17094 break; 17095 17096 case 1024: 17097- 17098-/* Line 1455 of yacc.c */ 17099 #line 6593 "preproc.y" 17100 { 17101 (yyval.str) = cat_str(3,make_str("location"),(yyvsp[(2) - (3)].str),make_str("default")); 17102@@ -34147,8 +32566,6 @@ 17103 break; 17104 17105 case 1025: 17106- 17107-/* Line 1455 of yacc.c */ 17108 #line 6597 "preproc.y" 17109 { 17110 (yyval.str) = cat_str(3,make_str("template"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 17111@@ -34156,8 +32573,6 @@ 17112 break; 17113 17114 case 1026: 17115- 17116-/* Line 1455 of yacc.c */ 17117 #line 6601 "preproc.y" 17118 { 17119 (yyval.str) = cat_str(3,make_str("template"),(yyvsp[(2) - (3)].str),make_str("default")); 17120@@ -34165,8 +32580,6 @@ 17121 break; 17122 17123 case 1027: 17124- 17125-/* Line 1455 of yacc.c */ 17126 #line 6605 "preproc.y" 17127 { 17128 (yyval.str) = cat_str(3,make_str("encoding"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 17129@@ -34174,8 +32587,6 @@ 17130 break; 17131 17132 case 1028: 17133- 17134-/* Line 1455 of yacc.c */ 17135 #line 6609 "preproc.y" 17136 { 17137 (yyval.str) = cat_str(3,make_str("encoding"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 17138@@ -34183,8 +32594,6 @@ 17139 break; 17140 17141 case 1029: 17142- 17143-/* Line 1455 of yacc.c */ 17144 #line 6613 "preproc.y" 17145 { 17146 (yyval.str) = cat_str(3,make_str("encoding"),(yyvsp[(2) - (3)].str),make_str("default")); 17147@@ -34192,8 +32601,6 @@ 17148 break; 17149 17150 case 1030: 17151- 17152-/* Line 1455 of yacc.c */ 17153 #line 6617 "preproc.y" 17154 { 17155 (yyval.str) = cat_str(3,make_str("lc_collate"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 17156@@ -34201,8 +32608,6 @@ 17157 break; 17158 17159 case 1031: 17160- 17161-/* Line 1455 of yacc.c */ 17162 #line 6621 "preproc.y" 17163 { 17164 (yyval.str) = cat_str(3,make_str("lc_collate"),(yyvsp[(2) - (3)].str),make_str("default")); 17165@@ -34210,8 +32615,6 @@ 17166 break; 17167 17168 case 1032: 17169- 17170-/* Line 1455 of yacc.c */ 17171 #line 6625 "preproc.y" 17172 { 17173 (yyval.str) = cat_str(3,make_str("lc_ctype"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 17174@@ -34219,8 +32622,6 @@ 17175 break; 17176 17177 case 1033: 17178- 17179-/* Line 1455 of yacc.c */ 17180 #line 6629 "preproc.y" 17181 { 17182 (yyval.str) = cat_str(3,make_str("lc_ctype"),(yyvsp[(2) - (3)].str),make_str("default")); 17183@@ -34228,8 +32629,6 @@ 17184 break; 17185 17186 case 1034: 17187- 17188-/* Line 1455 of yacc.c */ 17189 #line 6633 "preproc.y" 17190 { 17191 (yyval.str) = cat_str(3,make_str("connection limit"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 17192@@ -34237,8 +32636,6 @@ 17193 break; 17194 17195 case 1035: 17196- 17197-/* Line 1455 of yacc.c */ 17198 #line 6637 "preproc.y" 17199 { 17200 (yyval.str) = cat_str(3,make_str("owner"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 17201@@ -34246,8 +32643,6 @@ 17202 break; 17203 17204 case 1036: 17205- 17206-/* Line 1455 of yacc.c */ 17207 #line 6641 "preproc.y" 17208 { 17209 (yyval.str) = cat_str(3,make_str("owner"),(yyvsp[(2) - (3)].str),make_str("default")); 17210@@ -34255,8 +32650,6 @@ 17211 break; 17212 17213 case 1037: 17214- 17215-/* Line 1455 of yacc.c */ 17216 #line 6649 "preproc.y" 17217 { 17218 (yyval.str) = make_str("="); 17219@@ -34264,16 +32657,12 @@ 17220 break; 17221 17222 case 1038: 17223- 17224-/* Line 1455 of yacc.c */ 17225 #line 6653 "preproc.y" 17226 { 17227 (yyval.str)=EMPTY; ;} 17228 break; 17229 17230 case 1039: 17231- 17232-/* Line 1455 of yacc.c */ 17233 #line 6660 "preproc.y" 17234 { 17235 (yyval.str) = cat_str(4,make_str("alter database"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 17236@@ -34281,8 +32670,6 @@ 17237 break; 17238 17239 case 1040: 17240- 17241-/* Line 1455 of yacc.c */ 17242 #line 6664 "preproc.y" 17243 { 17244 (yyval.str) = cat_str(4,make_str("alter database"),(yyvsp[(3) - (6)].str),make_str("set tablespace"),(yyvsp[(6) - (6)].str)); 17245@@ -34290,8 +32677,6 @@ 17246 break; 17247 17248 case 1041: 17249- 17250-/* Line 1455 of yacc.c */ 17251 #line 6672 "preproc.y" 17252 { 17253 (yyval.str) = cat_str(3,make_str("alter database"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 17254@@ -34299,8 +32684,6 @@ 17255 break; 17256 17257 case 1042: 17258- 17259-/* Line 1455 of yacc.c */ 17260 #line 6680 "preproc.y" 17261 { 17262 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 17263@@ -34308,16 +32691,12 @@ 17264 break; 17265 17266 case 1043: 17267- 17268-/* Line 1455 of yacc.c */ 17269 #line 6684 "preproc.y" 17270 { 17271 (yyval.str)=EMPTY; ;} 17272 break; 17273 17274 case 1044: 17275- 17276-/* Line 1455 of yacc.c */ 17277 #line 6691 "preproc.y" 17278 { 17279 (yyval.str) = cat_str(3,make_str("connection limit"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 17280@@ -34325,8 +32704,6 @@ 17281 break; 17282 17283 case 1045: 17284- 17285-/* Line 1455 of yacc.c */ 17286 #line 6699 "preproc.y" 17287 { 17288 (yyval.str) = cat_str(2,make_str("drop database"),(yyvsp[(3) - (3)].str)); 17289@@ -34334,8 +32711,6 @@ 17290 break; 17291 17292 case 1046: 17293- 17294-/* Line 1455 of yacc.c */ 17295 #line 6703 "preproc.y" 17296 { 17297 (yyval.str) = cat_str(2,make_str("drop database if exists"),(yyvsp[(5) - (5)].str)); 17298@@ -34343,8 +32718,6 @@ 17299 break; 17300 17301 case 1047: 17302- 17303-/* Line 1455 of yacc.c */ 17304 #line 6711 "preproc.y" 17305 { 17306 (yyval.str) = cat_str(5,make_str("create domain"),(yyvsp[(3) - (6)].str),(yyvsp[(4) - (6)].str),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 17307@@ -34352,8 +32725,6 @@ 17308 break; 17309 17310 case 1048: 17311- 17312-/* Line 1455 of yacc.c */ 17313 #line 6719 "preproc.y" 17314 { 17315 (yyval.str) = cat_str(3,make_str("alter domain"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 17316@@ -34361,8 +32732,6 @@ 17317 break; 17318 17319 case 1049: 17320- 17321-/* Line 1455 of yacc.c */ 17322 #line 6723 "preproc.y" 17323 { 17324 (yyval.str) = cat_str(3,make_str("alter domain"),(yyvsp[(3) - (6)].str),make_str("drop not null")); 17325@@ -34370,8 +32739,6 @@ 17326 break; 17327 17328 case 1050: 17329- 17330-/* Line 1455 of yacc.c */ 17331 #line 6727 "preproc.y" 17332 { 17333 (yyval.str) = cat_str(3,make_str("alter domain"),(yyvsp[(3) - (6)].str),make_str("set not null")); 17334@@ -34379,8 +32746,6 @@ 17335 break; 17336 17337 case 1051: 17338- 17339-/* Line 1455 of yacc.c */ 17340 #line 6731 "preproc.y" 17341 { 17342 (yyval.str) = cat_str(4,make_str("alter domain"),(yyvsp[(3) - (5)].str),make_str("add"),(yyvsp[(5) - (5)].str)); 17343@@ -34388,8 +32753,6 @@ 17344 break; 17345 17346 case 1052: 17347- 17348-/* Line 1455 of yacc.c */ 17349 #line 6735 "preproc.y" 17350 { 17351 (yyval.str) = cat_str(5,make_str("alter domain"),(yyvsp[(3) - (7)].str),make_str("drop constraint"),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 17352@@ -34397,8 +32760,6 @@ 17353 break; 17354 17355 case 1053: 17356- 17357-/* Line 1455 of yacc.c */ 17358 #line 6743 "preproc.y" 17359 { 17360 (yyval.str) = make_str("as"); 17361@@ -34406,16 +32767,12 @@ 17362 break; 17363 17364 case 1054: 17365- 17366-/* Line 1455 of yacc.c */ 17367 #line 6747 "preproc.y" 17368 { 17369 (yyval.str)=EMPTY; ;} 17370 break; 17371 17372 case 1055: 17373- 17374-/* Line 1455 of yacc.c */ 17375 #line 6754 "preproc.y" 17376 { 17377 (yyval.str) = cat_str(3,make_str("alter text search dictionary"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 17378@@ -34423,8 +32780,6 @@ 17379 break; 17380 17381 case 1056: 17382- 17383-/* Line 1455 of yacc.c */ 17384 #line 6762 "preproc.y" 17385 { 17386 (yyval.str) = cat_str(6,make_str("alter text search configuration"),(yyvsp[(5) - (11)].str),make_str("add mapping for"),(yyvsp[(9) - (11)].str),make_str("with"),(yyvsp[(11) - (11)].str)); 17387@@ -34432,8 +32787,6 @@ 17388 break; 17389 17390 case 1057: 17391- 17392-/* Line 1455 of yacc.c */ 17393 #line 6766 "preproc.y" 17394 { 17395 (yyval.str) = cat_str(6,make_str("alter text search configuration"),(yyvsp[(5) - (11)].str),make_str("alter mapping for"),(yyvsp[(9) - (11)].str),make_str("with"),(yyvsp[(11) - (11)].str)); 17396@@ -34441,8 +32794,6 @@ 17397 break; 17398 17399 case 1058: 17400- 17401-/* Line 1455 of yacc.c */ 17402 #line 6770 "preproc.y" 17403 { 17404 (yyval.str) = cat_str(6,make_str("alter text search configuration"),(yyvsp[(5) - (11)].str),make_str("alter mapping replace"),(yyvsp[(9) - (11)].str),make_str("with"),(yyvsp[(11) - (11)].str)); 17405@@ -34450,8 +32801,6 @@ 17406 break; 17407 17408 case 1059: 17409- 17410-/* Line 1455 of yacc.c */ 17411 #line 6774 "preproc.y" 17412 { 17413 (yyval.str) = cat_str(8,make_str("alter text search configuration"),(yyvsp[(5) - (13)].str),make_str("alter mapping for"),(yyvsp[(9) - (13)].str),make_str("replace"),(yyvsp[(11) - (13)].str),make_str("with"),(yyvsp[(13) - (13)].str)); 17414@@ -34459,8 +32808,6 @@ 17415 break; 17416 17417 case 1060: 17418- 17419-/* Line 1455 of yacc.c */ 17420 #line 6778 "preproc.y" 17421 { 17422 (yyval.str) = cat_str(4,make_str("alter text search configuration"),(yyvsp[(5) - (9)].str),make_str("drop mapping for"),(yyvsp[(9) - (9)].str)); 17423@@ -34468,8 +32815,6 @@ 17424 break; 17425 17426 case 1061: 17427- 17428-/* Line 1455 of yacc.c */ 17429 #line 6782 "preproc.y" 17430 { 17431 (yyval.str) = cat_str(4,make_str("alter text search configuration"),(yyvsp[(5) - (11)].str),make_str("drop mapping if exists for"),(yyvsp[(11) - (11)].str)); 17432@@ -34477,8 +32822,6 @@ 17433 break; 17434 17435 case 1062: 17436- 17437-/* Line 1455 of yacc.c */ 17438 #line 6790 "preproc.y" 17439 { 17440 (yyval.str) = cat_str(10,make_str("create"),(yyvsp[(2) - (10)].str),make_str("conversion"),(yyvsp[(4) - (10)].str),make_str("for"),(yyvsp[(6) - (10)].str),make_str("to"),(yyvsp[(8) - (10)].str),make_str("from"),(yyvsp[(10) - (10)].str)); 17441@@ -34486,8 +32829,6 @@ 17442 break; 17443 17444 case 1063: 17445- 17446-/* Line 1455 of yacc.c */ 17447 #line 6798 "preproc.y" 17448 { 17449 (yyval.str) = cat_str(4,make_str("cluster"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 17450@@ -34495,8 +32836,6 @@ 17451 break; 17452 17453 case 1064: 17454- 17455-/* Line 1455 of yacc.c */ 17456 #line 6802 "preproc.y" 17457 { 17458 (yyval.str) = cat_str(2,make_str("cluster"),(yyvsp[(2) - (2)].str)); 17459@@ -34504,8 +32843,6 @@ 17460 break; 17461 17462 case 1065: 17463- 17464-/* Line 1455 of yacc.c */ 17465 #line 6806 "preproc.y" 17466 { 17467 (yyval.str) = cat_str(5,make_str("cluster"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),make_str("on"),(yyvsp[(5) - (5)].str)); 17468@@ -34513,8 +32850,6 @@ 17469 break; 17470 17471 case 1066: 17472- 17473-/* Line 1455 of yacc.c */ 17474 #line 6814 "preproc.y" 17475 { 17476 (yyval.str) = cat_str(2,make_str("using"),(yyvsp[(2) - (2)].str)); 17477@@ -34522,16 +32857,12 @@ 17478 break; 17479 17480 case 1067: 17481- 17482-/* Line 1455 of yacc.c */ 17483 #line 6818 "preproc.y" 17484 { 17485 (yyval.str)=EMPTY; ;} 17486 break; 17487 17488 case 1068: 17489- 17490-/* Line 1455 of yacc.c */ 17491 #line 6825 "preproc.y" 17492 { 17493 (yyval.str) = cat_str(4,make_str("vacuum"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 17494@@ -34539,8 +32870,6 @@ 17495 break; 17496 17497 case 1069: 17498- 17499-/* Line 1455 of yacc.c */ 17500 #line 6829 "preproc.y" 17501 { 17502 (yyval.str) = cat_str(5,make_str("vacuum"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 17503@@ -34548,8 +32877,6 @@ 17504 break; 17505 17506 case 1070: 17507- 17508-/* Line 1455 of yacc.c */ 17509 #line 6833 "preproc.y" 17510 { 17511 (yyval.str) = cat_str(5,make_str("vacuum"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 17512@@ -34557,8 +32884,6 @@ 17513 break; 17514 17515 case 1071: 17516- 17517-/* Line 1455 of yacc.c */ 17518 #line 6837 "preproc.y" 17519 { 17520 (yyval.str) = cat_str(3,make_str("vacuum ("),(yyvsp[(3) - (4)].str),make_str(")")); 17521@@ -34566,8 +32891,6 @@ 17522 break; 17523 17524 case 1072: 17525- 17526-/* Line 1455 of yacc.c */ 17527 #line 6841 "preproc.y" 17528 { 17529 (yyval.str) = cat_str(5,make_str("vacuum ("),(yyvsp[(3) - (6)].str),make_str(")"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 17530@@ -34575,8 +32898,6 @@ 17531 break; 17532 17533 case 1073: 17534- 17535-/* Line 1455 of yacc.c */ 17536 #line 6849 "preproc.y" 17537 { 17538 (yyval.str) = (yyvsp[(1) - (1)].str); 17539@@ -34584,8 +32905,6 @@ 17540 break; 17541 17542 case 1074: 17543- 17544-/* Line 1455 of yacc.c */ 17545 #line 6853 "preproc.y" 17546 { 17547 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 17548@@ -34593,8 +32912,6 @@ 17549 break; 17550 17551 case 1075: 17552- 17553-/* Line 1455 of yacc.c */ 17554 #line 6861 "preproc.y" 17555 { 17556 (yyval.str) = (yyvsp[(1) - (1)].str); 17557@@ -34602,8 +32919,6 @@ 17558 break; 17559 17560 case 1076: 17561- 17562-/* Line 1455 of yacc.c */ 17563 #line 6865 "preproc.y" 17564 { 17565 (yyval.str) = make_str("verbose"); 17566@@ -34611,8 +32926,6 @@ 17567 break; 17568 17569 case 1077: 17570- 17571-/* Line 1455 of yacc.c */ 17572 #line 6869 "preproc.y" 17573 { 17574 (yyval.str) = make_str("freeze"); 17575@@ -34620,8 +32933,6 @@ 17576 break; 17577 17578 case 1078: 17579- 17580-/* Line 1455 of yacc.c */ 17581 #line 6873 "preproc.y" 17582 { 17583 (yyval.str) = make_str("full"); 17584@@ -34629,8 +32940,6 @@ 17585 break; 17586 17587 case 1079: 17588- 17589-/* Line 1455 of yacc.c */ 17590 #line 6881 "preproc.y" 17591 { 17592 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 17593@@ -34638,8 +32947,6 @@ 17594 break; 17595 17596 case 1080: 17597- 17598-/* Line 1455 of yacc.c */ 17599 #line 6885 "preproc.y" 17600 { 17601 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 17602@@ -34647,8 +32954,6 @@ 17603 break; 17604 17605 case 1081: 17606- 17607-/* Line 1455 of yacc.c */ 17608 #line 6893 "preproc.y" 17609 { 17610 (yyval.str) = make_str("analyze"); 17611@@ -34656,8 +32961,6 @@ 17612 break; 17613 17614 case 1082: 17615- 17616-/* Line 1455 of yacc.c */ 17617 #line 6897 "preproc.y" 17618 { 17619 (yyval.str) = make_str("analyse"); 17620@@ -34665,8 +32968,6 @@ 17621 break; 17622 17623 case 1083: 17624- 17625-/* Line 1455 of yacc.c */ 17626 #line 6905 "preproc.y" 17627 { 17628 (yyval.str) = make_str("verbose"); 17629@@ -34674,16 +32975,12 @@ 17630 break; 17631 17632 case 1084: 17633- 17634-/* Line 1455 of yacc.c */ 17635 #line 6909 "preproc.y" 17636 { 17637 (yyval.str)=EMPTY; ;} 17638 break; 17639 17640 case 1085: 17641- 17642-/* Line 1455 of yacc.c */ 17643 #line 6916 "preproc.y" 17644 { 17645 (yyval.str) = make_str("full"); 17646@@ -34691,16 +32988,12 @@ 17647 break; 17648 17649 case 1086: 17650- 17651-/* Line 1455 of yacc.c */ 17652 #line 6920 "preproc.y" 17653 { 17654 (yyval.str)=EMPTY; ;} 17655 break; 17656 17657 case 1087: 17658- 17659-/* Line 1455 of yacc.c */ 17660 #line 6927 "preproc.y" 17661 { 17662 (yyval.str) = make_str("freeze"); 17663@@ -34708,16 +33001,12 @@ 17664 break; 17665 17666 case 1088: 17667- 17668-/* Line 1455 of yacc.c */ 17669 #line 6931 "preproc.y" 17670 { 17671 (yyval.str)=EMPTY; ;} 17672 break; 17673 17674 case 1089: 17675- 17676-/* Line 1455 of yacc.c */ 17677 #line 6938 "preproc.y" 17678 { 17679 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 17680@@ -34725,16 +33014,12 @@ 17681 break; 17682 17683 case 1090: 17684- 17685-/* Line 1455 of yacc.c */ 17686 #line 6942 "preproc.y" 17687 { 17688 (yyval.str)=EMPTY; ;} 17689 break; 17690 17691 case 1091: 17692- 17693-/* Line 1455 of yacc.c */ 17694 #line 6949 "preproc.y" 17695 { 17696 (yyval.str) = cat_str(2,make_str("explain"),(yyvsp[(2) - (2)].str)); 17697@@ -34742,8 +33027,6 @@ 17698 break; 17699 17700 case 1092: 17701- 17702-/* Line 1455 of yacc.c */ 17703 #line 6953 "preproc.y" 17704 { 17705 (yyval.str) = cat_str(4,make_str("explain"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 17706@@ -34751,8 +33034,6 @@ 17707 break; 17708 17709 case 1093: 17710- 17711-/* Line 1455 of yacc.c */ 17712 #line 6957 "preproc.y" 17713 { 17714 (yyval.str) = cat_str(2,make_str("explain verbose"),(yyvsp[(3) - (3)].str)); 17715@@ -34760,8 +33041,6 @@ 17716 break; 17717 17718 case 1094: 17719- 17720-/* Line 1455 of yacc.c */ 17721 #line 6961 "preproc.y" 17722 { 17723 (yyval.str) = cat_str(4,make_str("explain ("),(yyvsp[(3) - (5)].str),make_str(")"),(yyvsp[(5) - (5)].str)); 17724@@ -34769,8 +33048,6 @@ 17725 break; 17726 17727 case 1095: 17728- 17729-/* Line 1455 of yacc.c */ 17730 #line 6969 "preproc.y" 17731 { 17732 (yyval.str) = (yyvsp[(1) - (1)].str); 17733@@ -34778,8 +33055,6 @@ 17734 break; 17735 17736 case 1096: 17737- 17738-/* Line 1455 of yacc.c */ 17739 #line 6973 "preproc.y" 17740 { 17741 (yyval.str) = (yyvsp[(1) - (1)].str); 17742@@ -34787,8 +33062,6 @@ 17743 break; 17744 17745 case 1097: 17746- 17747-/* Line 1455 of yacc.c */ 17748 #line 6977 "preproc.y" 17749 { 17750 (yyval.str) = (yyvsp[(1) - (1)].str); 17751@@ -34796,8 +33069,6 @@ 17752 break; 17753 17754 case 1098: 17755- 17756-/* Line 1455 of yacc.c */ 17757 #line 6981 "preproc.y" 17758 { 17759 (yyval.str) = (yyvsp[(1) - (1)].str); 17760@@ -34805,8 +33076,6 @@ 17761 break; 17762 17763 case 1099: 17764- 17765-/* Line 1455 of yacc.c */ 17766 #line 6985 "preproc.y" 17767 { 17768 (yyval.str) = (yyvsp[(1) - (1)].str); 17769@@ -34814,8 +33083,6 @@ 17770 break; 17771 17772 case 1100: 17773- 17774-/* Line 1455 of yacc.c */ 17775 #line 6989 "preproc.y" 17776 { 17777 (yyval.str) = (yyvsp[(1) - (1)].str); 17778@@ -34823,8 +33090,6 @@ 17779 break; 17780 17781 case 1101: 17782- 17783-/* Line 1455 of yacc.c */ 17784 #line 6993 "preproc.y" 17785 { 17786 (yyval.str) = (yyvsp[(1) - (1)].str); 17787@@ -34832,8 +33097,6 @@ 17788 break; 17789 17790 case 1102: 17791- 17792-/* Line 1455 of yacc.c */ 17793 #line 7001 "preproc.y" 17794 { 17795 (yyval.str) = (yyvsp[(1) - (1)].str); 17796@@ -34841,8 +33104,6 @@ 17797 break; 17798 17799 case 1103: 17800- 17801-/* Line 1455 of yacc.c */ 17802 #line 7005 "preproc.y" 17803 { 17804 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 17805@@ -34850,8 +33111,6 @@ 17806 break; 17807 17808 case 1104: 17809- 17810-/* Line 1455 of yacc.c */ 17811 #line 7013 "preproc.y" 17812 { 17813 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 17814@@ -34859,8 +33118,6 @@ 17815 break; 17816 17817 case 1105: 17818- 17819-/* Line 1455 of yacc.c */ 17820 #line 7021 "preproc.y" 17821 { 17822 (yyval.str) = (yyvsp[(1) - (1)].str); 17823@@ -34868,8 +33125,6 @@ 17824 break; 17825 17826 case 1106: 17827- 17828-/* Line 1455 of yacc.c */ 17829 #line 7025 "preproc.y" 17830 { 17831 (yyval.str) = (yyvsp[(1) - (1)].str); 17832@@ -34877,8 +33132,6 @@ 17833 break; 17834 17835 case 1107: 17836- 17837-/* Line 1455 of yacc.c */ 17838 #line 7029 "preproc.y" 17839 { 17840 (yyval.str) = make_str("verbose"); 17841@@ -34886,8 +33139,6 @@ 17842 break; 17843 17844 case 1108: 17845- 17846-/* Line 1455 of yacc.c */ 17847 #line 7037 "preproc.y" 17848 { 17849 (yyval.str) = (yyvsp[(1) - (1)].str); 17850@@ -34895,8 +33146,6 @@ 17851 break; 17852 17853 case 1109: 17854- 17855-/* Line 1455 of yacc.c */ 17856 #line 7041 "preproc.y" 17857 { 17858 (yyval.str) = (yyvsp[(1) - (1)].str); 17859@@ -34904,16 +33153,12 @@ 17860 break; 17861 17862 case 1110: 17863- 17864-/* Line 1455 of yacc.c */ 17865 #line 7045 "preproc.y" 17866 { 17867 (yyval.str)=EMPTY; ;} 17868 break; 17869 17870 case 1111: 17871- 17872-/* Line 1455 of yacc.c */ 17873 #line 7052 "preproc.y" 17874 { 17875 (yyval.prep).name = (yyvsp[(2) - (5)].str); 17876@@ -34923,8 +33168,6 @@ 17877 break; 17878 17879 case 1112: 17880- 17881-/* Line 1455 of yacc.c */ 17882 #line 7058 "preproc.y" 17883 { 17884 (yyval.prep).name = (yyvsp[(2) - (4)].str); 17885@@ -34934,8 +33177,6 @@ 17886 break; 17887 17888 case 1113: 17889- 17890-/* Line 1455 of yacc.c */ 17891 #line 7068 "preproc.y" 17892 { 17893 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 17894@@ -34943,16 +33184,12 @@ 17895 break; 17896 17897 case 1114: 17898- 17899-/* Line 1455 of yacc.c */ 17900 #line 7072 "preproc.y" 17901 { 17902 (yyval.str)=EMPTY; ;} 17903 break; 17904 17905 case 1115: 17906- 17907-/* Line 1455 of yacc.c */ 17908 #line 7079 "preproc.y" 17909 { 17910 (yyval.str) = (yyvsp[(1) - (1)].str); 17911@@ -34960,8 +33197,6 @@ 17912 break; 17913 17914 case 1116: 17915- 17916-/* Line 1455 of yacc.c */ 17917 #line 7083 "preproc.y" 17918 { 17919 (yyval.str) = (yyvsp[(1) - (1)].str); 17920@@ -34969,8 +33204,6 @@ 17921 break; 17922 17923 case 1117: 17924- 17925-/* Line 1455 of yacc.c */ 17926 #line 7087 "preproc.y" 17927 { 17928 (yyval.str) = (yyvsp[(1) - (1)].str); 17929@@ -34978,8 +33211,6 @@ 17930 break; 17931 17932 case 1118: 17933- 17934-/* Line 1455 of yacc.c */ 17935 #line 7091 "preproc.y" 17936 { 17937 (yyval.str) = (yyvsp[(1) - (1)].str); 17938@@ -34987,15 +33218,11 @@ 17939 break; 17940 17941 case 1119: 17942- 17943-/* Line 1455 of yacc.c */ 17944 #line 7099 "preproc.y" 17945 { (yyval.str) = (yyvsp[(2) - (4)].str); ;} 17946 break; 17947 17948 case 1120: 17949- 17950-/* Line 1455 of yacc.c */ 17951 #line 7101 "preproc.y" 17952 { 17953 (yyval.str) = cat_str(7,make_str("create"),(yyvsp[(2) - (8)].str),make_str("table"),(yyvsp[(4) - (8)].str),make_str("as execute"),(yyvsp[(7) - (8)].str),(yyvsp[(8) - (8)].str)); 17954@@ -35003,8 +33230,6 @@ 17955 break; 17956 17957 case 1121: 17958- 17959-/* Line 1455 of yacc.c */ 17960 #line 7109 "preproc.y" 17961 { 17962 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 17963@@ -35012,16 +33237,12 @@ 17964 break; 17965 17966 case 1122: 17967- 17968-/* Line 1455 of yacc.c */ 17969 #line 7113 "preproc.y" 17970 { 17971 (yyval.str)=EMPTY; ;} 17972 break; 17973 17974 case 1123: 17975- 17976-/* Line 1455 of yacc.c */ 17977 #line 7120 "preproc.y" 17978 { 17979 (yyval.str) = cat_str(4,make_str("insert into"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 17980@@ -35029,8 +33250,6 @@ 17981 break; 17982 17983 case 1124: 17984- 17985-/* Line 1455 of yacc.c */ 17986 #line 7128 "preproc.y" 17987 { 17988 (yyval.str) = (yyvsp[(1) - (1)].str); 17989@@ -35038,8 +33257,6 @@ 17990 break; 17991 17992 case 1125: 17993- 17994-/* Line 1455 of yacc.c */ 17995 #line 7132 "preproc.y" 17996 { 17997 (yyval.str) = cat_str(4,make_str("("),(yyvsp[(2) - (4)].str),make_str(")"),(yyvsp[(4) - (4)].str)); 17998@@ -35047,8 +33264,6 @@ 17999 break; 18000 18001 case 1126: 18002- 18003-/* Line 1455 of yacc.c */ 18004 #line 7136 "preproc.y" 18005 { 18006 (yyval.str) = make_str("default values"); 18007@@ -35056,8 +33271,6 @@ 18008 break; 18009 18010 case 1127: 18011- 18012-/* Line 1455 of yacc.c */ 18013 #line 7144 "preproc.y" 18014 { 18015 (yyval.str) = (yyvsp[(1) - (1)].str); 18016@@ -35065,8 +33278,6 @@ 18017 break; 18018 18019 case 1128: 18020- 18021-/* Line 1455 of yacc.c */ 18022 #line 7148 "preproc.y" 18023 { 18024 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 18025@@ -35074,8 +33285,6 @@ 18026 break; 18027 18028 case 1129: 18029- 18030-/* Line 1455 of yacc.c */ 18031 #line 7156 "preproc.y" 18032 { 18033 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 18034@@ -35083,8 +33292,6 @@ 18035 break; 18036 18037 case 1130: 18038- 18039-/* Line 1455 of yacc.c */ 18040 #line 7164 "preproc.y" 18041 { 18042 (yyval.str) = cat_str(2,make_str("returning"),(yyvsp[(2) - (3)].str)); 18043@@ -35092,16 +33299,12 @@ 18044 break; 18045 18046 case 1131: 18047- 18048-/* Line 1455 of yacc.c */ 18049 #line 7168 "preproc.y" 18050 { 18051 (yyval.str)=EMPTY; ;} 18052 break; 18053 18054 case 1132: 18055- 18056-/* Line 1455 of yacc.c */ 18057 #line 7175 "preproc.y" 18058 { 18059 (yyval.str) = cat_str(5,make_str("delete from"),(yyvsp[(3) - (6)].str),(yyvsp[(4) - (6)].str),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 18060@@ -35109,8 +33312,6 @@ 18061 break; 18062 18063 case 1133: 18064- 18065-/* Line 1455 of yacc.c */ 18066 #line 7183 "preproc.y" 18067 { 18068 (yyval.str) = cat_str(2,make_str("using"),(yyvsp[(2) - (2)].str)); 18069@@ -35118,16 +33319,12 @@ 18070 break; 18071 18072 case 1134: 18073- 18074-/* Line 1455 of yacc.c */ 18075 #line 7187 "preproc.y" 18076 { 18077 (yyval.str)=EMPTY; ;} 18078 break; 18079 18080 case 1135: 18081- 18082-/* Line 1455 of yacc.c */ 18083 #line 7194 "preproc.y" 18084 { 18085 (yyval.str) = cat_str(5,make_str("lock"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 18086@@ -35135,8 +33332,6 @@ 18087 break; 18088 18089 case 1136: 18090- 18091-/* Line 1455 of yacc.c */ 18092 #line 7202 "preproc.y" 18093 { 18094 (yyval.str) = cat_str(3,make_str("in"),(yyvsp[(2) - (3)].str),make_str("mode")); 18095@@ -35144,16 +33339,12 @@ 18096 break; 18097 18098 case 1137: 18099- 18100-/* Line 1455 of yacc.c */ 18101 #line 7206 "preproc.y" 18102 { 18103 (yyval.str)=EMPTY; ;} 18104 break; 18105 18106 case 1138: 18107- 18108-/* Line 1455 of yacc.c */ 18109 #line 7213 "preproc.y" 18110 { 18111 (yyval.str) = make_str("access share"); 18112@@ -35161,8 +33352,6 @@ 18113 break; 18114 18115 case 1139: 18116- 18117-/* Line 1455 of yacc.c */ 18118 #line 7217 "preproc.y" 18119 { 18120 (yyval.str) = make_str("row share"); 18121@@ -35170,8 +33359,6 @@ 18122 break; 18123 18124 case 1140: 18125- 18126-/* Line 1455 of yacc.c */ 18127 #line 7221 "preproc.y" 18128 { 18129 (yyval.str) = make_str("row exclusive"); 18130@@ -35179,8 +33366,6 @@ 18131 break; 18132 18133 case 1141: 18134- 18135-/* Line 1455 of yacc.c */ 18136 #line 7225 "preproc.y" 18137 { 18138 (yyval.str) = make_str("share update exclusive"); 18139@@ -35188,8 +33373,6 @@ 18140 break; 18141 18142 case 1142: 18143- 18144-/* Line 1455 of yacc.c */ 18145 #line 7229 "preproc.y" 18146 { 18147 (yyval.str) = make_str("share"); 18148@@ -35197,8 +33380,6 @@ 18149 break; 18150 18151 case 1143: 18152- 18153-/* Line 1455 of yacc.c */ 18154 #line 7233 "preproc.y" 18155 { 18156 (yyval.str) = make_str("share row exclusive"); 18157@@ -35206,8 +33387,6 @@ 18158 break; 18159 18160 case 1144: 18161- 18162-/* Line 1455 of yacc.c */ 18163 #line 7237 "preproc.y" 18164 { 18165 (yyval.str) = make_str("exclusive"); 18166@@ -35215,8 +33394,6 @@ 18167 break; 18168 18169 case 1145: 18170- 18171-/* Line 1455 of yacc.c */ 18172 #line 7241 "preproc.y" 18173 { 18174 (yyval.str) = make_str("access exclusive"); 18175@@ -35224,8 +33401,6 @@ 18176 break; 18177 18178 case 1146: 18179- 18180-/* Line 1455 of yacc.c */ 18181 #line 7249 "preproc.y" 18182 { 18183 (yyval.str) = make_str("nowait"); 18184@@ -35233,16 +33408,12 @@ 18185 break; 18186 18187 case 1147: 18188- 18189-/* Line 1455 of yacc.c */ 18190 #line 7253 "preproc.y" 18191 { 18192 (yyval.str)=EMPTY; ;} 18193 break; 18194 18195 case 1148: 18196- 18197-/* Line 1455 of yacc.c */ 18198 #line 7260 "preproc.y" 18199 { 18200 (yyval.str) = cat_str(7,make_str("update"),(yyvsp[(2) - (7)].str),make_str("set"),(yyvsp[(4) - (7)].str),(yyvsp[(5) - (7)].str),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str)); 18201@@ -35250,8 +33421,6 @@ 18202 break; 18203 18204 case 1149: 18205- 18206-/* Line 1455 of yacc.c */ 18207 #line 7268 "preproc.y" 18208 { 18209 (yyval.str) = (yyvsp[(1) - (1)].str); 18210@@ -35259,8 +33428,6 @@ 18211 break; 18212 18213 case 1150: 18214- 18215-/* Line 1455 of yacc.c */ 18216 #line 7272 "preproc.y" 18217 { 18218 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 18219@@ -35268,8 +33435,6 @@ 18220 break; 18221 18222 case 1151: 18223- 18224-/* Line 1455 of yacc.c */ 18225 #line 7280 "preproc.y" 18226 { 18227 (yyval.str) = (yyvsp[(1) - (1)].str); 18228@@ -35277,8 +33442,6 @@ 18229 break; 18230 18231 case 1152: 18232- 18233-/* Line 1455 of yacc.c */ 18234 #line 7284 "preproc.y" 18235 { 18236 (yyval.str) = (yyvsp[(1) - (1)].str); 18237@@ -35286,8 +33449,6 @@ 18238 break; 18239 18240 case 1153: 18241- 18242-/* Line 1455 of yacc.c */ 18243 #line 7292 "preproc.y" 18244 { 18245 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("="),(yyvsp[(3) - (3)].str)); 18246@@ -35295,8 +33456,6 @@ 18247 break; 18248 18249 case 1154: 18250- 18251-/* Line 1455 of yacc.c */ 18252 #line 7300 "preproc.y" 18253 { 18254 (yyval.str) = cat_str(4,make_str("("),(yyvsp[(2) - (5)].str),make_str(") ="),(yyvsp[(5) - (5)].str)); 18255@@ -35304,8 +33463,6 @@ 18256 break; 18257 18258 case 1155: 18259- 18260-/* Line 1455 of yacc.c */ 18261 #line 7308 "preproc.y" 18262 { 18263 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 18264@@ -35313,8 +33470,6 @@ 18265 break; 18266 18267 case 1156: 18268- 18269-/* Line 1455 of yacc.c */ 18270 #line 7316 "preproc.y" 18271 { 18272 (yyval.str) = (yyvsp[(1) - (1)].str); 18273@@ -35322,8 +33477,6 @@ 18274 break; 18275 18276 case 1157: 18277- 18278-/* Line 1455 of yacc.c */ 18279 #line 7320 "preproc.y" 18280 { 18281 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 18282@@ -35331,8 +33484,6 @@ 18283 break; 18284 18285 case 1158: 18286- 18287-/* Line 1455 of yacc.c */ 18288 #line 7328 "preproc.y" 18289 { 18290 struct cursor *ptr, *this; 18291@@ -35384,8 +33535,6 @@ 18292 break; 18293 18294 case 1159: 18295- 18296-/* Line 1455 of yacc.c */ 18297 #line 7380 "preproc.y" 18298 { 18299 (yyval.str) = (yyvsp[(1) - (1)].str); 18300@@ -35393,8 +33542,6 @@ 18301 break; 18302 18303 case 1160: 18304- 18305-/* Line 1455 of yacc.c */ 18306 #line 7384 "preproc.y" 18307 { 18308 char *curname = mm_alloc(strlen((yyvsp[(1) - (1)].str)) + 2); 18309@@ -35406,16 +33553,12 @@ 18310 break; 18311 18312 case 1161: 18313- 18314-/* Line 1455 of yacc.c */ 18315 #line 7396 "preproc.y" 18316 { 18317 (yyval.str)=EMPTY; ;} 18318 break; 18319 18320 case 1162: 18321- 18322-/* Line 1455 of yacc.c */ 18323 #line 7399 "preproc.y" 18324 { 18325 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("no scroll")); 18326@@ -35423,8 +33566,6 @@ 18327 break; 18328 18329 case 1163: 18330- 18331-/* Line 1455 of yacc.c */ 18332 #line 7403 "preproc.y" 18333 { 18334 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),make_str("scroll")); 18335@@ -35432,8 +33573,6 @@ 18336 break; 18337 18338 case 1164: 18339- 18340-/* Line 1455 of yacc.c */ 18341 #line 7407 "preproc.y" 18342 { 18343 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),make_str("binary")); 18344@@ -35441,8 +33580,6 @@ 18345 break; 18346 18347 case 1165: 18348- 18349-/* Line 1455 of yacc.c */ 18350 #line 7411 "preproc.y" 18351 { 18352 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),make_str("insensitive")); 18353@@ -35450,8 +33587,6 @@ 18354 break; 18355 18356 case 1166: 18357- 18358-/* Line 1455 of yacc.c */ 18359 #line 7419 "preproc.y" 18360 { 18361 if (compat == ECPG_COMPAT_INFORMIX_SE && autocommit == true) 18362@@ -35462,8 +33597,6 @@ 18363 break; 18364 18365 case 1167: 18366- 18367-/* Line 1455 of yacc.c */ 18368 #line 7426 "preproc.y" 18369 { 18370 (yyval.str) = make_str("with hold"); 18371@@ -35471,8 +33604,6 @@ 18372 break; 18373 18374 case 1168: 18375- 18376-/* Line 1455 of yacc.c */ 18377 #line 7430 "preproc.y" 18378 { 18379 (yyval.str) = make_str("without hold"); 18380@@ -35480,8 +33611,6 @@ 18381 break; 18382 18383 case 1169: 18384- 18385-/* Line 1455 of yacc.c */ 18386 #line 7438 "preproc.y" 18387 { 18388 (yyval.str) = (yyvsp[(1) - (1)].str); 18389@@ -35489,8 +33618,6 @@ 18390 break; 18391 18392 case 1170: 18393- 18394-/* Line 1455 of yacc.c */ 18395 #line 7442 "preproc.y" 18396 { 18397 (yyval.str) = (yyvsp[(1) - (1)].str); 18398@@ -35498,8 +33625,6 @@ 18399 break; 18400 18401 case 1171: 18402- 18403-/* Line 1455 of yacc.c */ 18404 #line 7450 "preproc.y" 18405 { 18406 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 18407@@ -35507,8 +33632,6 @@ 18408 break; 18409 18410 case 1172: 18411- 18412-/* Line 1455 of yacc.c */ 18413 #line 7454 "preproc.y" 18414 { 18415 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 18416@@ -35516,8 +33639,6 @@ 18417 break; 18418 18419 case 1173: 18420- 18421-/* Line 1455 of yacc.c */ 18422 #line 7462 "preproc.y" 18423 { 18424 (yyval.str) = (yyvsp[(1) - (1)].str); 18425@@ -35525,8 +33646,6 @@ 18426 break; 18427 18428 case 1174: 18429- 18430-/* Line 1455 of yacc.c */ 18431 #line 7466 "preproc.y" 18432 { 18433 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 18434@@ -35534,8 +33653,6 @@ 18435 break; 18436 18437 case 1175: 18438- 18439-/* Line 1455 of yacc.c */ 18440 #line 7470 "preproc.y" 18441 { 18442 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 18443@@ -35543,8 +33660,6 @@ 18444 break; 18445 18446 case 1176: 18447- 18448-/* Line 1455 of yacc.c */ 18449 #line 7474 "preproc.y" 18450 { 18451 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 18452@@ -35552,8 +33667,6 @@ 18453 break; 18454 18455 case 1177: 18456- 18457-/* Line 1455 of yacc.c */ 18458 #line 7478 "preproc.y" 18459 { 18460 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 18461@@ -35561,8 +33674,6 @@ 18462 break; 18463 18464 case 1178: 18465- 18466-/* Line 1455 of yacc.c */ 18467 #line 7482 "preproc.y" 18468 { 18469 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 18470@@ -35570,8 +33681,6 @@ 18471 break; 18472 18473 case 1179: 18474- 18475-/* Line 1455 of yacc.c */ 18476 #line 7486 "preproc.y" 18477 { 18478 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 18479@@ -35579,8 +33688,6 @@ 18480 break; 18481 18482 case 1180: 18483- 18484-/* Line 1455 of yacc.c */ 18485 #line 7490 "preproc.y" 18486 { 18487 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 18488@@ -35588,8 +33695,6 @@ 18489 break; 18490 18491 case 1181: 18492- 18493-/* Line 1455 of yacc.c */ 18494 #line 7498 "preproc.y" 18495 { 18496 (yyval.str) = (yyvsp[(1) - (1)].str); 18497@@ -35597,8 +33702,6 @@ 18498 break; 18499 18500 case 1182: 18501- 18502-/* Line 1455 of yacc.c */ 18503 #line 7502 "preproc.y" 18504 { 18505 (yyval.str) = (yyvsp[(1) - (1)].str); 18506@@ -35606,8 +33709,6 @@ 18507 break; 18508 18509 case 1183: 18510- 18511-/* Line 1455 of yacc.c */ 18512 #line 7510 "preproc.y" 18513 { 18514 (yyval.str) = cat_str(9,make_str("select"),(yyvsp[(2) - (9)].str),(yyvsp[(3) - (9)].str),(yyvsp[(4) - (9)].str),(yyvsp[(5) - (9)].str),(yyvsp[(6) - (9)].str),(yyvsp[(7) - (9)].str),(yyvsp[(8) - (9)].str),(yyvsp[(9) - (9)].str)); 18515@@ -35615,8 +33716,6 @@ 18516 break; 18517 18518 case 1184: 18519- 18520-/* Line 1455 of yacc.c */ 18521 #line 7514 "preproc.y" 18522 { 18523 (yyval.str) = (yyvsp[(1) - (1)].str); 18524@@ -35624,8 +33723,6 @@ 18525 break; 18526 18527 case 1185: 18528- 18529-/* Line 1455 of yacc.c */ 18530 #line 7518 "preproc.y" 18531 { 18532 (yyval.str) = cat_str(2,make_str("table"),(yyvsp[(2) - (2)].str)); 18533@@ -35633,8 +33730,6 @@ 18534 break; 18535 18536 case 1186: 18537- 18538-/* Line 1455 of yacc.c */ 18539 #line 7522 "preproc.y" 18540 { 18541 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),make_str("union"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 18542@@ -35642,8 +33737,6 @@ 18543 break; 18544 18545 case 1187: 18546- 18547-/* Line 1455 of yacc.c */ 18548 #line 7526 "preproc.y" 18549 { 18550 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),make_str("intersect"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 18551@@ -35651,8 +33744,6 @@ 18552 break; 18553 18554 case 1188: 18555- 18556-/* Line 1455 of yacc.c */ 18557 #line 7530 "preproc.y" 18558 { 18559 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),make_str("except"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 18560@@ -35660,8 +33751,6 @@ 18561 break; 18562 18563 case 1189: 18564- 18565-/* Line 1455 of yacc.c */ 18566 #line 7538 "preproc.y" 18567 { 18568 (yyval.str) = cat_str(2,make_str("with"),(yyvsp[(2) - (2)].str)); 18569@@ -35669,8 +33758,6 @@ 18570 break; 18571 18572 case 1190: 18573- 18574-/* Line 1455 of yacc.c */ 18575 #line 7542 "preproc.y" 18576 { 18577 (yyval.str) = cat_str(2,make_str("with recursive"),(yyvsp[(3) - (3)].str)); 18578@@ -35678,8 +33765,6 @@ 18579 break; 18580 18581 case 1191: 18582- 18583-/* Line 1455 of yacc.c */ 18584 #line 7550 "preproc.y" 18585 { 18586 (yyval.str) = (yyvsp[(1) - (1)].str); 18587@@ -35687,8 +33772,6 @@ 18588 break; 18589 18590 case 1192: 18591- 18592-/* Line 1455 of yacc.c */ 18593 #line 7554 "preproc.y" 18594 { 18595 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 18596@@ -35696,8 +33779,6 @@ 18597 break; 18598 18599 case 1193: 18600- 18601-/* Line 1455 of yacc.c */ 18602 #line 7562 "preproc.y" 18603 { 18604 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),make_str("as"),(yyvsp[(4) - (4)].str)); 18605@@ -35705,8 +33786,6 @@ 18606 break; 18607 18608 case 1194: 18609- 18610-/* Line 1455 of yacc.c */ 18611 #line 7570 "preproc.y" 18612 { 18613 FoundInto = 1; 18614@@ -35715,23 +33794,17 @@ 18615 break; 18616 18617 case 1195: 18618- 18619-/* Line 1455 of yacc.c */ 18620 #line 7574 "preproc.y" 18621 { (yyval.str) = EMPTY; ;} 18622 break; 18623 18624 case 1196: 18625- 18626-/* Line 1455 of yacc.c */ 18627 #line 7576 "preproc.y" 18628 { 18629 (yyval.str)=EMPTY; ;} 18630 break; 18631 18632 case 1197: 18633- 18634-/* Line 1455 of yacc.c */ 18635 #line 7583 "preproc.y" 18636 { 18637 (yyval.str) = cat_str(3,make_str("temporary"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 18638@@ -35739,8 +33812,6 @@ 18639 break; 18640 18641 case 1198: 18642- 18643-/* Line 1455 of yacc.c */ 18644 #line 7587 "preproc.y" 18645 { 18646 (yyval.str) = cat_str(3,make_str("temp"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 18647@@ -35748,8 +33819,6 @@ 18648 break; 18649 18650 case 1199: 18651- 18652-/* Line 1455 of yacc.c */ 18653 #line 7591 "preproc.y" 18654 { 18655 (yyval.str) = cat_str(3,make_str("local temporary"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 18656@@ -35757,8 +33826,6 @@ 18657 break; 18658 18659 case 1200: 18660- 18661-/* Line 1455 of yacc.c */ 18662 #line 7595 "preproc.y" 18663 { 18664 (yyval.str) = cat_str(3,make_str("local temp"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 18665@@ -35766,8 +33833,6 @@ 18666 break; 18667 18668 case 1201: 18669- 18670-/* Line 1455 of yacc.c */ 18671 #line 7599 "preproc.y" 18672 { 18673 (yyval.str) = cat_str(3,make_str("global temporary"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 18674@@ -35775,8 +33840,6 @@ 18675 break; 18676 18677 case 1202: 18678- 18679-/* Line 1455 of yacc.c */ 18680 #line 7603 "preproc.y" 18681 { 18682 (yyval.str) = cat_str(3,make_str("global temp"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 18683@@ -35784,8 +33847,6 @@ 18684 break; 18685 18686 case 1203: 18687- 18688-/* Line 1455 of yacc.c */ 18689 #line 7607 "preproc.y" 18690 { 18691 (yyval.str) = cat_str(2,make_str("table"),(yyvsp[(2) - (2)].str)); 18692@@ -35793,8 +33854,6 @@ 18693 break; 18694 18695 case 1204: 18696- 18697-/* Line 1455 of yacc.c */ 18698 #line 7611 "preproc.y" 18699 { 18700 (yyval.str) = (yyvsp[(1) - (1)].str); 18701@@ -35802,8 +33861,6 @@ 18702 break; 18703 18704 case 1205: 18705- 18706-/* Line 1455 of yacc.c */ 18707 #line 7619 "preproc.y" 18708 { 18709 (yyval.str) = make_str("table"); 18710@@ -35811,16 +33868,12 @@ 18711 break; 18712 18713 case 1206: 18714- 18715-/* Line 1455 of yacc.c */ 18716 #line 7623 "preproc.y" 18717 { 18718 (yyval.str)=EMPTY; ;} 18719 break; 18720 18721 case 1207: 18722- 18723-/* Line 1455 of yacc.c */ 18724 #line 7630 "preproc.y" 18725 { 18726 (yyval.str) = make_str("all"); 18727@@ -35828,8 +33881,6 @@ 18728 break; 18729 18730 case 1208: 18731- 18732-/* Line 1455 of yacc.c */ 18733 #line 7634 "preproc.y" 18734 { 18735 (yyval.str) = make_str("distinct"); 18736@@ -35837,16 +33888,12 @@ 18737 break; 18738 18739 case 1209: 18740- 18741-/* Line 1455 of yacc.c */ 18742 #line 7638 "preproc.y" 18743 { 18744 (yyval.str)=EMPTY; ;} 18745 break; 18746 18747 case 1210: 18748- 18749-/* Line 1455 of yacc.c */ 18750 #line 7645 "preproc.y" 18751 { 18752 (yyval.str) = make_str("distinct"); 18753@@ -35854,8 +33901,6 @@ 18754 break; 18755 18756 case 1211: 18757- 18758-/* Line 1455 of yacc.c */ 18759 #line 7649 "preproc.y" 18760 { 18761 (yyval.str) = cat_str(3,make_str("distinct on ("),(yyvsp[(4) - (5)].str),make_str(")")); 18762@@ -35863,8 +33908,6 @@ 18763 break; 18764 18765 case 1212: 18766- 18767-/* Line 1455 of yacc.c */ 18768 #line 7653 "preproc.y" 18769 { 18770 (yyval.str) = make_str("all"); 18771@@ -35872,16 +33915,12 @@ 18772 break; 18773 18774 case 1213: 18775- 18776-/* Line 1455 of yacc.c */ 18777 #line 7657 "preproc.y" 18778 { 18779 (yyval.str)=EMPTY; ;} 18780 break; 18781 18782 case 1214: 18783- 18784-/* Line 1455 of yacc.c */ 18785 #line 7664 "preproc.y" 18786 { 18787 (yyval.str) = (yyvsp[(1) - (1)].str); 18788@@ -35889,16 +33928,12 @@ 18789 break; 18790 18791 case 1215: 18792- 18793-/* Line 1455 of yacc.c */ 18794 #line 7668 "preproc.y" 18795 { 18796 (yyval.str)=EMPTY; ;} 18797 break; 18798 18799 case 1216: 18800- 18801-/* Line 1455 of yacc.c */ 18802 #line 7675 "preproc.y" 18803 { 18804 (yyval.str) = cat_str(2,make_str("order by"),(yyvsp[(3) - (3)].str)); 18805@@ -35906,8 +33941,6 @@ 18806 break; 18807 18808 case 1217: 18809- 18810-/* Line 1455 of yacc.c */ 18811 #line 7683 "preproc.y" 18812 { 18813 (yyval.str) = (yyvsp[(1) - (1)].str); 18814@@ -35915,8 +33948,6 @@ 18815 break; 18816 18817 case 1218: 18818- 18819-/* Line 1455 of yacc.c */ 18820 #line 7687 "preproc.y" 18821 { 18822 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 18823@@ -35924,8 +33955,6 @@ 18824 break; 18825 18826 case 1219: 18827- 18828-/* Line 1455 of yacc.c */ 18829 #line 7695 "preproc.y" 18830 { 18831 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),make_str("using"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 18832@@ -35933,8 +33962,6 @@ 18833 break; 18834 18835 case 1220: 18836- 18837-/* Line 1455 of yacc.c */ 18838 #line 7699 "preproc.y" 18839 { 18840 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 18841@@ -35942,8 +33969,6 @@ 18842 break; 18843 18844 case 1221: 18845- 18846-/* Line 1455 of yacc.c */ 18847 #line 7707 "preproc.y" 18848 { 18849 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 18850@@ -35951,8 +33976,6 @@ 18851 break; 18852 18853 case 1222: 18854- 18855-/* Line 1455 of yacc.c */ 18856 #line 7711 "preproc.y" 18857 { 18858 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 18859@@ -35960,8 +33983,6 @@ 18860 break; 18861 18862 case 1223: 18863- 18864-/* Line 1455 of yacc.c */ 18865 #line 7715 "preproc.y" 18866 { 18867 (yyval.str) = (yyvsp[(1) - (1)].str); 18868@@ -35969,8 +33990,6 @@ 18869 break; 18870 18871 case 1224: 18872- 18873-/* Line 1455 of yacc.c */ 18874 #line 7719 "preproc.y" 18875 { 18876 (yyval.str) = (yyvsp[(1) - (1)].str); 18877@@ -35978,8 +33997,6 @@ 18878 break; 18879 18880 case 1225: 18881- 18882-/* Line 1455 of yacc.c */ 18883 #line 7727 "preproc.y" 18884 { 18885 (yyval.str) = (yyvsp[(1) - (1)].str); 18886@@ -35987,16 +34004,12 @@ 18887 break; 18888 18889 case 1226: 18890- 18891-/* Line 1455 of yacc.c */ 18892 #line 7731 "preproc.y" 18893 { 18894 (yyval.str)=EMPTY; ;} 18895 break; 18896 18897 case 1227: 18898- 18899-/* Line 1455 of yacc.c */ 18900 #line 7738 "preproc.y" 18901 { 18902 (yyval.str) = cat_str(2,make_str("limit"),(yyvsp[(2) - (2)].str)); 18903@@ -36004,8 +34017,6 @@ 18904 break; 18905 18906 case 1228: 18907- 18908-/* Line 1455 of yacc.c */ 18909 #line 7742 "preproc.y" 18910 { 18911 mmerror(PARSE_ERROR, ET_WARNING, "no longer supported LIMIT #,# syntax passed to server"); 18912@@ -36014,8 +34025,6 @@ 18913 break; 18914 18915 case 1229: 18916- 18917-/* Line 1455 of yacc.c */ 18918 #line 7747 "preproc.y" 18919 { 18920 (yyval.str) = cat_str(5,make_str("fetch"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),make_str("only")); 18921@@ -36023,8 +34032,6 @@ 18922 break; 18923 18924 case 1230: 18925- 18926-/* Line 1455 of yacc.c */ 18927 #line 7755 "preproc.y" 18928 { 18929 (yyval.str) = cat_str(2,make_str("offset"),(yyvsp[(2) - (2)].str)); 18930@@ -36032,8 +34039,6 @@ 18931 break; 18932 18933 case 1231: 18934- 18935-/* Line 1455 of yacc.c */ 18936 #line 7759 "preproc.y" 18937 { 18938 (yyval.str) = cat_str(3,make_str("offset"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 18939@@ -36041,8 +34046,6 @@ 18940 break; 18941 18942 case 1232: 18943- 18944-/* Line 1455 of yacc.c */ 18945 #line 7767 "preproc.y" 18946 { 18947 (yyval.str) = (yyvsp[(1) - (1)].str); 18948@@ -36050,8 +34053,6 @@ 18949 break; 18950 18951 case 1233: 18952- 18953-/* Line 1455 of yacc.c */ 18954 #line 7771 "preproc.y" 18955 { 18956 (yyval.str) = make_str("all"); 18957@@ -36059,8 +34060,6 @@ 18958 break; 18959 18960 case 1234: 18961- 18962-/* Line 1455 of yacc.c */ 18963 #line 7779 "preproc.y" 18964 { 18965 (yyval.str) = (yyvsp[(1) - (1)].str); 18966@@ -36068,8 +34067,6 @@ 18967 break; 18968 18969 case 1235: 18970- 18971-/* Line 1455 of yacc.c */ 18972 #line 7787 "preproc.y" 18973 { 18974 (yyval.str) = (yyvsp[(1) - (1)].str); 18975@@ -36077,8 +34074,6 @@ 18976 break; 18977 18978 case 1236: 18979- 18980-/* Line 1455 of yacc.c */ 18981 #line 7791 "preproc.y" 18982 { 18983 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 18984@@ -36086,16 +34081,12 @@ 18985 break; 18986 18987 case 1237: 18988- 18989-/* Line 1455 of yacc.c */ 18990 #line 7795 "preproc.y" 18991 { 18992 (yyval.str)=EMPTY; ;} 18993 break; 18994 18995 case 1238: 18996- 18997-/* Line 1455 of yacc.c */ 18998 #line 7802 "preproc.y" 18999 { 19000 (yyval.str) = (yyvsp[(1) - (1)].str); 19001@@ -36103,8 +34094,6 @@ 19002 break; 19003 19004 case 1239: 19005- 19006-/* Line 1455 of yacc.c */ 19007 #line 7810 "preproc.y" 19008 { 19009 (yyval.str) = make_str("row"); 19010@@ -36112,8 +34101,6 @@ 19011 break; 19012 19013 case 1240: 19014- 19015-/* Line 1455 of yacc.c */ 19016 #line 7814 "preproc.y" 19017 { 19018 (yyval.str) = make_str("rows"); 19019@@ -36121,8 +34108,6 @@ 19020 break; 19021 19022 case 1241: 19023- 19024-/* Line 1455 of yacc.c */ 19025 #line 7822 "preproc.y" 19026 { 19027 (yyval.str) = make_str("first"); 19028@@ -36130,8 +34115,6 @@ 19029 break; 19030 19031 case 1242: 19032- 19033-/* Line 1455 of yacc.c */ 19034 #line 7826 "preproc.y" 19035 { 19036 (yyval.str) = make_str("next"); 19037@@ -36139,8 +34122,6 @@ 19038 break; 19039 19040 case 1243: 19041- 19042-/* Line 1455 of yacc.c */ 19043 #line 7834 "preproc.y" 19044 { 19045 (yyval.str) = cat_str(2,make_str("group by"),(yyvsp[(3) - (3)].str)); 19046@@ -36148,16 +34129,12 @@ 19047 break; 19048 19049 case 1244: 19050- 19051-/* Line 1455 of yacc.c */ 19052 #line 7838 "preproc.y" 19053 { 19054 (yyval.str)=EMPTY; ;} 19055 break; 19056 19057 case 1245: 19058- 19059-/* Line 1455 of yacc.c */ 19060 #line 7845 "preproc.y" 19061 { 19062 (yyval.str) = cat_str(2,make_str("having"),(yyvsp[(2) - (2)].str)); 19063@@ -36165,16 +34142,12 @@ 19064 break; 19065 19066 case 1246: 19067- 19068-/* Line 1455 of yacc.c */ 19069 #line 7849 "preproc.y" 19070 { 19071 (yyval.str)=EMPTY; ;} 19072 break; 19073 19074 case 1247: 19075- 19076-/* Line 1455 of yacc.c */ 19077 #line 7856 "preproc.y" 19078 { 19079 (yyval.str) = (yyvsp[(1) - (1)].str); 19080@@ -36182,8 +34155,6 @@ 19081 break; 19082 19083 case 1248: 19084- 19085-/* Line 1455 of yacc.c */ 19086 #line 7860 "preproc.y" 19087 { 19088 (yyval.str) = make_str("for read only"); 19089@@ -36191,8 +34162,6 @@ 19090 break; 19091 19092 case 1249: 19093- 19094-/* Line 1455 of yacc.c */ 19095 #line 7868 "preproc.y" 19096 { 19097 (yyval.str) = (yyvsp[(1) - (1)].str); 19098@@ -36200,16 +34169,12 @@ 19099 break; 19100 19101 case 1250: 19102- 19103-/* Line 1455 of yacc.c */ 19104 #line 7872 "preproc.y" 19105 { 19106 (yyval.str)=EMPTY; ;} 19107 break; 19108 19109 case 1251: 19110- 19111-/* Line 1455 of yacc.c */ 19112 #line 7879 "preproc.y" 19113 { 19114 (yyval.str) = (yyvsp[(1) - (1)].str); 19115@@ -36217,8 +34182,6 @@ 19116 break; 19117 19118 case 1252: 19119- 19120-/* Line 1455 of yacc.c */ 19121 #line 7883 "preproc.y" 19122 { 19123 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 19124@@ -36226,8 +34189,6 @@ 19125 break; 19126 19127 case 1253: 19128- 19129-/* Line 1455 of yacc.c */ 19130 #line 7891 "preproc.y" 19131 { 19132 (yyval.str) = cat_str(3,make_str("for update"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 19133@@ -36235,8 +34196,6 @@ 19134 break; 19135 19136 case 1254: 19137- 19138-/* Line 1455 of yacc.c */ 19139 #line 7895 "preproc.y" 19140 { 19141 (yyval.str) = cat_str(3,make_str("for share"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 19142@@ -36244,8 +34203,6 @@ 19143 break; 19144 19145 case 1255: 19146- 19147-/* Line 1455 of yacc.c */ 19148 #line 7903 "preproc.y" 19149 { 19150 (yyval.str) = cat_str(2,make_str("of"),(yyvsp[(2) - (2)].str)); 19151@@ -36253,16 +34210,12 @@ 19152 break; 19153 19154 case 1256: 19155- 19156-/* Line 1455 of yacc.c */ 19157 #line 7907 "preproc.y" 19158 { 19159 (yyval.str)=EMPTY; ;} 19160 break; 19161 19162 case 1257: 19163- 19164-/* Line 1455 of yacc.c */ 19165 #line 7914 "preproc.y" 19166 { 19167 (yyval.str) = cat_str(2,make_str("values"),(yyvsp[(2) - (2)].str)); 19168@@ -36270,8 +34223,6 @@ 19169 break; 19170 19171 case 1258: 19172- 19173-/* Line 1455 of yacc.c */ 19174 #line 7918 "preproc.y" 19175 { 19176 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 19177@@ -36279,8 +34230,6 @@ 19178 break; 19179 19180 case 1259: 19181- 19182-/* Line 1455 of yacc.c */ 19183 #line 7926 "preproc.y" 19184 { 19185 (yyval.str) = cat_str(2,make_str("from"),(yyvsp[(2) - (2)].str)); 19186@@ -36288,16 +34237,12 @@ 19187 break; 19188 19189 case 1260: 19190- 19191-/* Line 1455 of yacc.c */ 19192 #line 7930 "preproc.y" 19193 { 19194 (yyval.str)=EMPTY; ;} 19195 break; 19196 19197 case 1261: 19198- 19199-/* Line 1455 of yacc.c */ 19200 #line 7937 "preproc.y" 19201 { 19202 (yyval.str) = (yyvsp[(1) - (1)].str); 19203@@ -36305,8 +34250,6 @@ 19204 break; 19205 19206 case 1262: 19207- 19208-/* Line 1455 of yacc.c */ 19209 #line 7941 "preproc.y" 19210 { 19211 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 19212@@ -36314,8 +34257,6 @@ 19213 break; 19214 19215 case 1263: 19216- 19217-/* Line 1455 of yacc.c */ 19218 #line 7949 "preproc.y" 19219 { 19220 (yyval.str) = (yyvsp[(1) - (1)].str); 19221@@ -36323,8 +34264,6 @@ 19222 break; 19223 19224 case 1264: 19225- 19226-/* Line 1455 of yacc.c */ 19227 #line 7953 "preproc.y" 19228 { 19229 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 19230@@ -36332,8 +34271,6 @@ 19231 break; 19232 19233 case 1265: 19234- 19235-/* Line 1455 of yacc.c */ 19236 #line 7957 "preproc.y" 19237 { 19238 (yyval.str) = (yyvsp[(1) - (1)].str); 19239@@ -36341,8 +34278,6 @@ 19240 break; 19241 19242 case 1266: 19243- 19244-/* Line 1455 of yacc.c */ 19245 #line 7961 "preproc.y" 19246 { 19247 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 19248@@ -36350,8 +34285,6 @@ 19249 break; 19250 19251 case 1267: 19252- 19253-/* Line 1455 of yacc.c */ 19254 #line 7965 "preproc.y" 19255 { 19256 (yyval.str) = cat_str(4,(yyvsp[(1) - (5)].str),make_str("as ("),(yyvsp[(4) - (5)].str),make_str(")")); 19257@@ -36359,8 +34292,6 @@ 19258 break; 19259 19260 case 1268: 19261- 19262-/* Line 1455 of yacc.c */ 19263 #line 7969 "preproc.y" 19264 { 19265 (yyval.str) = cat_str(6,(yyvsp[(1) - (6)].str),make_str("as"),(yyvsp[(3) - (6)].str),make_str("("),(yyvsp[(5) - (6)].str),make_str(")")); 19266@@ -36368,8 +34299,6 @@ 19267 break; 19268 19269 case 1269: 19270- 19271-/* Line 1455 of yacc.c */ 19272 #line 7973 "preproc.y" 19273 { 19274 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),(yyvsp[(2) - (5)].str),make_str("("),(yyvsp[(4) - (5)].str),make_str(")")); 19275@@ -36377,8 +34306,6 @@ 19276 break; 19277 19278 case 1270: 19279- 19280-/* Line 1455 of yacc.c */ 19281 #line 7977 "preproc.y" 19282 { 19283 mmerror(PARSE_ERROR, ET_ERROR, "subquery in FROM must have an alias"); 19284@@ -36388,8 +34315,6 @@ 19285 break; 19286 19287 case 1271: 19288- 19289-/* Line 1455 of yacc.c */ 19290 #line 7983 "preproc.y" 19291 { 19292 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 19293@@ -36397,8 +34322,6 @@ 19294 break; 19295 19296 case 1272: 19297- 19298-/* Line 1455 of yacc.c */ 19299 #line 7987 "preproc.y" 19300 { 19301 (yyval.str) = (yyvsp[(1) - (1)].str); 19302@@ -36406,8 +34329,6 @@ 19303 break; 19304 19305 case 1273: 19306- 19307-/* Line 1455 of yacc.c */ 19308 #line 7991 "preproc.y" 19309 { 19310 (yyval.str) = cat_str(4,make_str("("),(yyvsp[(2) - (4)].str),make_str(")"),(yyvsp[(4) - (4)].str)); 19311@@ -36415,8 +34336,6 @@ 19312 break; 19313 19314 case 1274: 19315- 19316-/* Line 1455 of yacc.c */ 19317 #line 7999 "preproc.y" 19318 { 19319 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 19320@@ -36424,8 +34343,6 @@ 19321 break; 19322 19323 case 1275: 19324- 19325-/* Line 1455 of yacc.c */ 19326 #line 8003 "preproc.y" 19327 { 19328 (yyval.str) = cat_str(3,(yyvsp[(1) - (4)].str),make_str("cross join"),(yyvsp[(4) - (4)].str)); 19329@@ -36433,8 +34350,6 @@ 19330 break; 19331 19332 case 1276: 19333- 19334-/* Line 1455 of yacc.c */ 19335 #line 8007 "preproc.y" 19336 { 19337 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),(yyvsp[(2) - (5)].str),make_str("join"),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str)); 19338@@ -36442,8 +34357,6 @@ 19339 break; 19340 19341 case 1277: 19342- 19343-/* Line 1455 of yacc.c */ 19344 #line 8011 "preproc.y" 19345 { 19346 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),make_str("join"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 19347@@ -36451,8 +34364,6 @@ 19348 break; 19349 19350 case 1278: 19351- 19352-/* Line 1455 of yacc.c */ 19353 #line 8015 "preproc.y" 19354 { 19355 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),make_str("natural"),(yyvsp[(3) - (5)].str),make_str("join"),(yyvsp[(5) - (5)].str)); 19356@@ -36460,8 +34371,6 @@ 19357 break; 19358 19359 case 1279: 19360- 19361-/* Line 1455 of yacc.c */ 19362 #line 8019 "preproc.y" 19363 { 19364 (yyval.str) = cat_str(3,(yyvsp[(1) - (4)].str),make_str("natural join"),(yyvsp[(4) - (4)].str)); 19365@@ -36469,8 +34378,6 @@ 19366 break; 19367 19368 case 1280: 19369- 19370-/* Line 1455 of yacc.c */ 19371 #line 8027 "preproc.y" 19372 { 19373 (yyval.str) = cat_str(5,make_str("as"),(yyvsp[(2) - (5)].str),make_str("("),(yyvsp[(4) - (5)].str),make_str(")")); 19374@@ -36478,8 +34385,6 @@ 19375 break; 19376 19377 case 1281: 19378- 19379-/* Line 1455 of yacc.c */ 19380 #line 8031 "preproc.y" 19381 { 19382 (yyval.str) = cat_str(2,make_str("as"),(yyvsp[(2) - (2)].str)); 19383@@ -36487,8 +34392,6 @@ 19384 break; 19385 19386 case 1282: 19387- 19388-/* Line 1455 of yacc.c */ 19389 #line 8035 "preproc.y" 19390 { 19391 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),make_str("("),(yyvsp[(3) - (4)].str),make_str(")")); 19392@@ -36496,8 +34399,6 @@ 19393 break; 19394 19395 case 1283: 19396- 19397-/* Line 1455 of yacc.c */ 19398 #line 8039 "preproc.y" 19399 { 19400 (yyval.str) = (yyvsp[(1) - (1)].str); 19401@@ -36505,8 +34406,6 @@ 19402 break; 19403 19404 case 1284: 19405- 19406-/* Line 1455 of yacc.c */ 19407 #line 8047 "preproc.y" 19408 { 19409 (yyval.str) = cat_str(2,make_str("full"),(yyvsp[(2) - (2)].str)); 19410@@ -36514,8 +34413,6 @@ 19411 break; 19412 19413 case 1285: 19414- 19415-/* Line 1455 of yacc.c */ 19416 #line 8051 "preproc.y" 19417 { 19418 (yyval.str) = cat_str(2,make_str("left"),(yyvsp[(2) - (2)].str)); 19419@@ -36523,8 +34420,6 @@ 19420 break; 19421 19422 case 1286: 19423- 19424-/* Line 1455 of yacc.c */ 19425 #line 8055 "preproc.y" 19426 { 19427 (yyval.str) = cat_str(2,make_str("right"),(yyvsp[(2) - (2)].str)); 19428@@ -36532,8 +34427,6 @@ 19429 break; 19430 19431 case 1287: 19432- 19433-/* Line 1455 of yacc.c */ 19434 #line 8059 "preproc.y" 19435 { 19436 (yyval.str) = make_str("inner"); 19437@@ -36541,8 +34434,6 @@ 19438 break; 19439 19440 case 1288: 19441- 19442-/* Line 1455 of yacc.c */ 19443 #line 8067 "preproc.y" 19444 { 19445 (yyval.str) = make_str("outer"); 19446@@ -36550,16 +34441,12 @@ 19447 break; 19448 19449 case 1289: 19450- 19451-/* Line 1455 of yacc.c */ 19452 #line 8071 "preproc.y" 19453 { 19454 (yyval.str)=EMPTY; ;} 19455 break; 19456 19457 case 1290: 19458- 19459-/* Line 1455 of yacc.c */ 19460 #line 8078 "preproc.y" 19461 { 19462 (yyval.str) = cat_str(3,make_str("using ("),(yyvsp[(3) - (4)].str),make_str(")")); 19463@@ -36567,8 +34454,6 @@ 19464 break; 19465 19466 case 1291: 19467- 19468-/* Line 1455 of yacc.c */ 19469 #line 8082 "preproc.y" 19470 { 19471 (yyval.str) = cat_str(2,make_str("on"),(yyvsp[(2) - (2)].str)); 19472@@ -36576,8 +34461,6 @@ 19473 break; 19474 19475 case 1292: 19476- 19477-/* Line 1455 of yacc.c */ 19478 #line 8090 "preproc.y" 19479 { 19480 (yyval.str) = (yyvsp[(1) - (1)].str); 19481@@ -36585,8 +34468,6 @@ 19482 break; 19483 19484 case 1293: 19485- 19486-/* Line 1455 of yacc.c */ 19487 #line 8094 "preproc.y" 19488 { 19489 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),make_str("*")); 19490@@ -36594,8 +34475,6 @@ 19491 break; 19492 19493 case 1294: 19494- 19495-/* Line 1455 of yacc.c */ 19496 #line 8098 "preproc.y" 19497 { 19498 (yyval.str) = cat_str(2,make_str("only"),(yyvsp[(2) - (2)].str)); 19499@@ -36603,8 +34482,6 @@ 19500 break; 19501 19502 case 1295: 19503- 19504-/* Line 1455 of yacc.c */ 19505 #line 8102 "preproc.y" 19506 { 19507 (yyval.str) = cat_str(3,make_str("only ("),(yyvsp[(3) - (4)].str),make_str(")")); 19508@@ -36612,8 +34489,6 @@ 19509 break; 19510 19511 case 1296: 19512- 19513-/* Line 1455 of yacc.c */ 19514 #line 8110 "preproc.y" 19515 { 19516 (yyval.str) = (yyvsp[(1) - (1)].str); 19517@@ -36621,8 +34496,6 @@ 19518 break; 19519 19520 case 1297: 19521- 19522-/* Line 1455 of yacc.c */ 19523 #line 8114 "preproc.y" 19524 { 19525 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 19526@@ -36630,8 +34503,6 @@ 19527 break; 19528 19529 case 1298: 19530- 19531-/* Line 1455 of yacc.c */ 19532 #line 8122 "preproc.y" 19533 { 19534 (yyval.str) = (yyvsp[(1) - (1)].str); 19535@@ -36639,8 +34510,6 @@ 19536 break; 19537 19538 case 1299: 19539- 19540-/* Line 1455 of yacc.c */ 19541 #line 8126 "preproc.y" 19542 { 19543 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 19544@@ -36648,8 +34517,6 @@ 19545 break; 19546 19547 case 1300: 19548- 19549-/* Line 1455 of yacc.c */ 19550 #line 8130 "preproc.y" 19551 { 19552 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("as"),(yyvsp[(3) - (3)].str)); 19553@@ -36657,8 +34524,6 @@ 19554 break; 19555 19556 case 1301: 19557- 19558-/* Line 1455 of yacc.c */ 19559 #line 8138 "preproc.y" 19560 { 19561 (yyval.str) = (yyvsp[(1) - (1)].str); 19562@@ -36666,8 +34531,6 @@ 19563 break; 19564 19565 case 1302: 19566- 19567-/* Line 1455 of yacc.c */ 19568 #line 8146 "preproc.y" 19569 { 19570 (yyval.str) = cat_str(2,make_str("where"),(yyvsp[(2) - (2)].str)); 19571@@ -36675,16 +34538,12 @@ 19572 break; 19573 19574 case 1303: 19575- 19576-/* Line 1455 of yacc.c */ 19577 #line 8150 "preproc.y" 19578 { 19579 (yyval.str)=EMPTY; ;} 19580 break; 19581 19582 case 1304: 19583- 19584-/* Line 1455 of yacc.c */ 19585 #line 8157 "preproc.y" 19586 { 19587 (yyval.str) = cat_str(2,make_str("where"),(yyvsp[(2) - (2)].str)); 19588@@ -36692,8 +34551,6 @@ 19589 break; 19590 19591 case 1305: 19592- 19593-/* Line 1455 of yacc.c */ 19594 #line 8161 "preproc.y" 19595 { 19596 (yyval.str) = cat_str(2,make_str("where current of"),(yyvsp[(4) - (4)].str)); 19597@@ -36701,16 +34558,12 @@ 19598 break; 19599 19600 case 1306: 19601- 19602-/* Line 1455 of yacc.c */ 19603 #line 8165 "preproc.y" 19604 { 19605 (yyval.str)=EMPTY; ;} 19606 break; 19607 19608 case 1307: 19609- 19610-/* Line 1455 of yacc.c */ 19611 #line 8172 "preproc.y" 19612 { 19613 (yyval.str) = (yyvsp[(1) - (1)].str); 19614@@ -36718,8 +34571,6 @@ 19615 break; 19616 19617 case 1308: 19618- 19619-/* Line 1455 of yacc.c */ 19620 #line 8176 "preproc.y" 19621 { 19622 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 19623@@ -36727,8 +34578,6 @@ 19624 break; 19625 19626 case 1309: 19627- 19628-/* Line 1455 of yacc.c */ 19629 #line 8184 "preproc.y" 19630 { 19631 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 19632@@ -36736,22 +34585,16 @@ 19633 break; 19634 19635 case 1310: 19636- 19637-/* Line 1455 of yacc.c */ 19638 #line 8192 "preproc.y" 19639 { (yyval.str) = cat2_str((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].index).str); ;} 19640 break; 19641 19642 case 1311: 19643- 19644-/* Line 1455 of yacc.c */ 19645 #line 8194 "preproc.y" 19646 { (yyval.str) = cat_str(3, make_str("setof"), (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].index).str); ;} 19647 break; 19648 19649 case 1312: 19650- 19651-/* Line 1455 of yacc.c */ 19652 #line 8196 "preproc.y" 19653 { 19654 (yyval.str) = cat_str(4,(yyvsp[(1) - (5)].str),make_str("array ["),(yyvsp[(4) - (5)].str),make_str("]")); 19655@@ -36759,8 +34602,6 @@ 19656 break; 19657 19658 case 1313: 19659- 19660-/* Line 1455 of yacc.c */ 19661 #line 8200 "preproc.y" 19662 { 19663 (yyval.str) = cat_str(5,make_str("setof"),(yyvsp[(2) - (6)].str),make_str("array ["),(yyvsp[(5) - (6)].str),make_str("]")); 19664@@ -36768,8 +34609,6 @@ 19665 break; 19666 19667 case 1314: 19668- 19669-/* Line 1455 of yacc.c */ 19670 #line 8204 "preproc.y" 19671 { 19672 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),make_str("array")); 19673@@ -36777,8 +34616,6 @@ 19674 break; 19675 19676 case 1315: 19677- 19678-/* Line 1455 of yacc.c */ 19679 #line 8208 "preproc.y" 19680 { 19681 (yyval.str) = cat_str(3,make_str("setof"),(yyvsp[(2) - (3)].str),make_str("array")); 19682@@ -36786,8 +34623,6 @@ 19683 break; 19684 19685 case 1316: 19686- 19687-/* Line 1455 of yacc.c */ 19688 #line 8216 "preproc.y" 19689 { 19690 (yyval.index).index1 = (yyvsp[(1) - (3)].index).index1; 19691@@ -36801,8 +34636,6 @@ 19692 break; 19693 19694 case 1317: 19695- 19696-/* Line 1455 of yacc.c */ 19697 #line 8226 "preproc.y" 19698 { 19699 (yyval.index).index1 = (yyvsp[(1) - (4)].index).index1; 19700@@ -36816,8 +34649,6 @@ 19701 break; 19702 19703 case 1318: 19704- 19705-/* Line 1455 of yacc.c */ 19706 #line 8236 "preproc.y" 19707 { 19708 (yyval.index).index1 = make_str("-1"); 19709@@ -36827,8 +34658,6 @@ 19710 break; 19711 19712 case 1319: 19713- 19714-/* Line 1455 of yacc.c */ 19715 #line 8246 "preproc.y" 19716 { 19717 (yyval.str) = (yyvsp[(1) - (1)].str); 19718@@ -36836,8 +34665,6 @@ 19719 break; 19720 19721 case 1320: 19722- 19723-/* Line 1455 of yacc.c */ 19724 #line 8250 "preproc.y" 19725 { 19726 (yyval.str) = (yyvsp[(1) - (1)].str); 19727@@ -36845,8 +34672,6 @@ 19728 break; 19729 19730 case 1321: 19731- 19732-/* Line 1455 of yacc.c */ 19733 #line 8254 "preproc.y" 19734 { 19735 (yyval.str) = (yyvsp[(1) - (1)].str); 19736@@ -36854,8 +34679,6 @@ 19737 break; 19738 19739 case 1322: 19740- 19741-/* Line 1455 of yacc.c */ 19742 #line 8258 "preproc.y" 19743 { 19744 (yyval.str) = (yyvsp[(1) - (1)].str); 19745@@ -36863,8 +34686,6 @@ 19746 break; 19747 19748 case 1323: 19749- 19750-/* Line 1455 of yacc.c */ 19751 #line 8262 "preproc.y" 19752 { 19753 (yyval.str) = (yyvsp[(1) - (1)].str); 19754@@ -36872,8 +34693,6 @@ 19755 break; 19756 19757 case 1324: 19758- 19759-/* Line 1455 of yacc.c */ 19760 #line 8266 "preproc.y" 19761 { 19762 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 19763@@ -36881,8 +34700,6 @@ 19764 break; 19765 19766 case 1325: 19767- 19768-/* Line 1455 of yacc.c */ 19769 #line 8270 "preproc.y" 19770 { 19771 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),make_str("("),(yyvsp[(3) - (5)].str),make_str(")"),(yyvsp[(5) - (5)].str)); 19772@@ -36890,8 +34707,6 @@ 19773 break; 19774 19775 case 1326: 19776- 19777-/* Line 1455 of yacc.c */ 19778 #line 8278 "preproc.y" 19779 { 19780 (yyval.str) = (yyvsp[(1) - (1)].str); 19781@@ -36899,8 +34714,6 @@ 19782 break; 19783 19784 case 1327: 19785- 19786-/* Line 1455 of yacc.c */ 19787 #line 8282 "preproc.y" 19788 { 19789 (yyval.str) = (yyvsp[(1) - (1)].str); 19790@@ -36908,8 +34721,6 @@ 19791 break; 19792 19793 case 1328: 19794- 19795-/* Line 1455 of yacc.c */ 19796 #line 8286 "preproc.y" 19797 { 19798 (yyval.str) = (yyvsp[(1) - (1)].str); 19799@@ -36917,8 +34728,6 @@ 19800 break; 19801 19802 case 1329: 19803- 19804-/* Line 1455 of yacc.c */ 19805 #line 8290 "preproc.y" 19806 { 19807 (yyval.str) = (yyvsp[(1) - (1)].str); 19808@@ -36926,8 +34735,6 @@ 19809 break; 19810 19811 case 1330: 19812- 19813-/* Line 1455 of yacc.c */ 19814 #line 8298 "preproc.y" 19815 { 19816 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 19817@@ -36935,8 +34742,6 @@ 19818 break; 19819 19820 case 1331: 19821- 19822-/* Line 1455 of yacc.c */ 19823 #line 8302 "preproc.y" 19824 { 19825 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 19826@@ -36944,8 +34749,6 @@ 19827 break; 19828 19829 case 1332: 19830- 19831-/* Line 1455 of yacc.c */ 19832 #line 8310 "preproc.y" 19833 { 19834 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 19835@@ -36953,16 +34756,12 @@ 19836 break; 19837 19838 case 1333: 19839- 19840-/* Line 1455 of yacc.c */ 19841 #line 8314 "preproc.y" 19842 { 19843 (yyval.str)=EMPTY; ;} 19844 break; 19845 19846 case 1334: 19847- 19848-/* Line 1455 of yacc.c */ 19849 #line 8321 "preproc.y" 19850 { 19851 (yyval.str) = make_str("int"); 19852@@ -36970,8 +34769,6 @@ 19853 break; 19854 19855 case 1335: 19856- 19857-/* Line 1455 of yacc.c */ 19858 #line 8325 "preproc.y" 19859 { 19860 (yyval.str) = make_str("integer"); 19861@@ -36979,8 +34776,6 @@ 19862 break; 19863 19864 case 1336: 19865- 19866-/* Line 1455 of yacc.c */ 19867 #line 8329 "preproc.y" 19868 { 19869 (yyval.str) = make_str("smallint"); 19870@@ -36988,8 +34783,6 @@ 19871 break; 19872 19873 case 1337: 19874- 19875-/* Line 1455 of yacc.c */ 19876 #line 8333 "preproc.y" 19877 { 19878 (yyval.str) = make_str("bigint"); 19879@@ -36997,8 +34790,6 @@ 19880 break; 19881 19882 case 1338: 19883- 19884-/* Line 1455 of yacc.c */ 19885 #line 8337 "preproc.y" 19886 { 19887 (yyval.str) = make_str("real"); 19888@@ -37006,8 +34797,6 @@ 19889 break; 19890 19891 case 1339: 19892- 19893-/* Line 1455 of yacc.c */ 19894 #line 8341 "preproc.y" 19895 { 19896 (yyval.str) = cat_str(2,make_str("float"),(yyvsp[(2) - (2)].str)); 19897@@ -37015,8 +34804,6 @@ 19898 break; 19899 19900 case 1340: 19901- 19902-/* Line 1455 of yacc.c */ 19903 #line 8345 "preproc.y" 19904 { 19905 (yyval.str) = make_str("double precision"); 19906@@ -37024,8 +34811,6 @@ 19907 break; 19908 19909 case 1341: 19910- 19911-/* Line 1455 of yacc.c */ 19912 #line 8349 "preproc.y" 19913 { 19914 (yyval.str) = cat_str(2,make_str("decimal"),(yyvsp[(2) - (2)].str)); 19915@@ -37033,8 +34818,6 @@ 19916 break; 19917 19918 case 1342: 19919- 19920-/* Line 1455 of yacc.c */ 19921 #line 8353 "preproc.y" 19922 { 19923 (yyval.str) = cat_str(2,make_str("dec"),(yyvsp[(2) - (2)].str)); 19924@@ -37042,8 +34825,6 @@ 19925 break; 19926 19927 case 1343: 19928- 19929-/* Line 1455 of yacc.c */ 19930 #line 8357 "preproc.y" 19931 { 19932 (yyval.str) = cat_str(2,make_str("numeric"),(yyvsp[(2) - (2)].str)); 19933@@ -37051,8 +34832,6 @@ 19934 break; 19935 19936 case 1344: 19937- 19938-/* Line 1455 of yacc.c */ 19939 #line 8361 "preproc.y" 19940 { 19941 (yyval.str) = make_str("boolean"); 19942@@ -37060,8 +34839,6 @@ 19943 break; 19944 19945 case 1345: 19946- 19947-/* Line 1455 of yacc.c */ 19948 #line 8369 "preproc.y" 19949 { 19950 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 19951@@ -37069,16 +34846,12 @@ 19952 break; 19953 19954 case 1346: 19955- 19956-/* Line 1455 of yacc.c */ 19957 #line 8373 "preproc.y" 19958 { 19959 (yyval.str)=EMPTY; ;} 19960 break; 19961 19962 case 1347: 19963- 19964-/* Line 1455 of yacc.c */ 19965 #line 8380 "preproc.y" 19966 { 19967 (yyval.str) = (yyvsp[(1) - (1)].str); 19968@@ -37086,8 +34859,6 @@ 19969 break; 19970 19971 case 1348: 19972- 19973-/* Line 1455 of yacc.c */ 19974 #line 8384 "preproc.y" 19975 { 19976 (yyval.str) = (yyvsp[(1) - (1)].str); 19977@@ -37095,8 +34866,6 @@ 19978 break; 19979 19980 case 1349: 19981- 19982-/* Line 1455 of yacc.c */ 19983 #line 8392 "preproc.y" 19984 { 19985 (yyval.str) = (yyvsp[(1) - (1)].str); 19986@@ -37104,8 +34873,6 @@ 19987 break; 19988 19989 case 1350: 19990- 19991-/* Line 1455 of yacc.c */ 19992 #line 8396 "preproc.y" 19993 { 19994 (yyval.str) = (yyvsp[(1) - (1)].str); 19995@@ -37113,8 +34880,6 @@ 19996 break; 19997 19998 case 1351: 19999- 20000-/* Line 1455 of yacc.c */ 20001 #line 8404 "preproc.y" 20002 { 20003 (yyval.str) = cat_str(5,make_str("bit"),(yyvsp[(2) - (5)].str),make_str("("),(yyvsp[(4) - (5)].str),make_str(")")); 20004@@ -37122,8 +34887,6 @@ 20005 break; 20006 20007 case 1352: 20008- 20009-/* Line 1455 of yacc.c */ 20010 #line 8412 "preproc.y" 20011 { 20012 (yyval.str) = cat_str(2,make_str("bit"),(yyvsp[(2) - (2)].str)); 20013@@ -37131,8 +34894,6 @@ 20014 break; 20015 20016 case 1353: 20017- 20018-/* Line 1455 of yacc.c */ 20019 #line 8420 "preproc.y" 20020 { 20021 (yyval.str) = (yyvsp[(1) - (1)].str); 20022@@ -37140,8 +34901,6 @@ 20023 break; 20024 20025 case 1354: 20026- 20027-/* Line 1455 of yacc.c */ 20028 #line 8424 "preproc.y" 20029 { 20030 (yyval.str) = (yyvsp[(1) - (1)].str); 20031@@ -37149,8 +34908,6 @@ 20032 break; 20033 20034 case 1355: 20035- 20036-/* Line 1455 of yacc.c */ 20037 #line 8432 "preproc.y" 20038 { 20039 (yyval.str) = (yyvsp[(1) - (1)].str); 20040@@ -37158,8 +34915,6 @@ 20041 break; 20042 20043 case 1356: 20044- 20045-/* Line 1455 of yacc.c */ 20046 #line 8436 "preproc.y" 20047 { 20048 (yyval.str) = (yyvsp[(1) - (1)].str); 20049@@ -37167,8 +34922,6 @@ 20050 break; 20051 20052 case 1357: 20053- 20054-/* Line 1455 of yacc.c */ 20055 #line 8444 "preproc.y" 20056 { 20057 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),make_str("("),(yyvsp[(3) - (5)].str),make_str(")"),(yyvsp[(5) - (5)].str)); 20058@@ -37176,8 +34929,6 @@ 20059 break; 20060 20061 case 1358: 20062- 20063-/* Line 1455 of yacc.c */ 20064 #line 8452 "preproc.y" 20065 { 20066 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 20067@@ -37185,8 +34936,6 @@ 20068 break; 20069 20070 case 1359: 20071- 20072-/* Line 1455 of yacc.c */ 20073 #line 8460 "preproc.y" 20074 { 20075 (yyval.str) = cat_str(2,make_str("character"),(yyvsp[(2) - (2)].str)); 20076@@ -37194,8 +34943,6 @@ 20077 break; 20078 20079 case 1360: 20080- 20081-/* Line 1455 of yacc.c */ 20082 #line 8464 "preproc.y" 20083 { 20084 (yyval.str) = cat_str(2,make_str("char"),(yyvsp[(2) - (2)].str)); 20085@@ -37203,8 +34950,6 @@ 20086 break; 20087 20088 case 1361: 20089- 20090-/* Line 1455 of yacc.c */ 20091 #line 8468 "preproc.y" 20092 { 20093 (yyval.str) = make_str("varchar"); 20094@@ -37212,8 +34957,6 @@ 20095 break; 20096 20097 case 1362: 20098- 20099-/* Line 1455 of yacc.c */ 20100 #line 8472 "preproc.y" 20101 { 20102 (yyval.str) = cat_str(2,make_str("national character"),(yyvsp[(3) - (3)].str)); 20103@@ -37221,8 +34964,6 @@ 20104 break; 20105 20106 case 1363: 20107- 20108-/* Line 1455 of yacc.c */ 20109 #line 8476 "preproc.y" 20110 { 20111 (yyval.str) = cat_str(2,make_str("national char"),(yyvsp[(3) - (3)].str)); 20112@@ -37230,8 +34971,6 @@ 20113 break; 20114 20115 case 1364: 20116- 20117-/* Line 1455 of yacc.c */ 20118 #line 8480 "preproc.y" 20119 { 20120 (yyval.str) = cat_str(2,make_str("nchar"),(yyvsp[(2) - (2)].str)); 20121@@ -37239,8 +34978,6 @@ 20122 break; 20123 20124 case 1365: 20125- 20126-/* Line 1455 of yacc.c */ 20127 #line 8488 "preproc.y" 20128 { 20129 (yyval.str) = make_str("varying"); 20130@@ -37248,16 +34985,12 @@ 20131 break; 20132 20133 case 1366: 20134- 20135-/* Line 1455 of yacc.c */ 20136 #line 8492 "preproc.y" 20137 { 20138 (yyval.str)=EMPTY; ;} 20139 break; 20140 20141 case 1367: 20142- 20143-/* Line 1455 of yacc.c */ 20144 #line 8499 "preproc.y" 20145 { 20146 (yyval.str) = cat_str(2,make_str("character set"),(yyvsp[(3) - (3)].str)); 20147@@ -37265,16 +34998,12 @@ 20148 break; 20149 20150 case 1368: 20151- 20152-/* Line 1455 of yacc.c */ 20153 #line 8503 "preproc.y" 20154 { 20155 (yyval.str)=EMPTY; ;} 20156 break; 20157 20158 case 1369: 20159- 20160-/* Line 1455 of yacc.c */ 20161 #line 8510 "preproc.y" 20162 { 20163 (yyval.str) = cat_str(4,make_str("timestamp ("),(yyvsp[(3) - (5)].str),make_str(")"),(yyvsp[(5) - (5)].str)); 20164@@ -37282,8 +35011,6 @@ 20165 break; 20166 20167 case 1370: 20168- 20169-/* Line 1455 of yacc.c */ 20170 #line 8514 "preproc.y" 20171 { 20172 (yyval.str) = cat_str(2,make_str("timestamp"),(yyvsp[(2) - (2)].str)); 20173@@ -37291,8 +35018,6 @@ 20174 break; 20175 20176 case 1371: 20177- 20178-/* Line 1455 of yacc.c */ 20179 #line 8518 "preproc.y" 20180 { 20181 (yyval.str) = cat_str(4,make_str("time ("),(yyvsp[(3) - (5)].str),make_str(")"),(yyvsp[(5) - (5)].str)); 20182@@ -37300,8 +35025,6 @@ 20183 break; 20184 20185 case 1372: 20186- 20187-/* Line 1455 of yacc.c */ 20188 #line 8522 "preproc.y" 20189 { 20190 (yyval.str) = cat_str(2,make_str("time"),(yyvsp[(2) - (2)].str)); 20191@@ -37309,8 +35032,6 @@ 20192 break; 20193 20194 case 1373: 20195- 20196-/* Line 1455 of yacc.c */ 20197 #line 8530 "preproc.y" 20198 { 20199 (yyval.str) = make_str("interval"); 20200@@ -37318,8 +35039,6 @@ 20201 break; 20202 20203 case 1374: 20204- 20205-/* Line 1455 of yacc.c */ 20206 #line 8538 "preproc.y" 20207 { 20208 (yyval.str) = make_str("with time zone"); 20209@@ -37327,8 +35046,6 @@ 20210 break; 20211 20212 case 1375: 20213- 20214-/* Line 1455 of yacc.c */ 20215 #line 8542 "preproc.y" 20216 { 20217 (yyval.str) = make_str("without time zone"); 20218@@ -37336,16 +35053,12 @@ 20219 break; 20220 20221 case 1376: 20222- 20223-/* Line 1455 of yacc.c */ 20224 #line 8546 "preproc.y" 20225 { 20226 (yyval.str)=EMPTY; ;} 20227 break; 20228 20229 case 1377: 20230- 20231-/* Line 1455 of yacc.c */ 20232 #line 8553 "preproc.y" 20233 { 20234 (yyval.str) = make_str("year"); 20235@@ -37353,8 +35066,6 @@ 20236 break; 20237 20238 case 1378: 20239- 20240-/* Line 1455 of yacc.c */ 20241 #line 8557 "preproc.y" 20242 { 20243 (yyval.str) = make_str("month"); 20244@@ -37362,8 +35073,6 @@ 20245 break; 20246 20247 case 1379: 20248- 20249-/* Line 1455 of yacc.c */ 20250 #line 8561 "preproc.y" 20251 { 20252 (yyval.str) = make_str("day"); 20253@@ -37371,8 +35080,6 @@ 20254 break; 20255 20256 case 1380: 20257- 20258-/* Line 1455 of yacc.c */ 20259 #line 8565 "preproc.y" 20260 { 20261 (yyval.str) = make_str("hour"); 20262@@ -37380,8 +35087,6 @@ 20263 break; 20264 20265 case 1381: 20266- 20267-/* Line 1455 of yacc.c */ 20268 #line 8569 "preproc.y" 20269 { 20270 (yyval.str) = make_str("minute"); 20271@@ -37389,8 +35094,6 @@ 20272 break; 20273 20274 case 1382: 20275- 20276-/* Line 1455 of yacc.c */ 20277 #line 8573 "preproc.y" 20278 { 20279 (yyval.str) = (yyvsp[(1) - (1)].str); 20280@@ -37398,8 +35101,6 @@ 20281 break; 20282 20283 case 1383: 20284- 20285-/* Line 1455 of yacc.c */ 20286 #line 8577 "preproc.y" 20287 { 20288 (yyval.str) = make_str("year to month"); 20289@@ -37407,8 +35108,6 @@ 20290 break; 20291 20292 case 1384: 20293- 20294-/* Line 1455 of yacc.c */ 20295 #line 8581 "preproc.y" 20296 { 20297 (yyval.str) = make_str("day to hour"); 20298@@ -37416,8 +35115,6 @@ 20299 break; 20300 20301 case 1385: 20302- 20303-/* Line 1455 of yacc.c */ 20304 #line 8585 "preproc.y" 20305 { 20306 (yyval.str) = make_str("day to minute"); 20307@@ -37425,8 +35122,6 @@ 20308 break; 20309 20310 case 1386: 20311- 20312-/* Line 1455 of yacc.c */ 20313 #line 8589 "preproc.y" 20314 { 20315 (yyval.str) = cat_str(2,make_str("day to"),(yyvsp[(3) - (3)].str)); 20316@@ -37434,8 +35129,6 @@ 20317 break; 20318 20319 case 1387: 20320- 20321-/* Line 1455 of yacc.c */ 20322 #line 8593 "preproc.y" 20323 { 20324 (yyval.str) = make_str("hour to minute"); 20325@@ -37443,8 +35136,6 @@ 20326 break; 20327 20328 case 1388: 20329- 20330-/* Line 1455 of yacc.c */ 20331 #line 8597 "preproc.y" 20332 { 20333 (yyval.str) = cat_str(2,make_str("hour to"),(yyvsp[(3) - (3)].str)); 20334@@ -37452,8 +35143,6 @@ 20335 break; 20336 20337 case 1389: 20338- 20339-/* Line 1455 of yacc.c */ 20340 #line 8601 "preproc.y" 20341 { 20342 (yyval.str) = cat_str(2,make_str("minute to"),(yyvsp[(3) - (3)].str)); 20343@@ -37461,16 +35150,12 @@ 20344 break; 20345 20346 case 1390: 20347- 20348-/* Line 1455 of yacc.c */ 20349 #line 8605 "preproc.y" 20350 { 20351 (yyval.str)=EMPTY; ;} 20352 break; 20353 20354 case 1391: 20355- 20356-/* Line 1455 of yacc.c */ 20357 #line 8612 "preproc.y" 20358 { 20359 (yyval.str) = make_str("second"); 20360@@ -37478,8 +35163,6 @@ 20361 break; 20362 20363 case 1392: 20364- 20365-/* Line 1455 of yacc.c */ 20366 #line 8616 "preproc.y" 20367 { 20368 (yyval.str) = cat_str(3,make_str("second ("),(yyvsp[(3) - (4)].str),make_str(")")); 20369@@ -37487,8 +35170,6 @@ 20370 break; 20371 20372 case 1393: 20373- 20374-/* Line 1455 of yacc.c */ 20375 #line 8624 "preproc.y" 20376 { 20377 (yyval.str) = (yyvsp[(1) - (1)].str); 20378@@ -37496,8 +35177,6 @@ 20379 break; 20380 20381 case 1394: 20382- 20383-/* Line 1455 of yacc.c */ 20384 #line 8628 "preproc.y" 20385 { 20386 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("::"),(yyvsp[(3) - (3)].str)); 20387@@ -37505,8 +35184,6 @@ 20388 break; 20389 20390 case 1395: 20391- 20392-/* Line 1455 of yacc.c */ 20393 #line 8632 "preproc.y" 20394 { 20395 (yyval.str) = cat_str(3,(yyvsp[(1) - (5)].str),make_str("at time zone"),(yyvsp[(5) - (5)].str)); 20396@@ -37514,8 +35191,6 @@ 20397 break; 20398 20399 case 1396: 20400- 20401-/* Line 1455 of yacc.c */ 20402 #line 8636 "preproc.y" 20403 { 20404 (yyval.str) = cat_str(2,make_str("+"),(yyvsp[(2) - (2)].str)); 20405@@ -37523,8 +35198,6 @@ 20406 break; 20407 20408 case 1397: 20409- 20410-/* Line 1455 of yacc.c */ 20411 #line 8640 "preproc.y" 20412 { 20413 (yyval.str) = cat_str(2,make_str("-"),(yyvsp[(2) - (2)].str)); 20414@@ -37532,8 +35205,6 @@ 20415 break; 20416 20417 case 1398: 20418- 20419-/* Line 1455 of yacc.c */ 20420 #line 8644 "preproc.y" 20421 { 20422 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("+"),(yyvsp[(3) - (3)].str)); 20423@@ -37541,8 +35212,6 @@ 20424 break; 20425 20426 case 1399: 20427- 20428-/* Line 1455 of yacc.c */ 20429 #line 8648 "preproc.y" 20430 { 20431 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("-"),(yyvsp[(3) - (3)].str)); 20432@@ -37550,8 +35219,6 @@ 20433 break; 20434 20435 case 1400: 20436- 20437-/* Line 1455 of yacc.c */ 20438 #line 8652 "preproc.y" 20439 { 20440 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("*"),(yyvsp[(3) - (3)].str)); 20441@@ -37559,8 +35226,6 @@ 20442 break; 20443 20444 case 1401: 20445- 20446-/* Line 1455 of yacc.c */ 20447 #line 8656 "preproc.y" 20448 { 20449 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("/"),(yyvsp[(3) - (3)].str)); 20450@@ -37568,8 +35233,6 @@ 20451 break; 20452 20453 case 1402: 20454- 20455-/* Line 1455 of yacc.c */ 20456 #line 8660 "preproc.y" 20457 { 20458 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("%"),(yyvsp[(3) - (3)].str)); 20459@@ -37577,8 +35240,6 @@ 20460 break; 20461 20462 case 1403: 20463- 20464-/* Line 1455 of yacc.c */ 20465 #line 8664 "preproc.y" 20466 { 20467 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("^"),(yyvsp[(3) - (3)].str)); 20468@@ -37586,8 +35247,6 @@ 20469 break; 20470 20471 case 1404: 20472- 20473-/* Line 1455 of yacc.c */ 20474 #line 8668 "preproc.y" 20475 { 20476 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("<"),(yyvsp[(3) - (3)].str)); 20477@@ -37595,8 +35254,6 @@ 20478 break; 20479 20480 case 1405: 20481- 20482-/* Line 1455 of yacc.c */ 20483 #line 8672 "preproc.y" 20484 { 20485 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(">"),(yyvsp[(3) - (3)].str)); 20486@@ -37604,8 +35261,6 @@ 20487 break; 20488 20489 case 1406: 20490- 20491-/* Line 1455 of yacc.c */ 20492 #line 8676 "preproc.y" 20493 { 20494 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("="),(yyvsp[(3) - (3)].str)); 20495@@ -37613,8 +35268,6 @@ 20496 break; 20497 20498 case 1407: 20499- 20500-/* Line 1455 of yacc.c */ 20501 #line 8680 "preproc.y" 20502 { 20503 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 20504@@ -37622,8 +35275,6 @@ 20505 break; 20506 20507 case 1408: 20508- 20509-/* Line 1455 of yacc.c */ 20510 #line 8684 "preproc.y" 20511 { 20512 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 20513@@ -37631,8 +35282,6 @@ 20514 break; 20515 20516 case 1409: 20517- 20518-/* Line 1455 of yacc.c */ 20519 #line 8688 "preproc.y" 20520 { 20521 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 20522@@ -37640,8 +35289,6 @@ 20523 break; 20524 20525 case 1410: 20526- 20527-/* Line 1455 of yacc.c */ 20528 #line 8692 "preproc.y" 20529 { 20530 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("and"),(yyvsp[(3) - (3)].str)); 20531@@ -37649,8 +35296,6 @@ 20532 break; 20533 20534 case 1411: 20535- 20536-/* Line 1455 of yacc.c */ 20537 #line 8696 "preproc.y" 20538 { 20539 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("or"),(yyvsp[(3) - (3)].str)); 20540@@ -37658,8 +35303,6 @@ 20541 break; 20542 20543 case 1412: 20544- 20545-/* Line 1455 of yacc.c */ 20546 #line 8700 "preproc.y" 20547 { 20548 (yyval.str) = cat_str(2,make_str("not"),(yyvsp[(2) - (2)].str)); 20549@@ -37667,8 +35310,6 @@ 20550 break; 20551 20552 case 1413: 20553- 20554-/* Line 1455 of yacc.c */ 20555 #line 8704 "preproc.y" 20556 { 20557 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("like"),(yyvsp[(3) - (3)].str)); 20558@@ -37676,8 +35317,6 @@ 20559 break; 20560 20561 case 1414: 20562- 20563-/* Line 1455 of yacc.c */ 20564 #line 8708 "preproc.y" 20565 { 20566 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),make_str("like"),(yyvsp[(3) - (5)].str),make_str("escape"),(yyvsp[(5) - (5)].str)); 20567@@ -37685,8 +35324,6 @@ 20568 break; 20569 20570 case 1415: 20571- 20572-/* Line 1455 of yacc.c */ 20573 #line 8712 "preproc.y" 20574 { 20575 (yyval.str) = cat_str(3,(yyvsp[(1) - (4)].str),make_str("not like"),(yyvsp[(4) - (4)].str)); 20576@@ -37694,8 +35331,6 @@ 20577 break; 20578 20579 case 1416: 20580- 20581-/* Line 1455 of yacc.c */ 20582 #line 8716 "preproc.y" 20583 { 20584 (yyval.str) = cat_str(5,(yyvsp[(1) - (6)].str),make_str("not like"),(yyvsp[(4) - (6)].str),make_str("escape"),(yyvsp[(6) - (6)].str)); 20585@@ -37703,8 +35338,6 @@ 20586 break; 20587 20588 case 1417: 20589- 20590-/* Line 1455 of yacc.c */ 20591 #line 8720 "preproc.y" 20592 { 20593 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("ilike"),(yyvsp[(3) - (3)].str)); 20594@@ -37712,8 +35345,6 @@ 20595 break; 20596 20597 case 1418: 20598- 20599-/* Line 1455 of yacc.c */ 20600 #line 8724 "preproc.y" 20601 { 20602 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),make_str("ilike"),(yyvsp[(3) - (5)].str),make_str("escape"),(yyvsp[(5) - (5)].str)); 20603@@ -37721,8 +35352,6 @@ 20604 break; 20605 20606 case 1419: 20607- 20608-/* Line 1455 of yacc.c */ 20609 #line 8728 "preproc.y" 20610 { 20611 (yyval.str) = cat_str(3,(yyvsp[(1) - (4)].str),make_str("not ilike"),(yyvsp[(4) - (4)].str)); 20612@@ -37730,8 +35359,6 @@ 20613 break; 20614 20615 case 1420: 20616- 20617-/* Line 1455 of yacc.c */ 20618 #line 8732 "preproc.y" 20619 { 20620 (yyval.str) = cat_str(5,(yyvsp[(1) - (6)].str),make_str("not ilike"),(yyvsp[(4) - (6)].str),make_str("escape"),(yyvsp[(6) - (6)].str)); 20621@@ -37739,8 +35366,6 @@ 20622 break; 20623 20624 case 1421: 20625- 20626-/* Line 1455 of yacc.c */ 20627 #line 8736 "preproc.y" 20628 { 20629 (yyval.str) = cat_str(3,(yyvsp[(1) - (4)].str),make_str("similar to"),(yyvsp[(4) - (4)].str)); 20630@@ -37748,8 +35373,6 @@ 20631 break; 20632 20633 case 1422: 20634- 20635-/* Line 1455 of yacc.c */ 20636 #line 8740 "preproc.y" 20637 { 20638 (yyval.str) = cat_str(5,(yyvsp[(1) - (6)].str),make_str("similar to"),(yyvsp[(4) - (6)].str),make_str("escape"),(yyvsp[(6) - (6)].str)); 20639@@ -37757,8 +35380,6 @@ 20640 break; 20641 20642 case 1423: 20643- 20644-/* Line 1455 of yacc.c */ 20645 #line 8744 "preproc.y" 20646 { 20647 (yyval.str) = cat_str(3,(yyvsp[(1) - (5)].str),make_str("not similar to"),(yyvsp[(5) - (5)].str)); 20648@@ -37766,8 +35387,6 @@ 20649 break; 20650 20651 case 1424: 20652- 20653-/* Line 1455 of yacc.c */ 20654 #line 8748 "preproc.y" 20655 { 20656 (yyval.str) = cat_str(5,(yyvsp[(1) - (7)].str),make_str("not similar to"),(yyvsp[(5) - (7)].str),make_str("escape"),(yyvsp[(7) - (7)].str)); 20657@@ -37775,8 +35394,6 @@ 20658 break; 20659 20660 case 1425: 20661- 20662-/* Line 1455 of yacc.c */ 20663 #line 8752 "preproc.y" 20664 { 20665 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("is null")); 20666@@ -37784,8 +35401,6 @@ 20667 break; 20668 20669 case 1426: 20670- 20671-/* Line 1455 of yacc.c */ 20672 #line 8756 "preproc.y" 20673 { 20674 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),make_str("isnull")); 20675@@ -37793,8 +35408,6 @@ 20676 break; 20677 20678 case 1427: 20679- 20680-/* Line 1455 of yacc.c */ 20681 #line 8760 "preproc.y" 20682 { 20683 (yyval.str) = cat_str(2,(yyvsp[(1) - (4)].str),make_str("is not null")); 20684@@ -37802,8 +35415,6 @@ 20685 break; 20686 20687 case 1428: 20688- 20689-/* Line 1455 of yacc.c */ 20690 #line 8764 "preproc.y" 20691 { 20692 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),make_str("notnull")); 20693@@ -37811,8 +35422,6 @@ 20694 break; 20695 20696 case 1429: 20697- 20698-/* Line 1455 of yacc.c */ 20699 #line 8768 "preproc.y" 20700 { 20701 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("overlaps"),(yyvsp[(3) - (3)].str)); 20702@@ -37820,8 +35429,6 @@ 20703 break; 20704 20705 case 1430: 20706- 20707-/* Line 1455 of yacc.c */ 20708 #line 8772 "preproc.y" 20709 { 20710 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("is true")); 20711@@ -37829,8 +35436,6 @@ 20712 break; 20713 20714 case 1431: 20715- 20716-/* Line 1455 of yacc.c */ 20717 #line 8776 "preproc.y" 20718 { 20719 (yyval.str) = cat_str(2,(yyvsp[(1) - (4)].str),make_str("is not true")); 20720@@ -37838,8 +35443,6 @@ 20721 break; 20722 20723 case 1432: 20724- 20725-/* Line 1455 of yacc.c */ 20726 #line 8780 "preproc.y" 20727 { 20728 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("is false")); 20729@@ -37847,8 +35450,6 @@ 20730 break; 20731 20732 case 1433: 20733- 20734-/* Line 1455 of yacc.c */ 20735 #line 8784 "preproc.y" 20736 { 20737 (yyval.str) = cat_str(2,(yyvsp[(1) - (4)].str),make_str("is not false")); 20738@@ -37856,8 +35457,6 @@ 20739 break; 20740 20741 case 1434: 20742- 20743-/* Line 1455 of yacc.c */ 20744 #line 8788 "preproc.y" 20745 { 20746 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("is unknown")); 20747@@ -37865,8 +35464,6 @@ 20748 break; 20749 20750 case 1435: 20751- 20752-/* Line 1455 of yacc.c */ 20753 #line 8792 "preproc.y" 20754 { 20755 (yyval.str) = cat_str(2,(yyvsp[(1) - (4)].str),make_str("is not unknown")); 20756@@ -37874,8 +35471,6 @@ 20757 break; 20758 20759 case 1436: 20760- 20761-/* Line 1455 of yacc.c */ 20762 #line 8796 "preproc.y" 20763 { 20764 (yyval.str) = cat_str(3,(yyvsp[(1) - (5)].str),make_str("is distinct from"),(yyvsp[(5) - (5)].str)); 20765@@ -37883,8 +35478,6 @@ 20766 break; 20767 20768 case 1437: 20769- 20770-/* Line 1455 of yacc.c */ 20771 #line 8800 "preproc.y" 20772 { 20773 (yyval.str) = cat_str(3,(yyvsp[(1) - (6)].str),make_str("is not distinct from"),(yyvsp[(6) - (6)].str)); 20774@@ -37892,8 +35485,6 @@ 20775 break; 20776 20777 case 1438: 20778- 20779-/* Line 1455 of yacc.c */ 20780 #line 8804 "preproc.y" 20781 { 20782 (yyval.str) = cat_str(4,(yyvsp[(1) - (6)].str),make_str("is of ("),(yyvsp[(5) - (6)].str),make_str(")")); 20783@@ -37901,8 +35492,6 @@ 20784 break; 20785 20786 case 1439: 20787- 20788-/* Line 1455 of yacc.c */ 20789 #line 8808 "preproc.y" 20790 { 20791 (yyval.str) = cat_str(4,(yyvsp[(1) - (7)].str),make_str("is not of ("),(yyvsp[(6) - (7)].str),make_str(")")); 20792@@ -37910,8 +35499,6 @@ 20793 break; 20794 20795 case 1440: 20796- 20797-/* Line 1455 of yacc.c */ 20798 #line 8812 "preproc.y" 20799 { 20800 (yyval.str) = cat_str(6,(yyvsp[(1) - (6)].str),make_str("between"),(yyvsp[(3) - (6)].str),(yyvsp[(4) - (6)].str),make_str("and"),(yyvsp[(6) - (6)].str)); 20801@@ -37919,8 +35506,6 @@ 20802 break; 20803 20804 case 1441: 20805- 20806-/* Line 1455 of yacc.c */ 20807 #line 8816 "preproc.y" 20808 { 20809 (yyval.str) = cat_str(6,(yyvsp[(1) - (7)].str),make_str("not between"),(yyvsp[(4) - (7)].str),(yyvsp[(5) - (7)].str),make_str("and"),(yyvsp[(7) - (7)].str)); 20810@@ -37928,8 +35513,6 @@ 20811 break; 20812 20813 case 1442: 20814- 20815-/* Line 1455 of yacc.c */ 20816 #line 8820 "preproc.y" 20817 { 20818 (yyval.str) = cat_str(5,(yyvsp[(1) - (6)].str),make_str("between symmetric"),(yyvsp[(4) - (6)].str),make_str("and"),(yyvsp[(6) - (6)].str)); 20819@@ -37937,8 +35520,6 @@ 20820 break; 20821 20822 case 1443: 20823- 20824-/* Line 1455 of yacc.c */ 20825 #line 8824 "preproc.y" 20826 { 20827 (yyval.str) = cat_str(5,(yyvsp[(1) - (7)].str),make_str("not between symmetric"),(yyvsp[(5) - (7)].str),make_str("and"),(yyvsp[(7) - (7)].str)); 20828@@ -37946,8 +35527,6 @@ 20829 break; 20830 20831 case 1444: 20832- 20833-/* Line 1455 of yacc.c */ 20834 #line 8828 "preproc.y" 20835 { 20836 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("in"),(yyvsp[(3) - (3)].str)); 20837@@ -37955,8 +35534,6 @@ 20838 break; 20839 20840 case 1445: 20841- 20842-/* Line 1455 of yacc.c */ 20843 #line 8832 "preproc.y" 20844 { 20845 (yyval.str) = cat_str(3,(yyvsp[(1) - (4)].str),make_str("not in"),(yyvsp[(4) - (4)].str)); 20846@@ -37964,8 +35541,6 @@ 20847 break; 20848 20849 case 1446: 20850- 20851-/* Line 1455 of yacc.c */ 20852 #line 8836 "preproc.y" 20853 { 20854 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 20855@@ -37973,8 +35548,6 @@ 20856 break; 20857 20858 case 1447: 20859- 20860-/* Line 1455 of yacc.c */ 20861 #line 8840 "preproc.y" 20862 { 20863 (yyval.str) = cat_str(6,(yyvsp[(1) - (6)].str),(yyvsp[(2) - (6)].str),(yyvsp[(3) - (6)].str),make_str("("),(yyvsp[(5) - (6)].str),make_str(")")); 20864@@ -37982,8 +35555,6 @@ 20865 break; 20866 20867 case 1448: 20868- 20869-/* Line 1455 of yacc.c */ 20870 #line 8844 "preproc.y" 20871 { 20872 mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server"); 20873@@ -37992,8 +35563,6 @@ 20874 break; 20875 20876 case 1449: 20877- 20878-/* Line 1455 of yacc.c */ 20879 #line 8849 "preproc.y" 20880 { 20881 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("is document")); 20882@@ -38001,8 +35570,6 @@ 20883 break; 20884 20885 case 1450: 20886- 20887-/* Line 1455 of yacc.c */ 20888 #line 8853 "preproc.y" 20889 { 20890 (yyval.str) = cat_str(2,(yyvsp[(1) - (4)].str),make_str("is not document")); 20891@@ -38010,8 +35577,6 @@ 20892 break; 20893 20894 case 1451: 20895- 20896-/* Line 1455 of yacc.c */ 20897 #line 8861 "preproc.y" 20898 { 20899 (yyval.str) = (yyvsp[(1) - (1)].str); 20900@@ -38019,8 +35584,6 @@ 20901 break; 20902 20903 case 1452: 20904- 20905-/* Line 1455 of yacc.c */ 20906 #line 8865 "preproc.y" 20907 { 20908 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("::"),(yyvsp[(3) - (3)].str)); 20909@@ -38028,8 +35591,6 @@ 20910 break; 20911 20912 case 1453: 20913- 20914-/* Line 1455 of yacc.c */ 20915 #line 8869 "preproc.y" 20916 { 20917 (yyval.str) = cat_str(2,make_str("+"),(yyvsp[(2) - (2)].str)); 20918@@ -38037,8 +35598,6 @@ 20919 break; 20920 20921 case 1454: 20922- 20923-/* Line 1455 of yacc.c */ 20924 #line 8873 "preproc.y" 20925 { 20926 (yyval.str) = cat_str(2,make_str("-"),(yyvsp[(2) - (2)].str)); 20927@@ -38046,8 +35605,6 @@ 20928 break; 20929 20930 case 1455: 20931- 20932-/* Line 1455 of yacc.c */ 20933 #line 8877 "preproc.y" 20934 { 20935 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("+"),(yyvsp[(3) - (3)].str)); 20936@@ -38055,8 +35612,6 @@ 20937 break; 20938 20939 case 1456: 20940- 20941-/* Line 1455 of yacc.c */ 20942 #line 8881 "preproc.y" 20943 { 20944 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("-"),(yyvsp[(3) - (3)].str)); 20945@@ -38064,8 +35619,6 @@ 20946 break; 20947 20948 case 1457: 20949- 20950-/* Line 1455 of yacc.c */ 20951 #line 8885 "preproc.y" 20952 { 20953 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("*"),(yyvsp[(3) - (3)].str)); 20954@@ -38073,8 +35626,6 @@ 20955 break; 20956 20957 case 1458: 20958- 20959-/* Line 1455 of yacc.c */ 20960 #line 8889 "preproc.y" 20961 { 20962 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("/"),(yyvsp[(3) - (3)].str)); 20963@@ -38082,8 +35633,6 @@ 20964 break; 20965 20966 case 1459: 20967- 20968-/* Line 1455 of yacc.c */ 20969 #line 8893 "preproc.y" 20970 { 20971 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("%"),(yyvsp[(3) - (3)].str)); 20972@@ -38091,8 +35640,6 @@ 20973 break; 20974 20975 case 1460: 20976- 20977-/* Line 1455 of yacc.c */ 20978 #line 8897 "preproc.y" 20979 { 20980 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("^"),(yyvsp[(3) - (3)].str)); 20981@@ -38100,8 +35647,6 @@ 20982 break; 20983 20984 case 1461: 20985- 20986-/* Line 1455 of yacc.c */ 20987 #line 8901 "preproc.y" 20988 { 20989 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("<"),(yyvsp[(3) - (3)].str)); 20990@@ -38109,8 +35654,6 @@ 20991 break; 20992 20993 case 1462: 20994- 20995-/* Line 1455 of yacc.c */ 20996 #line 8905 "preproc.y" 20997 { 20998 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(">"),(yyvsp[(3) - (3)].str)); 20999@@ -38118,8 +35661,6 @@ 21000 break; 21001 21002 case 1463: 21003- 21004-/* Line 1455 of yacc.c */ 21005 #line 8909 "preproc.y" 21006 { 21007 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("="),(yyvsp[(3) - (3)].str)); 21008@@ -38127,8 +35668,6 @@ 21009 break; 21010 21011 case 1464: 21012- 21013-/* Line 1455 of yacc.c */ 21014 #line 8913 "preproc.y" 21015 { 21016 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 21017@@ -38136,8 +35675,6 @@ 21018 break; 21019 21020 case 1465: 21021- 21022-/* Line 1455 of yacc.c */ 21023 #line 8917 "preproc.y" 21024 { 21025 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 21026@@ -38145,8 +35682,6 @@ 21027 break; 21028 21029 case 1466: 21030- 21031-/* Line 1455 of yacc.c */ 21032 #line 8921 "preproc.y" 21033 { 21034 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 21035@@ -38154,8 +35689,6 @@ 21036 break; 21037 21038 case 1467: 21039- 21040-/* Line 1455 of yacc.c */ 21041 #line 8925 "preproc.y" 21042 { 21043 (yyval.str) = cat_str(3,(yyvsp[(1) - (5)].str),make_str("is distinct from"),(yyvsp[(5) - (5)].str)); 21044@@ -38163,8 +35696,6 @@ 21045 break; 21046 21047 case 1468: 21048- 21049-/* Line 1455 of yacc.c */ 21050 #line 8929 "preproc.y" 21051 { 21052 (yyval.str) = cat_str(3,(yyvsp[(1) - (6)].str),make_str("is not distinct from"),(yyvsp[(6) - (6)].str)); 21053@@ -38172,8 +35703,6 @@ 21054 break; 21055 21056 case 1469: 21057- 21058-/* Line 1455 of yacc.c */ 21059 #line 8933 "preproc.y" 21060 { 21061 (yyval.str) = cat_str(4,(yyvsp[(1) - (6)].str),make_str("is of ("),(yyvsp[(5) - (6)].str),make_str(")")); 21062@@ -38181,8 +35710,6 @@ 21063 break; 21064 21065 case 1470: 21066- 21067-/* Line 1455 of yacc.c */ 21068 #line 8937 "preproc.y" 21069 { 21070 (yyval.str) = cat_str(4,(yyvsp[(1) - (7)].str),make_str("is not of ("),(yyvsp[(6) - (7)].str),make_str(")")); 21071@@ -38190,8 +35717,6 @@ 21072 break; 21073 21074 case 1471: 21075- 21076-/* Line 1455 of yacc.c */ 21077 #line 8941 "preproc.y" 21078 { 21079 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("is document")); 21080@@ -38199,8 +35724,6 @@ 21081 break; 21082 21083 case 1472: 21084- 21085-/* Line 1455 of yacc.c */ 21086 #line 8945 "preproc.y" 21087 { 21088 (yyval.str) = cat_str(2,(yyvsp[(1) - (4)].str),make_str("is not document")); 21089@@ -38208,8 +35731,6 @@ 21090 break; 21091 21092 case 1473: 21093- 21094-/* Line 1455 of yacc.c */ 21095 #line 8953 "preproc.y" 21096 { 21097 (yyval.str) = (yyvsp[(1) - (1)].str); 21098@@ -38217,8 +35738,6 @@ 21099 break; 21100 21101 case 1474: 21102- 21103-/* Line 1455 of yacc.c */ 21104 #line 8957 "preproc.y" 21105 { 21106 (yyval.str) = (yyvsp[(1) - (1)].str); 21107@@ -38226,8 +35745,6 @@ 21108 break; 21109 21110 case 1475: 21111- 21112-/* Line 1455 of yacc.c */ 21113 #line 8961 "preproc.y" 21114 { 21115 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 21116@@ -38235,8 +35752,6 @@ 21117 break; 21118 21119 case 1476: 21120- 21121-/* Line 1455 of yacc.c */ 21122 #line 8965 "preproc.y" 21123 { 21124 (yyval.str) = cat_str(4,make_str("("),(yyvsp[(2) - (4)].str),make_str(")"),(yyvsp[(4) - (4)].str)); 21125@@ -38244,8 +35759,6 @@ 21126 break; 21127 21128 case 1477: 21129- 21130-/* Line 1455 of yacc.c */ 21131 #line 8969 "preproc.y" 21132 { 21133 (yyval.str) = (yyvsp[(1) - (1)].str); 21134@@ -38253,8 +35766,6 @@ 21135 break; 21136 21137 case 1478: 21138- 21139-/* Line 1455 of yacc.c */ 21140 #line 8973 "preproc.y" 21141 { 21142 (yyval.str) = (yyvsp[(1) - (1)].str); 21143@@ -38262,8 +35773,6 @@ 21144 break; 21145 21146 case 1479: 21147- 21148-/* Line 1455 of yacc.c */ 21149 #line 8977 "preproc.y" 21150 { 21151 (yyval.str) = (yyvsp[(1) - (1)].str); 21152@@ -38271,8 +35780,6 @@ 21153 break; 21154 21155 case 1480: 21156- 21157-/* Line 1455 of yacc.c */ 21158 #line 8981 "preproc.y" 21159 { 21160 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 21161@@ -38280,8 +35787,6 @@ 21162 break; 21163 21164 case 1481: 21165- 21166-/* Line 1455 of yacc.c */ 21167 #line 8985 "preproc.y" 21168 { 21169 (yyval.str) = cat_str(2,make_str("exists"),(yyvsp[(2) - (2)].str)); 21170@@ -38289,8 +35794,6 @@ 21171 break; 21172 21173 case 1482: 21174- 21175-/* Line 1455 of yacc.c */ 21176 #line 8989 "preproc.y" 21177 { 21178 (yyval.str) = cat_str(2,make_str("array"),(yyvsp[(2) - (2)].str)); 21179@@ -38298,8 +35801,6 @@ 21180 break; 21181 21182 case 1483: 21183- 21184-/* Line 1455 of yacc.c */ 21185 #line 8993 "preproc.y" 21186 { 21187 (yyval.str) = cat_str(2,make_str("array"),(yyvsp[(2) - (2)].str)); 21188@@ -38307,8 +35808,6 @@ 21189 break; 21190 21191 case 1484: 21192- 21193-/* Line 1455 of yacc.c */ 21194 #line 8997 "preproc.y" 21195 { 21196 (yyval.str) = (yyvsp[(1) - (1)].str); 21197@@ -38316,8 +35815,6 @@ 21198 break; 21199 21200 case 1485: 21201- 21202-/* Line 1455 of yacc.c */ 21203 #line 9005 "preproc.y" 21204 { 21205 (yyval.str) = cat_str(3,(yyvsp[(1) - (4)].str),make_str("( )"),(yyvsp[(4) - (4)].str)); 21206@@ -38325,8 +35822,6 @@ 21207 break; 21208 21209 case 1486: 21210- 21211-/* Line 1455 of yacc.c */ 21212 #line 9009 "preproc.y" 21213 { 21214 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),make_str("("),(yyvsp[(3) - (5)].str),make_str(")"),(yyvsp[(5) - (5)].str)); 21215@@ -38334,8 +35829,6 @@ 21216 break; 21217 21218 case 1487: 21219- 21220-/* Line 1455 of yacc.c */ 21221 #line 9013 "preproc.y" 21222 { 21223 (yyval.str) = cat_str(5,(yyvsp[(1) - (6)].str),make_str("( variadic"),(yyvsp[(4) - (6)].str),make_str(")"),(yyvsp[(6) - (6)].str)); 21224@@ -38343,8 +35836,6 @@ 21225 break; 21226 21227 case 1488: 21228- 21229-/* Line 1455 of yacc.c */ 21230 #line 9017 "preproc.y" 21231 { 21232 (yyval.str) = cat_str(7,(yyvsp[(1) - (8)].str),make_str("("),(yyvsp[(3) - (8)].str),make_str(", variadic"),(yyvsp[(6) - (8)].str),make_str(")"),(yyvsp[(8) - (8)].str)); 21233@@ -38352,8 +35843,6 @@ 21234 break; 21235 21236 case 1489: 21237- 21238-/* Line 1455 of yacc.c */ 21239 #line 9021 "preproc.y" 21240 { 21241 (yyval.str) = cat_str(6,(yyvsp[(1) - (6)].str),make_str("("),(yyvsp[(3) - (6)].str),(yyvsp[(4) - (6)].str),make_str(")"),(yyvsp[(6) - (6)].str)); 21242@@ -38361,8 +35850,6 @@ 21243 break; 21244 21245 case 1490: 21246- 21247-/* Line 1455 of yacc.c */ 21248 #line 9025 "preproc.y" 21249 { 21250 (yyval.str) = cat_str(6,(yyvsp[(1) - (7)].str),make_str("( all"),(yyvsp[(4) - (7)].str),(yyvsp[(5) - (7)].str),make_str(")"),(yyvsp[(7) - (7)].str)); 21251@@ -38370,8 +35857,6 @@ 21252 break; 21253 21254 case 1491: 21255- 21256-/* Line 1455 of yacc.c */ 21257 #line 9029 "preproc.y" 21258 { 21259 (yyval.str) = cat_str(6,(yyvsp[(1) - (7)].str),make_str("( distinct"),(yyvsp[(4) - (7)].str),(yyvsp[(5) - (7)].str),make_str(")"),(yyvsp[(7) - (7)].str)); 21260@@ -38379,8 +35864,6 @@ 21261 break; 21262 21263 case 1492: 21264- 21265-/* Line 1455 of yacc.c */ 21266 #line 9033 "preproc.y" 21267 { 21268 (yyval.str) = cat_str(3,(yyvsp[(1) - (5)].str),make_str("( * )"),(yyvsp[(5) - (5)].str)); 21269@@ -38388,8 +35871,6 @@ 21270 break; 21271 21272 case 1493: 21273- 21274-/* Line 1455 of yacc.c */ 21275 #line 9037 "preproc.y" 21276 { 21277 (yyval.str) = make_str("current_date"); 21278@@ -38397,8 +35878,6 @@ 21279 break; 21280 21281 case 1494: 21282- 21283-/* Line 1455 of yacc.c */ 21284 #line 9041 "preproc.y" 21285 { 21286 (yyval.str) = make_str("current_time"); 21287@@ -38406,8 +35885,6 @@ 21288 break; 21289 21290 case 1495: 21291- 21292-/* Line 1455 of yacc.c */ 21293 #line 9045 "preproc.y" 21294 { 21295 (yyval.str) = cat_str(3,make_str("current_time ("),(yyvsp[(3) - (4)].str),make_str(")")); 21296@@ -38415,8 +35892,6 @@ 21297 break; 21298 21299 case 1496: 21300- 21301-/* Line 1455 of yacc.c */ 21302 #line 9049 "preproc.y" 21303 { 21304 (yyval.str) = make_str("current_timestamp"); 21305@@ -38424,8 +35899,6 @@ 21306 break; 21307 21308 case 1497: 21309- 21310-/* Line 1455 of yacc.c */ 21311 #line 9053 "preproc.y" 21312 { 21313 (yyval.str) = cat_str(3,make_str("current_timestamp ("),(yyvsp[(3) - (4)].str),make_str(")")); 21314@@ -38433,8 +35906,6 @@ 21315 break; 21316 21317 case 1498: 21318- 21319-/* Line 1455 of yacc.c */ 21320 #line 9057 "preproc.y" 21321 { 21322 (yyval.str) = make_str("localtime"); 21323@@ -38442,8 +35913,6 @@ 21324 break; 21325 21326 case 1499: 21327- 21328-/* Line 1455 of yacc.c */ 21329 #line 9061 "preproc.y" 21330 { 21331 (yyval.str) = cat_str(3,make_str("localtime ("),(yyvsp[(3) - (4)].str),make_str(")")); 21332@@ -38451,8 +35920,6 @@ 21333 break; 21334 21335 case 1500: 21336- 21337-/* Line 1455 of yacc.c */ 21338 #line 9065 "preproc.y" 21339 { 21340 (yyval.str) = make_str("localtimestamp"); 21341@@ -38460,8 +35927,6 @@ 21342 break; 21343 21344 case 1501: 21345- 21346-/* Line 1455 of yacc.c */ 21347 #line 9069 "preproc.y" 21348 { 21349 (yyval.str) = cat_str(3,make_str("localtimestamp ("),(yyvsp[(3) - (4)].str),make_str(")")); 21350@@ -38469,8 +35934,6 @@ 21351 break; 21352 21353 case 1502: 21354- 21355-/* Line 1455 of yacc.c */ 21356 #line 9073 "preproc.y" 21357 { 21358 (yyval.str) = make_str("current_role"); 21359@@ -38478,8 +35941,6 @@ 21360 break; 21361 21362 case 1503: 21363- 21364-/* Line 1455 of yacc.c */ 21365 #line 9077 "preproc.y" 21366 { 21367 (yyval.str) = make_str("current_user"); 21368@@ -38487,8 +35948,6 @@ 21369 break; 21370 21371 case 1504: 21372- 21373-/* Line 1455 of yacc.c */ 21374 #line 9081 "preproc.y" 21375 { 21376 (yyval.str) = make_str("session_user"); 21377@@ -38496,8 +35955,6 @@ 21378 break; 21379 21380 case 1505: 21381- 21382-/* Line 1455 of yacc.c */ 21383 #line 9085 "preproc.y" 21384 { 21385 (yyval.str) = make_str("user"); 21386@@ -38505,8 +35962,6 @@ 21387 break; 21388 21389 case 1506: 21390- 21391-/* Line 1455 of yacc.c */ 21392 #line 9089 "preproc.y" 21393 { 21394 (yyval.str) = make_str("current_catalog"); 21395@@ -38514,8 +35969,6 @@ 21396 break; 21397 21398 case 1507: 21399- 21400-/* Line 1455 of yacc.c */ 21401 #line 9093 "preproc.y" 21402 { 21403 (yyval.str) = make_str("current_schema"); 21404@@ -38523,8 +35976,6 @@ 21405 break; 21406 21407 case 1508: 21408- 21409-/* Line 1455 of yacc.c */ 21410 #line 9097 "preproc.y" 21411 { 21412 (yyval.str) = cat_str(5,make_str("cast ("),(yyvsp[(3) - (6)].str),make_str("as"),(yyvsp[(5) - (6)].str),make_str(")")); 21413@@ -38532,8 +35983,6 @@ 21414 break; 21415 21416 case 1509: 21417- 21418-/* Line 1455 of yacc.c */ 21419 #line 9101 "preproc.y" 21420 { 21421 (yyval.str) = cat_str(3,make_str("extract ("),(yyvsp[(3) - (4)].str),make_str(")")); 21422@@ -38541,8 +35990,6 @@ 21423 break; 21424 21425 case 1510: 21426- 21427-/* Line 1455 of yacc.c */ 21428 #line 9105 "preproc.y" 21429 { 21430 (yyval.str) = cat_str(3,make_str("overlay ("),(yyvsp[(3) - (4)].str),make_str(")")); 21431@@ -38550,8 +35997,6 @@ 21432 break; 21433 21434 case 1511: 21435- 21436-/* Line 1455 of yacc.c */ 21437 #line 9109 "preproc.y" 21438 { 21439 (yyval.str) = cat_str(3,make_str("position ("),(yyvsp[(3) - (4)].str),make_str(")")); 21440@@ -38559,8 +36004,6 @@ 21441 break; 21442 21443 case 1512: 21444- 21445-/* Line 1455 of yacc.c */ 21446 #line 9113 "preproc.y" 21447 { 21448 (yyval.str) = cat_str(3,make_str("substring ("),(yyvsp[(3) - (4)].str),make_str(")")); 21449@@ -38568,8 +36011,6 @@ 21450 break; 21451 21452 case 1513: 21453- 21454-/* Line 1455 of yacc.c */ 21455 #line 9117 "preproc.y" 21456 { 21457 (yyval.str) = cat_str(5,make_str("treat ("),(yyvsp[(3) - (6)].str),make_str("as"),(yyvsp[(5) - (6)].str),make_str(")")); 21458@@ -38577,8 +36018,6 @@ 21459 break; 21460 21461 case 1514: 21462- 21463-/* Line 1455 of yacc.c */ 21464 #line 9121 "preproc.y" 21465 { 21466 (yyval.str) = cat_str(3,make_str("trim ( both"),(yyvsp[(4) - (5)].str),make_str(")")); 21467@@ -38586,8 +36025,6 @@ 21468 break; 21469 21470 case 1515: 21471- 21472-/* Line 1455 of yacc.c */ 21473 #line 9125 "preproc.y" 21474 { 21475 (yyval.str) = cat_str(3,make_str("trim ( leading"),(yyvsp[(4) - (5)].str),make_str(")")); 21476@@ -38595,8 +36032,6 @@ 21477 break; 21478 21479 case 1516: 21480- 21481-/* Line 1455 of yacc.c */ 21482 #line 9129 "preproc.y" 21483 { 21484 (yyval.str) = cat_str(3,make_str("trim ( trailing"),(yyvsp[(4) - (5)].str),make_str(")")); 21485@@ -38604,8 +36039,6 @@ 21486 break; 21487 21488 case 1517: 21489- 21490-/* Line 1455 of yacc.c */ 21491 #line 9133 "preproc.y" 21492 { 21493 (yyval.str) = cat_str(3,make_str("trim ("),(yyvsp[(3) - (4)].str),make_str(")")); 21494@@ -38613,8 +36046,6 @@ 21495 break; 21496 21497 case 1518: 21498- 21499-/* Line 1455 of yacc.c */ 21500 #line 9137 "preproc.y" 21501 { 21502 (yyval.str) = cat_str(5,make_str("nullif ("),(yyvsp[(3) - (6)].str),make_str(","),(yyvsp[(5) - (6)].str),make_str(")")); 21503@@ -38622,8 +36053,6 @@ 21504 break; 21505 21506 case 1519: 21507- 21508-/* Line 1455 of yacc.c */ 21509 #line 9141 "preproc.y" 21510 { 21511 (yyval.str) = cat_str(3,make_str("coalesce ("),(yyvsp[(3) - (4)].str),make_str(")")); 21512@@ -38631,8 +36060,6 @@ 21513 break; 21514 21515 case 1520: 21516- 21517-/* Line 1455 of yacc.c */ 21518 #line 9145 "preproc.y" 21519 { 21520 (yyval.str) = cat_str(3,make_str("greatest ("),(yyvsp[(3) - (4)].str),make_str(")")); 21521@@ -38640,8 +36067,6 @@ 21522 break; 21523 21524 case 1521: 21525- 21526-/* Line 1455 of yacc.c */ 21527 #line 9149 "preproc.y" 21528 { 21529 (yyval.str) = cat_str(3,make_str("least ("),(yyvsp[(3) - (4)].str),make_str(")")); 21530@@ -38649,8 +36074,6 @@ 21531 break; 21532 21533 case 1522: 21534- 21535-/* Line 1455 of yacc.c */ 21536 #line 9153 "preproc.y" 21537 { 21538 (yyval.str) = cat_str(3,make_str("xmlconcat ("),(yyvsp[(3) - (4)].str),make_str(")")); 21539@@ -38658,8 +36081,6 @@ 21540 break; 21541 21542 case 1523: 21543- 21544-/* Line 1455 of yacc.c */ 21545 #line 9157 "preproc.y" 21546 { 21547 (yyval.str) = cat_str(3,make_str("xmlelement ( name"),(yyvsp[(4) - (5)].str),make_str(")")); 21548@@ -38667,8 +36088,6 @@ 21549 break; 21550 21551 case 1524: 21552- 21553-/* Line 1455 of yacc.c */ 21554 #line 9161 "preproc.y" 21555 { 21556 (yyval.str) = cat_str(5,make_str("xmlelement ( name"),(yyvsp[(4) - (7)].str),make_str(","),(yyvsp[(6) - (7)].str),make_str(")")); 21557@@ -38676,8 +36095,6 @@ 21558 break; 21559 21560 case 1525: 21561- 21562-/* Line 1455 of yacc.c */ 21563 #line 9165 "preproc.y" 21564 { 21565 (yyval.str) = cat_str(5,make_str("xmlelement ( name"),(yyvsp[(4) - (7)].str),make_str(","),(yyvsp[(6) - (7)].str),make_str(")")); 21566@@ -38685,8 +36102,6 @@ 21567 break; 21568 21569 case 1526: 21570- 21571-/* Line 1455 of yacc.c */ 21572 #line 9169 "preproc.y" 21573 { 21574 (yyval.str) = cat_str(7,make_str("xmlelement ( name"),(yyvsp[(4) - (9)].str),make_str(","),(yyvsp[(6) - (9)].str),make_str(","),(yyvsp[(8) - (9)].str),make_str(")")); 21575@@ -38694,8 +36109,6 @@ 21576 break; 21577 21578 case 1527: 21579- 21580-/* Line 1455 of yacc.c */ 21581 #line 9173 "preproc.y" 21582 { 21583 (yyval.str) = cat_str(3,make_str("xmlforest ("),(yyvsp[(3) - (4)].str),make_str(")")); 21584@@ -38703,8 +36116,6 @@ 21585 break; 21586 21587 case 1528: 21588- 21589-/* Line 1455 of yacc.c */ 21590 #line 9177 "preproc.y" 21591 { 21592 (yyval.str) = cat_str(5,make_str("xmlparse ("),(yyvsp[(3) - (6)].str),(yyvsp[(4) - (6)].str),(yyvsp[(5) - (6)].str),make_str(")")); 21593@@ -38712,8 +36123,6 @@ 21594 break; 21595 21596 case 1529: 21597- 21598-/* Line 1455 of yacc.c */ 21599 #line 9181 "preproc.y" 21600 { 21601 (yyval.str) = cat_str(3,make_str("xmlpi ( name"),(yyvsp[(4) - (5)].str),make_str(")")); 21602@@ -38721,8 +36130,6 @@ 21603 break; 21604 21605 case 1530: 21606- 21607-/* Line 1455 of yacc.c */ 21608 #line 9185 "preproc.y" 21609 { 21610 (yyval.str) = cat_str(5,make_str("xmlpi ( name"),(yyvsp[(4) - (7)].str),make_str(","),(yyvsp[(6) - (7)].str),make_str(")")); 21611@@ -38730,8 +36137,6 @@ 21612 break; 21613 21614 case 1531: 21615- 21616-/* Line 1455 of yacc.c */ 21617 #line 9189 "preproc.y" 21618 { 21619 (yyval.str) = cat_str(6,make_str("xmlroot ("),(yyvsp[(3) - (7)].str),make_str(","),(yyvsp[(5) - (7)].str),(yyvsp[(6) - (7)].str),make_str(")")); 21620@@ -38739,8 +36144,6 @@ 21621 break; 21622 21623 case 1532: 21624- 21625-/* Line 1455 of yacc.c */ 21626 #line 9193 "preproc.y" 21627 { 21628 (yyval.str) = cat_str(6,make_str("xmlserialize ("),(yyvsp[(3) - (7)].str),(yyvsp[(4) - (7)].str),make_str("as"),(yyvsp[(6) - (7)].str),make_str(")")); 21629@@ -38748,8 +36151,6 @@ 21630 break; 21631 21632 case 1533: 21633- 21634-/* Line 1455 of yacc.c */ 21635 #line 9201 "preproc.y" 21636 { 21637 (yyval.str) = cat_str(2,make_str("version"),(yyvsp[(2) - (2)].str)); 21638@@ -38757,8 +36158,6 @@ 21639 break; 21640 21641 case 1534: 21642- 21643-/* Line 1455 of yacc.c */ 21644 #line 9205 "preproc.y" 21645 { 21646 (yyval.str) = make_str("version no value"); 21647@@ -38766,8 +36165,6 @@ 21648 break; 21649 21650 case 1535: 21651- 21652-/* Line 1455 of yacc.c */ 21653 #line 9213 "preproc.y" 21654 { 21655 (yyval.str) = make_str(", standalone yes"); 21656@@ -38775,8 +36172,6 @@ 21657 break; 21658 21659 case 1536: 21660- 21661-/* Line 1455 of yacc.c */ 21662 #line 9217 "preproc.y" 21663 { 21664 (yyval.str) = make_str(", standalone no"); 21665@@ -38784,8 +36179,6 @@ 21666 break; 21667 21668 case 1537: 21669- 21670-/* Line 1455 of yacc.c */ 21671 #line 9221 "preproc.y" 21672 { 21673 (yyval.str) = make_str(", standalone no value"); 21674@@ -38793,16 +36186,12 @@ 21675 break; 21676 21677 case 1538: 21678- 21679-/* Line 1455 of yacc.c */ 21680 #line 9225 "preproc.y" 21681 { 21682 (yyval.str)=EMPTY; ;} 21683 break; 21684 21685 case 1539: 21686- 21687-/* Line 1455 of yacc.c */ 21688 #line 9232 "preproc.y" 21689 { 21690 (yyval.str) = cat_str(3,make_str("xmlattributes ("),(yyvsp[(3) - (4)].str),make_str(")")); 21691@@ -38810,8 +36199,6 @@ 21692 break; 21693 21694 case 1540: 21695- 21696-/* Line 1455 of yacc.c */ 21697 #line 9240 "preproc.y" 21698 { 21699 (yyval.str) = (yyvsp[(1) - (1)].str); 21700@@ -38819,8 +36206,6 @@ 21701 break; 21702 21703 case 1541: 21704- 21705-/* Line 1455 of yacc.c */ 21706 #line 9244 "preproc.y" 21707 { 21708 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 21709@@ -38828,8 +36213,6 @@ 21710 break; 21711 21712 case 1542: 21713- 21714-/* Line 1455 of yacc.c */ 21715 #line 9252 "preproc.y" 21716 { 21717 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("as"),(yyvsp[(3) - (3)].str)); 21718@@ -38837,8 +36220,6 @@ 21719 break; 21720 21721 case 1543: 21722- 21723-/* Line 1455 of yacc.c */ 21724 #line 9256 "preproc.y" 21725 { 21726 (yyval.str) = (yyvsp[(1) - (1)].str); 21727@@ -38846,8 +36227,6 @@ 21728 break; 21729 21730 case 1544: 21731- 21732-/* Line 1455 of yacc.c */ 21733 #line 9264 "preproc.y" 21734 { 21735 (yyval.str) = make_str("document"); 21736@@ -38855,8 +36234,6 @@ 21737 break; 21738 21739 case 1545: 21740- 21741-/* Line 1455 of yacc.c */ 21742 #line 9268 "preproc.y" 21743 { 21744 (yyval.str) = make_str("content"); 21745@@ -38864,8 +36241,6 @@ 21746 break; 21747 21748 case 1546: 21749- 21750-/* Line 1455 of yacc.c */ 21751 #line 9276 "preproc.y" 21752 { 21753 (yyval.str) = make_str("preserve whitespace"); 21754@@ -38873,8 +36248,6 @@ 21755 break; 21756 21757 case 1547: 21758- 21759-/* Line 1455 of yacc.c */ 21760 #line 9280 "preproc.y" 21761 { 21762 (yyval.str) = make_str("strip whitespace"); 21763@@ -38882,16 +36255,12 @@ 21764 break; 21765 21766 case 1548: 21767- 21768-/* Line 1455 of yacc.c */ 21769 #line 9284 "preproc.y" 21770 { 21771 (yyval.str)=EMPTY; ;} 21772 break; 21773 21774 case 1549: 21775- 21776-/* Line 1455 of yacc.c */ 21777 #line 9291 "preproc.y" 21778 { 21779 (yyval.str) = cat_str(2,make_str("window"),(yyvsp[(2) - (2)].str)); 21780@@ -38899,16 +36268,12 @@ 21781 break; 21782 21783 case 1550: 21784- 21785-/* Line 1455 of yacc.c */ 21786 #line 9295 "preproc.y" 21787 { 21788 (yyval.str)=EMPTY; ;} 21789 break; 21790 21791 case 1551: 21792- 21793-/* Line 1455 of yacc.c */ 21794 #line 9302 "preproc.y" 21795 { 21796 (yyval.str) = (yyvsp[(1) - (1)].str); 21797@@ -38916,8 +36281,6 @@ 21798 break; 21799 21800 case 1552: 21801- 21802-/* Line 1455 of yacc.c */ 21803 #line 9306 "preproc.y" 21804 { 21805 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 21806@@ -38925,8 +36288,6 @@ 21807 break; 21808 21809 case 1553: 21810- 21811-/* Line 1455 of yacc.c */ 21812 #line 9314 "preproc.y" 21813 { 21814 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("as"),(yyvsp[(3) - (3)].str)); 21815@@ -38934,8 +36295,6 @@ 21816 break; 21817 21818 case 1554: 21819- 21820-/* Line 1455 of yacc.c */ 21821 #line 9322 "preproc.y" 21822 { 21823 (yyval.str) = cat_str(2,make_str("over"),(yyvsp[(2) - (2)].str)); 21824@@ -38943,8 +36302,6 @@ 21825 break; 21826 21827 case 1555: 21828- 21829-/* Line 1455 of yacc.c */ 21830 #line 9326 "preproc.y" 21831 { 21832 (yyval.str) = cat_str(2,make_str("over"),(yyvsp[(2) - (2)].str)); 21833@@ -38952,16 +36309,12 @@ 21834 break; 21835 21836 case 1556: 21837- 21838-/* Line 1455 of yacc.c */ 21839 #line 9330 "preproc.y" 21840 { 21841 (yyval.str)=EMPTY; ;} 21842 break; 21843 21844 case 1557: 21845- 21846-/* Line 1455 of yacc.c */ 21847 #line 9337 "preproc.y" 21848 { 21849 (yyval.str) = cat_str(6,make_str("("),(yyvsp[(2) - (6)].str),(yyvsp[(3) - (6)].str),(yyvsp[(4) - (6)].str),(yyvsp[(5) - (6)].str),make_str(")")); 21850@@ -38969,8 +36322,6 @@ 21851 break; 21852 21853 case 1558: 21854- 21855-/* Line 1455 of yacc.c */ 21856 #line 9345 "preproc.y" 21857 { 21858 (yyval.str) = (yyvsp[(1) - (1)].str); 21859@@ -38978,16 +36329,12 @@ 21860 break; 21861 21862 case 1559: 21863- 21864-/* Line 1455 of yacc.c */ 21865 #line 9349 "preproc.y" 21866 { 21867 (yyval.str)=EMPTY; ;} 21868 break; 21869 21870 case 1560: 21871- 21872-/* Line 1455 of yacc.c */ 21873 #line 9356 "preproc.y" 21874 { 21875 (yyval.str) = cat_str(2,make_str("partition by"),(yyvsp[(3) - (3)].str)); 21876@@ -38995,16 +36342,12 @@ 21877 break; 21878 21879 case 1561: 21880- 21881-/* Line 1455 of yacc.c */ 21882 #line 9360 "preproc.y" 21883 { 21884 (yyval.str)=EMPTY; ;} 21885 break; 21886 21887 case 1562: 21888- 21889-/* Line 1455 of yacc.c */ 21890 #line 9367 "preproc.y" 21891 { 21892 mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server"); 21893@@ -39013,8 +36356,6 @@ 21894 break; 21895 21896 case 1563: 21897- 21898-/* Line 1455 of yacc.c */ 21899 #line 9372 "preproc.y" 21900 { 21901 (yyval.str) = cat_str(2,make_str("rows"),(yyvsp[(2) - (2)].str)); 21902@@ -39022,16 +36363,12 @@ 21903 break; 21904 21905 case 1564: 21906- 21907-/* Line 1455 of yacc.c */ 21908 #line 9376 "preproc.y" 21909 { 21910 (yyval.str)=EMPTY; ;} 21911 break; 21912 21913 case 1565: 21914- 21915-/* Line 1455 of yacc.c */ 21916 #line 9383 "preproc.y" 21917 { 21918 (yyval.str) = (yyvsp[(1) - (1)].str); 21919@@ -39039,8 +36376,6 @@ 21920 break; 21921 21922 case 1566: 21923- 21924-/* Line 1455 of yacc.c */ 21925 #line 9387 "preproc.y" 21926 { 21927 (yyval.str) = cat_str(4,make_str("between"),(yyvsp[(2) - (4)].str),make_str("and"),(yyvsp[(4) - (4)].str)); 21928@@ -39048,8 +36383,6 @@ 21929 break; 21930 21931 case 1567: 21932- 21933-/* Line 1455 of yacc.c */ 21934 #line 9395 "preproc.y" 21935 { 21936 (yyval.str) = make_str("unbounded preceding"); 21937@@ -39057,8 +36390,6 @@ 21938 break; 21939 21940 case 1568: 21941- 21942-/* Line 1455 of yacc.c */ 21943 #line 9399 "preproc.y" 21944 { 21945 (yyval.str) = make_str("unbounded following"); 21946@@ -39066,8 +36397,6 @@ 21947 break; 21948 21949 case 1569: 21950- 21951-/* Line 1455 of yacc.c */ 21952 #line 9403 "preproc.y" 21953 { 21954 (yyval.str) = make_str("current row"); 21955@@ -39075,8 +36404,6 @@ 21956 break; 21957 21958 case 1570: 21959- 21960-/* Line 1455 of yacc.c */ 21961 #line 9407 "preproc.y" 21962 { 21963 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),make_str("preceding")); 21964@@ -39084,8 +36411,6 @@ 21965 break; 21966 21967 case 1571: 21968- 21969-/* Line 1455 of yacc.c */ 21970 #line 9411 "preproc.y" 21971 { 21972 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),make_str("following")); 21973@@ -39093,8 +36418,6 @@ 21974 break; 21975 21976 case 1572: 21977- 21978-/* Line 1455 of yacc.c */ 21979 #line 9419 "preproc.y" 21980 { 21981 (yyval.str) = cat_str(3,make_str("row ("),(yyvsp[(3) - (4)].str),make_str(")")); 21982@@ -39102,8 +36425,6 @@ 21983 break; 21984 21985 case 1573: 21986- 21987-/* Line 1455 of yacc.c */ 21988 #line 9423 "preproc.y" 21989 { 21990 (yyval.str) = make_str("row ( )"); 21991@@ -39111,8 +36432,6 @@ 21992 break; 21993 21994 case 1574: 21995- 21996-/* Line 1455 of yacc.c */ 21997 #line 9427 "preproc.y" 21998 { 21999 (yyval.str) = cat_str(5,make_str("("),(yyvsp[(2) - (5)].str),make_str(","),(yyvsp[(4) - (5)].str),make_str(")")); 22000@@ -39120,8 +36439,6 @@ 22001 break; 22002 22003 case 1575: 22004- 22005-/* Line 1455 of yacc.c */ 22006 #line 9435 "preproc.y" 22007 { 22008 (yyval.str) = make_str("any"); 22009@@ -39129,8 +36446,6 @@ 22010 break; 22011 22012 case 1576: 22013- 22014-/* Line 1455 of yacc.c */ 22015 #line 9439 "preproc.y" 22016 { 22017 (yyval.str) = make_str("some"); 22018@@ -39138,8 +36453,6 @@ 22019 break; 22020 22021 case 1577: 22022- 22023-/* Line 1455 of yacc.c */ 22024 #line 9443 "preproc.y" 22025 { 22026 (yyval.str) = make_str("all"); 22027@@ -39147,8 +36460,6 @@ 22028 break; 22029 22030 case 1578: 22031- 22032-/* Line 1455 of yacc.c */ 22033 #line 9451 "preproc.y" 22034 { 22035 (yyval.str) = (yyvsp[(1) - (1)].str); 22036@@ -39156,8 +36467,6 @@ 22037 break; 22038 22039 case 1579: 22040- 22041-/* Line 1455 of yacc.c */ 22042 #line 9455 "preproc.y" 22043 { 22044 (yyval.str) = (yyvsp[(1) - (1)].str); 22045@@ -39165,8 +36474,6 @@ 22046 break; 22047 22048 case 1580: 22049- 22050-/* Line 1455 of yacc.c */ 22051 #line 9463 "preproc.y" 22052 { 22053 (yyval.str) = make_str("+"); 22054@@ -39174,8 +36481,6 @@ 22055 break; 22056 22057 case 1581: 22058- 22059-/* Line 1455 of yacc.c */ 22060 #line 9467 "preproc.y" 22061 { 22062 (yyval.str) = make_str("-"); 22063@@ -39183,8 +36488,6 @@ 22064 break; 22065 22066 case 1582: 22067- 22068-/* Line 1455 of yacc.c */ 22069 #line 9471 "preproc.y" 22070 { 22071 (yyval.str) = make_str("*"); 22072@@ -39192,8 +36495,6 @@ 22073 break; 22074 22075 case 1583: 22076- 22077-/* Line 1455 of yacc.c */ 22078 #line 9475 "preproc.y" 22079 { 22080 (yyval.str) = make_str("/"); 22081@@ -39201,8 +36502,6 @@ 22082 break; 22083 22084 case 1584: 22085- 22086-/* Line 1455 of yacc.c */ 22087 #line 9479 "preproc.y" 22088 { 22089 (yyval.str) = make_str("%"); 22090@@ -39210,8 +36509,6 @@ 22091 break; 22092 22093 case 1585: 22094- 22095-/* Line 1455 of yacc.c */ 22096 #line 9483 "preproc.y" 22097 { 22098 (yyval.str) = make_str("^"); 22099@@ -39219,8 +36516,6 @@ 22100 break; 22101 22102 case 1586: 22103- 22104-/* Line 1455 of yacc.c */ 22105 #line 9487 "preproc.y" 22106 { 22107 (yyval.str) = make_str("<"); 22108@@ -39228,8 +36523,6 @@ 22109 break; 22110 22111 case 1587: 22112- 22113-/* Line 1455 of yacc.c */ 22114 #line 9491 "preproc.y" 22115 { 22116 (yyval.str) = make_str(">"); 22117@@ -39237,8 +36530,6 @@ 22118 break; 22119 22120 case 1588: 22121- 22122-/* Line 1455 of yacc.c */ 22123 #line 9495 "preproc.y" 22124 { 22125 (yyval.str) = make_str("="); 22126@@ -39246,8 +36537,6 @@ 22127 break; 22128 22129 case 1589: 22130- 22131-/* Line 1455 of yacc.c */ 22132 #line 9503 "preproc.y" 22133 { 22134 (yyval.str) = (yyvsp[(1) - (1)].str); 22135@@ -39255,8 +36544,6 @@ 22136 break; 22137 22138 case 1590: 22139- 22140-/* Line 1455 of yacc.c */ 22141 #line 9507 "preproc.y" 22142 { 22143 (yyval.str) = cat_str(3,make_str("operator ("),(yyvsp[(3) - (4)].str),make_str(")")); 22144@@ -39264,8 +36551,6 @@ 22145 break; 22146 22147 case 1591: 22148- 22149-/* Line 1455 of yacc.c */ 22150 #line 9515 "preproc.y" 22151 { 22152 (yyval.str) = (yyvsp[(1) - (1)].str); 22153@@ -39273,8 +36558,6 @@ 22154 break; 22155 22156 case 1592: 22157- 22158-/* Line 1455 of yacc.c */ 22159 #line 9519 "preproc.y" 22160 { 22161 (yyval.str) = cat_str(3,make_str("operator ("),(yyvsp[(3) - (4)].str),make_str(")")); 22162@@ -39282,8 +36565,6 @@ 22163 break; 22164 22165 case 1593: 22166- 22167-/* Line 1455 of yacc.c */ 22168 #line 9527 "preproc.y" 22169 { 22170 (yyval.str) = (yyvsp[(1) - (1)].str); 22171@@ -39291,8 +36572,6 @@ 22172 break; 22173 22174 case 1594: 22175- 22176-/* Line 1455 of yacc.c */ 22177 #line 9531 "preproc.y" 22178 { 22179 (yyval.str) = cat_str(3,make_str("operator ("),(yyvsp[(3) - (4)].str),make_str(")")); 22180@@ -39300,8 +36579,6 @@ 22181 break; 22182 22183 case 1595: 22184- 22185-/* Line 1455 of yacc.c */ 22186 #line 9535 "preproc.y" 22187 { 22188 (yyval.str) = make_str("like"); 22189@@ -39309,8 +36586,6 @@ 22190 break; 22191 22192 case 1596: 22193- 22194-/* Line 1455 of yacc.c */ 22195 #line 9539 "preproc.y" 22196 { 22197 (yyval.str) = make_str("not like"); 22198@@ -39318,8 +36593,6 @@ 22199 break; 22200 22201 case 1597: 22202- 22203-/* Line 1455 of yacc.c */ 22204 #line 9543 "preproc.y" 22205 { 22206 (yyval.str) = make_str("ilike"); 22207@@ -39327,8 +36600,6 @@ 22208 break; 22209 22210 case 1598: 22211- 22212-/* Line 1455 of yacc.c */ 22213 #line 9547 "preproc.y" 22214 { 22215 (yyval.str) = make_str("not ilike"); 22216@@ -39336,8 +36607,6 @@ 22217 break; 22218 22219 case 1599: 22220- 22221-/* Line 1455 of yacc.c */ 22222 #line 9555 "preproc.y" 22223 { 22224 (yyval.str) = (yyvsp[(1) - (1)].str); 22225@@ -39345,8 +36614,6 @@ 22226 break; 22227 22228 case 1600: 22229- 22230-/* Line 1455 of yacc.c */ 22231 #line 9559 "preproc.y" 22232 { 22233 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 22234@@ -39354,8 +36621,6 @@ 22235 break; 22236 22237 case 1601: 22238- 22239-/* Line 1455 of yacc.c */ 22240 #line 9567 "preproc.y" 22241 { 22242 (yyval.str) = (yyvsp[(1) - (1)].str); 22243@@ -39363,8 +36628,6 @@ 22244 break; 22245 22246 case 1602: 22247- 22248-/* Line 1455 of yacc.c */ 22249 #line 9571 "preproc.y" 22250 { 22251 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 22252@@ -39372,8 +36635,6 @@ 22253 break; 22254 22255 case 1603: 22256- 22257-/* Line 1455 of yacc.c */ 22258 #line 9579 "preproc.y" 22259 { 22260 (yyval.str) = (yyvsp[(1) - (1)].str); 22261@@ -39381,8 +36642,6 @@ 22262 break; 22263 22264 case 1604: 22265- 22266-/* Line 1455 of yacc.c */ 22267 #line 9583 "preproc.y" 22268 { 22269 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(":="),(yyvsp[(3) - (3)].str)); 22270@@ -39390,8 +36649,6 @@ 22271 break; 22272 22273 case 1605: 22274- 22275-/* Line 1455 of yacc.c */ 22276 #line 9591 "preproc.y" 22277 { 22278 (yyval.str) = (yyvsp[(1) - (1)].str); 22279@@ -39399,8 +36656,6 @@ 22280 break; 22281 22282 case 1606: 22283- 22284-/* Line 1455 of yacc.c */ 22285 #line 9595 "preproc.y" 22286 { 22287 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 22288@@ -39408,8 +36663,6 @@ 22289 break; 22290 22291 case 1607: 22292- 22293-/* Line 1455 of yacc.c */ 22294 #line 9603 "preproc.y" 22295 { 22296 (yyval.str) = cat_str(3,make_str("["),(yyvsp[(2) - (3)].str),make_str("]")); 22297@@ -39417,8 +36670,6 @@ 22298 break; 22299 22300 case 1608: 22301- 22302-/* Line 1455 of yacc.c */ 22303 #line 9607 "preproc.y" 22304 { 22305 (yyval.str) = cat_str(3,make_str("["),(yyvsp[(2) - (3)].str),make_str("]")); 22306@@ -39426,8 +36677,6 @@ 22307 break; 22308 22309 case 1609: 22310- 22311-/* Line 1455 of yacc.c */ 22312 #line 9611 "preproc.y" 22313 { 22314 (yyval.str) = make_str("[ ]"); 22315@@ -39435,8 +36684,6 @@ 22316 break; 22317 22318 case 1610: 22319- 22320-/* Line 1455 of yacc.c */ 22321 #line 9619 "preproc.y" 22322 { 22323 (yyval.str) = (yyvsp[(1) - (1)].str); 22324@@ -39444,8 +36691,6 @@ 22325 break; 22326 22327 case 1611: 22328- 22329-/* Line 1455 of yacc.c */ 22330 #line 9623 "preproc.y" 22331 { 22332 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 22333@@ -39453,8 +36698,6 @@ 22334 break; 22335 22336 case 1612: 22337- 22338-/* Line 1455 of yacc.c */ 22339 #line 9631 "preproc.y" 22340 { 22341 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("from"),(yyvsp[(3) - (3)].str)); 22342@@ -39462,16 +36705,12 @@ 22343 break; 22344 22345 case 1613: 22346- 22347-/* Line 1455 of yacc.c */ 22348 #line 9635 "preproc.y" 22349 { 22350 (yyval.str)=EMPTY; ;} 22351 break; 22352 22353 case 1614: 22354- 22355-/* Line 1455 of yacc.c */ 22356 #line 9642 "preproc.y" 22357 { 22358 (yyval.str) = (yyvsp[(1) - (1)].str); 22359@@ -39479,8 +36718,6 @@ 22360 break; 22361 22362 case 1615: 22363- 22364-/* Line 1455 of yacc.c */ 22365 #line 9646 "preproc.y" 22366 { 22367 (yyval.str) = make_str("year"); 22368@@ -39488,8 +36725,6 @@ 22369 break; 22370 22371 case 1616: 22372- 22373-/* Line 1455 of yacc.c */ 22374 #line 9650 "preproc.y" 22375 { 22376 (yyval.str) = make_str("month"); 22377@@ -39497,8 +36732,6 @@ 22378 break; 22379 22380 case 1617: 22381- 22382-/* Line 1455 of yacc.c */ 22383 #line 9654 "preproc.y" 22384 { 22385 (yyval.str) = make_str("day"); 22386@@ -39506,8 +36739,6 @@ 22387 break; 22388 22389 case 1618: 22390- 22391-/* Line 1455 of yacc.c */ 22392 #line 9658 "preproc.y" 22393 { 22394 (yyval.str) = make_str("hour"); 22395@@ -39515,8 +36746,6 @@ 22396 break; 22397 22398 case 1619: 22399- 22400-/* Line 1455 of yacc.c */ 22401 #line 9662 "preproc.y" 22402 { 22403 (yyval.str) = make_str("minute"); 22404@@ -39524,8 +36753,6 @@ 22405 break; 22406 22407 case 1620: 22408- 22409-/* Line 1455 of yacc.c */ 22410 #line 9666 "preproc.y" 22411 { 22412 (yyval.str) = make_str("second"); 22413@@ -39533,8 +36760,6 @@ 22414 break; 22415 22416 case 1621: 22417- 22418-/* Line 1455 of yacc.c */ 22419 #line 9670 "preproc.y" 22420 { 22421 (yyval.str) = (yyvsp[(1) - (1)].str); 22422@@ -39542,8 +36767,6 @@ 22423 break; 22424 22425 case 1622: 22426- 22427-/* Line 1455 of yacc.c */ 22428 #line 9678 "preproc.y" 22429 { 22430 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 22431@@ -39551,8 +36774,6 @@ 22432 break; 22433 22434 case 1623: 22435- 22436-/* Line 1455 of yacc.c */ 22437 #line 9682 "preproc.y" 22438 { 22439 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 22440@@ -39560,8 +36781,6 @@ 22441 break; 22442 22443 case 1624: 22444- 22445-/* Line 1455 of yacc.c */ 22446 #line 9690 "preproc.y" 22447 { 22448 (yyval.str) = cat_str(2,make_str("placing"),(yyvsp[(2) - (2)].str)); 22449@@ -39569,8 +36788,6 @@ 22450 break; 22451 22452 case 1625: 22453- 22454-/* Line 1455 of yacc.c */ 22455 #line 9698 "preproc.y" 22456 { 22457 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("in"),(yyvsp[(3) - (3)].str)); 22458@@ -39578,16 +36795,12 @@ 22459 break; 22460 22461 case 1626: 22462- 22463-/* Line 1455 of yacc.c */ 22464 #line 9702 "preproc.y" 22465 { 22466 (yyval.str)=EMPTY; ;} 22467 break; 22468 22469 case 1627: 22470- 22471-/* Line 1455 of yacc.c */ 22472 #line 9709 "preproc.y" 22473 { 22474 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 22475@@ -39595,8 +36808,6 @@ 22476 break; 22477 22478 case 1628: 22479- 22480-/* Line 1455 of yacc.c */ 22481 #line 9713 "preproc.y" 22482 { 22483 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 22484@@ -39604,8 +36815,6 @@ 22485 break; 22486 22487 case 1629: 22488- 22489-/* Line 1455 of yacc.c */ 22490 #line 9717 "preproc.y" 22491 { 22492 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 22493@@ -39613,8 +36822,6 @@ 22494 break; 22495 22496 case 1630: 22497- 22498-/* Line 1455 of yacc.c */ 22499 #line 9721 "preproc.y" 22500 { 22501 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 22502@@ -39622,8 +36829,6 @@ 22503 break; 22504 22505 case 1631: 22506- 22507-/* Line 1455 of yacc.c */ 22508 #line 9725 "preproc.y" 22509 { 22510 (yyval.str) = (yyvsp[(1) - (1)].str); 22511@@ -39631,16 +36836,12 @@ 22512 break; 22513 22514 case 1632: 22515- 22516-/* Line 1455 of yacc.c */ 22517 #line 9729 "preproc.y" 22518 { 22519 (yyval.str)=EMPTY; ;} 22520 break; 22521 22522 case 1633: 22523- 22524-/* Line 1455 of yacc.c */ 22525 #line 9736 "preproc.y" 22526 { 22527 (yyval.str) = cat_str(2,make_str("from"),(yyvsp[(2) - (2)].str)); 22528@@ -39648,8 +36849,6 @@ 22529 break; 22530 22531 case 1634: 22532- 22533-/* Line 1455 of yacc.c */ 22534 #line 9744 "preproc.y" 22535 { 22536 (yyval.str) = cat_str(2,make_str("for"),(yyvsp[(2) - (2)].str)); 22537@@ -39657,8 +36856,6 @@ 22538 break; 22539 22540 case 1635: 22541- 22542-/* Line 1455 of yacc.c */ 22543 #line 9752 "preproc.y" 22544 { 22545 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("from"),(yyvsp[(3) - (3)].str)); 22546@@ -39666,8 +36863,6 @@ 22547 break; 22548 22549 case 1636: 22550- 22551-/* Line 1455 of yacc.c */ 22552 #line 9756 "preproc.y" 22553 { 22554 (yyval.str) = cat_str(2,make_str("from"),(yyvsp[(2) - (2)].str)); 22555@@ -39675,8 +36870,6 @@ 22556 break; 22557 22558 case 1637: 22559- 22560-/* Line 1455 of yacc.c */ 22561 #line 9760 "preproc.y" 22562 { 22563 (yyval.str) = (yyvsp[(1) - (1)].str); 22564@@ -39684,8 +36877,6 @@ 22565 break; 22566 22567 case 1638: 22568- 22569-/* Line 1455 of yacc.c */ 22570 #line 9768 "preproc.y" 22571 { 22572 (yyval.str) = (yyvsp[(1) - (1)].str); 22573@@ -39693,8 +36884,6 @@ 22574 break; 22575 22576 case 1639: 22577- 22578-/* Line 1455 of yacc.c */ 22579 #line 9772 "preproc.y" 22580 { 22581 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 22582@@ -39702,8 +36891,6 @@ 22583 break; 22584 22585 case 1640: 22586- 22587-/* Line 1455 of yacc.c */ 22588 #line 9780 "preproc.y" 22589 { 22590 (yyval.str) = cat_str(5,make_str("case"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),make_str("end")); 22591@@ -39711,8 +36898,6 @@ 22592 break; 22593 22594 case 1641: 22595- 22596-/* Line 1455 of yacc.c */ 22597 #line 9788 "preproc.y" 22598 { 22599 (yyval.str) = (yyvsp[(1) - (1)].str); 22600@@ -39720,8 +36905,6 @@ 22601 break; 22602 22603 case 1642: 22604- 22605-/* Line 1455 of yacc.c */ 22606 #line 9792 "preproc.y" 22607 { 22608 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 22609@@ -39729,8 +36912,6 @@ 22610 break; 22611 22612 case 1643: 22613- 22614-/* Line 1455 of yacc.c */ 22615 #line 9800 "preproc.y" 22616 { 22617 (yyval.str) = cat_str(4,make_str("when"),(yyvsp[(2) - (4)].str),make_str("then"),(yyvsp[(4) - (4)].str)); 22618@@ -39738,8 +36919,6 @@ 22619 break; 22620 22621 case 1644: 22622- 22623-/* Line 1455 of yacc.c */ 22624 #line 9808 "preproc.y" 22625 { 22626 (yyval.str) = cat_str(2,make_str("else"),(yyvsp[(2) - (2)].str)); 22627@@ -39747,16 +36926,12 @@ 22628 break; 22629 22630 case 1645: 22631- 22632-/* Line 1455 of yacc.c */ 22633 #line 9812 "preproc.y" 22634 { 22635 (yyval.str)=EMPTY; ;} 22636 break; 22637 22638 case 1646: 22639- 22640-/* Line 1455 of yacc.c */ 22641 #line 9819 "preproc.y" 22642 { 22643 (yyval.str) = (yyvsp[(1) - (1)].str); 22644@@ -39764,16 +36939,12 @@ 22645 break; 22646 22647 case 1647: 22648- 22649-/* Line 1455 of yacc.c */ 22650 #line 9823 "preproc.y" 22651 { 22652 (yyval.str)=EMPTY; ;} 22653 break; 22654 22655 case 1648: 22656- 22657-/* Line 1455 of yacc.c */ 22658 #line 9830 "preproc.y" 22659 { 22660 (yyval.str) = (yyvsp[(1) - (1)].str); 22661@@ -39781,8 +36952,6 @@ 22662 break; 22663 22664 case 1649: 22665- 22666-/* Line 1455 of yacc.c */ 22667 #line 9834 "preproc.y" 22668 { 22669 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 22670@@ -39790,8 +36959,6 @@ 22671 break; 22672 22673 case 1650: 22674- 22675-/* Line 1455 of yacc.c */ 22676 #line 9842 "preproc.y" 22677 { 22678 (yyval.str) = cat_str(2,make_str("."),(yyvsp[(2) - (2)].str)); 22679@@ -39799,8 +36966,6 @@ 22680 break; 22681 22682 case 1651: 22683- 22684-/* Line 1455 of yacc.c */ 22685 #line 9846 "preproc.y" 22686 { 22687 (yyval.str) = make_str(". *"); 22688@@ -39808,8 +36973,6 @@ 22689 break; 22690 22691 case 1652: 22692- 22693-/* Line 1455 of yacc.c */ 22694 #line 9850 "preproc.y" 22695 { 22696 (yyval.str) = cat_str(3,make_str("["),(yyvsp[(2) - (3)].str),make_str("]")); 22697@@ -39817,8 +36980,6 @@ 22698 break; 22699 22700 case 1653: 22701- 22702-/* Line 1455 of yacc.c */ 22703 #line 9854 "preproc.y" 22704 { 22705 (yyval.str) = cat_str(5,make_str("["),(yyvsp[(2) - (5)].str),make_str(":"),(yyvsp[(4) - (5)].str),make_str("]")); 22706@@ -39826,8 +36987,6 @@ 22707 break; 22708 22709 case 1654: 22710- 22711-/* Line 1455 of yacc.c */ 22712 #line 9862 "preproc.y" 22713 { 22714 (yyval.str) = (yyvsp[(1) - (1)].str); 22715@@ -39835,8 +36994,6 @@ 22716 break; 22717 22718 case 1655: 22719- 22720-/* Line 1455 of yacc.c */ 22721 #line 9866 "preproc.y" 22722 { 22723 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 22724@@ -39844,16 +37001,12 @@ 22725 break; 22726 22727 case 1656: 22728- 22729-/* Line 1455 of yacc.c */ 22730 #line 9874 "preproc.y" 22731 { 22732 (yyval.str)=EMPTY; ;} 22733 break; 22734 22735 case 1657: 22736- 22737-/* Line 1455 of yacc.c */ 22738 #line 9877 "preproc.y" 22739 { 22740 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 22741@@ -39861,8 +37014,6 @@ 22742 break; 22743 22744 case 1658: 22745- 22746-/* Line 1455 of yacc.c */ 22747 #line 9885 "preproc.y" 22748 { 22749 (yyval.str) = make_str("asymmetric"); 22750@@ -39870,16 +37021,12 @@ 22751 break; 22752 22753 case 1659: 22754- 22755-/* Line 1455 of yacc.c */ 22756 #line 9889 "preproc.y" 22757 { 22758 (yyval.str)=EMPTY; ;} 22759 break; 22760 22761 case 1660: 22762- 22763-/* Line 1455 of yacc.c */ 22764 #line 9896 "preproc.y" 22765 { 22766 (yyval.str) = (yyvsp[(1) - (1)].str); 22767@@ -39887,8 +37034,6 @@ 22768 break; 22769 22770 case 1661: 22771- 22772-/* Line 1455 of yacc.c */ 22773 #line 9900 "preproc.y" 22774 { 22775 (yyval.str) = make_str("default"); 22776@@ -39896,8 +37041,6 @@ 22777 break; 22778 22779 case 1662: 22780- 22781-/* Line 1455 of yacc.c */ 22782 #line 9908 "preproc.y" 22783 { 22784 (yyval.str) = (yyvsp[(1) - (1)].str); 22785@@ -39905,8 +37048,6 @@ 22786 break; 22787 22788 case 1663: 22789- 22790-/* Line 1455 of yacc.c */ 22791 #line 9912 "preproc.y" 22792 { 22793 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 22794@@ -39914,8 +37055,6 @@ 22795 break; 22796 22797 case 1664: 22798- 22799-/* Line 1455 of yacc.c */ 22800 #line 9920 "preproc.y" 22801 { 22802 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")")); 22803@@ -39923,8 +37062,6 @@ 22804 break; 22805 22806 case 1665: 22807- 22808-/* Line 1455 of yacc.c */ 22809 #line 9928 "preproc.y" 22810 { 22811 (yyval.str) = (yyvsp[(1) - (1)].str); 22812@@ -39932,8 +37069,6 @@ 22813 break; 22814 22815 case 1666: 22816- 22817-/* Line 1455 of yacc.c */ 22818 #line 9932 "preproc.y" 22819 { 22820 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 22821@@ -39941,8 +37076,6 @@ 22822 break; 22823 22824 case 1667: 22825- 22826-/* Line 1455 of yacc.c */ 22827 #line 9940 "preproc.y" 22828 { 22829 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("as"),(yyvsp[(3) - (3)].str)); 22830@@ -39950,8 +37083,6 @@ 22831 break; 22832 22833 case 1668: 22834- 22835-/* Line 1455 of yacc.c */ 22836 #line 9944 "preproc.y" 22837 { 22838 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 22839@@ -39959,8 +37090,6 @@ 22840 break; 22841 22842 case 1669: 22843- 22844-/* Line 1455 of yacc.c */ 22845 #line 9948 "preproc.y" 22846 { 22847 (yyval.str) = (yyvsp[(1) - (1)].str); 22848@@ -39968,8 +37097,6 @@ 22849 break; 22850 22851 case 1670: 22852- 22853-/* Line 1455 of yacc.c */ 22854 #line 9952 "preproc.y" 22855 { 22856 (yyval.str) = make_str("*"); 22857@@ -39977,8 +37104,6 @@ 22858 break; 22859 22860 case 1671: 22861- 22862-/* Line 1455 of yacc.c */ 22863 #line 9960 "preproc.y" 22864 { 22865 (yyval.str) = (yyvsp[(1) - (1)].str); 22866@@ -39986,8 +37111,6 @@ 22867 break; 22868 22869 case 1672: 22870- 22871-/* Line 1455 of yacc.c */ 22872 #line 9964 "preproc.y" 22873 { 22874 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 22875@@ -39995,8 +37118,6 @@ 22876 break; 22877 22878 case 1673: 22879- 22880-/* Line 1455 of yacc.c */ 22881 #line 9972 "preproc.y" 22882 { 22883 (yyval.str) = (yyvsp[(1) - (1)].str); 22884@@ -40004,8 +37125,6 @@ 22885 break; 22886 22887 case 1674: 22888- 22889-/* Line 1455 of yacc.c */ 22890 #line 9976 "preproc.y" 22891 { 22892 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 22893@@ -40013,8 +37132,6 @@ 22894 break; 22895 22896 case 1675: 22897- 22898-/* Line 1455 of yacc.c */ 22899 #line 9984 "preproc.y" 22900 { 22901 (yyval.str) = (yyvsp[(1) - (1)].str); 22902@@ -40022,8 +37139,6 @@ 22903 break; 22904 22905 case 1676: 22906- 22907-/* Line 1455 of yacc.c */ 22908 #line 9988 "preproc.y" 22909 { 22910 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str)); 22911@@ -40031,8 +37146,6 @@ 22912 break; 22913 22914 case 1677: 22915- 22916-/* Line 1455 of yacc.c */ 22917 #line 9996 "preproc.y" 22918 { 22919 (yyval.str) = (yyvsp[(1) - (1)].str); 22920@@ -40040,8 +37153,6 @@ 22921 break; 22922 22923 case 1678: 22924- 22925-/* Line 1455 of yacc.c */ 22926 #line 10004 "preproc.y" 22927 { 22928 (yyval.str) = (yyvsp[(1) - (1)].str); 22929@@ -40049,8 +37160,6 @@ 22930 break; 22931 22932 case 1679: 22933- 22934-/* Line 1455 of yacc.c */ 22935 #line 10012 "preproc.y" 22936 { 22937 (yyval.str) = (yyvsp[(1) - (1)].str); 22938@@ -40058,8 +37167,6 @@ 22939 break; 22940 22941 case 1680: 22942- 22943-/* Line 1455 of yacc.c */ 22944 #line 10020 "preproc.y" 22945 { 22946 (yyval.str) = (yyvsp[(1) - (1)].str); 22947@@ -40067,8 +37174,6 @@ 22948 break; 22949 22950 case 1681: 22951- 22952-/* Line 1455 of yacc.c */ 22953 #line 10028 "preproc.y" 22954 { 22955 (yyval.str) = (yyvsp[(1) - (1)].str); 22956@@ -40076,8 +37181,6 @@ 22957 break; 22958 22959 case 1682: 22960- 22961-/* Line 1455 of yacc.c */ 22962 #line 10036 "preproc.y" 22963 { 22964 (yyval.str) = (yyvsp[(1) - (1)].str); 22965@@ -40085,8 +37188,6 @@ 22966 break; 22967 22968 case 1683: 22969- 22970-/* Line 1455 of yacc.c */ 22971 #line 10044 "preproc.y" 22972 { 22973 (yyval.str) = (yyvsp[(1) - (1)].str); 22974@@ -40094,8 +37195,6 @@ 22975 break; 22976 22977 case 1684: 22978- 22979-/* Line 1455 of yacc.c */ 22980 #line 10048 "preproc.y" 22981 { 22982 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 22983@@ -40103,8 +37202,6 @@ 22984 break; 22985 22986 case 1685: 22987- 22988-/* Line 1455 of yacc.c */ 22989 #line 10056 "preproc.y" 22990 { 22991 (yyval.str) = (yyvsp[(1) - (1)].str); 22992@@ -40112,8 +37209,6 @@ 22993 break; 22994 22995 case 1686: 22996- 22997-/* Line 1455 of yacc.c */ 22998 #line 10060 "preproc.y" 22999 { 23000 (yyval.str) = (yyvsp[(1) - (1)].str); 23001@@ -40121,8 +37216,6 @@ 23002 break; 23003 23004 case 1687: 23005- 23006-/* Line 1455 of yacc.c */ 23007 #line 10064 "preproc.y" 23008 { 23009 (yyval.str) = (yyvsp[(1) - (1)].str); 23010@@ -40130,8 +37223,6 @@ 23011 break; 23012 23013 case 1688: 23014- 23015-/* Line 1455 of yacc.c */ 23016 #line 10068 "preproc.y" 23017 { 23018 (yyval.str) = (yyvsp[(1) - (1)].str); 23019@@ -40139,8 +37230,6 @@ 23020 break; 23021 23022 case 1689: 23023- 23024-/* Line 1455 of yacc.c */ 23025 #line 10072 "preproc.y" 23026 { 23027 (yyval.str) = make_str("xconst"); 23028@@ -40148,8 +37237,6 @@ 23029 break; 23030 23031 case 1690: 23032- 23033-/* Line 1455 of yacc.c */ 23034 #line 10076 "preproc.y" 23035 { 23036 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 23037@@ -40157,8 +37244,6 @@ 23038 break; 23039 23040 case 1691: 23041- 23042-/* Line 1455 of yacc.c */ 23043 #line 10080 "preproc.y" 23044 { 23045 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),make_str("("),(yyvsp[(3) - (5)].str),make_str(")"),(yyvsp[(5) - (5)].str)); 23046@@ -40166,8 +37251,6 @@ 23047 break; 23048 23049 case 1692: 23050- 23051-/* Line 1455 of yacc.c */ 23052 #line 10084 "preproc.y" 23053 { 23054 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 23055@@ -40175,8 +37258,6 @@ 23056 break; 23057 23058 case 1693: 23059- 23060-/* Line 1455 of yacc.c */ 23061 #line 10088 "preproc.y" 23062 { 23063 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 23064@@ -40184,8 +37265,6 @@ 23065 break; 23066 23067 case 1694: 23068- 23069-/* Line 1455 of yacc.c */ 23070 #line 10092 "preproc.y" 23071 { 23072 (yyval.str) = cat_str(6,(yyvsp[(1) - (6)].str),make_str("("),(yyvsp[(3) - (6)].str),make_str(")"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str)); 23073@@ -40193,8 +37272,6 @@ 23074 break; 23075 23076 case 1695: 23077- 23078-/* Line 1455 of yacc.c */ 23079 #line 10096 "preproc.y" 23080 { 23081 (yyval.str) = make_str("true"); 23082@@ -40202,8 +37279,6 @@ 23083 break; 23084 23085 case 1696: 23086- 23087-/* Line 1455 of yacc.c */ 23088 #line 10100 "preproc.y" 23089 { 23090 (yyval.str) = make_str("false"); 23091@@ -40211,8 +37286,6 @@ 23092 break; 23093 23094 case 1697: 23095- 23096-/* Line 1455 of yacc.c */ 23097 #line 10104 "preproc.y" 23098 { 23099 (yyval.str) = make_str("null"); 23100@@ -40220,29 +37293,21 @@ 23101 break; 23102 23103 case 1698: 23104- 23105-/* Line 1455 of yacc.c */ 23106 #line 10107 "preproc.y" 23107 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 23108 break; 23109 23110 case 1699: 23111- 23112-/* Line 1455 of yacc.c */ 23113 #line 10108 "preproc.y" 23114 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 23115 break; 23116 23117 case 1700: 23118- 23119-/* Line 1455 of yacc.c */ 23120 #line 10114 "preproc.y" 23121 { (yyval.str) = make_name(); ;} 23122 break; 23123 23124 case 1701: 23125- 23126-/* Line 1455 of yacc.c */ 23127 #line 10120 "preproc.y" 23128 { 23129 (yyval.str) = (yyvsp[(1) - (1)].str); 23130@@ -40250,8 +37315,6 @@ 23131 break; 23132 23133 case 1702: 23134- 23135-/* Line 1455 of yacc.c */ 23136 #line 10128 "preproc.y" 23137 { 23138 (yyval.str) = (yyvsp[(1) - (1)].str); 23139@@ -40259,15 +37322,11 @@ 23140 break; 23141 23142 case 1703: 23143- 23144-/* Line 1455 of yacc.c */ 23145 #line 10131 "preproc.y" 23146 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 23147 break; 23148 23149 case 1704: 23150- 23151-/* Line 1455 of yacc.c */ 23152 #line 10133 "preproc.y" 23153 { 23154 (yyval.str) = cat_str(2,make_str("+"),(yyvsp[(2) - (2)].str)); 23155@@ -40275,8 +37334,6 @@ 23156 break; 23157 23158 case 1705: 23159- 23160-/* Line 1455 of yacc.c */ 23161 #line 10137 "preproc.y" 23162 { 23163 (yyval.str) = cat_str(2,make_str("-"),(yyvsp[(2) - (2)].str)); 23164@@ -40284,8 +37341,6 @@ 23165 break; 23166 23167 case 1706: 23168- 23169-/* Line 1455 of yacc.c */ 23170 #line 10145 "preproc.y" 23171 { 23172 (yyval.str) = make_str("abort"); 23173@@ -40293,8 +37348,6 @@ 23174 break; 23175 23176 case 1707: 23177- 23178-/* Line 1455 of yacc.c */ 23179 #line 10149 "preproc.y" 23180 { 23181 (yyval.str) = make_str("absolute"); 23182@@ -40302,8 +37355,6 @@ 23183 break; 23184 23185 case 1708: 23186- 23187-/* Line 1455 of yacc.c */ 23188 #line 10153 "preproc.y" 23189 { 23190 (yyval.str) = make_str("access"); 23191@@ -40311,8 +37362,6 @@ 23192 break; 23193 23194 case 1709: 23195- 23196-/* Line 1455 of yacc.c */ 23197 #line 10157 "preproc.y" 23198 { 23199 (yyval.str) = make_str("action"); 23200@@ -40320,8 +37369,6 @@ 23201 break; 23202 23203 case 1710: 23204- 23205-/* Line 1455 of yacc.c */ 23206 #line 10161 "preproc.y" 23207 { 23208 (yyval.str) = make_str("add"); 23209@@ -40329,8 +37376,6 @@ 23210 break; 23211 23212 case 1711: 23213- 23214-/* Line 1455 of yacc.c */ 23215 #line 10165 "preproc.y" 23216 { 23217 (yyval.str) = make_str("admin"); 23218@@ -40338,8 +37383,6 @@ 23219 break; 23220 23221 case 1712: 23222- 23223-/* Line 1455 of yacc.c */ 23224 #line 10169 "preproc.y" 23225 { 23226 (yyval.str) = make_str("after"); 23227@@ -40347,8 +37390,6 @@ 23228 break; 23229 23230 case 1713: 23231- 23232-/* Line 1455 of yacc.c */ 23233 #line 10173 "preproc.y" 23234 { 23235 (yyval.str) = make_str("aggregate"); 23236@@ -40356,8 +37397,6 @@ 23237 break; 23238 23239 case 1714: 23240- 23241-/* Line 1455 of yacc.c */ 23242 #line 10177 "preproc.y" 23243 { 23244 (yyval.str) = make_str("also"); 23245@@ -40365,8 +37404,6 @@ 23246 break; 23247 23248 case 1715: 23249- 23250-/* Line 1455 of yacc.c */ 23251 #line 10181 "preproc.y" 23252 { 23253 (yyval.str) = make_str("alter"); 23254@@ -40374,8 +37411,6 @@ 23255 break; 23256 23257 case 1716: 23258- 23259-/* Line 1455 of yacc.c */ 23260 #line 10185 "preproc.y" 23261 { 23262 (yyval.str) = make_str("always"); 23263@@ -40383,8 +37418,6 @@ 23264 break; 23265 23266 case 1717: 23267- 23268-/* Line 1455 of yacc.c */ 23269 #line 10189 "preproc.y" 23270 { 23271 (yyval.str) = make_str("assertion"); 23272@@ -40392,8 +37425,6 @@ 23273 break; 23274 23275 case 1718: 23276- 23277-/* Line 1455 of yacc.c */ 23278 #line 10193 "preproc.y" 23279 { 23280 (yyval.str) = make_str("assignment"); 23281@@ -40401,8 +37432,6 @@ 23282 break; 23283 23284 case 1719: 23285- 23286-/* Line 1455 of yacc.c */ 23287 #line 10197 "preproc.y" 23288 { 23289 (yyval.str) = make_str("at"); 23290@@ -40410,8 +37439,6 @@ 23291 break; 23292 23293 case 1720: 23294- 23295-/* Line 1455 of yacc.c */ 23296 #line 10201 "preproc.y" 23297 { 23298 (yyval.str) = make_str("backward"); 23299@@ -40419,8 +37446,6 @@ 23300 break; 23301 23302 case 1721: 23303- 23304-/* Line 1455 of yacc.c */ 23305 #line 10205 "preproc.y" 23306 { 23307 (yyval.str) = make_str("before"); 23308@@ -40428,8 +37453,6 @@ 23309 break; 23310 23311 case 1722: 23312- 23313-/* Line 1455 of yacc.c */ 23314 #line 10209 "preproc.y" 23315 { 23316 (yyval.str) = make_str("begin"); 23317@@ -40437,8 +37460,6 @@ 23318 break; 23319 23320 case 1723: 23321- 23322-/* Line 1455 of yacc.c */ 23323 #line 10213 "preproc.y" 23324 { 23325 (yyval.str) = make_str("by"); 23326@@ -40446,8 +37467,6 @@ 23327 break; 23328 23329 case 1724: 23330- 23331-/* Line 1455 of yacc.c */ 23332 #line 10217 "preproc.y" 23333 { 23334 (yyval.str) = make_str("cache"); 23335@@ -40455,8 +37474,6 @@ 23336 break; 23337 23338 case 1725: 23339- 23340-/* Line 1455 of yacc.c */ 23341 #line 10221 "preproc.y" 23342 { 23343 (yyval.str) = make_str("called"); 23344@@ -40464,8 +37481,6 @@ 23345 break; 23346 23347 case 1726: 23348- 23349-/* Line 1455 of yacc.c */ 23350 #line 10225 "preproc.y" 23351 { 23352 (yyval.str) = make_str("cascade"); 23353@@ -40473,8 +37488,6 @@ 23354 break; 23355 23356 case 1727: 23357- 23358-/* Line 1455 of yacc.c */ 23359 #line 10229 "preproc.y" 23360 { 23361 (yyval.str) = make_str("cascaded"); 23362@@ -40482,8 +37495,6 @@ 23363 break; 23364 23365 case 1728: 23366- 23367-/* Line 1455 of yacc.c */ 23368 #line 10233 "preproc.y" 23369 { 23370 (yyval.str) = make_str("catalog"); 23371@@ -40491,8 +37502,6 @@ 23372 break; 23373 23374 case 1729: 23375- 23376-/* Line 1455 of yacc.c */ 23377 #line 10237 "preproc.y" 23378 { 23379 (yyval.str) = make_str("chain"); 23380@@ -40500,8 +37509,6 @@ 23381 break; 23382 23383 case 1730: 23384- 23385-/* Line 1455 of yacc.c */ 23386 #line 10241 "preproc.y" 23387 { 23388 (yyval.str) = make_str("characteristics"); 23389@@ -40509,8 +37516,6 @@ 23390 break; 23391 23392 case 1731: 23393- 23394-/* Line 1455 of yacc.c */ 23395 #line 10245 "preproc.y" 23396 { 23397 (yyval.str) = make_str("checkpoint"); 23398@@ -40518,8 +37523,6 @@ 23399 break; 23400 23401 case 1732: 23402- 23403-/* Line 1455 of yacc.c */ 23404 #line 10249 "preproc.y" 23405 { 23406 (yyval.str) = make_str("class"); 23407@@ -40527,8 +37530,6 @@ 23408 break; 23409 23410 case 1733: 23411- 23412-/* Line 1455 of yacc.c */ 23413 #line 10253 "preproc.y" 23414 { 23415 (yyval.str) = make_str("close"); 23416@@ -40536,8 +37537,6 @@ 23417 break; 23418 23419 case 1734: 23420- 23421-/* Line 1455 of yacc.c */ 23422 #line 10257 "preproc.y" 23423 { 23424 (yyval.str) = make_str("cluster"); 23425@@ -40545,8 +37544,6 @@ 23426 break; 23427 23428 case 1735: 23429- 23430-/* Line 1455 of yacc.c */ 23431 #line 10261 "preproc.y" 23432 { 23433 (yyval.str) = make_str("comment"); 23434@@ -40554,8 +37551,6 @@ 23435 break; 23436 23437 case 1736: 23438- 23439-/* Line 1455 of yacc.c */ 23440 #line 10265 "preproc.y" 23441 { 23442 (yyval.str) = make_str("comments"); 23443@@ -40563,8 +37558,6 @@ 23444 break; 23445 23446 case 1737: 23447- 23448-/* Line 1455 of yacc.c */ 23449 #line 10269 "preproc.y" 23450 { 23451 (yyval.str) = make_str("commit"); 23452@@ -40572,8 +37565,6 @@ 23453 break; 23454 23455 case 1738: 23456- 23457-/* Line 1455 of yacc.c */ 23458 #line 10273 "preproc.y" 23459 { 23460 (yyval.str) = make_str("committed"); 23461@@ -40581,8 +37572,6 @@ 23462 break; 23463 23464 case 1739: 23465- 23466-/* Line 1455 of yacc.c */ 23467 #line 10277 "preproc.y" 23468 { 23469 (yyval.str) = make_str("configuration"); 23470@@ -40590,8 +37579,6 @@ 23471 break; 23472 23473 case 1740: 23474- 23475-/* Line 1455 of yacc.c */ 23476 #line 10281 "preproc.y" 23477 { 23478 (yyval.str) = make_str("constraints"); 23479@@ -40599,8 +37586,6 @@ 23480 break; 23481 23482 case 1741: 23483- 23484-/* Line 1455 of yacc.c */ 23485 #line 10285 "preproc.y" 23486 { 23487 (yyval.str) = make_str("content"); 23488@@ -40608,8 +37593,6 @@ 23489 break; 23490 23491 case 1742: 23492- 23493-/* Line 1455 of yacc.c */ 23494 #line 10289 "preproc.y" 23495 { 23496 (yyval.str) = make_str("continue"); 23497@@ -40617,8 +37600,6 @@ 23498 break; 23499 23500 case 1743: 23501- 23502-/* Line 1455 of yacc.c */ 23503 #line 10293 "preproc.y" 23504 { 23505 (yyval.str) = make_str("conversion"); 23506@@ -40626,8 +37607,6 @@ 23507 break; 23508 23509 case 1744: 23510- 23511-/* Line 1455 of yacc.c */ 23512 #line 10297 "preproc.y" 23513 { 23514 (yyval.str) = make_str("copy"); 23515@@ -40635,8 +37614,6 @@ 23516 break; 23517 23518 case 1745: 23519- 23520-/* Line 1455 of yacc.c */ 23521 #line 10301 "preproc.y" 23522 { 23523 (yyval.str) = make_str("cost"); 23524@@ -40644,8 +37621,6 @@ 23525 break; 23526 23527 case 1746: 23528- 23529-/* Line 1455 of yacc.c */ 23530 #line 10305 "preproc.y" 23531 { 23532 (yyval.str) = make_str("createdb"); 23533@@ -40653,8 +37628,6 @@ 23534 break; 23535 23536 case 1747: 23537- 23538-/* Line 1455 of yacc.c */ 23539 #line 10309 "preproc.y" 23540 { 23541 (yyval.str) = make_str("createrole"); 23542@@ -40662,8 +37635,6 @@ 23543 break; 23544 23545 case 1748: 23546- 23547-/* Line 1455 of yacc.c */ 23548 #line 10313 "preproc.y" 23549 { 23550 (yyval.str) = make_str("createuser"); 23551@@ -40671,8 +37642,6 @@ 23552 break; 23553 23554 case 1749: 23555- 23556-/* Line 1455 of yacc.c */ 23557 #line 10317 "preproc.y" 23558 { 23559 (yyval.str) = make_str("csv"); 23560@@ -40680,8 +37649,6 @@ 23561 break; 23562 23563 case 1750: 23564- 23565-/* Line 1455 of yacc.c */ 23566 #line 10321 "preproc.y" 23567 { 23568 (yyval.str) = make_str("cursor"); 23569@@ -40689,8 +37656,6 @@ 23570 break; 23571 23572 case 1751: 23573- 23574-/* Line 1455 of yacc.c */ 23575 #line 10325 "preproc.y" 23576 { 23577 (yyval.str) = make_str("cycle"); 23578@@ -40698,8 +37663,6 @@ 23579 break; 23580 23581 case 1752: 23582- 23583-/* Line 1455 of yacc.c */ 23584 #line 10329 "preproc.y" 23585 { 23586 (yyval.str) = make_str("data"); 23587@@ -40707,8 +37670,6 @@ 23588 break; 23589 23590 case 1753: 23591- 23592-/* Line 1455 of yacc.c */ 23593 #line 10333 "preproc.y" 23594 { 23595 (yyval.str) = make_str("database"); 23596@@ -40716,8 +37677,6 @@ 23597 break; 23598 23599 case 1754: 23600- 23601-/* Line 1455 of yacc.c */ 23602 #line 10337 "preproc.y" 23603 { 23604 (yyval.str) = make_str("deallocate"); 23605@@ -40725,8 +37684,6 @@ 23606 break; 23607 23608 case 1755: 23609- 23610-/* Line 1455 of yacc.c */ 23611 #line 10341 "preproc.y" 23612 { 23613 (yyval.str) = make_str("declare"); 23614@@ -40734,8 +37691,6 @@ 23615 break; 23616 23617 case 1756: 23618- 23619-/* Line 1455 of yacc.c */ 23620 #line 10345 "preproc.y" 23621 { 23622 (yyval.str) = make_str("defaults"); 23623@@ -40743,8 +37698,6 @@ 23624 break; 23625 23626 case 1757: 23627- 23628-/* Line 1455 of yacc.c */ 23629 #line 10349 "preproc.y" 23630 { 23631 (yyval.str) = make_str("deferred"); 23632@@ -40752,8 +37705,6 @@ 23633 break; 23634 23635 case 1758: 23636- 23637-/* Line 1455 of yacc.c */ 23638 #line 10353 "preproc.y" 23639 { 23640 (yyval.str) = make_str("definer"); 23641@@ -40761,8 +37712,6 @@ 23642 break; 23643 23644 case 1759: 23645- 23646-/* Line 1455 of yacc.c */ 23647 #line 10357 "preproc.y" 23648 { 23649 (yyval.str) = make_str("delete"); 23650@@ -40770,8 +37719,6 @@ 23651 break; 23652 23653 case 1760: 23654- 23655-/* Line 1455 of yacc.c */ 23656 #line 10361 "preproc.y" 23657 { 23658 (yyval.str) = make_str("delimiter"); 23659@@ -40779,8 +37726,6 @@ 23660 break; 23661 23662 case 1761: 23663- 23664-/* Line 1455 of yacc.c */ 23665 #line 10365 "preproc.y" 23666 { 23667 (yyval.str) = make_str("delimiters"); 23668@@ -40788,8 +37733,6 @@ 23669 break; 23670 23671 case 1762: 23672- 23673-/* Line 1455 of yacc.c */ 23674 #line 10369 "preproc.y" 23675 { 23676 (yyval.str) = make_str("dictionary"); 23677@@ -40797,8 +37740,6 @@ 23678 break; 23679 23680 case 1763: 23681- 23682-/* Line 1455 of yacc.c */ 23683 #line 10373 "preproc.y" 23684 { 23685 (yyval.str) = make_str("disable"); 23686@@ -40806,8 +37747,6 @@ 23687 break; 23688 23689 case 1764: 23690- 23691-/* Line 1455 of yacc.c */ 23692 #line 10377 "preproc.y" 23693 { 23694 (yyval.str) = make_str("discard"); 23695@@ -40815,8 +37754,6 @@ 23696 break; 23697 23698 case 1765: 23699- 23700-/* Line 1455 of yacc.c */ 23701 #line 10381 "preproc.y" 23702 { 23703 (yyval.str) = make_str("document"); 23704@@ -40824,8 +37761,6 @@ 23705 break; 23706 23707 case 1766: 23708- 23709-/* Line 1455 of yacc.c */ 23710 #line 10385 "preproc.y" 23711 { 23712 (yyval.str) = make_str("domain"); 23713@@ -40833,8 +37768,6 @@ 23714 break; 23715 23716 case 1767: 23717- 23718-/* Line 1455 of yacc.c */ 23719 #line 10389 "preproc.y" 23720 { 23721 (yyval.str) = make_str("double"); 23722@@ -40842,8 +37775,6 @@ 23723 break; 23724 23725 case 1768: 23726- 23727-/* Line 1455 of yacc.c */ 23728 #line 10393 "preproc.y" 23729 { 23730 (yyval.str) = make_str("drop"); 23731@@ -40851,8 +37782,6 @@ 23732 break; 23733 23734 case 1769: 23735- 23736-/* Line 1455 of yacc.c */ 23737 #line 10397 "preproc.y" 23738 { 23739 (yyval.str) = make_str("each"); 23740@@ -40860,8 +37789,6 @@ 23741 break; 23742 23743 case 1770: 23744- 23745-/* Line 1455 of yacc.c */ 23746 #line 10401 "preproc.y" 23747 { 23748 (yyval.str) = make_str("enable"); 23749@@ -40869,8 +37796,6 @@ 23750 break; 23751 23752 case 1771: 23753- 23754-/* Line 1455 of yacc.c */ 23755 #line 10405 "preproc.y" 23756 { 23757 (yyval.str) = make_str("encoding"); 23758@@ -40878,8 +37803,6 @@ 23759 break; 23760 23761 case 1772: 23762- 23763-/* Line 1455 of yacc.c */ 23764 #line 10409 "preproc.y" 23765 { 23766 (yyval.str) = make_str("encrypted"); 23767@@ -40887,8 +37810,6 @@ 23768 break; 23769 23770 case 1773: 23771- 23772-/* Line 1455 of yacc.c */ 23773 #line 10413 "preproc.y" 23774 { 23775 (yyval.str) = make_str("enum"); 23776@@ -40896,8 +37817,6 @@ 23777 break; 23778 23779 case 1774: 23780- 23781-/* Line 1455 of yacc.c */ 23782 #line 10417 "preproc.y" 23783 { 23784 (yyval.str) = make_str("escape"); 23785@@ -40905,8 +37824,6 @@ 23786 break; 23787 23788 case 1775: 23789- 23790-/* Line 1455 of yacc.c */ 23791 #line 10421 "preproc.y" 23792 { 23793 (yyval.str) = make_str("exclude"); 23794@@ -40914,8 +37831,6 @@ 23795 break; 23796 23797 case 1776: 23798- 23799-/* Line 1455 of yacc.c */ 23800 #line 10425 "preproc.y" 23801 { 23802 (yyval.str) = make_str("excluding"); 23803@@ -40923,8 +37838,6 @@ 23804 break; 23805 23806 case 1777: 23807- 23808-/* Line 1455 of yacc.c */ 23809 #line 10429 "preproc.y" 23810 { 23811 (yyval.str) = make_str("exclusive"); 23812@@ -40932,8 +37845,6 @@ 23813 break; 23814 23815 case 1778: 23816- 23817-/* Line 1455 of yacc.c */ 23818 #line 10433 "preproc.y" 23819 { 23820 (yyval.str) = make_str("execute"); 23821@@ -40941,8 +37852,6 @@ 23822 break; 23823 23824 case 1779: 23825- 23826-/* Line 1455 of yacc.c */ 23827 #line 10437 "preproc.y" 23828 { 23829 (yyval.str) = make_str("explain"); 23830@@ -40950,8 +37859,6 @@ 23831 break; 23832 23833 case 1780: 23834- 23835-/* Line 1455 of yacc.c */ 23836 #line 10441 "preproc.y" 23837 { 23838 (yyval.str) = make_str("external"); 23839@@ -40959,8 +37866,6 @@ 23840 break; 23841 23842 case 1781: 23843- 23844-/* Line 1455 of yacc.c */ 23845 #line 10445 "preproc.y" 23846 { 23847 (yyval.str) = make_str("family"); 23848@@ -40968,8 +37873,6 @@ 23849 break; 23850 23851 case 1782: 23852- 23853-/* Line 1455 of yacc.c */ 23854 #line 10449 "preproc.y" 23855 { 23856 (yyval.str) = make_str("first"); 23857@@ -40977,8 +37880,6 @@ 23858 break; 23859 23860 case 1783: 23861- 23862-/* Line 1455 of yacc.c */ 23863 #line 10453 "preproc.y" 23864 { 23865 (yyval.str) = make_str("following"); 23866@@ -40986,8 +37887,6 @@ 23867 break; 23868 23869 case 1784: 23870- 23871-/* Line 1455 of yacc.c */ 23872 #line 10457 "preproc.y" 23873 { 23874 (yyval.str) = make_str("force"); 23875@@ -40995,8 +37894,6 @@ 23876 break; 23877 23878 case 1785: 23879- 23880-/* Line 1455 of yacc.c */ 23881 #line 10461 "preproc.y" 23882 { 23883 (yyval.str) = make_str("forward"); 23884@@ -41004,8 +37901,6 @@ 23885 break; 23886 23887 case 1786: 23888- 23889-/* Line 1455 of yacc.c */ 23890 #line 10465 "preproc.y" 23891 { 23892 (yyval.str) = make_str("function"); 23893@@ -41013,8 +37908,6 @@ 23894 break; 23895 23896 case 1787: 23897- 23898-/* Line 1455 of yacc.c */ 23899 #line 10469 "preproc.y" 23900 { 23901 (yyval.str) = make_str("functions"); 23902@@ -41022,8 +37915,6 @@ 23903 break; 23904 23905 case 1788: 23906- 23907-/* Line 1455 of yacc.c */ 23908 #line 10473 "preproc.y" 23909 { 23910 (yyval.str) = make_str("global"); 23911@@ -41031,8 +37922,6 @@ 23912 break; 23913 23914 case 1789: 23915- 23916-/* Line 1455 of yacc.c */ 23917 #line 10477 "preproc.y" 23918 { 23919 (yyval.str) = make_str("granted"); 23920@@ -41040,8 +37929,6 @@ 23921 break; 23922 23923 case 1790: 23924- 23925-/* Line 1455 of yacc.c */ 23926 #line 10481 "preproc.y" 23927 { 23928 (yyval.str) = make_str("handler"); 23929@@ -41049,8 +37936,6 @@ 23930 break; 23931 23932 case 1791: 23933- 23934-/* Line 1455 of yacc.c */ 23935 #line 10485 "preproc.y" 23936 { 23937 (yyval.str) = make_str("header"); 23938@@ -41058,8 +37943,6 @@ 23939 break; 23940 23941 case 1792: 23942- 23943-/* Line 1455 of yacc.c */ 23944 #line 10489 "preproc.y" 23945 { 23946 (yyval.str) = make_str("hold"); 23947@@ -41067,8 +37950,6 @@ 23948 break; 23949 23950 case 1793: 23951- 23952-/* Line 1455 of yacc.c */ 23953 #line 10493 "preproc.y" 23954 { 23955 (yyval.str) = make_str("identity"); 23956@@ -41076,8 +37957,6 @@ 23957 break; 23958 23959 case 1794: 23960- 23961-/* Line 1455 of yacc.c */ 23962 #line 10497 "preproc.y" 23963 { 23964 (yyval.str) = make_str("if"); 23965@@ -41085,8 +37964,6 @@ 23966 break; 23967 23968 case 1795: 23969- 23970-/* Line 1455 of yacc.c */ 23971 #line 10501 "preproc.y" 23972 { 23973 (yyval.str) = make_str("immediate"); 23974@@ -41094,8 +37971,6 @@ 23975 break; 23976 23977 case 1796: 23978- 23979-/* Line 1455 of yacc.c */ 23980 #line 10505 "preproc.y" 23981 { 23982 (yyval.str) = make_str("immutable"); 23983@@ -41103,8 +37978,6 @@ 23984 break; 23985 23986 case 1797: 23987- 23988-/* Line 1455 of yacc.c */ 23989 #line 10509 "preproc.y" 23990 { 23991 (yyval.str) = make_str("implicit"); 23992@@ -41112,8 +37985,6 @@ 23993 break; 23994 23995 case 1798: 23996- 23997-/* Line 1455 of yacc.c */ 23998 #line 10513 "preproc.y" 23999 { 24000 (yyval.str) = make_str("including"); 24001@@ -41121,8 +37992,6 @@ 24002 break; 24003 24004 case 1799: 24005- 24006-/* Line 1455 of yacc.c */ 24007 #line 10517 "preproc.y" 24008 { 24009 (yyval.str) = make_str("increment"); 24010@@ -41130,8 +37999,6 @@ 24011 break; 24012 24013 case 1800: 24014- 24015-/* Line 1455 of yacc.c */ 24016 #line 10521 "preproc.y" 24017 { 24018 (yyval.str) = make_str("index"); 24019@@ -41139,8 +38006,6 @@ 24020 break; 24021 24022 case 1801: 24023- 24024-/* Line 1455 of yacc.c */ 24025 #line 10525 "preproc.y" 24026 { 24027 (yyval.str) = make_str("indexes"); 24028@@ -41148,8 +38013,6 @@ 24029 break; 24030 24031 case 1802: 24032- 24033-/* Line 1455 of yacc.c */ 24034 #line 10529 "preproc.y" 24035 { 24036 (yyval.str) = make_str("inherit"); 24037@@ -41157,8 +38020,6 @@ 24038 break; 24039 24040 case 1803: 24041- 24042-/* Line 1455 of yacc.c */ 24043 #line 10533 "preproc.y" 24044 { 24045 (yyval.str) = make_str("inherits"); 24046@@ -41166,8 +38027,6 @@ 24047 break; 24048 24049 case 1804: 24050- 24051-/* Line 1455 of yacc.c */ 24052 #line 10537 "preproc.y" 24053 { 24054 (yyval.str) = make_str("inline"); 24055@@ -41175,8 +38034,6 @@ 24056 break; 24057 24058 case 1805: 24059- 24060-/* Line 1455 of yacc.c */ 24061 #line 10541 "preproc.y" 24062 { 24063 (yyval.str) = make_str("insensitive"); 24064@@ -41184,8 +38041,6 @@ 24065 break; 24066 24067 case 1806: 24068- 24069-/* Line 1455 of yacc.c */ 24070 #line 10545 "preproc.y" 24071 { 24072 (yyval.str) = make_str("insert"); 24073@@ -41193,8 +38048,6 @@ 24074 break; 24075 24076 case 1807: 24077- 24078-/* Line 1455 of yacc.c */ 24079 #line 10549 "preproc.y" 24080 { 24081 (yyval.str) = make_str("instead"); 24082@@ -41202,8 +38055,6 @@ 24083 break; 24084 24085 case 1808: 24086- 24087-/* Line 1455 of yacc.c */ 24088 #line 10553 "preproc.y" 24089 { 24090 (yyval.str) = make_str("invoker"); 24091@@ -41211,8 +38062,6 @@ 24092 break; 24093 24094 case 1809: 24095- 24096-/* Line 1455 of yacc.c */ 24097 #line 10557 "preproc.y" 24098 { 24099 (yyval.str) = make_str("isolation"); 24100@@ -41220,8 +38069,6 @@ 24101 break; 24102 24103 case 1810: 24104- 24105-/* Line 1455 of yacc.c */ 24106 #line 10561 "preproc.y" 24107 { 24108 (yyval.str) = make_str("key"); 24109@@ -41229,8 +38076,6 @@ 24110 break; 24111 24112 case 1811: 24113- 24114-/* Line 1455 of yacc.c */ 24115 #line 10565 "preproc.y" 24116 { 24117 (yyval.str) = make_str("language"); 24118@@ -41238,8 +38083,6 @@ 24119 break; 24120 24121 case 1812: 24122- 24123-/* Line 1455 of yacc.c */ 24124 #line 10569 "preproc.y" 24125 { 24126 (yyval.str) = make_str("large"); 24127@@ -41247,8 +38090,6 @@ 24128 break; 24129 24130 case 1813: 24131- 24132-/* Line 1455 of yacc.c */ 24133 #line 10573 "preproc.y" 24134 { 24135 (yyval.str) = make_str("last"); 24136@@ -41256,8 +38097,6 @@ 24137 break; 24138 24139 case 1814: 24140- 24141-/* Line 1455 of yacc.c */ 24142 #line 10577 "preproc.y" 24143 { 24144 (yyval.str) = make_str("lc_collate"); 24145@@ -41265,8 +38104,6 @@ 24146 break; 24147 24148 case 1815: 24149- 24150-/* Line 1455 of yacc.c */ 24151 #line 10581 "preproc.y" 24152 { 24153 (yyval.str) = make_str("lc_ctype"); 24154@@ -41274,8 +38111,6 @@ 24155 break; 24156 24157 case 1816: 24158- 24159-/* Line 1455 of yacc.c */ 24160 #line 10585 "preproc.y" 24161 { 24162 (yyval.str) = make_str("level"); 24163@@ -41283,8 +38118,6 @@ 24164 break; 24165 24166 case 1817: 24167- 24168-/* Line 1455 of yacc.c */ 24169 #line 10589 "preproc.y" 24170 { 24171 (yyval.str) = make_str("listen"); 24172@@ -41292,8 +38125,6 @@ 24173 break; 24174 24175 case 1818: 24176- 24177-/* Line 1455 of yacc.c */ 24178 #line 10593 "preproc.y" 24179 { 24180 (yyval.str) = make_str("load"); 24181@@ -41301,8 +38132,6 @@ 24182 break; 24183 24184 case 1819: 24185- 24186-/* Line 1455 of yacc.c */ 24187 #line 10597 "preproc.y" 24188 { 24189 (yyval.str) = make_str("local"); 24190@@ -41310,8 +38139,6 @@ 24191 break; 24192 24193 case 1820: 24194- 24195-/* Line 1455 of yacc.c */ 24196 #line 10601 "preproc.y" 24197 { 24198 (yyval.str) = make_str("location"); 24199@@ -41319,8 +38146,6 @@ 24200 break; 24201 24202 case 1821: 24203- 24204-/* Line 1455 of yacc.c */ 24205 #line 10605 "preproc.y" 24206 { 24207 (yyval.str) = make_str("lock"); 24208@@ -41328,8 +38153,6 @@ 24209 break; 24210 24211 case 1822: 24212- 24213-/* Line 1455 of yacc.c */ 24214 #line 10609 "preproc.y" 24215 { 24216 (yyval.str) = make_str("login"); 24217@@ -41337,8 +38160,6 @@ 24218 break; 24219 24220 case 1823: 24221- 24222-/* Line 1455 of yacc.c */ 24223 #line 10613 "preproc.y" 24224 { 24225 (yyval.str) = make_str("mapping"); 24226@@ -41346,8 +38167,6 @@ 24227 break; 24228 24229 case 1824: 24230- 24231-/* Line 1455 of yacc.c */ 24232 #line 10617 "preproc.y" 24233 { 24234 (yyval.str) = make_str("match"); 24235@@ -41355,8 +38174,6 @@ 24236 break; 24237 24238 case 1825: 24239- 24240-/* Line 1455 of yacc.c */ 24241 #line 10621 "preproc.y" 24242 { 24243 (yyval.str) = make_str("maxvalue"); 24244@@ -41364,8 +38181,6 @@ 24245 break; 24246 24247 case 1826: 24248- 24249-/* Line 1455 of yacc.c */ 24250 #line 10625 "preproc.y" 24251 { 24252 (yyval.str) = make_str("minvalue"); 24253@@ -41373,8 +38188,6 @@ 24254 break; 24255 24256 case 1827: 24257- 24258-/* Line 1455 of yacc.c */ 24259 #line 10629 "preproc.y" 24260 { 24261 (yyval.str) = make_str("mode"); 24262@@ -41382,8 +38195,6 @@ 24263 break; 24264 24265 case 1828: 24266- 24267-/* Line 1455 of yacc.c */ 24268 #line 10633 "preproc.y" 24269 { 24270 (yyval.str) = make_str("move"); 24271@@ -41391,8 +38202,6 @@ 24272 break; 24273 24274 case 1829: 24275- 24276-/* Line 1455 of yacc.c */ 24277 #line 10637 "preproc.y" 24278 { 24279 (yyval.str) = make_str("name"); 24280@@ -41400,8 +38209,6 @@ 24281 break; 24282 24283 case 1830: 24284- 24285-/* Line 1455 of yacc.c */ 24286 #line 10641 "preproc.y" 24287 { 24288 (yyval.str) = make_str("names"); 24289@@ -41409,8 +38216,6 @@ 24290 break; 24291 24292 case 1831: 24293- 24294-/* Line 1455 of yacc.c */ 24295 #line 10645 "preproc.y" 24296 { 24297 (yyval.str) = make_str("next"); 24298@@ -41418,8 +38223,6 @@ 24299 break; 24300 24301 case 1832: 24302- 24303-/* Line 1455 of yacc.c */ 24304 #line 10649 "preproc.y" 24305 { 24306 (yyval.str) = make_str("no"); 24307@@ -41427,8 +38230,6 @@ 24308 break; 24309 24310 case 1833: 24311- 24312-/* Line 1455 of yacc.c */ 24313 #line 10653 "preproc.y" 24314 { 24315 (yyval.str) = make_str("nocreatedb"); 24316@@ -41436,8 +38237,6 @@ 24317 break; 24318 24319 case 1834: 24320- 24321-/* Line 1455 of yacc.c */ 24322 #line 10657 "preproc.y" 24323 { 24324 (yyval.str) = make_str("nocreaterole"); 24325@@ -41445,8 +38244,6 @@ 24326 break; 24327 24328 case 1835: 24329- 24330-/* Line 1455 of yacc.c */ 24331 #line 10661 "preproc.y" 24332 { 24333 (yyval.str) = make_str("nocreateuser"); 24334@@ -41454,8 +38251,6 @@ 24335 break; 24336 24337 case 1836: 24338- 24339-/* Line 1455 of yacc.c */ 24340 #line 10665 "preproc.y" 24341 { 24342 (yyval.str) = make_str("noinherit"); 24343@@ -41463,8 +38258,6 @@ 24344 break; 24345 24346 case 1837: 24347- 24348-/* Line 1455 of yacc.c */ 24349 #line 10669 "preproc.y" 24350 { 24351 (yyval.str) = make_str("nologin"); 24352@@ -41472,8 +38265,6 @@ 24353 break; 24354 24355 case 1838: 24356- 24357-/* Line 1455 of yacc.c */ 24358 #line 10673 "preproc.y" 24359 { 24360 (yyval.str) = make_str("nosuperuser"); 24361@@ -41481,8 +38272,6 @@ 24362 break; 24363 24364 case 1839: 24365- 24366-/* Line 1455 of yacc.c */ 24367 #line 10677 "preproc.y" 24368 { 24369 (yyval.str) = make_str("nothing"); 24370@@ -41490,8 +38279,6 @@ 24371 break; 24372 24373 case 1840: 24374- 24375-/* Line 1455 of yacc.c */ 24376 #line 10681 "preproc.y" 24377 { 24378 (yyval.str) = make_str("notify"); 24379@@ -41499,8 +38286,6 @@ 24380 break; 24381 24382 case 1841: 24383- 24384-/* Line 1455 of yacc.c */ 24385 #line 10685 "preproc.y" 24386 { 24387 (yyval.str) = make_str("nowait"); 24388@@ -41508,8 +38293,6 @@ 24389 break; 24390 24391 case 1842: 24392- 24393-/* Line 1455 of yacc.c */ 24394 #line 10689 "preproc.y" 24395 { 24396 (yyval.str) = make_str("nulls"); 24397@@ -41517,8 +38300,6 @@ 24398 break; 24399 24400 case 1843: 24401- 24402-/* Line 1455 of yacc.c */ 24403 #line 10693 "preproc.y" 24404 { 24405 (yyval.str) = make_str("object"); 24406@@ -41526,8 +38307,6 @@ 24407 break; 24408 24409 case 1844: 24410- 24411-/* Line 1455 of yacc.c */ 24412 #line 10697 "preproc.y" 24413 { 24414 (yyval.str) = make_str("of"); 24415@@ -41535,8 +38314,6 @@ 24416 break; 24417 24418 case 1845: 24419- 24420-/* Line 1455 of yacc.c */ 24421 #line 10701 "preproc.y" 24422 { 24423 (yyval.str) = make_str("off"); 24424@@ -41544,8 +38321,6 @@ 24425 break; 24426 24427 case 1846: 24428- 24429-/* Line 1455 of yacc.c */ 24430 #line 10705 "preproc.y" 24431 { 24432 (yyval.str) = make_str("oids"); 24433@@ -41553,8 +38328,6 @@ 24434 break; 24435 24436 case 1847: 24437- 24438-/* Line 1455 of yacc.c */ 24439 #line 10709 "preproc.y" 24440 { 24441 (yyval.str) = make_str("operator"); 24442@@ -41562,8 +38335,6 @@ 24443 break; 24444 24445 case 1848: 24446- 24447-/* Line 1455 of yacc.c */ 24448 #line 10713 "preproc.y" 24449 { 24450 (yyval.str) = make_str("option"); 24451@@ -41571,8 +38342,6 @@ 24452 break; 24453 24454 case 1849: 24455- 24456-/* Line 1455 of yacc.c */ 24457 #line 10717 "preproc.y" 24458 { 24459 (yyval.str) = make_str("options"); 24460@@ -41580,8 +38349,6 @@ 24461 break; 24462 24463 case 1850: 24464- 24465-/* Line 1455 of yacc.c */ 24466 #line 10721 "preproc.y" 24467 { 24468 (yyval.str) = make_str("owned"); 24469@@ -41589,8 +38356,6 @@ 24470 break; 24471 24472 case 1851: 24473- 24474-/* Line 1455 of yacc.c */ 24475 #line 10725 "preproc.y" 24476 { 24477 (yyval.str) = make_str("owner"); 24478@@ -41598,8 +38363,6 @@ 24479 break; 24480 24481 case 1852: 24482- 24483-/* Line 1455 of yacc.c */ 24484 #line 10729 "preproc.y" 24485 { 24486 (yyval.str) = make_str("parser"); 24487@@ -41607,8 +38370,6 @@ 24488 break; 24489 24490 case 1853: 24491- 24492-/* Line 1455 of yacc.c */ 24493 #line 10733 "preproc.y" 24494 { 24495 (yyval.str) = make_str("partial"); 24496@@ -41616,8 +38377,6 @@ 24497 break; 24498 24499 case 1854: 24500- 24501-/* Line 1455 of yacc.c */ 24502 #line 10737 "preproc.y" 24503 { 24504 (yyval.str) = make_str("partition"); 24505@@ -41625,8 +38384,6 @@ 24506 break; 24507 24508 case 1855: 24509- 24510-/* Line 1455 of yacc.c */ 24511 #line 10741 "preproc.y" 24512 { 24513 (yyval.str) = make_str("password"); 24514@@ -41634,8 +38391,6 @@ 24515 break; 24516 24517 case 1856: 24518- 24519-/* Line 1455 of yacc.c */ 24520 #line 10745 "preproc.y" 24521 { 24522 (yyval.str) = make_str("plans"); 24523@@ -41643,8 +38398,6 @@ 24524 break; 24525 24526 case 1857: 24527- 24528-/* Line 1455 of yacc.c */ 24529 #line 10749 "preproc.y" 24530 { 24531 (yyval.str) = make_str("preceding"); 24532@@ -41652,8 +38405,6 @@ 24533 break; 24534 24535 case 1858: 24536- 24537-/* Line 1455 of yacc.c */ 24538 #line 10753 "preproc.y" 24539 { 24540 (yyval.str) = make_str("prepare"); 24541@@ -41661,8 +38412,6 @@ 24542 break; 24543 24544 case 1859: 24545- 24546-/* Line 1455 of yacc.c */ 24547 #line 10757 "preproc.y" 24548 { 24549 (yyval.str) = make_str("prepared"); 24550@@ -41670,8 +38419,6 @@ 24551 break; 24552 24553 case 1860: 24554- 24555-/* Line 1455 of yacc.c */ 24556 #line 10761 "preproc.y" 24557 { 24558 (yyval.str) = make_str("preserve"); 24559@@ -41679,8 +38426,6 @@ 24560 break; 24561 24562 case 1861: 24563- 24564-/* Line 1455 of yacc.c */ 24565 #line 10765 "preproc.y" 24566 { 24567 (yyval.str) = make_str("prior"); 24568@@ -41688,8 +38433,6 @@ 24569 break; 24570 24571 case 1862: 24572- 24573-/* Line 1455 of yacc.c */ 24574 #line 10769 "preproc.y" 24575 { 24576 (yyval.str) = make_str("privileges"); 24577@@ -41697,8 +38440,6 @@ 24578 break; 24579 24580 case 1863: 24581- 24582-/* Line 1455 of yacc.c */ 24583 #line 10773 "preproc.y" 24584 { 24585 (yyval.str) = make_str("procedural"); 24586@@ -41706,8 +38447,6 @@ 24587 break; 24588 24589 case 1864: 24590- 24591-/* Line 1455 of yacc.c */ 24592 #line 10777 "preproc.y" 24593 { 24594 (yyval.str) = make_str("procedure"); 24595@@ -41715,8 +38454,6 @@ 24596 break; 24597 24598 case 1865: 24599- 24600-/* Line 1455 of yacc.c */ 24601 #line 10781 "preproc.y" 24602 { 24603 (yyval.str) = make_str("quote"); 24604@@ -41724,8 +38461,6 @@ 24605 break; 24606 24607 case 1866: 24608- 24609-/* Line 1455 of yacc.c */ 24610 #line 10785 "preproc.y" 24611 { 24612 (yyval.str) = make_str("range"); 24613@@ -41733,8 +38468,6 @@ 24614 break; 24615 24616 case 1867: 24617- 24618-/* Line 1455 of yacc.c */ 24619 #line 10789 "preproc.y" 24620 { 24621 (yyval.str) = make_str("read"); 24622@@ -41742,8 +38475,6 @@ 24623 break; 24624 24625 case 1868: 24626- 24627-/* Line 1455 of yacc.c */ 24628 #line 10793 "preproc.y" 24629 { 24630 (yyval.str) = make_str("reassign"); 24631@@ -41751,8 +38482,6 @@ 24632 break; 24633 24634 case 1869: 24635- 24636-/* Line 1455 of yacc.c */ 24637 #line 10797 "preproc.y" 24638 { 24639 (yyval.str) = make_str("recheck"); 24640@@ -41760,8 +38489,6 @@ 24641 break; 24642 24643 case 1870: 24644- 24645-/* Line 1455 of yacc.c */ 24646 #line 10801 "preproc.y" 24647 { 24648 (yyval.str) = make_str("recursive"); 24649@@ -41769,8 +38496,6 @@ 24650 break; 24651 24652 case 1871: 24653- 24654-/* Line 1455 of yacc.c */ 24655 #line 10805 "preproc.y" 24656 { 24657 (yyval.str) = make_str("reindex"); 24658@@ -41778,8 +38503,6 @@ 24659 break; 24660 24661 case 1872: 24662- 24663-/* Line 1455 of yacc.c */ 24664 #line 10809 "preproc.y" 24665 { 24666 (yyval.str) = make_str("relative"); 24667@@ -41787,8 +38510,6 @@ 24668 break; 24669 24670 case 1873: 24671- 24672-/* Line 1455 of yacc.c */ 24673 #line 10813 "preproc.y" 24674 { 24675 (yyval.str) = make_str("release"); 24676@@ -41796,8 +38517,6 @@ 24677 break; 24678 24679 case 1874: 24680- 24681-/* Line 1455 of yacc.c */ 24682 #line 10817 "preproc.y" 24683 { 24684 (yyval.str) = make_str("rename"); 24685@@ -41805,8 +38524,6 @@ 24686 break; 24687 24688 case 1875: 24689- 24690-/* Line 1455 of yacc.c */ 24691 #line 10821 "preproc.y" 24692 { 24693 (yyval.str) = make_str("repeatable"); 24694@@ -41814,8 +38531,6 @@ 24695 break; 24696 24697 case 1876: 24698- 24699-/* Line 1455 of yacc.c */ 24700 #line 10825 "preproc.y" 24701 { 24702 (yyval.str) = make_str("replace"); 24703@@ -41823,8 +38538,6 @@ 24704 break; 24705 24706 case 1877: 24707- 24708-/* Line 1455 of yacc.c */ 24709 #line 10829 "preproc.y" 24710 { 24711 (yyval.str) = make_str("replica"); 24712@@ -41832,8 +38545,6 @@ 24713 break; 24714 24715 case 1878: 24716- 24717-/* Line 1455 of yacc.c */ 24718 #line 10833 "preproc.y" 24719 { 24720 (yyval.str) = make_str("reset"); 24721@@ -41841,8 +38552,6 @@ 24722 break; 24723 24724 case 1879: 24725- 24726-/* Line 1455 of yacc.c */ 24727 #line 10837 "preproc.y" 24728 { 24729 (yyval.str) = make_str("restart"); 24730@@ -41850,8 +38559,6 @@ 24731 break; 24732 24733 case 1880: 24734- 24735-/* Line 1455 of yacc.c */ 24736 #line 10841 "preproc.y" 24737 { 24738 (yyval.str) = make_str("restrict"); 24739@@ -41859,8 +38566,6 @@ 24740 break; 24741 24742 case 1881: 24743- 24744-/* Line 1455 of yacc.c */ 24745 #line 10845 "preproc.y" 24746 { 24747 (yyval.str) = make_str("returns"); 24748@@ -41868,8 +38573,6 @@ 24749 break; 24750 24751 case 1882: 24752- 24753-/* Line 1455 of yacc.c */ 24754 #line 10849 "preproc.y" 24755 { 24756 (yyval.str) = make_str("revoke"); 24757@@ -41877,8 +38580,6 @@ 24758 break; 24759 24760 case 1883: 24761- 24762-/* Line 1455 of yacc.c */ 24763 #line 10853 "preproc.y" 24764 { 24765 (yyval.str) = make_str("role"); 24766@@ -41886,8 +38587,6 @@ 24767 break; 24768 24769 case 1884: 24770- 24771-/* Line 1455 of yacc.c */ 24772 #line 10857 "preproc.y" 24773 { 24774 (yyval.str) = make_str("rollback"); 24775@@ -41895,8 +38594,6 @@ 24776 break; 24777 24778 case 1885: 24779- 24780-/* Line 1455 of yacc.c */ 24781 #line 10861 "preproc.y" 24782 { 24783 (yyval.str) = make_str("rows"); 24784@@ -41904,8 +38601,6 @@ 24785 break; 24786 24787 case 1886: 24788- 24789-/* Line 1455 of yacc.c */ 24790 #line 10865 "preproc.y" 24791 { 24792 (yyval.str) = make_str("rule"); 24793@@ -41913,8 +38608,6 @@ 24794 break; 24795 24796 case 1887: 24797- 24798-/* Line 1455 of yacc.c */ 24799 #line 10869 "preproc.y" 24800 { 24801 (yyval.str) = make_str("savepoint"); 24802@@ -41922,8 +38615,6 @@ 24803 break; 24804 24805 case 1888: 24806- 24807-/* Line 1455 of yacc.c */ 24808 #line 10873 "preproc.y" 24809 { 24810 (yyval.str) = make_str("schema"); 24811@@ -41931,8 +38622,6 @@ 24812 break; 24813 24814 case 1889: 24815- 24816-/* Line 1455 of yacc.c */ 24817 #line 10877 "preproc.y" 24818 { 24819 (yyval.str) = make_str("scroll"); 24820@@ -41940,8 +38629,6 @@ 24821 break; 24822 24823 case 1890: 24824- 24825-/* Line 1455 of yacc.c */ 24826 #line 10881 "preproc.y" 24827 { 24828 (yyval.str) = make_str("search"); 24829@@ -41949,8 +38636,6 @@ 24830 break; 24831 24832 case 1891: 24833- 24834-/* Line 1455 of yacc.c */ 24835 #line 10885 "preproc.y" 24836 { 24837 (yyval.str) = make_str("security"); 24838@@ -41958,8 +38643,6 @@ 24839 break; 24840 24841 case 1892: 24842- 24843-/* Line 1455 of yacc.c */ 24844 #line 10889 "preproc.y" 24845 { 24846 (yyval.str) = make_str("sequence"); 24847@@ -41967,8 +38650,6 @@ 24848 break; 24849 24850 case 1893: 24851- 24852-/* Line 1455 of yacc.c */ 24853 #line 10893 "preproc.y" 24854 { 24855 (yyval.str) = make_str("sequences"); 24856@@ -41976,8 +38657,6 @@ 24857 break; 24858 24859 case 1894: 24860- 24861-/* Line 1455 of yacc.c */ 24862 #line 10897 "preproc.y" 24863 { 24864 (yyval.str) = make_str("serializable"); 24865@@ -41985,8 +38664,6 @@ 24866 break; 24867 24868 case 1895: 24869- 24870-/* Line 1455 of yacc.c */ 24871 #line 10901 "preproc.y" 24872 { 24873 (yyval.str) = make_str("server"); 24874@@ -41994,8 +38671,6 @@ 24875 break; 24876 24877 case 1896: 24878- 24879-/* Line 1455 of yacc.c */ 24880 #line 10905 "preproc.y" 24881 { 24882 (yyval.str) = make_str("session"); 24883@@ -42003,8 +38678,6 @@ 24884 break; 24885 24886 case 1897: 24887- 24888-/* Line 1455 of yacc.c */ 24889 #line 10909 "preproc.y" 24890 { 24891 (yyval.str) = make_str("set"); 24892@@ -42012,8 +38685,6 @@ 24893 break; 24894 24895 case 1898: 24896- 24897-/* Line 1455 of yacc.c */ 24898 #line 10913 "preproc.y" 24899 { 24900 (yyval.str) = make_str("share"); 24901@@ -42021,8 +38692,6 @@ 24902 break; 24903 24904 case 1899: 24905- 24906-/* Line 1455 of yacc.c */ 24907 #line 10917 "preproc.y" 24908 { 24909 (yyval.str) = make_str("show"); 24910@@ -42030,8 +38699,6 @@ 24911 break; 24912 24913 case 1900: 24914- 24915-/* Line 1455 of yacc.c */ 24916 #line 10921 "preproc.y" 24917 { 24918 (yyval.str) = make_str("simple"); 24919@@ -42039,8 +38706,6 @@ 24920 break; 24921 24922 case 1901: 24923- 24924-/* Line 1455 of yacc.c */ 24925 #line 10925 "preproc.y" 24926 { 24927 (yyval.str) = make_str("stable"); 24928@@ -42048,8 +38713,6 @@ 24929 break; 24930 24931 case 1902: 24932- 24933-/* Line 1455 of yacc.c */ 24934 #line 10929 "preproc.y" 24935 { 24936 (yyval.str) = make_str("standalone"); 24937@@ -42057,8 +38720,6 @@ 24938 break; 24939 24940 case 1903: 24941- 24942-/* Line 1455 of yacc.c */ 24943 #line 10933 "preproc.y" 24944 { 24945 (yyval.str) = make_str("start"); 24946@@ -42066,8 +38727,6 @@ 24947 break; 24948 24949 case 1904: 24950- 24951-/* Line 1455 of yacc.c */ 24952 #line 10937 "preproc.y" 24953 { 24954 (yyval.str) = make_str("statement"); 24955@@ -42075,8 +38734,6 @@ 24956 break; 24957 24958 case 1905: 24959- 24960-/* Line 1455 of yacc.c */ 24961 #line 10941 "preproc.y" 24962 { 24963 (yyval.str) = make_str("statistics"); 24964@@ -42084,8 +38741,6 @@ 24965 break; 24966 24967 case 1906: 24968- 24969-/* Line 1455 of yacc.c */ 24970 #line 10945 "preproc.y" 24971 { 24972 (yyval.str) = make_str("stdin"); 24973@@ -42093,8 +38748,6 @@ 24974 break; 24975 24976 case 1907: 24977- 24978-/* Line 1455 of yacc.c */ 24979 #line 10949 "preproc.y" 24980 { 24981 (yyval.str) = make_str("stdout"); 24982@@ -42102,8 +38755,6 @@ 24983 break; 24984 24985 case 1908: 24986- 24987-/* Line 1455 of yacc.c */ 24988 #line 10953 "preproc.y" 24989 { 24990 (yyval.str) = make_str("storage"); 24991@@ -42111,8 +38762,6 @@ 24992 break; 24993 24994 case 1909: 24995- 24996-/* Line 1455 of yacc.c */ 24997 #line 10957 "preproc.y" 24998 { 24999 (yyval.str) = make_str("strict"); 25000@@ -42120,8 +38769,6 @@ 25001 break; 25002 25003 case 1910: 25004- 25005-/* Line 1455 of yacc.c */ 25006 #line 10961 "preproc.y" 25007 { 25008 (yyval.str) = make_str("strip"); 25009@@ -42129,8 +38776,6 @@ 25010 break; 25011 25012 case 1911: 25013- 25014-/* Line 1455 of yacc.c */ 25015 #line 10965 "preproc.y" 25016 { 25017 (yyval.str) = make_str("superuser"); 25018@@ -42138,8 +38783,6 @@ 25019 break; 25020 25021 case 1912: 25022- 25023-/* Line 1455 of yacc.c */ 25024 #line 10969 "preproc.y" 25025 { 25026 (yyval.str) = make_str("sysid"); 25027@@ -42147,8 +38790,6 @@ 25028 break; 25029 25030 case 1913: 25031- 25032-/* Line 1455 of yacc.c */ 25033 #line 10973 "preproc.y" 25034 { 25035 (yyval.str) = make_str("system"); 25036@@ -42156,8 +38797,6 @@ 25037 break; 25038 25039 case 1914: 25040- 25041-/* Line 1455 of yacc.c */ 25042 #line 10977 "preproc.y" 25043 { 25044 (yyval.str) = make_str("tables"); 25045@@ -42165,8 +38804,6 @@ 25046 break; 25047 25048 case 1915: 25049- 25050-/* Line 1455 of yacc.c */ 25051 #line 10981 "preproc.y" 25052 { 25053 (yyval.str) = make_str("tablespace"); 25054@@ -42174,8 +38811,6 @@ 25055 break; 25056 25057 case 1916: 25058- 25059-/* Line 1455 of yacc.c */ 25060 #line 10985 "preproc.y" 25061 { 25062 (yyval.str) = make_str("temp"); 25063@@ -42183,8 +38818,6 @@ 25064 break; 25065 25066 case 1917: 25067- 25068-/* Line 1455 of yacc.c */ 25069 #line 10989 "preproc.y" 25070 { 25071 (yyval.str) = make_str("template"); 25072@@ -42192,8 +38825,6 @@ 25073 break; 25074 25075 case 1918: 25076- 25077-/* Line 1455 of yacc.c */ 25078 #line 10993 "preproc.y" 25079 { 25080 (yyval.str) = make_str("temporary"); 25081@@ -42201,8 +38832,6 @@ 25082 break; 25083 25084 case 1919: 25085- 25086-/* Line 1455 of yacc.c */ 25087 #line 10997 "preproc.y" 25088 { 25089 (yyval.str) = make_str("text"); 25090@@ -42210,8 +38839,6 @@ 25091 break; 25092 25093 case 1920: 25094- 25095-/* Line 1455 of yacc.c */ 25096 #line 11001 "preproc.y" 25097 { 25098 (yyval.str) = make_str("transaction"); 25099@@ -42219,8 +38846,6 @@ 25100 break; 25101 25102 case 1921: 25103- 25104-/* Line 1455 of yacc.c */ 25105 #line 11005 "preproc.y" 25106 { 25107 (yyval.str) = make_str("trigger"); 25108@@ -42228,8 +38853,6 @@ 25109 break; 25110 25111 case 1922: 25112- 25113-/* Line 1455 of yacc.c */ 25114 #line 11009 "preproc.y" 25115 { 25116 (yyval.str) = make_str("truncate"); 25117@@ -42237,8 +38860,6 @@ 25118 break; 25119 25120 case 1923: 25121- 25122-/* Line 1455 of yacc.c */ 25123 #line 11013 "preproc.y" 25124 { 25125 (yyval.str) = make_str("trusted"); 25126@@ -42246,8 +38867,6 @@ 25127 break; 25128 25129 case 1924: 25130- 25131-/* Line 1455 of yacc.c */ 25132 #line 11017 "preproc.y" 25133 { 25134 (yyval.str) = make_str("type"); 25135@@ -42255,8 +38874,6 @@ 25136 break; 25137 25138 case 1925: 25139- 25140-/* Line 1455 of yacc.c */ 25141 #line 11021 "preproc.y" 25142 { 25143 (yyval.str) = make_str("unbounded"); 25144@@ -42264,8 +38881,6 @@ 25145 break; 25146 25147 case 1926: 25148- 25149-/* Line 1455 of yacc.c */ 25150 #line 11025 "preproc.y" 25151 { 25152 (yyval.str) = make_str("uncommitted"); 25153@@ -42273,8 +38888,6 @@ 25154 break; 25155 25156 case 1927: 25157- 25158-/* Line 1455 of yacc.c */ 25159 #line 11029 "preproc.y" 25160 { 25161 (yyval.str) = make_str("unencrypted"); 25162@@ -42282,8 +38895,6 @@ 25163 break; 25164 25165 case 1928: 25166- 25167-/* Line 1455 of yacc.c */ 25168 #line 11033 "preproc.y" 25169 { 25170 (yyval.str) = make_str("unknown"); 25171@@ -42291,8 +38902,6 @@ 25172 break; 25173 25174 case 1929: 25175- 25176-/* Line 1455 of yacc.c */ 25177 #line 11037 "preproc.y" 25178 { 25179 (yyval.str) = make_str("unlisten"); 25180@@ -42300,8 +38909,6 @@ 25181 break; 25182 25183 case 1930: 25184- 25185-/* Line 1455 of yacc.c */ 25186 #line 11041 "preproc.y" 25187 { 25188 (yyval.str) = make_str("until"); 25189@@ -42309,8 +38916,6 @@ 25190 break; 25191 25192 case 1931: 25193- 25194-/* Line 1455 of yacc.c */ 25195 #line 11045 "preproc.y" 25196 { 25197 (yyval.str) = make_str("update"); 25198@@ -42318,8 +38923,6 @@ 25199 break; 25200 25201 case 1932: 25202- 25203-/* Line 1455 of yacc.c */ 25204 #line 11049 "preproc.y" 25205 { 25206 (yyval.str) = make_str("vacuum"); 25207@@ -42327,8 +38930,6 @@ 25208 break; 25209 25210 case 1933: 25211- 25212-/* Line 1455 of yacc.c */ 25213 #line 11053 "preproc.y" 25214 { 25215 (yyval.str) = make_str("valid"); 25216@@ -42336,8 +38937,6 @@ 25217 break; 25218 25219 case 1934: 25220- 25221-/* Line 1455 of yacc.c */ 25222 #line 11057 "preproc.y" 25223 { 25224 (yyval.str) = make_str("validator"); 25225@@ -42345,8 +38944,6 @@ 25226 break; 25227 25228 case 1935: 25229- 25230-/* Line 1455 of yacc.c */ 25231 #line 11061 "preproc.y" 25232 { 25233 (yyval.str) = make_str("value"); 25234@@ -42354,8 +38951,6 @@ 25235 break; 25236 25237 case 1936: 25238- 25239-/* Line 1455 of yacc.c */ 25240 #line 11065 "preproc.y" 25241 { 25242 (yyval.str) = make_str("varying"); 25243@@ -42363,8 +38958,6 @@ 25244 break; 25245 25246 case 1937: 25247- 25248-/* Line 1455 of yacc.c */ 25249 #line 11069 "preproc.y" 25250 { 25251 (yyval.str) = make_str("version"); 25252@@ -42372,8 +38965,6 @@ 25253 break; 25254 25255 case 1938: 25256- 25257-/* Line 1455 of yacc.c */ 25258 #line 11073 "preproc.y" 25259 { 25260 (yyval.str) = make_str("view"); 25261@@ -42381,8 +38972,6 @@ 25262 break; 25263 25264 case 1939: 25265- 25266-/* Line 1455 of yacc.c */ 25267 #line 11077 "preproc.y" 25268 { 25269 (yyval.str) = make_str("volatile"); 25270@@ -42390,8 +38979,6 @@ 25271 break; 25272 25273 case 1940: 25274- 25275-/* Line 1455 of yacc.c */ 25276 #line 11081 "preproc.y" 25277 { 25278 (yyval.str) = make_str("whitespace"); 25279@@ -42399,8 +38986,6 @@ 25280 break; 25281 25282 case 1941: 25283- 25284-/* Line 1455 of yacc.c */ 25285 #line 11085 "preproc.y" 25286 { 25287 (yyval.str) = make_str("without"); 25288@@ -42408,8 +38993,6 @@ 25289 break; 25290 25291 case 1942: 25292- 25293-/* Line 1455 of yacc.c */ 25294 #line 11089 "preproc.y" 25295 { 25296 (yyval.str) = make_str("work"); 25297@@ -42417,8 +39000,6 @@ 25298 break; 25299 25300 case 1943: 25301- 25302-/* Line 1455 of yacc.c */ 25303 #line 11093 "preproc.y" 25304 { 25305 (yyval.str) = make_str("wrapper"); 25306@@ -42426,8 +39007,6 @@ 25307 break; 25308 25309 case 1944: 25310- 25311-/* Line 1455 of yacc.c */ 25312 #line 11097 "preproc.y" 25313 { 25314 (yyval.str) = make_str("write"); 25315@@ -42435,8 +39014,6 @@ 25316 break; 25317 25318 case 1945: 25319- 25320-/* Line 1455 of yacc.c */ 25321 #line 11101 "preproc.y" 25322 { 25323 (yyval.str) = make_str("xml"); 25324@@ -42444,8 +39021,6 @@ 25325 break; 25326 25327 case 1946: 25328- 25329-/* Line 1455 of yacc.c */ 25330 #line 11105 "preproc.y" 25331 { 25332 (yyval.str) = make_str("yes"); 25333@@ -42453,8 +39028,6 @@ 25334 break; 25335 25336 case 1947: 25337- 25338-/* Line 1455 of yacc.c */ 25339 #line 11109 "preproc.y" 25340 { 25341 (yyval.str) = make_str("zone"); 25342@@ -42462,8 +39035,6 @@ 25343 break; 25344 25345 case 1948: 25346- 25347-/* Line 1455 of yacc.c */ 25348 #line 11117 "preproc.y" 25349 { 25350 (yyval.str) = make_str("between"); 25351@@ -42471,8 +39042,6 @@ 25352 break; 25353 25354 case 1949: 25355- 25356-/* Line 1455 of yacc.c */ 25357 #line 11121 "preproc.y" 25358 { 25359 (yyval.str) = make_str("bigint"); 25360@@ -42480,8 +39049,6 @@ 25361 break; 25362 25363 case 1950: 25364- 25365-/* Line 1455 of yacc.c */ 25366 #line 11125 "preproc.y" 25367 { 25368 (yyval.str) = make_str("bit"); 25369@@ -42489,8 +39056,6 @@ 25370 break; 25371 25372 case 1951: 25373- 25374-/* Line 1455 of yacc.c */ 25375 #line 11129 "preproc.y" 25376 { 25377 (yyval.str) = make_str("boolean"); 25378@@ -42498,8 +39063,6 @@ 25379 break; 25380 25381 case 1952: 25382- 25383-/* Line 1455 of yacc.c */ 25384 #line 11133 "preproc.y" 25385 { 25386 (yyval.str) = make_str("character"); 25387@@ -42507,8 +39070,6 @@ 25388 break; 25389 25390 case 1953: 25391- 25392-/* Line 1455 of yacc.c */ 25393 #line 11137 "preproc.y" 25394 { 25395 (yyval.str) = make_str("coalesce"); 25396@@ -42516,8 +39077,6 @@ 25397 break; 25398 25399 case 1954: 25400- 25401-/* Line 1455 of yacc.c */ 25402 #line 11141 "preproc.y" 25403 { 25404 (yyval.str) = make_str("dec"); 25405@@ -42525,8 +39084,6 @@ 25406 break; 25407 25408 case 1955: 25409- 25410-/* Line 1455 of yacc.c */ 25411 #line 11145 "preproc.y" 25412 { 25413 (yyval.str) = make_str("decimal"); 25414@@ -42534,8 +39091,6 @@ 25415 break; 25416 25417 case 1956: 25418- 25419-/* Line 1455 of yacc.c */ 25420 #line 11149 "preproc.y" 25421 { 25422 (yyval.str) = make_str("exists"); 25423@@ -42543,8 +39098,6 @@ 25424 break; 25425 25426 case 1957: 25427- 25428-/* Line 1455 of yacc.c */ 25429 #line 11153 "preproc.y" 25430 { 25431 (yyval.str) = make_str("extract"); 25432@@ -42552,8 +39105,6 @@ 25433 break; 25434 25435 case 1958: 25436- 25437-/* Line 1455 of yacc.c */ 25438 #line 11157 "preproc.y" 25439 { 25440 (yyval.str) = make_str("float"); 25441@@ -42561,8 +39112,6 @@ 25442 break; 25443 25444 case 1959: 25445- 25446-/* Line 1455 of yacc.c */ 25447 #line 11161 "preproc.y" 25448 { 25449 (yyval.str) = make_str("greatest"); 25450@@ -42570,8 +39119,6 @@ 25451 break; 25452 25453 case 1960: 25454- 25455-/* Line 1455 of yacc.c */ 25456 #line 11165 "preproc.y" 25457 { 25458 (yyval.str) = make_str("inout"); 25459@@ -42579,8 +39126,6 @@ 25460 break; 25461 25462 case 1961: 25463- 25464-/* Line 1455 of yacc.c */ 25465 #line 11169 "preproc.y" 25466 { 25467 (yyval.str) = make_str("integer"); 25468@@ -42588,8 +39133,6 @@ 25469 break; 25470 25471 case 1962: 25472- 25473-/* Line 1455 of yacc.c */ 25474 #line 11173 "preproc.y" 25475 { 25476 (yyval.str) = make_str("interval"); 25477@@ -42597,8 +39140,6 @@ 25478 break; 25479 25480 case 1963: 25481- 25482-/* Line 1455 of yacc.c */ 25483 #line 11177 "preproc.y" 25484 { 25485 (yyval.str) = make_str("least"); 25486@@ -42606,8 +39147,6 @@ 25487 break; 25488 25489 case 1964: 25490- 25491-/* Line 1455 of yacc.c */ 25492 #line 11181 "preproc.y" 25493 { 25494 (yyval.str) = make_str("national"); 25495@@ -42615,8 +39154,6 @@ 25496 break; 25497 25498 case 1965: 25499- 25500-/* Line 1455 of yacc.c */ 25501 #line 11185 "preproc.y" 25502 { 25503 (yyval.str) = make_str("nchar"); 25504@@ -42624,8 +39161,6 @@ 25505 break; 25506 25507 case 1966: 25508- 25509-/* Line 1455 of yacc.c */ 25510 #line 11189 "preproc.y" 25511 { 25512 (yyval.str) = make_str("none"); 25513@@ -42633,8 +39168,6 @@ 25514 break; 25515 25516 case 1967: 25517- 25518-/* Line 1455 of yacc.c */ 25519 #line 11193 "preproc.y" 25520 { 25521 (yyval.str) = make_str("nullif"); 25522@@ -42642,8 +39175,6 @@ 25523 break; 25524 25525 case 1968: 25526- 25527-/* Line 1455 of yacc.c */ 25528 #line 11197 "preproc.y" 25529 { 25530 (yyval.str) = make_str("numeric"); 25531@@ -42651,8 +39182,6 @@ 25532 break; 25533 25534 case 1969: 25535- 25536-/* Line 1455 of yacc.c */ 25537 #line 11201 "preproc.y" 25538 { 25539 (yyval.str) = make_str("out"); 25540@@ -42660,8 +39189,6 @@ 25541 break; 25542 25543 case 1970: 25544- 25545-/* Line 1455 of yacc.c */ 25546 #line 11205 "preproc.y" 25547 { 25548 (yyval.str) = make_str("overlay"); 25549@@ -42669,8 +39196,6 @@ 25550 break; 25551 25552 case 1971: 25553- 25554-/* Line 1455 of yacc.c */ 25555 #line 11209 "preproc.y" 25556 { 25557 (yyval.str) = make_str("position"); 25558@@ -42678,8 +39203,6 @@ 25559 break; 25560 25561 case 1972: 25562- 25563-/* Line 1455 of yacc.c */ 25564 #line 11213 "preproc.y" 25565 { 25566 (yyval.str) = make_str("precision"); 25567@@ -42687,8 +39210,6 @@ 25568 break; 25569 25570 case 1973: 25571- 25572-/* Line 1455 of yacc.c */ 25573 #line 11217 "preproc.y" 25574 { 25575 (yyval.str) = make_str("real"); 25576@@ -42696,8 +39217,6 @@ 25577 break; 25578 25579 case 1974: 25580- 25581-/* Line 1455 of yacc.c */ 25582 #line 11221 "preproc.y" 25583 { 25584 (yyval.str) = make_str("row"); 25585@@ -42705,8 +39224,6 @@ 25586 break; 25587 25588 case 1975: 25589- 25590-/* Line 1455 of yacc.c */ 25591 #line 11225 "preproc.y" 25592 { 25593 (yyval.str) = make_str("setof"); 25594@@ -42714,8 +39231,6 @@ 25595 break; 25596 25597 case 1976: 25598- 25599-/* Line 1455 of yacc.c */ 25600 #line 11229 "preproc.y" 25601 { 25602 (yyval.str) = make_str("smallint"); 25603@@ -42723,8 +39238,6 @@ 25604 break; 25605 25606 case 1977: 25607- 25608-/* Line 1455 of yacc.c */ 25609 #line 11233 "preproc.y" 25610 { 25611 (yyval.str) = make_str("substring"); 25612@@ -42732,8 +39245,6 @@ 25613 break; 25614 25615 case 1978: 25616- 25617-/* Line 1455 of yacc.c */ 25618 #line 11237 "preproc.y" 25619 { 25620 (yyval.str) = make_str("time"); 25621@@ -42741,8 +39252,6 @@ 25622 break; 25623 25624 case 1979: 25625- 25626-/* Line 1455 of yacc.c */ 25627 #line 11241 "preproc.y" 25628 { 25629 (yyval.str) = make_str("timestamp"); 25630@@ -42750,8 +39259,6 @@ 25631 break; 25632 25633 case 1980: 25634- 25635-/* Line 1455 of yacc.c */ 25636 #line 11245 "preproc.y" 25637 { 25638 (yyval.str) = make_str("treat"); 25639@@ -42759,8 +39266,6 @@ 25640 break; 25641 25642 case 1981: 25643- 25644-/* Line 1455 of yacc.c */ 25645 #line 11249 "preproc.y" 25646 { 25647 (yyval.str) = make_str("trim"); 25648@@ -42768,8 +39273,6 @@ 25649 break; 25650 25651 case 1982: 25652- 25653-/* Line 1455 of yacc.c */ 25654 #line 11253 "preproc.y" 25655 { 25656 (yyval.str) = make_str("varchar"); 25657@@ -42777,8 +39280,6 @@ 25658 break; 25659 25660 case 1983: 25661- 25662-/* Line 1455 of yacc.c */ 25663 #line 11257 "preproc.y" 25664 { 25665 (yyval.str) = make_str("xmlattributes"); 25666@@ -42786,8 +39287,6 @@ 25667 break; 25668 25669 case 1984: 25670- 25671-/* Line 1455 of yacc.c */ 25672 #line 11261 "preproc.y" 25673 { 25674 (yyval.str) = make_str("xmlconcat"); 25675@@ -42795,8 +39294,6 @@ 25676 break; 25677 25678 case 1985: 25679- 25680-/* Line 1455 of yacc.c */ 25681 #line 11265 "preproc.y" 25682 { 25683 (yyval.str) = make_str("xmlelement"); 25684@@ -42804,8 +39301,6 @@ 25685 break; 25686 25687 case 1986: 25688- 25689-/* Line 1455 of yacc.c */ 25690 #line 11269 "preproc.y" 25691 { 25692 (yyval.str) = make_str("xmlforest"); 25693@@ -42813,8 +39308,6 @@ 25694 break; 25695 25696 case 1987: 25697- 25698-/* Line 1455 of yacc.c */ 25699 #line 11273 "preproc.y" 25700 { 25701 (yyval.str) = make_str("xmlparse"); 25702@@ -42822,8 +39315,6 @@ 25703 break; 25704 25705 case 1988: 25706- 25707-/* Line 1455 of yacc.c */ 25708 #line 11277 "preproc.y" 25709 { 25710 (yyval.str) = make_str("xmlpi"); 25711@@ -42831,8 +39322,6 @@ 25712 break; 25713 25714 case 1989: 25715- 25716-/* Line 1455 of yacc.c */ 25717 #line 11281 "preproc.y" 25718 { 25719 (yyval.str) = make_str("xmlroot"); 25720@@ -42840,8 +39329,6 @@ 25721 break; 25722 25723 case 1990: 25724- 25725-/* Line 1455 of yacc.c */ 25726 #line 11285 "preproc.y" 25727 { 25728 (yyval.str) = make_str("xmlserialize"); 25729@@ -42849,8 +39336,6 @@ 25730 break; 25731 25732 case 1991: 25733- 25734-/* Line 1455 of yacc.c */ 25735 #line 11293 "preproc.y" 25736 { 25737 (yyval.str) = make_str("authorization"); 25738@@ -42858,8 +39343,6 @@ 25739 break; 25740 25741 case 1992: 25742- 25743-/* Line 1455 of yacc.c */ 25744 #line 11297 "preproc.y" 25745 { 25746 (yyval.str) = make_str("binary"); 25747@@ -42867,8 +39350,6 @@ 25748 break; 25749 25750 case 1993: 25751- 25752-/* Line 1455 of yacc.c */ 25753 #line 11301 "preproc.y" 25754 { 25755 (yyval.str) = make_str("concurrently"); 25756@@ -42876,8 +39357,6 @@ 25757 break; 25758 25759 case 1994: 25760- 25761-/* Line 1455 of yacc.c */ 25762 #line 11305 "preproc.y" 25763 { 25764 (yyval.str) = make_str("cross"); 25765@@ -42885,8 +39364,6 @@ 25766 break; 25767 25768 case 1995: 25769- 25770-/* Line 1455 of yacc.c */ 25771 #line 11309 "preproc.y" 25772 { 25773 (yyval.str) = make_str("current_schema"); 25774@@ -42894,8 +39371,6 @@ 25775 break; 25776 25777 case 1996: 25778- 25779-/* Line 1455 of yacc.c */ 25780 #line 11313 "preproc.y" 25781 { 25782 (yyval.str) = make_str("freeze"); 25783@@ -42903,8 +39378,6 @@ 25784 break; 25785 25786 case 1997: 25787- 25788-/* Line 1455 of yacc.c */ 25789 #line 11317 "preproc.y" 25790 { 25791 (yyval.str) = make_str("full"); 25792@@ -42912,8 +39385,6 @@ 25793 break; 25794 25795 case 1998: 25796- 25797-/* Line 1455 of yacc.c */ 25798 #line 11321 "preproc.y" 25799 { 25800 (yyval.str) = make_str("ilike"); 25801@@ -42921,8 +39392,6 @@ 25802 break; 25803 25804 case 1999: 25805- 25806-/* Line 1455 of yacc.c */ 25807 #line 11325 "preproc.y" 25808 { 25809 (yyval.str) = make_str("inner"); 25810@@ -42930,8 +39399,6 @@ 25811 break; 25812 25813 case 2000: 25814- 25815-/* Line 1455 of yacc.c */ 25816 #line 11329 "preproc.y" 25817 { 25818 (yyval.str) = make_str("is"); 25819@@ -42939,8 +39406,6 @@ 25820 break; 25821 25822 case 2001: 25823- 25824-/* Line 1455 of yacc.c */ 25825 #line 11333 "preproc.y" 25826 { 25827 (yyval.str) = make_str("isnull"); 25828@@ -42948,8 +39413,6 @@ 25829 break; 25830 25831 case 2002: 25832- 25833-/* Line 1455 of yacc.c */ 25834 #line 11337 "preproc.y" 25835 { 25836 (yyval.str) = make_str("join"); 25837@@ -42957,8 +39420,6 @@ 25838 break; 25839 25840 case 2003: 25841- 25842-/* Line 1455 of yacc.c */ 25843 #line 11341 "preproc.y" 25844 { 25845 (yyval.str) = make_str("left"); 25846@@ -42966,8 +39427,6 @@ 25847 break; 25848 25849 case 2004: 25850- 25851-/* Line 1455 of yacc.c */ 25852 #line 11345 "preproc.y" 25853 { 25854 (yyval.str) = make_str("like"); 25855@@ -42975,8 +39434,6 @@ 25856 break; 25857 25858 case 2005: 25859- 25860-/* Line 1455 of yacc.c */ 25861 #line 11349 "preproc.y" 25862 { 25863 (yyval.str) = make_str("natural"); 25864@@ -42984,8 +39441,6 @@ 25865 break; 25866 25867 case 2006: 25868- 25869-/* Line 1455 of yacc.c */ 25870 #line 11353 "preproc.y" 25871 { 25872 (yyval.str) = make_str("notnull"); 25873@@ -42993,8 +39448,6 @@ 25874 break; 25875 25876 case 2007: 25877- 25878-/* Line 1455 of yacc.c */ 25879 #line 11357 "preproc.y" 25880 { 25881 (yyval.str) = make_str("outer"); 25882@@ -43002,8 +39455,6 @@ 25883 break; 25884 25885 case 2008: 25886- 25887-/* Line 1455 of yacc.c */ 25888 #line 11361 "preproc.y" 25889 { 25890 (yyval.str) = make_str("over"); 25891@@ -43011,8 +39462,6 @@ 25892 break; 25893 25894 case 2009: 25895- 25896-/* Line 1455 of yacc.c */ 25897 #line 11365 "preproc.y" 25898 { 25899 (yyval.str) = make_str("overlaps"); 25900@@ -43020,8 +39469,6 @@ 25901 break; 25902 25903 case 2010: 25904- 25905-/* Line 1455 of yacc.c */ 25906 #line 11369 "preproc.y" 25907 { 25908 (yyval.str) = make_str("right"); 25909@@ -43029,8 +39476,6 @@ 25910 break; 25911 25912 case 2011: 25913- 25914-/* Line 1455 of yacc.c */ 25915 #line 11373 "preproc.y" 25916 { 25917 (yyval.str) = make_str("similar"); 25918@@ -43038,8 +39483,6 @@ 25919 break; 25920 25921 case 2012: 25922- 25923-/* Line 1455 of yacc.c */ 25924 #line 11377 "preproc.y" 25925 { 25926 (yyval.str) = make_str("verbose"); 25927@@ -43047,8 +39490,6 @@ 25928 break; 25929 25930 case 2013: 25931- 25932-/* Line 1455 of yacc.c */ 25933 #line 11385 "preproc.y" 25934 { 25935 (yyval.str) = make_str("all"); 25936@@ -43056,8 +39497,6 @@ 25937 break; 25938 25939 case 2014: 25940- 25941-/* Line 1455 of yacc.c */ 25942 #line 11389 "preproc.y" 25943 { 25944 (yyval.str) = make_str("analyse"); 25945@@ -43065,8 +39504,6 @@ 25946 break; 25947 25948 case 2015: 25949- 25950-/* Line 1455 of yacc.c */ 25951 #line 11393 "preproc.y" 25952 { 25953 (yyval.str) = make_str("analyze"); 25954@@ -43074,8 +39511,6 @@ 25955 break; 25956 25957 case 2016: 25958- 25959-/* Line 1455 of yacc.c */ 25960 #line 11397 "preproc.y" 25961 { 25962 (yyval.str) = make_str("and"); 25963@@ -43083,8 +39518,6 @@ 25964 break; 25965 25966 case 2017: 25967- 25968-/* Line 1455 of yacc.c */ 25969 #line 11401 "preproc.y" 25970 { 25971 (yyval.str) = make_str("any"); 25972@@ -43092,8 +39525,6 @@ 25973 break; 25974 25975 case 2018: 25976- 25977-/* Line 1455 of yacc.c */ 25978 #line 11405 "preproc.y" 25979 { 25980 (yyval.str) = make_str("array"); 25981@@ -43101,8 +39532,6 @@ 25982 break; 25983 25984 case 2019: 25985- 25986-/* Line 1455 of yacc.c */ 25987 #line 11409 "preproc.y" 25988 { 25989 (yyval.str) = make_str("as"); 25990@@ -43110,8 +39539,6 @@ 25991 break; 25992 25993 case 2020: 25994- 25995-/* Line 1455 of yacc.c */ 25996 #line 11413 "preproc.y" 25997 { 25998 (yyval.str) = make_str("asc"); 25999@@ -43119,8 +39546,6 @@ 26000 break; 26001 26002 case 2021: 26003- 26004-/* Line 1455 of yacc.c */ 26005 #line 11417 "preproc.y" 26006 { 26007 (yyval.str) = make_str("asymmetric"); 26008@@ -43128,8 +39553,6 @@ 26009 break; 26010 26011 case 2022: 26012- 26013-/* Line 1455 of yacc.c */ 26014 #line 11421 "preproc.y" 26015 { 26016 (yyval.str) = make_str("both"); 26017@@ -43137,8 +39560,6 @@ 26018 break; 26019 26020 case 2023: 26021- 26022-/* Line 1455 of yacc.c */ 26023 #line 11425 "preproc.y" 26024 { 26025 (yyval.str) = make_str("case"); 26026@@ -43146,8 +39567,6 @@ 26027 break; 26028 26029 case 2024: 26030- 26031-/* Line 1455 of yacc.c */ 26032 #line 11429 "preproc.y" 26033 { 26034 (yyval.str) = make_str("cast"); 26035@@ -43155,8 +39574,6 @@ 26036 break; 26037 26038 case 2025: 26039- 26040-/* Line 1455 of yacc.c */ 26041 #line 11433 "preproc.y" 26042 { 26043 (yyval.str) = make_str("check"); 26044@@ -43164,8 +39581,6 @@ 26045 break; 26046 26047 case 2026: 26048- 26049-/* Line 1455 of yacc.c */ 26050 #line 11437 "preproc.y" 26051 { 26052 (yyval.str) = make_str("collate"); 26053@@ -43173,8 +39588,6 @@ 26054 break; 26055 26056 case 2027: 26057- 26058-/* Line 1455 of yacc.c */ 26059 #line 11441 "preproc.y" 26060 { 26061 (yyval.str) = make_str("column"); 26062@@ -43182,8 +39595,6 @@ 26063 break; 26064 26065 case 2028: 26066- 26067-/* Line 1455 of yacc.c */ 26068 #line 11445 "preproc.y" 26069 { 26070 (yyval.str) = make_str("constraint"); 26071@@ -43191,8 +39602,6 @@ 26072 break; 26073 26074 case 2029: 26075- 26076-/* Line 1455 of yacc.c */ 26077 #line 11449 "preproc.y" 26078 { 26079 (yyval.str) = make_str("create"); 26080@@ -43200,8 +39609,6 @@ 26081 break; 26082 26083 case 2030: 26084- 26085-/* Line 1455 of yacc.c */ 26086 #line 11453 "preproc.y" 26087 { 26088 (yyval.str) = make_str("current_catalog"); 26089@@ -43209,8 +39616,6 @@ 26090 break; 26091 26092 case 2031: 26093- 26094-/* Line 1455 of yacc.c */ 26095 #line 11457 "preproc.y" 26096 { 26097 (yyval.str) = make_str("current_date"); 26098@@ -43218,8 +39623,6 @@ 26099 break; 26100 26101 case 2032: 26102- 26103-/* Line 1455 of yacc.c */ 26104 #line 11461 "preproc.y" 26105 { 26106 (yyval.str) = make_str("current_role"); 26107@@ -43227,8 +39630,6 @@ 26108 break; 26109 26110 case 2033: 26111- 26112-/* Line 1455 of yacc.c */ 26113 #line 11465 "preproc.y" 26114 { 26115 (yyval.str) = make_str("current_time"); 26116@@ -43236,8 +39637,6 @@ 26117 break; 26118 26119 case 2034: 26120- 26121-/* Line 1455 of yacc.c */ 26122 #line 11469 "preproc.y" 26123 { 26124 (yyval.str) = make_str("current_timestamp"); 26125@@ -43245,8 +39644,6 @@ 26126 break; 26127 26128 case 2035: 26129- 26130-/* Line 1455 of yacc.c */ 26131 #line 11473 "preproc.y" 26132 { 26133 (yyval.str) = make_str("current_user"); 26134@@ -43254,8 +39651,6 @@ 26135 break; 26136 26137 case 2036: 26138- 26139-/* Line 1455 of yacc.c */ 26140 #line 11477 "preproc.y" 26141 { 26142 (yyval.str) = make_str("default"); 26143@@ -43263,8 +39658,6 @@ 26144 break; 26145 26146 case 2037: 26147- 26148-/* Line 1455 of yacc.c */ 26149 #line 11481 "preproc.y" 26150 { 26151 (yyval.str) = make_str("deferrable"); 26152@@ -43272,8 +39665,6 @@ 26153 break; 26154 26155 case 2038: 26156- 26157-/* Line 1455 of yacc.c */ 26158 #line 11485 "preproc.y" 26159 { 26160 (yyval.str) = make_str("desc"); 26161@@ -43281,8 +39672,6 @@ 26162 break; 26163 26164 case 2039: 26165- 26166-/* Line 1455 of yacc.c */ 26167 #line 11489 "preproc.y" 26168 { 26169 (yyval.str) = make_str("distinct"); 26170@@ -43290,8 +39679,6 @@ 26171 break; 26172 26173 case 2040: 26174- 26175-/* Line 1455 of yacc.c */ 26176 #line 11493 "preproc.y" 26177 { 26178 (yyval.str) = make_str("do"); 26179@@ -43299,8 +39686,6 @@ 26180 break; 26181 26182 case 2041: 26183- 26184-/* Line 1455 of yacc.c */ 26185 #line 11497 "preproc.y" 26186 { 26187 (yyval.str) = make_str("else"); 26188@@ -43308,8 +39693,6 @@ 26189 break; 26190 26191 case 2042: 26192- 26193-/* Line 1455 of yacc.c */ 26194 #line 11501 "preproc.y" 26195 { 26196 (yyval.str) = make_str("end"); 26197@@ -43317,8 +39700,6 @@ 26198 break; 26199 26200 case 2043: 26201- 26202-/* Line 1455 of yacc.c */ 26203 #line 11505 "preproc.y" 26204 { 26205 (yyval.str) = make_str("except"); 26206@@ -43326,8 +39707,6 @@ 26207 break; 26208 26209 case 2044: 26210- 26211-/* Line 1455 of yacc.c */ 26212 #line 11509 "preproc.y" 26213 { 26214 (yyval.str) = make_str("false"); 26215@@ -43335,8 +39714,6 @@ 26216 break; 26217 26218 case 2045: 26219- 26220-/* Line 1455 of yacc.c */ 26221 #line 11513 "preproc.y" 26222 { 26223 (yyval.str) = make_str("fetch"); 26224@@ -43344,8 +39721,6 @@ 26225 break; 26226 26227 case 2046: 26228- 26229-/* Line 1455 of yacc.c */ 26230 #line 11517 "preproc.y" 26231 { 26232 (yyval.str) = make_str("for"); 26233@@ -43353,8 +39728,6 @@ 26234 break; 26235 26236 case 2047: 26237- 26238-/* Line 1455 of yacc.c */ 26239 #line 11521 "preproc.y" 26240 { 26241 (yyval.str) = make_str("foreign"); 26242@@ -43362,8 +39735,6 @@ 26243 break; 26244 26245 case 2048: 26246- 26247-/* Line 1455 of yacc.c */ 26248 #line 11525 "preproc.y" 26249 { 26250 (yyval.str) = make_str("from"); 26251@@ -43371,8 +39742,6 @@ 26252 break; 26253 26254 case 2049: 26255- 26256-/* Line 1455 of yacc.c */ 26257 #line 11529 "preproc.y" 26258 { 26259 (yyval.str) = make_str("grant"); 26260@@ -43380,8 +39749,6 @@ 26261 break; 26262 26263 case 2050: 26264- 26265-/* Line 1455 of yacc.c */ 26266 #line 11533 "preproc.y" 26267 { 26268 (yyval.str) = make_str("group"); 26269@@ -43389,8 +39756,6 @@ 26270 break; 26271 26272 case 2051: 26273- 26274-/* Line 1455 of yacc.c */ 26275 #line 11537 "preproc.y" 26276 { 26277 (yyval.str) = make_str("having"); 26278@@ -43398,8 +39763,6 @@ 26279 break; 26280 26281 case 2052: 26282- 26283-/* Line 1455 of yacc.c */ 26284 #line 11541 "preproc.y" 26285 { 26286 (yyval.str) = make_str("in"); 26287@@ -43407,8 +39770,6 @@ 26288 break; 26289 26290 case 2053: 26291- 26292-/* Line 1455 of yacc.c */ 26293 #line 11545 "preproc.y" 26294 { 26295 (yyval.str) = make_str("initially"); 26296@@ -43416,8 +39777,6 @@ 26297 break; 26298 26299 case 2054: 26300- 26301-/* Line 1455 of yacc.c */ 26302 #line 11549 "preproc.y" 26303 { 26304 (yyval.str) = make_str("intersect"); 26305@@ -43425,8 +39784,6 @@ 26306 break; 26307 26308 case 2055: 26309- 26310-/* Line 1455 of yacc.c */ 26311 #line 11553 "preproc.y" 26312 { 26313 (yyval.str) = make_str("into"); 26314@@ -43434,8 +39791,6 @@ 26315 break; 26316 26317 case 2056: 26318- 26319-/* Line 1455 of yacc.c */ 26320 #line 11557 "preproc.y" 26321 { 26322 (yyval.str) = make_str("leading"); 26323@@ -43443,8 +39798,6 @@ 26324 break; 26325 26326 case 2057: 26327- 26328-/* Line 1455 of yacc.c */ 26329 #line 11561 "preproc.y" 26330 { 26331 (yyval.str) = make_str("limit"); 26332@@ -43452,8 +39805,6 @@ 26333 break; 26334 26335 case 2058: 26336- 26337-/* Line 1455 of yacc.c */ 26338 #line 11565 "preproc.y" 26339 { 26340 (yyval.str) = make_str("localtime"); 26341@@ -43461,8 +39812,6 @@ 26342 break; 26343 26344 case 2059: 26345- 26346-/* Line 1455 of yacc.c */ 26347 #line 11569 "preproc.y" 26348 { 26349 (yyval.str) = make_str("localtimestamp"); 26350@@ -43470,8 +39819,6 @@ 26351 break; 26352 26353 case 2060: 26354- 26355-/* Line 1455 of yacc.c */ 26356 #line 11573 "preproc.y" 26357 { 26358 (yyval.str) = make_str("not"); 26359@@ -43479,8 +39826,6 @@ 26360 break; 26361 26362 case 2061: 26363- 26364-/* Line 1455 of yacc.c */ 26365 #line 11577 "preproc.y" 26366 { 26367 (yyval.str) = make_str("null"); 26368@@ -43488,8 +39833,6 @@ 26369 break; 26370 26371 case 2062: 26372- 26373-/* Line 1455 of yacc.c */ 26374 #line 11581 "preproc.y" 26375 { 26376 (yyval.str) = make_str("offset"); 26377@@ -43497,8 +39840,6 @@ 26378 break; 26379 26380 case 2063: 26381- 26382-/* Line 1455 of yacc.c */ 26383 #line 11585 "preproc.y" 26384 { 26385 (yyval.str) = make_str("on"); 26386@@ -43506,8 +39847,6 @@ 26387 break; 26388 26389 case 2064: 26390- 26391-/* Line 1455 of yacc.c */ 26392 #line 11589 "preproc.y" 26393 { 26394 (yyval.str) = make_str("only"); 26395@@ -43515,8 +39854,6 @@ 26396 break; 26397 26398 case 2065: 26399- 26400-/* Line 1455 of yacc.c */ 26401 #line 11593 "preproc.y" 26402 { 26403 (yyval.str) = make_str("or"); 26404@@ -43524,8 +39861,6 @@ 26405 break; 26406 26407 case 2066: 26408- 26409-/* Line 1455 of yacc.c */ 26410 #line 11597 "preproc.y" 26411 { 26412 (yyval.str) = make_str("order"); 26413@@ -43533,8 +39868,6 @@ 26414 break; 26415 26416 case 2067: 26417- 26418-/* Line 1455 of yacc.c */ 26419 #line 11601 "preproc.y" 26420 { 26421 (yyval.str) = make_str("placing"); 26422@@ -43542,8 +39875,6 @@ 26423 break; 26424 26425 case 2068: 26426- 26427-/* Line 1455 of yacc.c */ 26428 #line 11605 "preproc.y" 26429 { 26430 (yyval.str) = make_str("primary"); 26431@@ -43551,8 +39882,6 @@ 26432 break; 26433 26434 case 2069: 26435- 26436-/* Line 1455 of yacc.c */ 26437 #line 11609 "preproc.y" 26438 { 26439 (yyval.str) = make_str("references"); 26440@@ -43560,8 +39889,6 @@ 26441 break; 26442 26443 case 2070: 26444- 26445-/* Line 1455 of yacc.c */ 26446 #line 11613 "preproc.y" 26447 { 26448 (yyval.str) = make_str("returning"); 26449@@ -43569,8 +39896,6 @@ 26450 break; 26451 26452 case 2071: 26453- 26454-/* Line 1455 of yacc.c */ 26455 #line 11617 "preproc.y" 26456 { 26457 (yyval.str) = make_str("select"); 26458@@ -43578,8 +39903,6 @@ 26459 break; 26460 26461 case 2072: 26462- 26463-/* Line 1455 of yacc.c */ 26464 #line 11621 "preproc.y" 26465 { 26466 (yyval.str) = make_str("session_user"); 26467@@ -43587,8 +39910,6 @@ 26468 break; 26469 26470 case 2073: 26471- 26472-/* Line 1455 of yacc.c */ 26473 #line 11625 "preproc.y" 26474 { 26475 (yyval.str) = make_str("some"); 26476@@ -43596,8 +39917,6 @@ 26477 break; 26478 26479 case 2074: 26480- 26481-/* Line 1455 of yacc.c */ 26482 #line 11629 "preproc.y" 26483 { 26484 (yyval.str) = make_str("symmetric"); 26485@@ -43605,8 +39924,6 @@ 26486 break; 26487 26488 case 2075: 26489- 26490-/* Line 1455 of yacc.c */ 26491 #line 11633 "preproc.y" 26492 { 26493 (yyval.str) = make_str("table"); 26494@@ -43614,8 +39931,6 @@ 26495 break; 26496 26497 case 2076: 26498- 26499-/* Line 1455 of yacc.c */ 26500 #line 11637 "preproc.y" 26501 { 26502 (yyval.str) = make_str("then"); 26503@@ -43623,8 +39938,6 @@ 26504 break; 26505 26506 case 2077: 26507- 26508-/* Line 1455 of yacc.c */ 26509 #line 11641 "preproc.y" 26510 { 26511 (yyval.str) = make_str("trailing"); 26512@@ -43632,8 +39945,6 @@ 26513 break; 26514 26515 case 2078: 26516- 26517-/* Line 1455 of yacc.c */ 26518 #line 11645 "preproc.y" 26519 { 26520 (yyval.str) = make_str("true"); 26521@@ -43641,8 +39952,6 @@ 26522 break; 26523 26524 case 2079: 26525- 26526-/* Line 1455 of yacc.c */ 26527 #line 11649 "preproc.y" 26528 { 26529 (yyval.str) = make_str("unique"); 26530@@ -43650,8 +39959,6 @@ 26531 break; 26532 26533 case 2080: 26534- 26535-/* Line 1455 of yacc.c */ 26536 #line 11653 "preproc.y" 26537 { 26538 (yyval.str) = make_str("user"); 26539@@ -43659,8 +39966,6 @@ 26540 break; 26541 26542 case 2081: 26543- 26544-/* Line 1455 of yacc.c */ 26545 #line 11657 "preproc.y" 26546 { 26547 (yyval.str) = make_str("using"); 26548@@ -43668,8 +39973,6 @@ 26549 break; 26550 26551 case 2082: 26552- 26553-/* Line 1455 of yacc.c */ 26554 #line 11661 "preproc.y" 26555 { 26556 (yyval.str) = make_str("variadic"); 26557@@ -43677,8 +39980,6 @@ 26558 break; 26559 26560 case 2083: 26561- 26562-/* Line 1455 of yacc.c */ 26563 #line 11665 "preproc.y" 26564 { 26565 (yyval.str) = make_str("when"); 26566@@ -43686,8 +39987,6 @@ 26567 break; 26568 26569 case 2084: 26570- 26571-/* Line 1455 of yacc.c */ 26572 #line 11669 "preproc.y" 26573 { 26574 (yyval.str) = make_str("where"); 26575@@ -43695,8 +39994,6 @@ 26576 break; 26577 26578 case 2085: 26579- 26580-/* Line 1455 of yacc.c */ 26581 #line 11673 "preproc.y" 26582 { 26583 (yyval.str) = make_str("window"); 26584@@ -43704,8 +40001,6 @@ 26585 break; 26586 26587 case 2086: 26588- 26589-/* Line 1455 of yacc.c */ 26590 #line 11677 "preproc.y" 26591 { 26592 (yyval.str) = make_str("with"); 26593@@ -43713,15 +40008,11 @@ 26594 break; 26595 26596 case 2089: 26597- 26598-/* Line 1455 of yacc.c */ 26599 #line 11690 "preproc.y" 26600 { connection = NULL; ;} 26601 break; 26602 26603 case 2091: 26604- 26605-/* Line 1455 of yacc.c */ 26606 #line 11693 "preproc.y" 26607 { 26608 fprintf(yyout, "%s", (yyvsp[(2) - (2)].str)); 26609@@ -43731,29 +40022,21 @@ 26610 break; 26611 26612 case 2093: 26613- 26614-/* Line 1455 of yacc.c */ 26615 #line 11699 "preproc.y" 26616 { fprintf(yyout, "%s", (yyvsp[(1) - (1)].str)); free((yyvsp[(1) - (1)].str)); ;} 26617 break; 26618 26619 case 2094: 26620- 26621-/* Line 1455 of yacc.c */ 26622 #line 11700 "preproc.y" 26623 { fprintf(yyout, "%s", (yyvsp[(1) - (1)].str)); free((yyvsp[(1) - (1)].str)); ;} 26624 break; 26625 26626 case 2095: 26627- 26628-/* Line 1455 of yacc.c */ 26629 #line 11701 "preproc.y" 26630 { braces_open++; fputs("{", yyout); ;} 26631 break; 26632 26633 case 2096: 26634- 26635-/* Line 1455 of yacc.c */ 26636 #line 11703 "preproc.y" 26637 { 26638 remove_typedefs(braces_open); 26639@@ -43768,15 +40051,11 @@ 26640 break; 26641 26642 case 2097: 26643- 26644-/* Line 1455 of yacc.c */ 26645 #line 11715 "preproc.y" 26646 {FoundInto = 0;;} 26647 break; 26648 26649 case 2098: 26650- 26651-/* Line 1455 of yacc.c */ 26652 #line 11716 "preproc.y" 26653 { 26654 if (FoundInto == 1) 26655@@ -43787,8 +40066,6 @@ 26656 break; 26657 26658 case 2099: 26659- 26660-/* Line 1455 of yacc.c */ 26661 #line 11725 "preproc.y" 26662 { 26663 connection = (yyvsp[(2) - (2)].str); 26664@@ -43803,36 +40080,26 @@ 26665 break; 26666 26667 case 2100: 26668- 26669-/* Line 1455 of yacc.c */ 26670 #line 11741 "preproc.y" 26671 { (yyval.str) = cat_str(5, (yyvsp[(3) - (5)].str), make_str(","), (yyvsp[(5) - (5)].str), make_str(","), (yyvsp[(4) - (5)].str)); ;} 26672 break; 26673 26674 case 2101: 26675- 26676-/* Line 1455 of yacc.c */ 26677 #line 11743 "preproc.y" 26678 { (yyval.str) = make_str("NULL, NULL, NULL, \"DEFAULT\""); ;} 26679 break; 26680 26681 case 2102: 26682- 26683-/* Line 1455 of yacc.c */ 26684 #line 11746 "preproc.y" 26685 { (yyval.str) = cat_str(3, make_str("NULL,"), (yyvsp[(2) - (2)].str), make_str(", NULL")); ;} 26686 break; 26687 26688 case 2103: 26689- 26690-/* Line 1455 of yacc.c */ 26691 #line 11748 "preproc.y" 26692 { (yyval.str) = cat2_str((yyvsp[(2) - (2)].str), make_str(", NULL, NULL, NULL")); ;} 26693 break; 26694 26695 case 2104: 26696- 26697-/* Line 1455 of yacc.c */ 26698 #line 11752 "preproc.y" 26699 { 26700 /* old style: dbname[@server][:port] */ 26701@@ -43848,8 +40115,6 @@ 26702 break; 26703 26704 case 2105: 26705- 26706-/* Line 1455 of yacc.c */ 26707 #line 11764 "preproc.y" 26708 { 26709 /* new style: <tcp|unix>:postgresql://server[:port][/dbname] */ 26710@@ -43869,8 +40134,6 @@ 26711 break; 26712 26713 case 2106: 26714- 26715-/* Line 1455 of yacc.c */ 26716 #line 11780 "preproc.y" 26717 { 26718 (yyval.str) = (yyvsp[(1) - (1)].str); 26719@@ -43878,8 +40141,6 @@ 26720 break; 26721 26722 case 2107: 26723- 26724-/* Line 1455 of yacc.c */ 26725 #line 11784 "preproc.y" 26726 { 26727 /* We can only process double quoted strings not single quotes ones, 26728@@ -43892,22 +40153,16 @@ 26729 break; 26730 26731 case 2108: 26732- 26733-/* Line 1455 of yacc.c */ 26734 #line 11794 "preproc.y" 26735 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 26736 break; 26737 26738 case 2109: 26739- 26740-/* Line 1455 of yacc.c */ 26741 #line 11795 "preproc.y" 26742 { (yyval.str) = EMPTY; ;} 26743 break; 26744 26745 case 2110: 26746- 26747-/* Line 1455 of yacc.c */ 26748 #line 11799 "preproc.y" 26749 { 26750 if (strcmp((yyvsp[(2) - (2)].str), "postgresql") != 0 && strcmp((yyvsp[(2) - (2)].str), "postgres") != 0) 26751@@ -43921,8 +40176,6 @@ 26752 break; 26753 26754 case 2111: 26755- 26756-/* Line 1455 of yacc.c */ 26757 #line 11811 "preproc.y" 26758 { 26759 if (strcmp((yyvsp[(1) - (2)].str), "@") != 0 && strcmp((yyvsp[(1) - (2)].str), "//") != 0) 26760@@ -43933,113 +40186,81 @@ 26761 break; 26762 26763 case 2112: 26764- 26765-/* Line 1455 of yacc.c */ 26766 #line 11819 "preproc.y" 26767 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 26768 break; 26769 26770 case 2113: 26771- 26772-/* Line 1455 of yacc.c */ 26773 #line 11820 "preproc.y" 26774 { (yyval.str) = EMPTY; ;} 26775 break; 26776 26777 case 2114: 26778- 26779-/* Line 1455 of yacc.c */ 26780 #line 11823 "preproc.y" 26781 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 26782 break; 26783 26784 case 2115: 26785- 26786-/* Line 1455 of yacc.c */ 26787 #line 11824 "preproc.y" 26788 { (yyval.str) = make3_str((yyvsp[(1) - (3)].str), make_str("."), (yyvsp[(3) - (3)].str)); ;} 26789 break; 26790 26791 case 2116: 26792- 26793-/* Line 1455 of yacc.c */ 26794 #line 11825 "preproc.y" 26795 { (yyval.str) = make_name(); ;} 26796 break; 26797 26798 case 2117: 26799- 26800-/* Line 1455 of yacc.c */ 26801 #line 11828 "preproc.y" 26802 { (yyval.str) = make2_str(make_str(":"), (yyvsp[(2) - (2)].str)); ;} 26803 break; 26804 26805 case 2118: 26806- 26807-/* Line 1455 of yacc.c */ 26808 #line 11829 "preproc.y" 26809 { (yyval.str) = EMPTY; ;} 26810 break; 26811 26812 case 2119: 26813- 26814-/* Line 1455 of yacc.c */ 26815 #line 11832 "preproc.y" 26816 { (yyval.str) = (yyvsp[(2) - (2)].str); ;} 26817 break; 26818 26819 case 2120: 26820- 26821-/* Line 1455 of yacc.c */ 26822 #line 11833 "preproc.y" 26823 { (yyval.str) = make_str("NULL"); ;} 26824 break; 26825 26826 case 2121: 26827- 26828-/* Line 1455 of yacc.c */ 26829 #line 11836 "preproc.y" 26830 { (yyval.str) = (yyvsp[(2) - (2)].str); ;} 26831 break; 26832 26833 case 2122: 26834- 26835-/* Line 1455 of yacc.c */ 26836 #line 11837 "preproc.y" 26837 { (yyval.str) = make_str("NULL, NULL"); ;} 26838 break; 26839 26840 case 2123: 26841- 26842-/* Line 1455 of yacc.c */ 26843 #line 11841 "preproc.y" 26844 { (yyval.str) = cat2_str((yyvsp[(1) - (1)].str), make_str(", NULL")); ;} 26845 break; 26846 26847 case 2124: 26848- 26849-/* Line 1455 of yacc.c */ 26850 #line 11843 "preproc.y" 26851 { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str(","), (yyvsp[(3) - (3)].str)); ;} 26852 break; 26853 26854 case 2125: 26855- 26856-/* Line 1455 of yacc.c */ 26857 #line 11845 "preproc.y" 26858 { (yyval.str) = cat_str(3, (yyvsp[(1) - (4)].str), make_str(","), (yyvsp[(4) - (4)].str)); ;} 26859 break; 26860 26861 case 2126: 26862- 26863-/* Line 1455 of yacc.c */ 26864 #line 11847 "preproc.y" 26865 { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str(","), (yyvsp[(3) - (3)].str)); ;} 26866 break; 26867 26868 case 2127: 26869- 26870-/* Line 1455 of yacc.c */ 26871 #line 11851 "preproc.y" 26872 { 26873 if ((yyvsp[(1) - (1)].str)[0] == '\"') 26874@@ -44050,8 +40271,6 @@ 26875 break; 26876 26877 case 2128: 26878- 26879-/* Line 1455 of yacc.c */ 26880 #line 11858 "preproc.y" 26881 { 26882 if ((yyvsp[(1) - (1)].str)[0] == '\"') 26883@@ -44062,8 +40281,6 @@ 26884 break; 26885 26886 case 2129: 26887- 26888-/* Line 1455 of yacc.c */ 26889 #line 11865 "preproc.y" 26890 { 26891 enum ECPGttype type = argsinsert->variable->type->type; 26892@@ -44081,8 +40298,6 @@ 26893 break; 26894 26895 case 2130: 26896- 26897-/* Line 1455 of yacc.c */ 26898 #line 11881 "preproc.y" 26899 { 26900 /* check if we have a string variable */ 26901@@ -44118,8 +40333,6 @@ 26902 break; 26903 26904 case 2131: 26905- 26906-/* Line 1455 of yacc.c */ 26907 #line 11915 "preproc.y" 26908 { 26909 if (strlen((yyvsp[(1) - (2)].str)) == 0) 26910@@ -44133,22 +40346,16 @@ 26911 break; 26912 26913 case 2132: 26914- 26915-/* Line 1455 of yacc.c */ 26916 #line 11924 "preproc.y" 26917 { (yyval.str) = EMPTY; ;} 26918 break; 26919 26920 case 2133: 26921- 26922-/* Line 1455 of yacc.c */ 26923 #line 11928 "preproc.y" 26924 { (yyval.str) = make2_str((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); ;} 26925 break; 26926 26927 case 2134: 26928- 26929-/* Line 1455 of yacc.c */ 26930 #line 11930 "preproc.y" 26931 { 26932 if (strlen((yyvsp[(3) - (4)].str)) == 0) 26933@@ -44162,36 +40369,26 @@ 26934 break; 26935 26936 case 2135: 26937- 26938-/* Line 1455 of yacc.c */ 26939 #line 11942 "preproc.y" 26940 { (yyval.str) = EMPTY; ;} 26941 break; 26942 26943 case 2136: 26944- 26945-/* Line 1455 of yacc.c */ 26946 #line 11944 "preproc.y" 26947 { (yyval.str) = make2_str(make_str("="), (yyvsp[(2) - (2)].str)); ;} 26948 break; 26949 26950 case 2137: 26951- 26952-/* Line 1455 of yacc.c */ 26953 #line 11946 "preproc.y" 26954 { (yyval.str) = make2_str(make_str("="), (yyvsp[(2) - (2)].str)); ;} 26955 break; 26956 26957 case 2138: 26958- 26959-/* Line 1455 of yacc.c */ 26960 #line 11948 "preproc.y" 26961 { (yyval.str) = make2_str(make_str("="), (yyvsp[(2) - (2)].str)); ;} 26962 break; 26963 26964 case 2139: 26965- 26966-/* Line 1455 of yacc.c */ 26967 #line 11951 "preproc.y" 26968 { 26969 if ((yyvsp[(1) - (1)].str)[0] == '\"' && (yyvsp[(1) - (1)].str)[strlen((yyvsp[(1) - (1)].str))-1] == '\"') /* already quoted? */ 26970@@ -44209,15 +40406,11 @@ 26971 break; 26972 26973 case 2140: 26974- 26975-/* Line 1455 of yacc.c */ 26976 #line 11964 "preproc.y" 26977 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 26978 break; 26979 26980 case 2141: 26981- 26982-/* Line 1455 of yacc.c */ 26983 #line 11972 "preproc.y" 26984 { 26985 struct cursor *ptr, *this; 26986@@ -44279,8 +40472,6 @@ 26987 break; 26988 26989 case 2142: 26990- 26991-/* Line 1455 of yacc.c */ 26992 #line 12032 "preproc.y" 26993 { 26994 /* execute immediate means prepare the statement and 26995@@ -44290,85 +40481,61 @@ 26996 break; 26997 26998 case 2144: 26999- 27000-/* Line 1455 of yacc.c */ 27001 #line 12042 "preproc.y" 27002 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27003 break; 27004 27005 case 2145: 27006- 27007-/* Line 1455 of yacc.c */ 27008 #line 12043 "preproc.y" 27009 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27010 break; 27011 27012 case 2146: 27013- 27014-/* Line 1455 of yacc.c */ 27015 #line 12046 "preproc.y" 27016 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27017 break; 27018 27019 case 2147: 27020- 27021-/* Line 1455 of yacc.c */ 27022 #line 12048 "preproc.y" 27023 { (yyval.str) = (yyvsp[(2) - (2)].str); ;} 27024 break; 27025 27026 case 2148: 27027- 27028-/* Line 1455 of yacc.c */ 27029 #line 12049 "preproc.y" 27030 { (yyval.str) = EMPTY; ;} 27031 break; 27032 27033 case 2149: 27034- 27035-/* Line 1455 of yacc.c */ 27036 #line 12052 "preproc.y" 27037 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27038 break; 27039 27040 case 2150: 27041- 27042-/* Line 1455 of yacc.c */ 27043 #line 12053 "preproc.y" 27044 { (yyval.str) = make_str("year to minute"); ;} 27045 break; 27046 27047 case 2151: 27048- 27049-/* Line 1455 of yacc.c */ 27050 #line 12054 "preproc.y" 27051 { (yyval.str) = make_str("year to second"); ;} 27052 break; 27053 27054 case 2152: 27055- 27056-/* Line 1455 of yacc.c */ 27057 #line 12055 "preproc.y" 27058 { (yyval.str) = make_str("day to day"); ;} 27059 break; 27060 27061 case 2153: 27062- 27063-/* Line 1455 of yacc.c */ 27064 #line 12056 "preproc.y" 27065 { (yyval.str) = make_str("month to month"); ;} 27066 break; 27067 27068 case 2154: 27069- 27070-/* Line 1455 of yacc.c */ 27071 #line 12063 "preproc.y" 27072 { fputs("/* exec sql begin declare section */", yyout); ;} 27073 break; 27074 27075 case 2155: 27076- 27077-/* Line 1455 of yacc.c */ 27078 #line 12065 "preproc.y" 27079 { 27080 fprintf(yyout, "%s/* exec sql end declare section */", (yyvsp[(3) - (4)].str)); 27081@@ -44378,78 +40545,56 @@ 27082 break; 27083 27084 case 2156: 27085- 27086-/* Line 1455 of yacc.c */ 27087 #line 12072 "preproc.y" 27088 {;} 27089 break; 27090 27091 case 2157: 27092- 27093-/* Line 1455 of yacc.c */ 27094 #line 12074 "preproc.y" 27095 {;} 27096 break; 27097 27098 case 2158: 27099- 27100-/* Line 1455 of yacc.c */ 27101 #line 12076 "preproc.y" 27102 { (yyval.str) = EMPTY; ;} 27103 break; 27104 27105 case 2159: 27106- 27107-/* Line 1455 of yacc.c */ 27108 #line 12077 "preproc.y" 27109 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27110 break; 27111 27112 case 2160: 27113- 27114-/* Line 1455 of yacc.c */ 27115 #line 12080 "preproc.y" 27116 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27117 break; 27118 27119 case 2161: 27120- 27121-/* Line 1455 of yacc.c */ 27122 #line 12081 "preproc.y" 27123 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27124 break; 27125 27126 case 2162: 27127- 27128-/* Line 1455 of yacc.c */ 27129 #line 12082 "preproc.y" 27130 { (yyval.str) = cat2_str((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); ;} 27131 break; 27132 27133 case 2163: 27134- 27135-/* Line 1455 of yacc.c */ 27136 #line 12083 "preproc.y" 27137 { (yyval.str) = cat2_str((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); ;} 27138 break; 27139 27140 case 2164: 27141- 27142-/* Line 1455 of yacc.c */ 27143 #line 12086 "preproc.y" 27144 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27145 break; 27146 27147 case 2165: 27148- 27149-/* Line 1455 of yacc.c */ 27150 #line 12087 "preproc.y" 27151 { (yyval.str) = cat2_str((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); ;} 27152 break; 27153 27154 case 2166: 27155- 27156-/* Line 1455 of yacc.c */ 27157 #line 12091 "preproc.y" 27158 { 27159 /* reset this variable so we see if there was */ 27160@@ -44459,8 +40604,6 @@ 27161 break; 27162 27163 case 2167: 27164- 27165-/* Line 1455 of yacc.c */ 27166 #line 12097 "preproc.y" 27167 { 27168 add_typedef((yyvsp[(5) - (7)].str), (yyvsp[(6) - (7)].index).index1, (yyvsp[(6) - (7)].index).index2, (yyvsp[(3) - (7)].type).type_enum, (yyvsp[(3) - (7)].type).type_dimension, (yyvsp[(3) - (7)].type).type_index, initializer, *(yyvsp[(4) - (7)].str) ? 1 : 0); 27169@@ -44472,8 +40615,6 @@ 27170 break; 27171 27172 case 2168: 27173- 27174-/* Line 1455 of yacc.c */ 27175 #line 12107 "preproc.y" 27176 { 27177 actual_type[struct_level].type_enum = (yyvsp[(2) - (2)].type).type_enum; 27178@@ -44487,8 +40628,6 @@ 27179 break; 27180 27181 case 2169: 27182- 27183-/* Line 1455 of yacc.c */ 27184 #line 12117 "preproc.y" 27185 { 27186 (yyval.str) = cat_str(5, actual_startline[struct_level], (yyvsp[(1) - (5)].str), (yyvsp[(2) - (5)].type).type_str, (yyvsp[(4) - (5)].str), make_str(";\n")); 27187@@ -44496,8 +40635,6 @@ 27188 break; 27189 27190 case 2170: 27191- 27192-/* Line 1455 of yacc.c */ 27193 #line 12121 "preproc.y" 27194 { 27195 actual_type[struct_level].type_enum = (yyvsp[(1) - (1)].type).type_enum; 27196@@ -44511,8 +40648,6 @@ 27197 break; 27198 27199 case 2171: 27200- 27201-/* Line 1455 of yacc.c */ 27202 #line 12131 "preproc.y" 27203 { 27204 (yyval.str) = cat_str(4, actual_startline[struct_level], (yyvsp[(1) - (4)].type).type_str, (yyvsp[(3) - (4)].str), make_str(";\n")); 27205@@ -44520,8 +40655,6 @@ 27206 break; 27207 27208 case 2172: 27209- 27210-/* Line 1455 of yacc.c */ 27211 #line 12135 "preproc.y" 27212 { 27213 (yyval.str) = cat2_str((yyvsp[(1) - (2)].str), make_str(";")); 27214@@ -44529,85 +40662,61 @@ 27215 break; 27216 27217 case 2173: 27218- 27219-/* Line 1455 of yacc.c */ 27220 #line 12140 "preproc.y" 27221 { (yyval.str) =cat2_str(make_str(":"), (yyvsp[(2) - (2)].str)); ;} 27222 break; 27223 27224 case 2174: 27225- 27226-/* Line 1455 of yacc.c */ 27227 #line 12141 "preproc.y" 27228 { (yyval.str) = EMPTY; ;} 27229 break; 27230 27231 case 2175: 27232- 27233-/* Line 1455 of yacc.c */ 27234 #line 12145 "preproc.y" 27235 {(yyval.str) = cat2_str ((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); ;} 27236 break; 27237 27238 case 2176: 27239- 27240-/* Line 1455 of yacc.c */ 27241 #line 12146 "preproc.y" 27242 {(yyval.str) = (yyvsp[(1) - (1)].str); ;} 27243 break; 27244 27245 case 2177: 27246- 27247-/* Line 1455 of yacc.c */ 27248 #line 12147 "preproc.y" 27249 {(yyval.str) = (yyvsp[(1) - (1)].str); ;} 27250 break; 27251 27252 case 2178: 27253- 27254-/* Line 1455 of yacc.c */ 27255 #line 12150 "preproc.y" 27256 { (yyval.str) = make_str("extern"); ;} 27257 break; 27258 27259 case 2179: 27260- 27261-/* Line 1455 of yacc.c */ 27262 #line 12151 "preproc.y" 27263 { (yyval.str) = make_str("static"); ;} 27264 break; 27265 27266 case 2180: 27267- 27268-/* Line 1455 of yacc.c */ 27269 #line 12152 "preproc.y" 27270 { (yyval.str) = make_str("register"); ;} 27271 break; 27272 27273 case 2181: 27274- 27275-/* Line 1455 of yacc.c */ 27276 #line 12153 "preproc.y" 27277 { (yyval.str) = make_str("auto"); ;} 27278 break; 27279 27280 case 2182: 27281- 27282-/* Line 1455 of yacc.c */ 27283 #line 12156 "preproc.y" 27284 { (yyval.str) = make_str("const"); ;} 27285 break; 27286 27287 case 2183: 27288- 27289-/* Line 1455 of yacc.c */ 27290 #line 12157 "preproc.y" 27291 { (yyval.str) = make_str("volatile"); ;} 27292 break; 27293 27294 case 2184: 27295- 27296-/* Line 1455 of yacc.c */ 27297 #line 12161 "preproc.y" 27298 { 27299 (yyval.type).type_enum = (yyvsp[(1) - (1)].type_enum); 27300@@ -44619,8 +40728,6 @@ 27301 break; 27302 27303 case 2185: 27304- 27305-/* Line 1455 of yacc.c */ 27306 #line 12169 "preproc.y" 27307 { 27308 (yyval.type).type_str = (yyvsp[(1) - (1)].str); 27309@@ -44641,8 +40748,6 @@ 27310 break; 27311 27312 case 2186: 27313- 27314-/* Line 1455 of yacc.c */ 27315 #line 12186 "preproc.y" 27316 { 27317 (yyval.type).type_str = (yyvsp[(1) - (1)].str); 27318@@ -44654,8 +40759,6 @@ 27319 break; 27320 27321 case 2187: 27322- 27323-/* Line 1455 of yacc.c */ 27324 #line 12194 "preproc.y" 27325 { 27326 if (strcmp((yyvsp[(1) - (5)].str), "numeric") == 0) 27327@@ -44682,8 +40785,6 @@ 27328 break; 27329 27330 case 2188: 27331- 27332-/* Line 1455 of yacc.c */ 27333 #line 12217 "preproc.y" 27334 { 27335 if (strlen((yyvsp[(2) - (2)].str)) != 0 && strcmp ((yyvsp[(1) - (2)].str), "datetime") != 0 && strcmp ((yyvsp[(1) - (2)].str), "interval") != 0) 27336@@ -44793,8 +40894,6 @@ 27337 break; 27338 27339 case 2189: 27340- 27341-/* Line 1455 of yacc.c */ 27342 #line 12323 "preproc.y" 27343 { 27344 /* this is for named structs/unions */ 27345@@ -44830,36 +40929,26 @@ 27346 break; 27347 27348 case 2190: 27349- 27350-/* Line 1455 of yacc.c */ 27351 #line 12357 "preproc.y" 27352 { (yyval.str) = cat_str(3, make_str("enum"), (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str)); ;} 27353 break; 27354 27355 case 2191: 27356- 27357-/* Line 1455 of yacc.c */ 27358 #line 12359 "preproc.y" 27359 { (yyval.str) = cat2_str(make_str("enum"), (yyvsp[(2) - (2)].str)); ;} 27360 break; 27361 27362 case 2192: 27363- 27364-/* Line 1455 of yacc.c */ 27365 #line 12361 "preproc.y" 27366 { (yyval.str) = cat2_str(make_str("enum"), (yyvsp[(2) - (2)].str)); ;} 27367 break; 27368 27369 case 2193: 27370- 27371-/* Line 1455 of yacc.c */ 27372 #line 12365 "preproc.y" 27373 { (yyval.str) = cat_str(3, make_str("{"), (yyvsp[(2) - (3)].str), make_str("}")); ;} 27374 break; 27375 27376 case 2194: 27377- 27378-/* Line 1455 of yacc.c */ 27379 #line 12368 "preproc.y" 27380 { 27381 struct_member_list[struct_level++] = NULL; 27382@@ -44870,8 +40959,6 @@ 27383 break; 27384 27385 case 2195: 27386- 27387-/* Line 1455 of yacc.c */ 27388 #line 12375 "preproc.y" 27389 { 27390 struct typedefs *ptr, *this; 27391@@ -44917,15 +41004,11 @@ 27392 break; 27393 27394 case 2196: 27395- 27396-/* Line 1455 of yacc.c */ 27397 #line 12418 "preproc.y" 27398 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27399 break; 27400 27401 case 2197: 27402- 27403-/* Line 1455 of yacc.c */ 27404 #line 12420 "preproc.y" 27405 { 27406 struct_member_list[struct_level++] = NULL; 27407@@ -44935,8 +41018,6 @@ 27408 break; 27409 27410 case 2198: 27411- 27412-/* Line 1455 of yacc.c */ 27413 #line 12426 "preproc.y" 27414 { 27415 ECPGfree_struct_member(struct_member_list[struct_level]); 27416@@ -44947,8 +41028,6 @@ 27417 break; 27418 27419 case 2199: 27420- 27421-/* Line 1455 of yacc.c */ 27422 #line 12435 "preproc.y" 27423 { 27424 (yyval.struct_union).su = make_str("struct"); 27425@@ -44958,8 +41037,6 @@ 27426 break; 27427 27428 case 2200: 27429- 27430-/* Line 1455 of yacc.c */ 27431 #line 12441 "preproc.y" 27432 { 27433 (yyval.struct_union).su = make_str("union"); 27434@@ -44968,8 +41045,6 @@ 27435 break; 27436 27437 case 2201: 27438- 27439-/* Line 1455 of yacc.c */ 27440 #line 12448 "preproc.y" 27441 { 27442 ECPGstruct_sizeof = make_str(""); /* This must not be NULL to distinguish from simple types. */ 27443@@ -44978,71 +41053,51 @@ 27444 break; 27445 27446 case 2202: 27447- 27448-/* Line 1455 of yacc.c */ 27449 #line 12452 "preproc.y" 27450 { (yyval.str) = make_str("union"); ;} 27451 break; 27452 27453 case 2203: 27454- 27455-/* Line 1455 of yacc.c */ 27456 #line 12455 "preproc.y" 27457 { (yyval.type_enum)=(yyvsp[(1) - (1)].type_enum); ;} 27458 break; 27459 27460 case 2204: 27461- 27462-/* Line 1455 of yacc.c */ 27463 #line 12456 "preproc.y" 27464 { (yyval.type_enum)=(yyvsp[(2) - (2)].type_enum); ;} 27465 break; 27466 27467 case 2205: 27468- 27469-/* Line 1455 of yacc.c */ 27470 #line 12459 "preproc.y" 27471 { (yyval.type_enum) = ECPGt_unsigned_short; ;} 27472 break; 27473 27474 case 2206: 27475- 27476-/* Line 1455 of yacc.c */ 27477 #line 12460 "preproc.y" 27478 { (yyval.type_enum) = ECPGt_unsigned_short; ;} 27479 break; 27480 27481 case 2207: 27482- 27483-/* Line 1455 of yacc.c */ 27484 #line 12461 "preproc.y" 27485 { (yyval.type_enum) = ECPGt_unsigned_int; ;} 27486 break; 27487 27488 case 2208: 27489- 27490-/* Line 1455 of yacc.c */ 27491 #line 12462 "preproc.y" 27492 { (yyval.type_enum) = ECPGt_unsigned_int; ;} 27493 break; 27494 27495 case 2209: 27496- 27497-/* Line 1455 of yacc.c */ 27498 #line 12463 "preproc.y" 27499 { (yyval.type_enum) = ECPGt_unsigned_long; ;} 27500 break; 27501 27502 case 2210: 27503- 27504-/* Line 1455 of yacc.c */ 27505 #line 12464 "preproc.y" 27506 { (yyval.type_enum) = ECPGt_unsigned_long; ;} 27507 break; 27508 27509 case 2211: 27510- 27511-/* Line 1455 of yacc.c */ 27512 #line 12466 "preproc.y" 27513 { 27514 #ifdef HAVE_LONG_LONG_INT 27515@@ -45054,8 +41109,6 @@ 27516 break; 27517 27518 case 2212: 27519- 27520-/* Line 1455 of yacc.c */ 27521 #line 12474 "preproc.y" 27522 { 27523 #ifdef HAVE_LONG_LONG_INT 27524@@ -45067,50 +41120,36 @@ 27525 break; 27526 27527 case 2213: 27528- 27529-/* Line 1455 of yacc.c */ 27530 #line 12481 "preproc.y" 27531 { (yyval.type_enum) = ECPGt_unsigned_char; ;} 27532 break; 27533 27534 case 2214: 27535- 27536-/* Line 1455 of yacc.c */ 27537 #line 12484 "preproc.y" 27538 { (yyval.type_enum) = ECPGt_short; ;} 27539 break; 27540 27541 case 2215: 27542- 27543-/* Line 1455 of yacc.c */ 27544 #line 12485 "preproc.y" 27545 { (yyval.type_enum) = ECPGt_short; ;} 27546 break; 27547 27548 case 2216: 27549- 27550-/* Line 1455 of yacc.c */ 27551 #line 12486 "preproc.y" 27552 { (yyval.type_enum) = ECPGt_int; ;} 27553 break; 27554 27555 case 2217: 27556- 27557-/* Line 1455 of yacc.c */ 27558 #line 12487 "preproc.y" 27559 { (yyval.type_enum) = ECPGt_long; ;} 27560 break; 27561 27562 case 2218: 27563- 27564-/* Line 1455 of yacc.c */ 27565 #line 12488 "preproc.y" 27566 { (yyval.type_enum) = ECPGt_long; ;} 27567 break; 27568 27569 case 2219: 27570- 27571-/* Line 1455 of yacc.c */ 27572 #line 12490 "preproc.y" 27573 { 27574 #ifdef HAVE_LONG_LONG_INT 27575@@ -45122,8 +41161,6 @@ 27576 break; 27577 27578 case 2220: 27579- 27580-/* Line 1455 of yacc.c */ 27581 #line 12498 "preproc.y" 27582 { 27583 #ifdef HAVE_LONG_LONG_INT 27584@@ -45135,43 +41172,31 @@ 27585 break; 27586 27587 case 2221: 27588- 27589-/* Line 1455 of yacc.c */ 27590 #line 12505 "preproc.y" 27591 { (yyval.type_enum) = ECPGt_bool; ;} 27592 break; 27593 27594 case 2222: 27595- 27596-/* Line 1455 of yacc.c */ 27597 #line 12506 "preproc.y" 27598 { (yyval.type_enum) = ECPGt_char; ;} 27599 break; 27600 27601 case 2223: 27602- 27603-/* Line 1455 of yacc.c */ 27604 #line 12507 "preproc.y" 27605 { (yyval.type_enum) = ECPGt_double; ;} 27606 break; 27607 27608 case 2226: 27609- 27610-/* Line 1455 of yacc.c */ 27611 #line 12515 "preproc.y" 27612 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27613 break; 27614 27615 case 2227: 27616- 27617-/* Line 1455 of yacc.c */ 27618 #line 12517 "preproc.y" 27619 { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str(","), (yyvsp[(3) - (3)].str)); ;} 27620 break; 27621 27622 case 2228: 27623- 27624-/* Line 1455 of yacc.c */ 27625 #line 12521 "preproc.y" 27626 { 27627 struct ECPGtype * type; 27628@@ -45260,15 +41285,11 @@ 27629 break; 27630 27631 case 2229: 27632- 27633-/* Line 1455 of yacc.c */ 27634 #line 12608 "preproc.y" 27635 { (yyval.str) = EMPTY; ;} 27636 break; 27637 27638 case 2230: 27639- 27640-/* Line 1455 of yacc.c */ 27641 #line 12610 "preproc.y" 27642 { 27643 initializer = 1; 27644@@ -45277,29 +41298,21 @@ 27645 break; 27646 27647 case 2231: 27648- 27649-/* Line 1455 of yacc.c */ 27650 #line 12616 "preproc.y" 27651 { (yyval.str) = EMPTY; ;} 27652 break; 27653 27654 case 2232: 27655- 27656-/* Line 1455 of yacc.c */ 27657 #line 12617 "preproc.y" 27658 { (yyval.str) = make_str("*"); ;} 27659 break; 27660 27661 case 2233: 27662- 27663-/* Line 1455 of yacc.c */ 27664 #line 12618 "preproc.y" 27665 { (yyval.str) = make_str("**"); ;} 27666 break; 27667 27668 case 2234: 27669- 27670-/* Line 1455 of yacc.c */ 27671 #line 12625 "preproc.y" 27672 { 27673 /* this is only supported for compatibility */ 27674@@ -45308,92 +41321,66 @@ 27675 break; 27676 27677 case 2235: 27678- 27679-/* Line 1455 of yacc.c */ 27680 #line 12633 "preproc.y" 27681 { (yyval.str) = (yyvsp[(2) - (2)].str); ;} 27682 break; 27683 27684 case 2236: 27685- 27686-/* Line 1455 of yacc.c */ 27687 #line 12636 "preproc.y" 27688 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27689 break; 27690 27691 case 2237: 27692- 27693-/* Line 1455 of yacc.c */ 27694 #line 12637 "preproc.y" 27695 { (yyval.str) = make_str("\"CURRENT\""); ;} 27696 break; 27697 27698 case 2238: 27699- 27700-/* Line 1455 of yacc.c */ 27701 #line 12638 "preproc.y" 27702 { (yyval.str) = make_str("\"ALL\""); ;} 27703 break; 27704 27705 case 2239: 27706- 27707-/* Line 1455 of yacc.c */ 27708 #line 12639 "preproc.y" 27709 { (yyval.str) = make_str("\"CURRENT\""); ;} 27710 break; 27711 27712 case 2240: 27713- 27714-/* Line 1455 of yacc.c */ 27715 #line 12642 "preproc.y" 27716 { (yyval.str) = make3_str(make_str("\""), (yyvsp[(1) - (1)].str), make_str("\"")); ;} 27717 break; 27718 27719 case 2241: 27720- 27721-/* Line 1455 of yacc.c */ 27722 #line 12643 "preproc.y" 27723 { (yyval.str) = make_str("\"DEFAULT\""); ;} 27724 break; 27725 27726 case 2242: 27727- 27728-/* Line 1455 of yacc.c */ 27729 #line 12644 "preproc.y" 27730 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27731 break; 27732 27733 case 2243: 27734- 27735-/* Line 1455 of yacc.c */ 27736 #line 12648 "preproc.y" 27737 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27738 break; 27739 27740 case 2244: 27741- 27742-/* Line 1455 of yacc.c */ 27743 #line 12650 "preproc.y" 27744 { (yyval.str) = make3_str(make_str("\""), (yyvsp[(1) - (1)].str), make_str("\"")); ;} 27745 break; 27746 27747 case 2245: 27748- 27749-/* Line 1455 of yacc.c */ 27750 #line 12657 "preproc.y" 27751 { (yyval.str) = (yyvsp[(2) - (2)].str); ;} 27752 break; 27753 27754 case 2246: 27755- 27756-/* Line 1455 of yacc.c */ 27757 #line 12658 "preproc.y" 27758 { (yyval.str) = make_str("all"); ;} 27759 break; 27760 27761 case 2247: 27762- 27763-/* Line 1455 of yacc.c */ 27764 #line 12665 "preproc.y" 27765 { 27766 if ((yyvsp[(2) - (3)].str)[0] == ':') 27767@@ -45403,36 +41390,26 @@ 27768 break; 27769 27770 case 2248: 27771- 27772-/* Line 1455 of yacc.c */ 27773 #line 12672 "preproc.y" 27774 { (yyval.str) = EMPTY; ;} 27775 break; 27776 27777 case 2249: 27778- 27779-/* Line 1455 of yacc.c */ 27780 #line 12673 "preproc.y" 27781 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27782 break; 27783 27784 case 2250: 27785- 27786-/* Line 1455 of yacc.c */ 27787 #line 12676 "preproc.y" 27788 { (yyval.str) = EMPTY; ;} 27789 break; 27790 27791 case 2251: 27792- 27793-/* Line 1455 of yacc.c */ 27794 #line 12677 "preproc.y" 27795 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27796 break; 27797 27798 case 2252: 27799- 27800-/* Line 1455 of yacc.c */ 27801 #line 12681 "preproc.y" 27802 { 27803 add_variable_to_head(&argsinsert, descriptor_variable((yyvsp[(4) - (4)].str),0), &no_indicator); 27804@@ -45441,8 +41418,6 @@ 27805 break; 27806 27807 case 2253: 27808- 27809-/* Line 1455 of yacc.c */ 27810 #line 12686 "preproc.y" 27811 { 27812 add_variable_to_head(&argsinsert, sqlda_variable((yyvsp[(3) - (3)].str)), &no_indicator); 27813@@ -45451,8 +41426,6 @@ 27814 break; 27815 27816 case 2254: 27817- 27818-/* Line 1455 of yacc.c */ 27819 #line 12693 "preproc.y" 27820 { 27821 add_variable_to_head(&argsresult, descriptor_variable((yyvsp[(4) - (4)].str),1), &no_indicator); 27822@@ -45461,8 +41434,6 @@ 27823 break; 27824 27825 case 2255: 27826- 27827-/* Line 1455 of yacc.c */ 27828 #line 12698 "preproc.y" 27829 { 27830 add_variable_to_head(&argsresult, sqlda_variable((yyvsp[(3) - (3)].str)), &no_indicator); 27831@@ -45471,8 +41442,6 @@ 27832 break; 27833 27834 case 2256: 27835- 27836-/* Line 1455 of yacc.c */ 27837 #line 12705 "preproc.y" 27838 { 27839 add_variable_to_head(&argsresult, sqlda_variable((yyvsp[(2) - (2)].str)), &no_indicator); 27840@@ -45481,8 +41450,6 @@ 27841 break; 27842 27843 case 2259: 27844- 27845-/* Line 1455 of yacc.c */ 27846 #line 12714 "preproc.y" 27847 { 27848 char *length = mm_alloc(32); 27849@@ -45493,85 +41460,61 @@ 27850 break; 27851 27852 case 2260: 27853- 27854-/* Line 1455 of yacc.c */ 27855 #line 12720 "preproc.y" 27856 { (yyval.str) = EMPTY; ;} 27857 break; 27858 27859 case 2261: 27860- 27861-/* Line 1455 of yacc.c */ 27862 #line 12721 "preproc.y" 27863 { (yyval.str) = EMPTY; ;} 27864 break; 27865 27866 case 2262: 27867- 27868-/* Line 1455 of yacc.c */ 27869 #line 12724 "preproc.y" 27870 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27871 break; 27872 27873 case 2263: 27874- 27875-/* Line 1455 of yacc.c */ 27876 #line 12725 "preproc.y" 27877 { (yyval.str) = cat_str(2, make_str("+"), (yyvsp[(2) - (2)].str)); ;} 27878 break; 27879 27880 case 2264: 27881- 27882-/* Line 1455 of yacc.c */ 27883 #line 12726 "preproc.y" 27884 { (yyval.str) = cat_str(2, make_str("-"), (yyvsp[(2) - (2)].str)); ;} 27885 break; 27886 27887 case 2265: 27888- 27889-/* Line 1455 of yacc.c */ 27890 #line 12727 "preproc.y" 27891 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27892 break; 27893 27894 case 2266: 27895- 27896-/* Line 1455 of yacc.c */ 27897 #line 12728 "preproc.y" 27898 { (yyval.str) = cat_str(2, make_str("+"), (yyvsp[(2) - (2)].str)); ;} 27899 break; 27900 27901 case 2267: 27902- 27903-/* Line 1455 of yacc.c */ 27904 #line 12729 "preproc.y" 27905 { (yyval.str) = cat_str(2, make_str("-"), (yyvsp[(2) - (2)].str)); ;} 27906 break; 27907 27908 case 2268: 27909- 27910-/* Line 1455 of yacc.c */ 27911 #line 12730 "preproc.y" 27912 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27913 break; 27914 27915 case 2269: 27916- 27917-/* Line 1455 of yacc.c */ 27918 #line 12731 "preproc.y" 27919 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27920 break; 27921 27922 case 2270: 27923- 27924-/* Line 1455 of yacc.c */ 27925 #line 12732 "preproc.y" 27926 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 27927 break; 27928 27929 case 2271: 27930- 27931-/* Line 1455 of yacc.c */ 27932 #line 12739 "preproc.y" 27933 { 27934 const char *con = connection ? connection : "NULL"; 27935@@ -45582,8 +41525,6 @@ 27936 break; 27937 27938 case 2272: 27939- 27940-/* Line 1455 of yacc.c */ 27941 #line 12746 "preproc.y" 27942 { 27943 const char *con = connection ? connection : "NULL"; 27944@@ -45599,8 +41540,6 @@ 27945 break; 27946 27947 case 2273: 27948- 27949-/* Line 1455 of yacc.c */ 27950 #line 12758 "preproc.y" 27951 { 27952 const char *con = connection ? connection : "NULL"; 27953@@ -45610,8 +41549,6 @@ 27954 break; 27955 27956 case 2274: 27957- 27958-/* Line 1455 of yacc.c */ 27959 #line 12764 "preproc.y" 27960 { 27961 const char *con = connection ? connection : "NULL"; 27962@@ -45622,8 +41559,6 @@ 27963 break; 27964 27965 case 2275: 27966- 27967-/* Line 1455 of yacc.c */ 27968 #line 12771 "preproc.y" 27969 { 27970 const char *con = connection ? connection : "NULL"; 27971@@ -45633,22 +41568,16 @@ 27972 break; 27973 27974 case 2276: 27975- 27976-/* Line 1455 of yacc.c */ 27977 #line 12778 "preproc.y" 27978 { (yyval.str) = make_str("output"); ;} 27979 break; 27980 27981 case 2277: 27982- 27983-/* Line 1455 of yacc.c */ 27984 #line 12779 "preproc.y" 27985 { (yyval.str) = EMPTY; ;} 27986 break; 27987 27988 case 2278: 27989- 27990-/* Line 1455 of yacc.c */ 27991 #line 12792 "preproc.y" 27992 { 27993 add_descriptor((yyvsp[(3) - (3)].str),connection); 27994@@ -45657,8 +41586,6 @@ 27995 break; 27996 27997 case 2279: 27998- 27999-/* Line 1455 of yacc.c */ 28000 #line 12803 "preproc.y" 28001 { 28002 drop_descriptor((yyvsp[(3) - (3)].str),connection); 28003@@ -45667,29 +41594,21 @@ 28004 break; 28005 28006 case 2280: 28007- 28008-/* Line 1455 of yacc.c */ 28009 #line 12814 "preproc.y" 28010 { (yyval.str) = (yyvsp[(3) - (4)].str); ;} 28011 break; 28012 28013 case 2283: 28014- 28015-/* Line 1455 of yacc.c */ 28016 #line 12822 "preproc.y" 28017 { push_assignment((yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].dtype_enum)); ;} 28018 break; 28019 28020 case 2284: 28021- 28022-/* Line 1455 of yacc.c */ 28023 #line 12827 "preproc.y" 28024 { (yyval.str) = (yyvsp[(3) - (4)].str); ;} 28025 break; 28026 28027 case 2287: 28028- 28029-/* Line 1455 of yacc.c */ 28030 #line 12835 "preproc.y" 28031 { 28032 push_assignment((yyvsp[(3) - (3)].str), (yyvsp[(1) - (3)].dtype_enum)); 28033@@ -45697,8 +41616,6 @@ 28034 break; 28035 28036 case 2288: 28037- 28038-/* Line 1455 of yacc.c */ 28039 #line 12841 "preproc.y" 28040 { 28041 char *length = mm_alloc(sizeof(int) * CHAR_BIT * 10 / 3); 28042@@ -45710,43 +41627,31 @@ 28043 break; 28044 28045 case 2289: 28046- 28047-/* Line 1455 of yacc.c */ 28048 #line 12848 "preproc.y" 28049 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28050 break; 28051 28052 case 2290: 28053- 28054-/* Line 1455 of yacc.c */ 28055 #line 12851 "preproc.y" 28056 { (yyval.dtype_enum) = ECPGd_count; ;} 28057 break; 28058 28059 case 2291: 28060- 28061-/* Line 1455 of yacc.c */ 28062 #line 12859 "preproc.y" 28063 { (yyval.descriptor).str = (yyvsp[(5) - (6)].str); (yyval.descriptor).name = (yyvsp[(3) - (6)].str); ;} 28064 break; 28065 28066 case 2294: 28067- 28068-/* Line 1455 of yacc.c */ 28069 #line 12866 "preproc.y" 28070 { push_assignment((yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].dtype_enum)); ;} 28071 break; 28072 28073 case 2295: 28074- 28075-/* Line 1455 of yacc.c */ 28076 #line 12870 "preproc.y" 28077 { (yyval.descriptor).str = (yyvsp[(5) - (6)].str); (yyval.descriptor).name = (yyvsp[(3) - (6)].str); ;} 28078 break; 28079 28080 case 2298: 28081- 28082-/* Line 1455 of yacc.c */ 28083 #line 12878 "preproc.y" 28084 { 28085 push_assignment((yyvsp[(3) - (3)].str), (yyvsp[(1) - (3)].dtype_enum)); 28086@@ -45754,8 +41659,6 @@ 28087 break; 28088 28089 case 2299: 28090- 28091-/* Line 1455 of yacc.c */ 28092 #line 12884 "preproc.y" 28093 { 28094 char *length = mm_alloc(sizeof(int) * CHAR_BIT * 10 / 3); 28095@@ -45767,15 +41670,11 @@ 28096 break; 28097 28098 case 2300: 28099- 28100-/* Line 1455 of yacc.c */ 28101 #line 12891 "preproc.y" 28102 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28103 break; 28104 28105 case 2301: 28106- 28107-/* Line 1455 of yacc.c */ 28108 #line 12893 "preproc.y" 28109 { 28110 char *length = mm_alloc(sizeof(int) * CHAR_BIT * 10 / 3); 28111@@ -45788,8 +41687,6 @@ 28112 break; 28113 28114 case 2302: 28115- 28116-/* Line 1455 of yacc.c */ 28117 #line 12902 "preproc.y" 28118 { 28119 char *length = mm_alloc(sizeof(int) * CHAR_BIT * 10 / 3); 28120@@ -45802,8 +41699,6 @@ 28121 break; 28122 28123 case 2303: 28124- 28125-/* Line 1455 of yacc.c */ 28126 #line 12911 "preproc.y" 28127 { 28128 char *length = mm_alloc(sizeof(int) * CHAR_BIT * 10 / 3); 28129@@ -45817,162 +41712,116 @@ 28130 break; 28131 28132 case 2304: 28133- 28134-/* Line 1455 of yacc.c */ 28135 #line 12922 "preproc.y" 28136 { (yyval.dtype_enum) = ECPGd_cardinality; ;} 28137 break; 28138 28139 case 2305: 28140- 28141-/* Line 1455 of yacc.c */ 28142 #line 12923 "preproc.y" 28143 { (yyval.dtype_enum) = ECPGd_data; ;} 28144 break; 28145 28146 case 2306: 28147- 28148-/* Line 1455 of yacc.c */ 28149 #line 12924 "preproc.y" 28150 { (yyval.dtype_enum) = ECPGd_di_code; ;} 28151 break; 28152 28153 case 2307: 28154- 28155-/* Line 1455 of yacc.c */ 28156 #line 12925 "preproc.y" 28157 { (yyval.dtype_enum) = ECPGd_di_precision; ;} 28158 break; 28159 28160 case 2308: 28161- 28162-/* Line 1455 of yacc.c */ 28163 #line 12926 "preproc.y" 28164 { (yyval.dtype_enum) = ECPGd_indicator; ;} 28165 break; 28166 28167 case 2309: 28168- 28169-/* Line 1455 of yacc.c */ 28170 #line 12927 "preproc.y" 28171 { (yyval.dtype_enum) = ECPGd_key_member; ;} 28172 break; 28173 28174 case 2310: 28175- 28176-/* Line 1455 of yacc.c */ 28177 #line 12928 "preproc.y" 28178 { (yyval.dtype_enum) = ECPGd_length; ;} 28179 break; 28180 28181 case 2311: 28182- 28183-/* Line 1455 of yacc.c */ 28184 #line 12929 "preproc.y" 28185 { (yyval.dtype_enum) = ECPGd_name; ;} 28186 break; 28187 28188 case 2312: 28189- 28190-/* Line 1455 of yacc.c */ 28191 #line 12930 "preproc.y" 28192 { (yyval.dtype_enum) = ECPGd_nullable; ;} 28193 break; 28194 28195 case 2313: 28196- 28197-/* Line 1455 of yacc.c */ 28198 #line 12931 "preproc.y" 28199 { (yyval.dtype_enum) = ECPGd_octet; ;} 28200 break; 28201 28202 case 2314: 28203- 28204-/* Line 1455 of yacc.c */ 28205 #line 12932 "preproc.y" 28206 { (yyval.dtype_enum) = ECPGd_precision; ;} 28207 break; 28208 28209 case 2315: 28210- 28211-/* Line 1455 of yacc.c */ 28212 #line 12933 "preproc.y" 28213 { (yyval.dtype_enum) = ECPGd_length; ;} 28214 break; 28215 28216 case 2316: 28217- 28218-/* Line 1455 of yacc.c */ 28219 #line 12934 "preproc.y" 28220 { (yyval.dtype_enum) = ECPGd_ret_octet; ;} 28221 break; 28222 28223 case 2317: 28224- 28225-/* Line 1455 of yacc.c */ 28226 #line 12935 "preproc.y" 28227 { (yyval.dtype_enum) = ECPGd_scale; ;} 28228 break; 28229 28230 case 2318: 28231- 28232-/* Line 1455 of yacc.c */ 28233 #line 12936 "preproc.y" 28234 { (yyval.dtype_enum) = ECPGd_type; ;} 28235 break; 28236 28237 case 2319: 28238- 28239-/* Line 1455 of yacc.c */ 28240 #line 12943 "preproc.y" 28241 { (yyval.str) = (yyvsp[(4) - (4)].str); ;} 28242 break; 28243 28244 case 2320: 28245- 28246-/* Line 1455 of yacc.c */ 28247 #line 12944 "preproc.y" 28248 { (yyval.str) = (yyvsp[(4) - (4)].str); ;} 28249 break; 28250 28251 case 2321: 28252- 28253-/* Line 1455 of yacc.c */ 28254 #line 12947 "preproc.y" 28255 { (yyval.str) = make_str("on"); ;} 28256 break; 28257 28258 case 2322: 28259- 28260-/* Line 1455 of yacc.c */ 28261 #line 12948 "preproc.y" 28262 { (yyval.str) = make_str("off"); ;} 28263 break; 28264 28265 case 2323: 28266- 28267-/* Line 1455 of yacc.c */ 28268 #line 12955 "preproc.y" 28269 { (yyval.str) = (yyvsp[(4) - (4)].str); ;} 28270 break; 28271 28272 case 2324: 28273- 28274-/* Line 1455 of yacc.c */ 28275 #line 12956 "preproc.y" 28276 { (yyval.str) = (yyvsp[(4) - (4)].str); ;} 28277 break; 28278 28279 case 2325: 28280- 28281-/* Line 1455 of yacc.c */ 28282 #line 12957 "preproc.y" 28283 { (yyval.str) = (yyvsp[(3) - (3)].str); ;} 28284 break; 28285 28286 case 2326: 28287- 28288-/* Line 1455 of yacc.c */ 28289 #line 12964 "preproc.y" 28290 { 28291 /* reset this variable so we see if there was */ 28292@@ -45982,8 +41831,6 @@ 28293 break; 28294 28295 case 2327: 28296- 28297-/* Line 1455 of yacc.c */ 28298 #line 12970 "preproc.y" 28299 { 28300 add_typedef((yyvsp[(3) - (7)].str), (yyvsp[(6) - (7)].index).index1, (yyvsp[(6) - (7)].index).index2, (yyvsp[(5) - (7)].type).type_enum, (yyvsp[(5) - (7)].type).type_dimension, (yyvsp[(5) - (7)].type).type_index, initializer, *(yyvsp[(7) - (7)].str) ? 1 : 0); 28301@@ -45996,22 +41843,16 @@ 28302 break; 28303 28304 case 2328: 28305- 28306-/* Line 1455 of yacc.c */ 28307 #line 12980 "preproc.y" 28308 { (yyval.str) = make_str("reference"); ;} 28309 break; 28310 28311 case 2329: 28312- 28313-/* Line 1455 of yacc.c */ 28314 #line 12981 "preproc.y" 28315 { (yyval.str) = EMPTY; ;} 28316 break; 28317 28318 case 2330: 28319- 28320-/* Line 1455 of yacc.c */ 28321 #line 12988 "preproc.y" 28322 { 28323 /* reset this variable so we see if there was */ 28324@@ -46021,8 +41862,6 @@ 28325 break; 28326 28327 case 2331: 28328- 28329-/* Line 1455 of yacc.c */ 28330 #line 12994 "preproc.y" 28331 { 28332 struct variable *p = find_variable((yyvsp[(3) - (7)].str)); 28333@@ -46084,8 +41923,6 @@ 28334 break; 28335 28336 case 2332: 28337- 28338-/* Line 1455 of yacc.c */ 28339 #line 13058 "preproc.y" 28340 { 28341 when_error.code = (yyvsp[(3) - (3)].action).code; 28342@@ -46095,8 +41932,6 @@ 28343 break; 28344 28345 case 2333: 28346- 28347-/* Line 1455 of yacc.c */ 28348 #line 13064 "preproc.y" 28349 { 28350 when_nf.code = (yyvsp[(4) - (4)].action).code; 28351@@ -46106,8 +41941,6 @@ 28352 break; 28353 28354 case 2334: 28355- 28356-/* Line 1455 of yacc.c */ 28357 #line 13070 "preproc.y" 28358 { 28359 when_warn.code = (yyvsp[(3) - (3)].action).code; 28360@@ -46117,8 +41950,6 @@ 28361 break; 28362 28363 case 2335: 28364- 28365-/* Line 1455 of yacc.c */ 28366 #line 13078 "preproc.y" 28367 { 28368 (yyval.action).code = W_NOTHING; 28369@@ -46128,8 +41959,6 @@ 28370 break; 28371 28372 case 2336: 28373- 28374-/* Line 1455 of yacc.c */ 28375 #line 13084 "preproc.y" 28376 { 28377 (yyval.action).code = W_SQLPRINT; 28378@@ -46139,8 +41968,6 @@ 28379 break; 28380 28381 case 2337: 28382- 28383-/* Line 1455 of yacc.c */ 28384 #line 13090 "preproc.y" 28385 { 28386 (yyval.action).code = W_STOP; 28387@@ -46150,8 +41977,6 @@ 28388 break; 28389 28390 case 2338: 28391- 28392-/* Line 1455 of yacc.c */ 28393 #line 13096 "preproc.y" 28394 { 28395 (yyval.action).code = W_GOTO; 28396@@ -46161,8 +41986,6 @@ 28397 break; 28398 28399 case 2339: 28400- 28401-/* Line 1455 of yacc.c */ 28402 #line 13102 "preproc.y" 28403 { 28404 (yyval.action).code = W_GOTO; 28405@@ -46172,8 +41995,6 @@ 28406 break; 28407 28408 case 2340: 28409- 28410-/* Line 1455 of yacc.c */ 28411 #line 13108 "preproc.y" 28412 { 28413 (yyval.action).code = W_DO; 28414@@ -46183,8 +42004,6 @@ 28415 break; 28416 28417 case 2341: 28418- 28419-/* Line 1455 of yacc.c */ 28420 #line 13114 "preproc.y" 28421 { 28422 (yyval.action).code = W_BREAK; 28423@@ -46194,8 +42013,6 @@ 28424 break; 28425 28426 case 2342: 28427- 28428-/* Line 1455 of yacc.c */ 28429 #line 13120 "preproc.y" 28430 { 28431 (yyval.action).code = W_DO; 28432@@ -46205,8 +42022,6 @@ 28433 break; 28434 28435 case 2343: 28436- 28437-/* Line 1455 of yacc.c */ 28438 #line 13126 "preproc.y" 28439 { 28440 (yyval.action).code = W_DO; 28441@@ -46216,687 +42031,491 @@ 28442 break; 28443 28444 case 2344: 28445- 28446-/* Line 1455 of yacc.c */ 28447 #line 13136 "preproc.y" 28448 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28449 break; 28450 28451 case 2345: 28452- 28453-/* Line 1455 of yacc.c */ 28454 #line 13137 "preproc.y" 28455 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28456 break; 28457 28458 case 2346: 28459- 28460-/* Line 1455 of yacc.c */ 28461 #line 13140 "preproc.y" 28462 { (yyval.str) = make_str("break"); ;} 28463 break; 28464 28465 case 2347: 28466- 28467-/* Line 1455 of yacc.c */ 28468 #line 13141 "preproc.y" 28469 { (yyval.str) = make_str("call"); ;} 28470 break; 28471 28472 case 2348: 28473- 28474-/* Line 1455 of yacc.c */ 28475 #line 13142 "preproc.y" 28476 { (yyval.str) = make_str("cardinality"); ;} 28477 break; 28478 28479 case 2349: 28480- 28481-/* Line 1455 of yacc.c */ 28482 #line 13143 "preproc.y" 28483 { (yyval.str) = make_str("count"); ;} 28484 break; 28485 28486 case 2350: 28487- 28488-/* Line 1455 of yacc.c */ 28489 #line 13144 "preproc.y" 28490 { (yyval.str) = make_str("datetime_interval_code"); ;} 28491 break; 28492 28493 case 2351: 28494- 28495-/* Line 1455 of yacc.c */ 28496 #line 13145 "preproc.y" 28497 { (yyval.str) = make_str("datetime_interval_precision"); ;} 28498 break; 28499 28500 case 2352: 28501- 28502-/* Line 1455 of yacc.c */ 28503 #line 13146 "preproc.y" 28504 { (yyval.str) = make_str("found"); ;} 28505 break; 28506 28507 case 2353: 28508- 28509-/* Line 1455 of yacc.c */ 28510 #line 13147 "preproc.y" 28511 { (yyval.str) = make_str("go"); ;} 28512 break; 28513 28514 case 2354: 28515- 28516-/* Line 1455 of yacc.c */ 28517 #line 13148 "preproc.y" 28518 { (yyval.str) = make_str("goto"); ;} 28519 break; 28520 28521 case 2355: 28522- 28523-/* Line 1455 of yacc.c */ 28524 #line 13149 "preproc.y" 28525 { (yyval.str) = make_str("identified"); ;} 28526 break; 28527 28528 case 2356: 28529- 28530-/* Line 1455 of yacc.c */ 28531 #line 13150 "preproc.y" 28532 { (yyval.str) = make_str("indicator"); ;} 28533 break; 28534 28535 case 2357: 28536- 28537-/* Line 1455 of yacc.c */ 28538 #line 13151 "preproc.y" 28539 { (yyval.str) = make_str("key_member"); ;} 28540 break; 28541 28542 case 2358: 28543- 28544-/* Line 1455 of yacc.c */ 28545 #line 13152 "preproc.y" 28546 { (yyval.str) = make_str("length"); ;} 28547 break; 28548 28549 case 2359: 28550- 28551-/* Line 1455 of yacc.c */ 28552 #line 13153 "preproc.y" 28553 { (yyval.str) = make_str("nullable"); ;} 28554 break; 28555 28556 case 2360: 28557- 28558-/* Line 1455 of yacc.c */ 28559 #line 13154 "preproc.y" 28560 { (yyval.str) = make_str("octet_length"); ;} 28561 break; 28562 28563 case 2361: 28564- 28565-/* Line 1455 of yacc.c */ 28566 #line 13155 "preproc.y" 28567 { (yyval.str) = make_str("returned_length"); ;} 28568 break; 28569 28570 case 2362: 28571- 28572-/* Line 1455 of yacc.c */ 28573 #line 13156 "preproc.y" 28574 { (yyval.str) = make_str("returned_octet_length"); ;} 28575 break; 28576 28577 case 2363: 28578- 28579-/* Line 1455 of yacc.c */ 28580 #line 13157 "preproc.y" 28581 { (yyval.str) = make_str("scale"); ;} 28582 break; 28583 28584 case 2364: 28585- 28586-/* Line 1455 of yacc.c */ 28587 #line 13158 "preproc.y" 28588 { (yyval.str) = make_str("section"); ;} 28589 break; 28590 28591 case 2365: 28592- 28593-/* Line 1455 of yacc.c */ 28594 #line 13159 "preproc.y" 28595 { (yyval.str) = make_str("sql"); ;} 28596 break; 28597 28598 case 2366: 28599- 28600-/* Line 1455 of yacc.c */ 28601 #line 13160 "preproc.y" 28602 { (yyval.str) = make_str("sqlerror"); ;} 28603 break; 28604 28605 case 2367: 28606- 28607-/* Line 1455 of yacc.c */ 28608 #line 13161 "preproc.y" 28609 { (yyval.str) = make_str("sqlprint"); ;} 28610 break; 28611 28612 case 2368: 28613- 28614-/* Line 1455 of yacc.c */ 28615 #line 13162 "preproc.y" 28616 { (yyval.str) = make_str("sqlwarning"); ;} 28617 break; 28618 28619 case 2369: 28620- 28621-/* Line 1455 of yacc.c */ 28622 #line 13163 "preproc.y" 28623 { (yyval.str) = make_str("stop"); ;} 28624 break; 28625 28626 case 2370: 28627- 28628-/* Line 1455 of yacc.c */ 28629 #line 13166 "preproc.y" 28630 { (yyval.str) = make_str("connect"); ;} 28631 break; 28632 28633 case 2371: 28634- 28635-/* Line 1455 of yacc.c */ 28636 #line 13167 "preproc.y" 28637 { (yyval.str) = make_str("describe"); ;} 28638 break; 28639 28640 case 2372: 28641- 28642-/* Line 1455 of yacc.c */ 28643 #line 13168 "preproc.y" 28644 { (yyval.str) = make_str("disconnect"); ;} 28645 break; 28646 28647 case 2373: 28648- 28649-/* Line 1455 of yacc.c */ 28650 #line 13169 "preproc.y" 28651 { (yyval.str) = make_str("open"); ;} 28652 break; 28653 28654 case 2374: 28655- 28656-/* Line 1455 of yacc.c */ 28657 #line 13170 "preproc.y" 28658 { (yyval.str) = make_str("var"); ;} 28659 break; 28660 28661 case 2375: 28662- 28663-/* Line 1455 of yacc.c */ 28664 #line 13171 "preproc.y" 28665 { (yyval.str) = make_str("whenever"); ;} 28666 break; 28667 28668 case 2376: 28669- 28670-/* Line 1455 of yacc.c */ 28671 #line 13175 "preproc.y" 28672 { (yyval.str) = make_str("bool"); ;} 28673 break; 28674 28675 case 2377: 28676- 28677-/* Line 1455 of yacc.c */ 28678 #line 13176 "preproc.y" 28679 { (yyval.str) = make_str("long"); ;} 28680 break; 28681 28682 case 2378: 28683- 28684-/* Line 1455 of yacc.c */ 28685 #line 13177 "preproc.y" 28686 { (yyval.str) = make_str("output"); ;} 28687 break; 28688 28689 case 2379: 28690- 28691-/* Line 1455 of yacc.c */ 28692 #line 13178 "preproc.y" 28693 { (yyval.str) = make_str("short"); ;} 28694 break; 28695 28696 case 2380: 28697- 28698-/* Line 1455 of yacc.c */ 28699 #line 13179 "preproc.y" 28700 { (yyval.str) = make_str("struct"); ;} 28701 break; 28702 28703 case 2381: 28704- 28705-/* Line 1455 of yacc.c */ 28706 #line 13180 "preproc.y" 28707 { (yyval.str) = make_str("signed"); ;} 28708 break; 28709 28710 case 2382: 28711- 28712-/* Line 1455 of yacc.c */ 28713 #line 13181 "preproc.y" 28714 { (yyval.str) = make_str("unsigned"); ;} 28715 break; 28716 28717 case 2383: 28718- 28719-/* Line 1455 of yacc.c */ 28720 #line 13184 "preproc.y" 28721 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28722 break; 28723 28724 case 2384: 28725- 28726-/* Line 1455 of yacc.c */ 28727 #line 13187 "preproc.y" 28728 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28729 break; 28730 28731 case 2385: 28732- 28733-/* Line 1455 of yacc.c */ 28734 #line 13188 "preproc.y" 28735 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28736 break; 28737 28738 case 2386: 28739- 28740-/* Line 1455 of yacc.c */ 28741 #line 13189 "preproc.y" 28742 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28743 break; 28744 28745 case 2387: 28746- 28747-/* Line 1455 of yacc.c */ 28748 #line 13190 "preproc.y" 28749 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28750 break; 28751 28752 case 2388: 28753- 28754-/* Line 1455 of yacc.c */ 28755 #line 13191 "preproc.y" 28756 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28757 break; 28758 28759 case 2389: 28760- 28761-/* Line 1455 of yacc.c */ 28762 #line 13192 "preproc.y" 28763 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28764 break; 28765 28766 case 2390: 28767- 28768-/* Line 1455 of yacc.c */ 28769 #line 13193 "preproc.y" 28770 { (yyval.str) = make_str("char"); ;} 28771 break; 28772 28773 case 2391: 28774- 28775-/* Line 1455 of yacc.c */ 28776 #line 13194 "preproc.y" 28777 { (yyval.str) = make_str("values"); ;} 28778 break; 28779 28780 case 2392: 28781- 28782-/* Line 1455 of yacc.c */ 28783 #line 13207 "preproc.y" 28784 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28785 break; 28786 28787 case 2393: 28788- 28789-/* Line 1455 of yacc.c */ 28790 #line 13208 "preproc.y" 28791 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28792 break; 28793 28794 case 2394: 28795- 28796-/* Line 1455 of yacc.c */ 28797 #line 13209 "preproc.y" 28798 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28799 break; 28800 28801 case 2395: 28802- 28803-/* Line 1455 of yacc.c */ 28804 #line 13210 "preproc.y" 28805 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28806 break; 28807 28808 case 2396: 28809- 28810-/* Line 1455 of yacc.c */ 28811 #line 13211 "preproc.y" 28812 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28813 break; 28814 28815 case 2397: 28816- 28817-/* Line 1455 of yacc.c */ 28818 #line 13212 "preproc.y" 28819 { (yyval.str) = make_str("char"); ;} 28820 break; 28821 28822 case 2398: 28823- 28824-/* Line 1455 of yacc.c */ 28825 #line 13213 "preproc.y" 28826 { (yyval.str) = make_str("values"); ;} 28827 break; 28828 28829 case 2399: 28830- 28831-/* Line 1455 of yacc.c */ 28832 #line 13218 "preproc.y" 28833 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28834 break; 28835 28836 case 2400: 28837- 28838-/* Line 1455 of yacc.c */ 28839 #line 13219 "preproc.y" 28840 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28841 break; 28842 28843 case 2401: 28844- 28845-/* Line 1455 of yacc.c */ 28846 #line 13220 "preproc.y" 28847 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28848 break; 28849 28850 case 2402: 28851- 28852-/* Line 1455 of yacc.c */ 28853 #line 13221 "preproc.y" 28854 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28855 break; 28856 28857 case 2403: 28858- 28859-/* Line 1455 of yacc.c */ 28860 #line 13222 "preproc.y" 28861 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28862 break; 28863 28864 case 2404: 28865- 28866-/* Line 1455 of yacc.c */ 28867 #line 13223 "preproc.y" 28868 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28869 break; 28870 28871 case 2405: 28872- 28873-/* Line 1455 of yacc.c */ 28874 #line 13229 "preproc.y" 28875 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28876 break; 28877 28878 case 2406: 28879- 28880-/* Line 1455 of yacc.c */ 28881 #line 13230 "preproc.y" 28882 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28883 break; 28884 28885 case 2407: 28886- 28887-/* Line 1455 of yacc.c */ 28888 #line 13231 "preproc.y" 28889 { (yyval.str) = make_str("char"); ;} 28890 break; 28891 28892 case 2408: 28893- 28894-/* Line 1455 of yacc.c */ 28895 #line 13232 "preproc.y" 28896 { (yyval.str) = make_str("current"); ;} 28897 break; 28898 28899 case 2409: 28900- 28901-/* Line 1455 of yacc.c */ 28902 #line 13233 "preproc.y" 28903 { (yyval.str) = make_str("input"); ;} 28904 break; 28905 28906 case 2410: 28907- 28908-/* Line 1455 of yacc.c */ 28909 #line 13234 "preproc.y" 28910 { (yyval.str) = make_str("int"); ;} 28911 break; 28912 28913 case 2411: 28914- 28915-/* Line 1455 of yacc.c */ 28916 #line 13235 "preproc.y" 28917 { (yyval.str) = make_str("to"); ;} 28918 break; 28919 28920 case 2412: 28921- 28922-/* Line 1455 of yacc.c */ 28923 #line 13236 "preproc.y" 28924 { (yyval.str) = make_str("union"); ;} 28925 break; 28926 28927 case 2413: 28928- 28929-/* Line 1455 of yacc.c */ 28930 #line 13237 "preproc.y" 28931 { (yyval.str) = make_str("values"); ;} 28932 break; 28933 28934 case 2414: 28935- 28936-/* Line 1455 of yacc.c */ 28937 #line 13238 "preproc.y" 28938 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28939 break; 28940 28941 case 2415: 28942- 28943-/* Line 1455 of yacc.c */ 28944 #line 13239 "preproc.y" 28945 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28946 break; 28947 28948 case 2416: 28949- 28950-/* Line 1455 of yacc.c */ 28951 #line 13242 "preproc.y" 28952 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28953 break; 28954 28955 case 2417: 28956- 28957-/* Line 1455 of yacc.c */ 28958 #line 13243 "preproc.y" 28959 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28960 break; 28961 28962 case 2418: 28963- 28964-/* Line 1455 of yacc.c */ 28965 #line 13244 "preproc.y" 28966 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28967 break; 28968 28969 case 2419: 28970- 28971-/* Line 1455 of yacc.c */ 28972 #line 13245 "preproc.y" 28973 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28974 break; 28975 28976 case 2420: 28977- 28978-/* Line 1455 of yacc.c */ 28979 #line 13246 "preproc.y" 28980 { (yyval.str) = make_str("connection"); ;} 28981 break; 28982 28983 case 2421: 28984- 28985-/* Line 1455 of yacc.c */ 28986 #line 13249 "preproc.y" 28987 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28988 break; 28989 28990 case 2422: 28991- 28992-/* Line 1455 of yacc.c */ 28993 #line 13250 "preproc.y" 28994 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 28995 break; 28996 28997 case 2423: 28998- 28999-/* Line 1455 of yacc.c */ 29000 #line 13251 "preproc.y" 29001 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29002 break; 29003 29004 case 2424: 29005- 29006-/* Line 1455 of yacc.c */ 29007 #line 13252 "preproc.y" 29008 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29009 break; 29010 29011 case 2425: 29012- 29013-/* Line 1455 of yacc.c */ 29014 #line 13255 "preproc.y" 29015 { (yyval.str) = make_str("auto"); ;} 29016 break; 29017 29018 case 2426: 29019- 29020-/* Line 1455 of yacc.c */ 29021 #line 13256 "preproc.y" 29022 { (yyval.str) = make_str("const"); ;} 29023 break; 29024 29025 case 2427: 29026- 29027-/* Line 1455 of yacc.c */ 29028 #line 13257 "preproc.y" 29029 { (yyval.str) = make_str("extern"); ;} 29030 break; 29031 29032 case 2428: 29033- 29034-/* Line 1455 of yacc.c */ 29035 #line 13258 "preproc.y" 29036 { (yyval.str) = make_str("register"); ;} 29037 break; 29038 29039 case 2429: 29040- 29041-/* Line 1455 of yacc.c */ 29042 #line 13259 "preproc.y" 29043 { (yyval.str) = make_str("static"); ;} 29044 break; 29045 29046 case 2430: 29047- 29048-/* Line 1455 of yacc.c */ 29049 #line 13260 "preproc.y" 29050 { (yyval.str) = make_str("typedef"); ;} 29051 break; 29052 29053 case 2431: 29054- 29055-/* Line 1455 of yacc.c */ 29056 #line 13261 "preproc.y" 29057 { (yyval.str) = make_str("volatile"); ;} 29058 break; 29059 29060 case 2432: 29061- 29062-/* Line 1455 of yacc.c */ 29063 #line 13278 "preproc.y" 29064 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29065 break; 29066 29067 case 2433: 29068- 29069-/* Line 1455 of yacc.c */ 29070 #line 13279 "preproc.y" 29071 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29072 break; 29073 29074 case 2434: 29075- 29076-/* Line 1455 of yacc.c */ 29077 #line 13280 "preproc.y" 29078 { (yyval.str) = make_str("connection"); ;} 29079 break; 29080 29081 case 2435: 29082- 29083-/* Line 1455 of yacc.c */ 29084 #line 13283 "preproc.y" 29085 { (yyval.str) = make_str("day"); ;} 29086 break; 29087 29088 case 2436: 29089- 29090-/* Line 1455 of yacc.c */ 29091 #line 13284 "preproc.y" 29092 { (yyval.str) = make_str("hour"); ;} 29093 break; 29094 29095 case 2437: 29096- 29097-/* Line 1455 of yacc.c */ 29098 #line 13285 "preproc.y" 29099 { (yyval.str) = make_str("minute"); ;} 29100 break; 29101 29102 case 2438: 29103- 29104-/* Line 1455 of yacc.c */ 29105 #line 13286 "preproc.y" 29106 { (yyval.str) = make_str("month"); ;} 29107 break; 29108 29109 case 2439: 29110- 29111-/* Line 1455 of yacc.c */ 29112 #line 13287 "preproc.y" 29113 { (yyval.str) = make_str("second"); ;} 29114 break; 29115 29116 case 2440: 29117- 29118-/* Line 1455 of yacc.c */ 29119 #line 13288 "preproc.y" 29120 { (yyval.str) = make_str("year"); ;} 29121 break; 29122 29123 case 2443: 29124- 29125-/* Line 1455 of yacc.c */ 29126 #line 13295 "preproc.y" 29127 { 29128 reset_variables(); 29129@@ -46905,36 +42524,26 @@ 29130 break; 29131 29132 case 2444: 29133- 29134-/* Line 1455 of yacc.c */ 29135 #line 13301 "preproc.y" 29136 { (yyval.str) = EMPTY; ;} 29137 break; 29138 29139 case 2445: 29140- 29141-/* Line 1455 of yacc.c */ 29142 #line 13302 "preproc.y" 29143 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29144 break; 29145 29146 case 2446: 29147- 29148-/* Line 1455 of yacc.c */ 29149 #line 13306 "preproc.y" 29150 { add_variable_to_head(&argsresult, find_variable((yyvsp[(1) - (2)].str)), find_variable((yyvsp[(2) - (2)].str))); ;} 29151 break; 29152 29153 case 2447: 29154- 29155-/* Line 1455 of yacc.c */ 29156 #line 13308 "preproc.y" 29157 { add_variable_to_head(&argsresult, find_variable((yyvsp[(1) - (1)].str)), &no_indicator); ;} 29158 break; 29159 29160 case 2448: 29161- 29162-/* Line 1455 of yacc.c */ 29163 #line 13313 "preproc.y" 29164 { 29165 if (find_variable((yyvsp[(2) - (2)].str))->type->type == ECPGt_array) 29166@@ -46946,8 +42555,6 @@ 29167 break; 29168 29169 case 2449: 29170- 29171-/* Line 1455 of yacc.c */ 29172 #line 13323 "preproc.y" 29173 { 29174 char *ptr = strstr((yyvsp[(1) - (1)].str), ".arr"); 29175@@ -46960,8 +42567,6 @@ 29176 break; 29177 29178 case 2450: 29179- 29180-/* Line 1455 of yacc.c */ 29181 #line 13334 "preproc.y" 29182 { 29183 add_variable_to_head(&argsinsert, find_variable((yyvsp[(1) - (1)].str)), &no_indicator); 29184@@ -46970,29 +42575,21 @@ 29185 break; 29186 29187 case 2451: 29188- 29189-/* Line 1455 of yacc.c */ 29190 #line 13340 "preproc.y" 29191 { check_indicator((find_variable((yyvsp[(1) - (1)].str)))->type); (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29192 break; 29193 29194 case 2452: 29195- 29196-/* Line 1455 of yacc.c */ 29197 #line 13341 "preproc.y" 29198 { check_indicator((find_variable((yyvsp[(2) - (2)].str)))->type); (yyval.str) = (yyvsp[(2) - (2)].str); ;} 29199 break; 29200 29201 case 2453: 29202- 29203-/* Line 1455 of yacc.c */ 29204 #line 13342 "preproc.y" 29205 { check_indicator((find_variable((yyvsp[(2) - (2)].str)))->type); (yyval.str) = (yyvsp[(2) - (2)].str); ;} 29206 break; 29207 29208 case 2454: 29209- 29210-/* Line 1455 of yacc.c */ 29211 #line 13346 "preproc.y" 29212 { 29213 /* As long as multidimensional arrays are not implemented we have to check for those here */ 29214@@ -47027,29 +42624,21 @@ 29215 break; 29216 29217 case 2455: 29218- 29219-/* Line 1455 of yacc.c */ 29220 #line 13378 "preproc.y" 29221 { (yyval.str) = make_name(); ;} 29222 break; 29223 29224 case 2456: 29225- 29226-/* Line 1455 of yacc.c */ 29227 #line 13380 "preproc.y" 29228 { (yyval.str) = make_name(); ;} 29229 break; 29230 29231 case 2457: 29232- 29233-/* Line 1455 of yacc.c */ 29234 #line 13382 "preproc.y" 29235 { (yyval.str) = make_name(); ;} 29236 break; 29237 29238 case 2458: 29239- 29240-/* Line 1455 of yacc.c */ 29241 #line 13386 "preproc.y" 29242 { 29243 /* could have been input as '' or $$ */ 29244@@ -47063,8 +42652,6 @@ 29245 break; 29246 29247 case 2459: 29248- 29249-/* Line 1455 of yacc.c */ 29250 #line 13396 "preproc.y" 29251 { 29252 (yyval.str) = (char *)mm_alloc(strlen((yyvsp[(1) - (1)].str)) + 4); 29253@@ -47078,8 +42665,6 @@ 29254 break; 29255 29256 case 2460: 29257- 29258-/* Line 1455 of yacc.c */ 29259 #line 13406 "preproc.y" 29260 { 29261 (yyval.str) = (char *)mm_alloc(strlen((yyvsp[(1) - (1)].str)) + 4); 29262@@ -47093,701 +42678,501 @@ 29263 break; 29264 29265 case 2461: 29266- 29267-/* Line 1455 of yacc.c */ 29268 #line 13415 "preproc.y" 29269 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29270 break; 29271 29272 case 2462: 29273- 29274-/* Line 1455 of yacc.c */ 29275 #line 13416 "preproc.y" 29276 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29277 break; 29278 29279 case 2463: 29280- 29281-/* Line 1455 of yacc.c */ 29282 #line 13419 "preproc.y" 29283 { (yyval.str) = make_name(); ;} 29284 break; 29285 29286 case 2464: 29287- 29288-/* Line 1455 of yacc.c */ 29289 #line 13421 "preproc.y" 29290 { (yyval.str) = make_name(); ;} 29291 break; 29292 29293 case 2465: 29294- 29295-/* Line 1455 of yacc.c */ 29296 #line 13422 "preproc.y" 29297 { (yyval.str) = make3_str(make_str("\""), (yyvsp[(1) - (1)].str), make_str("\"")); ;} 29298 break; 29299 29300 case 2466: 29301- 29302-/* Line 1455 of yacc.c */ 29303 #line 13423 "preproc.y" 29304 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29305 break; 29306 29307 case 2467: 29308- 29309-/* Line 1455 of yacc.c */ 29310 #line 13427 "preproc.y" 29311 { (yyval.str) = make3_str(make_str("\""), (yyvsp[(1) - (1)].str), make_str("\"")); ;} 29312 break; 29313 29314 case 2468: 29315- 29316-/* Line 1455 of yacc.c */ 29317 #line 13429 "preproc.y" 29318 { (yyval.str) = make3_str(make_str("("), (yyvsp[(1) - (1)].str), make_str(")")); ;} 29319 break; 29320 29321 case 2469: 29322- 29323-/* Line 1455 of yacc.c */ 29324 #line 13436 "preproc.y" 29325 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29326 break; 29327 29328 case 2470: 29329- 29330-/* Line 1455 of yacc.c */ 29331 #line 13437 "preproc.y" 29332 { (yyval.str) = make_str("()"); ;} 29333 break; 29334 29335 case 2471: 29336- 29337-/* Line 1455 of yacc.c */ 29338 #line 13439 "preproc.y" 29339 { (yyval.str) = cat_str(3, make_str("("), (yyvsp[(2) - (3)].str), make_str(")")); ;} 29340 break; 29341 29342 case 2472: 29343- 29344-/* Line 1455 of yacc.c */ 29345 #line 13442 "preproc.y" 29346 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29347 break; 29348 29349 case 2473: 29350- 29351-/* Line 1455 of yacc.c */ 29352 #line 13444 "preproc.y" 29353 { (yyval.str) = cat2_str((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); ;} 29354 break; 29355 29356 case 2474: 29357- 29358-/* Line 1455 of yacc.c */ 29359 #line 13447 "preproc.y" 29360 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29361 break; 29362 29363 case 2475: 29364- 29365-/* Line 1455 of yacc.c */ 29366 #line 13448 "preproc.y" 29367 { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str(","), (yyvsp[(3) - (3)].str)); ;} 29368 break; 29369 29370 case 2476: 29371- 29372-/* Line 1455 of yacc.c */ 29373 #line 13451 "preproc.y" 29374 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29375 break; 29376 29377 case 2477: 29378- 29379-/* Line 1455 of yacc.c */ 29380 #line 13452 "preproc.y" 29381 { (yyval.str) = cat_str(3, make_str("{"), (yyvsp[(2) - (3)].str), make_str("}")); ;} 29382 break; 29383 29384 case 2478: 29385- 29386-/* Line 1455 of yacc.c */ 29387 #line 13455 "preproc.y" 29388 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29389 break; 29390 29391 case 2479: 29392- 29393-/* Line 1455 of yacc.c */ 29394 #line 13456 "preproc.y" 29395 { (yyval.str) = make_str("("); ;} 29396 break; 29397 29398 case 2480: 29399- 29400-/* Line 1455 of yacc.c */ 29401 #line 13457 "preproc.y" 29402 { (yyval.str) = make_str(")"); ;} 29403 break; 29404 29405 case 2481: 29406- 29407-/* Line 1455 of yacc.c */ 29408 #line 13458 "preproc.y" 29409 { (yyval.str) = make_str(","); ;} 29410 break; 29411 29412 case 2482: 29413- 29414-/* Line 1455 of yacc.c */ 29415 #line 13459 "preproc.y" 29416 { (yyval.str) = make_str(";"); ;} 29417 break; 29418 29419 case 2483: 29420- 29421-/* Line 1455 of yacc.c */ 29422 #line 13462 "preproc.y" 29423 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29424 break; 29425 29426 case 2484: 29427- 29428-/* Line 1455 of yacc.c */ 29429 #line 13463 "preproc.y" 29430 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29431 break; 29432 29433 case 2485: 29434- 29435-/* Line 1455 of yacc.c */ 29436 #line 13464 "preproc.y" 29437 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29438 break; 29439 29440 case 2486: 29441- 29442-/* Line 1455 of yacc.c */ 29443 #line 13465 "preproc.y" 29444 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29445 break; 29446 29447 case 2487: 29448- 29449-/* Line 1455 of yacc.c */ 29450 #line 13466 "preproc.y" 29451 { (yyval.str) = make_str("*"); ;} 29452 break; 29453 29454 case 2488: 29455- 29456-/* Line 1455 of yacc.c */ 29457 #line 13467 "preproc.y" 29458 { (yyval.str) = make_str("+"); ;} 29459 break; 29460 29461 case 2489: 29462- 29463-/* Line 1455 of yacc.c */ 29464 #line 13468 "preproc.y" 29465 { (yyval.str) = make_str("-"); ;} 29466 break; 29467 29468 case 2490: 29469- 29470-/* Line 1455 of yacc.c */ 29471 #line 13469 "preproc.y" 29472 { (yyval.str) = make_str("/"); ;} 29473 break; 29474 29475 case 2491: 29476- 29477-/* Line 1455 of yacc.c */ 29478 #line 13470 "preproc.y" 29479 { (yyval.str) = make_str("%"); ;} 29480 break; 29481 29482 case 2492: 29483- 29484-/* Line 1455 of yacc.c */ 29485 #line 13471 "preproc.y" 29486 { (yyval.str) = make_str("NULL"); ;} 29487 break; 29488 29489 case 2493: 29490- 29491-/* Line 1455 of yacc.c */ 29492 #line 13472 "preproc.y" 29493 { (yyval.str) = make_str("+="); ;} 29494 break; 29495 29496 case 2494: 29497- 29498-/* Line 1455 of yacc.c */ 29499 #line 13473 "preproc.y" 29500 { (yyval.str) = make_str("&&"); ;} 29501 break; 29502 29503 case 2495: 29504- 29505-/* Line 1455 of yacc.c */ 29506 #line 13474 "preproc.y" 29507 { (yyval.str) = make_name(); ;} 29508 break; 29509 29510 case 2496: 29511- 29512-/* Line 1455 of yacc.c */ 29513 #line 13475 "preproc.y" 29514 { (yyval.str) = make_str("auto"); ;} 29515 break; 29516 29517 case 2497: 29518- 29519-/* Line 1455 of yacc.c */ 29520 #line 13476 "preproc.y" 29521 { (yyval.str) = make_str("const"); ;} 29522 break; 29523 29524 case 2498: 29525- 29526-/* Line 1455 of yacc.c */ 29527 #line 13477 "preproc.y" 29528 { (yyval.str) = make_str("--"); ;} 29529 break; 29530 29531 case 2499: 29532- 29533-/* Line 1455 of yacc.c */ 29534 #line 13478 "preproc.y" 29535 { (yyval.str) = make_str("/="); ;} 29536 break; 29537 29538 case 2500: 29539- 29540-/* Line 1455 of yacc.c */ 29541 #line 13479 "preproc.y" 29542 { (yyval.str) = make_str(".*"); ;} 29543 break; 29544 29545 case 2501: 29546- 29547-/* Line 1455 of yacc.c */ 29548 #line 13480 "preproc.y" 29549 { (yyval.str) = make_str("=="); ;} 29550 break; 29551 29552 case 2502: 29553- 29554-/* Line 1455 of yacc.c */ 29555 #line 13481 "preproc.y" 29556 { (yyval.str) = make_str("extern"); ;} 29557 break; 29558 29559 case 2503: 29560- 29561-/* Line 1455 of yacc.c */ 29562 #line 13482 "preproc.y" 29563 { (yyval.str) = make_str("++"); ;} 29564 break; 29565 29566 case 2504: 29567- 29568-/* Line 1455 of yacc.c */ 29569 #line 13483 "preproc.y" 29570 { (yyval.str) = make_str("<<"); ;} 29571 break; 29572 29573 case 2505: 29574- 29575-/* Line 1455 of yacc.c */ 29576 #line 13484 "preproc.y" 29577 { (yyval.str) = make_str("->"); ;} 29578 break; 29579 29580 case 2506: 29581- 29582-/* Line 1455 of yacc.c */ 29583 #line 13485 "preproc.y" 29584 { (yyval.str) = make_str("->*"); ;} 29585 break; 29586 29587 case 2507: 29588- 29589-/* Line 1455 of yacc.c */ 29590 #line 13486 "preproc.y" 29591 { (yyval.str) = make_str("%="); ;} 29592 break; 29593 29594 case 2508: 29595- 29596-/* Line 1455 of yacc.c */ 29597 #line 13487 "preproc.y" 29598 { (yyval.str) = make_str("*="); ;} 29599 break; 29600 29601 case 2509: 29602- 29603-/* Line 1455 of yacc.c */ 29604 #line 13488 "preproc.y" 29605 { (yyval.str) = make_str("!="); ;} 29606 break; 29607 29608 case 2510: 29609- 29610-/* Line 1455 of yacc.c */ 29611 #line 13489 "preproc.y" 29612 { (yyval.str) = make_str("||"); ;} 29613 break; 29614 29615 case 2511: 29616- 29617-/* Line 1455 of yacc.c */ 29618 #line 13490 "preproc.y" 29619 { (yyval.str) = make_str("register"); ;} 29620 break; 29621 29622 case 2512: 29623- 29624-/* Line 1455 of yacc.c */ 29625 #line 13491 "preproc.y" 29626 { (yyval.str) = make_str(">>"); ;} 29627 break; 29628 29629 case 2513: 29630- 29631-/* Line 1455 of yacc.c */ 29632 #line 13492 "preproc.y" 29633 { (yyval.str) = make_str("static"); ;} 29634 break; 29635 29636 case 2514: 29637- 29638-/* Line 1455 of yacc.c */ 29639 #line 13493 "preproc.y" 29640 { (yyval.str) = make_str("-="); ;} 29641 break; 29642 29643 case 2515: 29644- 29645-/* Line 1455 of yacc.c */ 29646 #line 13494 "preproc.y" 29647 { (yyval.str) = make_str("typedef"); ;} 29648 break; 29649 29650 case 2516: 29651- 29652-/* Line 1455 of yacc.c */ 29653 #line 13495 "preproc.y" 29654 { (yyval.str) = make_str("volatile"); ;} 29655 break; 29656 29657 case 2517: 29658- 29659-/* Line 1455 of yacc.c */ 29660 #line 13496 "preproc.y" 29661 { (yyval.str) = make_str("bool"); ;} 29662 break; 29663 29664 case 2518: 29665- 29666-/* Line 1455 of yacc.c */ 29667 #line 13497 "preproc.y" 29668 { (yyval.str) = make_str("enum"); ;} 29669 break; 29670 29671 case 2519: 29672- 29673-/* Line 1455 of yacc.c */ 29674 #line 13498 "preproc.y" 29675 { (yyval.str) = make_str("hour"); ;} 29676 break; 29677 29678 case 2520: 29679- 29680-/* Line 1455 of yacc.c */ 29681 #line 13499 "preproc.y" 29682 { (yyval.str) = make_str("int"); ;} 29683 break; 29684 29685 case 2521: 29686- 29687-/* Line 1455 of yacc.c */ 29688 #line 13500 "preproc.y" 29689 { (yyval.str) = make_str("long"); ;} 29690 break; 29691 29692 case 2522: 29693- 29694-/* Line 1455 of yacc.c */ 29695 #line 13501 "preproc.y" 29696 { (yyval.str) = make_str("minute"); ;} 29697 break; 29698 29699 case 2523: 29700- 29701-/* Line 1455 of yacc.c */ 29702 #line 13502 "preproc.y" 29703 { (yyval.str) = make_str("month"); ;} 29704 break; 29705 29706 case 2524: 29707- 29708-/* Line 1455 of yacc.c */ 29709 #line 13503 "preproc.y" 29710 { (yyval.str) = make_str("second"); ;} 29711 break; 29712 29713 case 2525: 29714- 29715-/* Line 1455 of yacc.c */ 29716 #line 13504 "preproc.y" 29717 { (yyval.str) = make_str("short"); ;} 29718 break; 29719 29720 case 2526: 29721- 29722-/* Line 1455 of yacc.c */ 29723 #line 13505 "preproc.y" 29724 { (yyval.str) = make_str("signed"); ;} 29725 break; 29726 29727 case 2527: 29728- 29729-/* Line 1455 of yacc.c */ 29730 #line 13506 "preproc.y" 29731 { (yyval.str) = make_str("struct"); ;} 29732 break; 29733 29734 case 2528: 29735- 29736-/* Line 1455 of yacc.c */ 29737 #line 13507 "preproc.y" 29738 { (yyval.str) = make_str("unsigned"); ;} 29739 break; 29740 29741 case 2529: 29742- 29743-/* Line 1455 of yacc.c */ 29744 #line 13508 "preproc.y" 29745 { (yyval.str) = make_str("year"); ;} 29746 break; 29747 29748 case 2530: 29749- 29750-/* Line 1455 of yacc.c */ 29751 #line 13509 "preproc.y" 29752 { (yyval.str) = make_str("char"); ;} 29753 break; 29754 29755 case 2531: 29756- 29757-/* Line 1455 of yacc.c */ 29758 #line 13510 "preproc.y" 29759 { (yyval.str) = make_str("float"); ;} 29760 break; 29761 29762 case 2532: 29763- 29764-/* Line 1455 of yacc.c */ 29765 #line 13511 "preproc.y" 29766 { (yyval.str) = make_str("to"); ;} 29767 break; 29768 29769 case 2533: 29770- 29771-/* Line 1455 of yacc.c */ 29772 #line 13512 "preproc.y" 29773 { (yyval.str) = make_str("union"); ;} 29774 break; 29775 29776 case 2534: 29777- 29778-/* Line 1455 of yacc.c */ 29779 #line 13513 "preproc.y" 29780 { (yyval.str) = make_str("varchar"); ;} 29781 break; 29782 29783 case 2535: 29784- 29785-/* Line 1455 of yacc.c */ 29786 #line 13514 "preproc.y" 29787 { (yyval.str) = make_str("["); ;} 29788 break; 29789 29790 case 2536: 29791- 29792-/* Line 1455 of yacc.c */ 29793 #line 13515 "preproc.y" 29794 { (yyval.str) = make_str("]"); ;} 29795 break; 29796 29797 case 2537: 29798- 29799-/* Line 1455 of yacc.c */ 29800 #line 13516 "preproc.y" 29801 { (yyval.str) = make_str("="); ;} 29802 break; 29803 29804 case 2538: 29805- 29806-/* Line 1455 of yacc.c */ 29807 #line 13517 "preproc.y" 29808 { (yyval.str) = make_str(":"); ;} 29809 break; 29810 29811 case 2539: 29812- 29813-/* Line 1455 of yacc.c */ 29814 #line 13520 "preproc.y" 29815 { (yyval.str) = (yyvsp[(2) - (2)].str); ;} 29816 break; 29817 29818 case 2540: 29819- 29820-/* Line 1455 of yacc.c */ 29821 #line 13521 "preproc.y" 29822 { (yyval.str) = (yyvsp[(3) - (3)].str); ;} 29823 break; 29824 29825 case 2541: 29826- 29827-/* Line 1455 of yacc.c */ 29828 #line 13522 "preproc.y" 29829 { (yyval.str) = make_str("all"); ;} 29830 break; 29831 29832 case 2542: 29833- 29834-/* Line 1455 of yacc.c */ 29835 #line 13523 "preproc.y" 29836 { (yyval.str) = make_str("all"); ;} 29837 break; 29838 29839 case 2543: 29840- 29841-/* Line 1455 of yacc.c */ 29842 #line 13526 "preproc.y" 29843 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29844 break; 29845 29846 case 2544: 29847- 29848-/* Line 1455 of yacc.c */ 29849 #line 13527 "preproc.y" 29850 { (yyval.str) = cat_str(3, make_str("("), (yyvsp[(2) - (3)].str), make_str(")")); ;} 29851 break; 29852 29853 case 2545: 29854- 29855-/* Line 1455 of yacc.c */ 29856 #line 13528 "preproc.y" 29857 { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str("+"), (yyvsp[(3) - (3)].str)); ;} 29858 break; 29859 29860 case 2546: 29861- 29862-/* Line 1455 of yacc.c */ 29863 #line 13529 "preproc.y" 29864 { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str("-"), (yyvsp[(3) - (3)].str)); ;} 29865 break; 29866 29867 case 2547: 29868- 29869-/* Line 1455 of yacc.c */ 29870 #line 13530 "preproc.y" 29871 { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str("*"), (yyvsp[(3) - (3)].str)); ;} 29872 break; 29873 29874 case 2548: 29875- 29876-/* Line 1455 of yacc.c */ 29877 #line 13531 "preproc.y" 29878 { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str("/"), (yyvsp[(3) - (3)].str)); ;} 29879 break; 29880 29881 case 2549: 29882- 29883-/* Line 1455 of yacc.c */ 29884 #line 13532 "preproc.y" 29885 { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str("%"), (yyvsp[(3) - (3)].str)); ;} 29886 break; 29887 29888 case 2550: 29889- 29890-/* Line 1455 of yacc.c */ 29891 #line 13533 "preproc.y" 29892 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29893 break; 29894 29895 case 2551: 29896- 29897-/* Line 1455 of yacc.c */ 29898 #line 13534 "preproc.y" 29899 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29900 break; 29901 29902 case 2552: 29903- 29904-/* Line 1455 of yacc.c */ 29905 #line 13537 "preproc.y" 29906 { (yyval.str) = EMPTY; ;} 29907 break; 29908 29909 case 2553: 29910- 29911-/* Line 1455 of yacc.c */ 29912 #line 13538 "preproc.y" 29913 { (yyval.str) = EMPTY; ;} 29914 break; 29915 29916 case 2554: 29917- 29918-/* Line 1455 of yacc.c */ 29919 #line 13539 "preproc.y" 29920 { (yyval.str) = EMPTY; ;} 29921 break; 29922 29923 case 2555: 29924- 29925-/* Line 1455 of yacc.c */ 29926 #line 13540 "preproc.y" 29927 { (yyval.str) = EMPTY; ;} 29928 break; 29929 29930 case 2556: 29931- 29932-/* Line 1455 of yacc.c */ 29933 #line 13541 "preproc.y" 29934 { (yyval.str) = EMPTY; ;} 29935 break; 29936 29937 case 2557: 29938- 29939-/* Line 1455 of yacc.c */ 29940 #line 13544 "preproc.y" 29941 { (yyval.str) = EMPTY; ;} 29942 break; 29943 29944 case 2558: 29945- 29946-/* Line 1455 of yacc.c */ 29947 #line 13545 "preproc.y" 29948 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29949 break; 29950 29951 case 2559: 29952- 29953-/* Line 1455 of yacc.c */ 29954 #line 13548 "preproc.y" 29955 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29956 break; 29957 29958 case 2560: 29959- 29960-/* Line 1455 of yacc.c */ 29961 #line 13550 "preproc.y" 29962 { 29963 struct variable *var; 29964@@ -47800,23 +43185,18 @@ 29965 break; 29966 29967 case 2561: 29968- 29969-/* Line 1455 of yacc.c */ 29970 #line 13560 "preproc.y" 29971 { (yyval.str) = EMPTY; ;} 29972 break; 29973 29974 case 2562: 29975- 29976-/* Line 1455 of yacc.c */ 29977 #line 13561 "preproc.y" 29978 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 29979 break; 29980 29981 29982- 29983-/* Line 1455 of yacc.c */ 29984-#line 47820 "preproc.c" 29985+/* Line 1267 of yacc.c. */ 29986+#line 43200 "preproc" 29987 default: break; 29988 } 29989 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 29990@@ -47892,7 +43272,7 @@ 29991 29992 if (yyerrstatus == 3) 29993 { 29994- /* If just tried and failed to reuse lookahead token after an 29995+ /* If just tried and failed to reuse look-ahead token after an 29996 error, discard it. */ 29997 29998 if (yychar <= YYEOF) 29999@@ -47909,7 +43289,7 @@ 30000 } 30001 } 30002 30003- /* Else will try to reuse lookahead token after shifting the error 30004+ /* Else will try to reuse look-ahead token after shifting the error 30005 token. */ 30006 goto yyerrlab1; 30007 30008@@ -47967,11 +43347,14 @@ 30009 YY_STACK_PRINT (yyss, yyssp); 30010 } 30011 30012+ if (yyn == YYFINAL) 30013+ YYACCEPT; 30014+ 30015 *++yyvsp = yylval; 30016 30017 yyerror_range[1] = yylloc; 30018 /* Using YYLLOC is tempting, but would change the location of 30019- the lookahead. YYLOC is available though. */ 30020+ the look-ahead. YYLOC is available though. */ 30021 YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2); 30022 *++yylsp = yyloc; 30023 30024@@ -47996,7 +43379,7 @@ 30025 yyresult = 1; 30026 goto yyreturn; 30027 30028-#if !defined(yyoverflow) || YYERROR_VERBOSE 30029+#ifndef yyoverflow 30030 /*-------------------------------------------------. 30031 | yyexhaustedlab -- memory exhaustion comes here. | 30032 `-------------------------------------------------*/ 30033@@ -48007,7 +43390,7 @@ 30034 #endif 30035 30036 yyreturn: 30037- if (yychar != YYEMPTY) 30038+ if (yychar != YYEOF && yychar != YYEMPTY) 30039 yydestruct ("Cleanup: discarding lookahead", 30040 yytoken, &yylval, &yylloc); 30041 /* Do not reclaim the symbols of the rule which action triggered 30042@@ -48033,8 +43416,6 @@ 30043 } 30044 30045 30046- 30047-/* Line 1675 of yacc.c */ 30048 #line 13564 "preproc.y" 30049 30050 30051--- postgresql-9.0.12/src/interfaces/ecpg/preproc/preproc.h 2013-02-04 13:44:29.000000000 -0800 30052+++ postgresql/src/interfaces/ecpg/preproc/preproc.h 2013-03-19 20:10:29.000000000 -0700 30053@@ -1,23 +1,24 @@ 30054- 30055-/* A Bison parser, made by GNU Bison 2.4.1. */ 30056+/* A Bison parser, made by GNU Bison 2.3. */ 30057 30058 /* Skeleton interface for Bison's Yacc-like parsers in C 30059- 30060- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 30061+ 30062+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 30063 Free Software Foundation, Inc. 30064- 30065- This program is free software: you can redistribute it and/or modify 30066+ 30067+ This program is free software; you can redistribute it and/or modify 30068 it under the terms of the GNU General Public License as published by 30069- the Free Software Foundation, either version 3 of the License, or 30070- (at your option) any later version. 30071- 30072+ the Free Software Foundation; either version 2, or (at your option) 30073+ any later version. 30074+ 30075 This program is distributed in the hope that it will be useful, 30076 but WITHOUT ANY WARRANTY; without even the implied warranty of 30077 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 30078 GNU General Public License for more details. 30079- 30080+ 30081 You should have received a copy of the GNU General Public License 30082- along with this program. If not, see <http://www.gnu.org/licenses/>. */ 30083+ along with this program; if not, write to the Free Software 30084+ Foundation, Inc., 51 Franklin Street, Fifth Floor, 30085+ Boston, MA 02110-1301, USA. */ 30086 30087 /* As a special exception, you may create a larger work that contains 30088 part or all of the Bison parser skeleton and distribute that work 30089@@ -28,11 +29,10 @@ 30090 special exception, which will cause the skeleton and the resulting 30091 Bison output files to be licensed under the GNU General Public 30092 License without this special exception. 30093- 30094+ 30095 This special exception was added by the Free Software Foundation in 30096 version 2.2 of Bison. */ 30097 30098- 30099 /* Tokens. */ 30100 #ifndef YYTOKENTYPE 30101 # define YYTOKENTYPE 30102@@ -529,16 +529,503 @@ 30103 UMINUS = 745 30104 }; 30105 #endif 30106+/* Tokens. */ 30107+#define SQL_ALLOCATE 258 30108+#define SQL_AUTOCOMMIT 259 30109+#define SQL_BOOL 260 30110+#define SQL_BREAK 261 30111+#define SQL_CALL 262 30112+#define SQL_CARDINALITY 263 30113+#define SQL_CONNECT 264 30114+#define SQL_COUNT 265 30115+#define SQL_DATETIME_INTERVAL_CODE 266 30116+#define SQL_DATETIME_INTERVAL_PRECISION 267 30117+#define SQL_DESCRIBE 268 30118+#define SQL_DESCRIPTOR 269 30119+#define SQL_DISCONNECT 270 30120+#define SQL_FOUND 271 30121+#define SQL_FREE 272 30122+#define SQL_GET 273 30123+#define SQL_GO 274 30124+#define SQL_GOTO 275 30125+#define SQL_IDENTIFIED 276 30126+#define SQL_INDICATOR 277 30127+#define SQL_KEY_MEMBER 278 30128+#define SQL_LENGTH 279 30129+#define SQL_LONG 280 30130+#define SQL_NULLABLE 281 30131+#define SQL_OCTET_LENGTH 282 30132+#define SQL_OPEN 283 30133+#define SQL_OUTPUT 284 30134+#define SQL_REFERENCE 285 30135+#define SQL_RETURNED_LENGTH 286 30136+#define SQL_RETURNED_OCTET_LENGTH 287 30137+#define SQL_SCALE 288 30138+#define SQL_SECTION 289 30139+#define SQL_SHORT 290 30140+#define SQL_SIGNED 291 30141+#define SQL_SQL 292 30142+#define SQL_SQLERROR 293 30143+#define SQL_SQLPRINT 294 30144+#define SQL_SQLWARNING 295 30145+#define SQL_START 296 30146+#define SQL_STOP 297 30147+#define SQL_STRUCT 298 30148+#define SQL_UNSIGNED 299 30149+#define SQL_VAR 300 30150+#define SQL_WHENEVER 301 30151+#define S_ADD 302 30152+#define S_AND 303 30153+#define S_ANYTHING 304 30154+#define S_AUTO 305 30155+#define S_CONST 306 30156+#define S_DEC 307 30157+#define S_DIV 308 30158+#define S_DOTPOINT 309 30159+#define S_EQUAL 310 30160+#define S_EXTERN 311 30161+#define S_INC 312 30162+#define S_LSHIFT 313 30163+#define S_MEMPOINT 314 30164+#define S_MEMBER 315 30165+#define S_MOD 316 30166+#define S_MUL 317 30167+#define S_NEQUAL 318 30168+#define S_OR 319 30169+#define S_REGISTER 320 30170+#define S_RSHIFT 321 30171+#define S_STATIC 322 30172+#define S_SUB 323 30173+#define S_VOLATILE 324 30174+#define S_TYPEDEF 325 30175+#define CSTRING 326 30176+#define CVARIABLE 327 30177+#define CPP_LINE 328 30178+#define IP 329 30179+#define DOLCONST 330 30180+#define ECONST 331 30181+#define NCONST 332 30182+#define UCONST 333 30183+#define UIDENT 334 30184+#define IDENT 335 30185+#define FCONST 336 30186+#define SCONST 337 30187+#define BCONST 338 30188+#define XCONST 339 30189+#define Op 340 30190+#define ICONST 341 30191+#define PARAM 342 30192+#define TYPECAST 343 30193+#define DOT_DOT 344 30194+#define COLON_EQUALS 345 30195+#define ABORT_P 346 30196+#define ABSOLUTE_P 347 30197+#define ACCESS 348 30198+#define ACTION 349 30199+#define ADD_P 350 30200+#define ADMIN 351 30201+#define AFTER 352 30202+#define AGGREGATE 353 30203+#define ALL 354 30204+#define ALSO 355 30205+#define ALTER 356 30206+#define ALWAYS 357 30207+#define ANALYSE 358 30208+#define ANALYZE 359 30209+#define AND 360 30210+#define ANY 361 30211+#define ARRAY 362 30212+#define AS 363 30213+#define ASC 364 30214+#define ASSERTION 365 30215+#define ASSIGNMENT 366 30216+#define ASYMMETRIC 367 30217+#define AT 368 30218+#define AUTHORIZATION 369 30219+#define BACKWARD 370 30220+#define BEFORE 371 30221+#define BEGIN_P 372 30222+#define BETWEEN 373 30223+#define BIGINT 374 30224+#define BINARY 375 30225+#define BIT 376 30226+#define BOOLEAN_P 377 30227+#define BOTH 378 30228+#define BY 379 30229+#define CACHE 380 30230+#define CALLED 381 30231+#define CASCADE 382 30232+#define CASCADED 383 30233+#define CASE 384 30234+#define CAST 385 30235+#define CATALOG_P 386 30236+#define CHAIN 387 30237+#define CHAR_P 388 30238+#define CHARACTER 389 30239+#define CHARACTERISTICS 390 30240+#define CHECK 391 30241+#define CHECKPOINT 392 30242+#define CLASS 393 30243+#define CLOSE 394 30244+#define CLUSTER 395 30245+#define COALESCE 396 30246+#define COLLATE 397 30247+#define COLUMN 398 30248+#define COMMENT 399 30249+#define COMMENTS 400 30250+#define COMMIT 401 30251+#define COMMITTED 402 30252+#define CONCURRENTLY 403 30253+#define CONFIGURATION 404 30254+#define CONNECTION 405 30255+#define CONSTRAINT 406 30256+#define CONSTRAINTS 407 30257+#define CONTENT_P 408 30258+#define CONTINUE_P 409 30259+#define CONVERSION_P 410 30260+#define COPY 411 30261+#define COST 412 30262+#define CREATE 413 30263+#define CREATEDB 414 30264+#define CREATEROLE 415 30265+#define CREATEUSER 416 30266+#define CROSS 417 30267+#define CSV 418 30268+#define CURRENT_P 419 30269+#define CURRENT_CATALOG 420 30270+#define CURRENT_DATE 421 30271+#define CURRENT_ROLE 422 30272+#define CURRENT_SCHEMA 423 30273+#define CURRENT_TIME 424 30274+#define CURRENT_TIMESTAMP 425 30275+#define CURRENT_USER 426 30276+#define CURSOR 427 30277+#define CYCLE 428 30278+#define DATA_P 429 30279+#define DATABASE 430 30280+#define DAY_P 431 30281+#define DEALLOCATE 432 30282+#define DEC 433 30283+#define DECIMAL_P 434 30284+#define DECLARE 435 30285+#define DEFAULT 436 30286+#define DEFAULTS 437 30287+#define DEFERRABLE 438 30288+#define DEFERRED 439 30289+#define DEFINER 440 30290+#define DELETE_P 441 30291+#define DELIMITER 442 30292+#define DELIMITERS 443 30293+#define DESC 444 30294+#define DICTIONARY 445 30295+#define DISABLE_P 446 30296+#define DISCARD 447 30297+#define DISTINCT 448 30298+#define DO 449 30299+#define DOCUMENT_P 450 30300+#define DOMAIN_P 451 30301+#define DOUBLE_P 452 30302+#define DROP 453 30303+#define EACH 454 30304+#define ELSE 455 30305+#define ENABLE_P 456 30306+#define ENCODING 457 30307+#define ENCRYPTED 458 30308+#define END_P 459 30309+#define ENUM_P 460 30310+#define ESCAPE 461 30311+#define EXCEPT 462 30312+#define EXCLUDE 463 30313+#define EXCLUDING 464 30314+#define EXCLUSIVE 465 30315+#define EXECUTE 466 30316+#define EXISTS 467 30317+#define EXPLAIN 468 30318+#define EXTERNAL 469 30319+#define EXTRACT 470 30320+#define FALSE_P 471 30321+#define FAMILY 472 30322+#define FETCH 473 30323+#define FIRST_P 474 30324+#define FLOAT_P 475 30325+#define FOLLOWING 476 30326+#define FOR 477 30327+#define FORCE 478 30328+#define FOREIGN 479 30329+#define FORWARD 480 30330+#define FREEZE 481 30331+#define FROM 482 30332+#define FULL 483 30333+#define FUNCTION 484 30334+#define FUNCTIONS 485 30335+#define GLOBAL 486 30336+#define GRANT 487 30337+#define GRANTED 488 30338+#define GREATEST 489 30339+#define GROUP_P 490 30340+#define HANDLER 491 30341+#define HAVING 492 30342+#define HEADER_P 493 30343+#define HOLD 494 30344+#define HOUR_P 495 30345+#define IDENTITY_P 496 30346+#define IF_P 497 30347+#define ILIKE 498 30348+#define IMMEDIATE 499 30349+#define IMMUTABLE 500 30350+#define IMPLICIT_P 501 30351+#define IN_P 502 30352+#define INCLUDING 503 30353+#define INCREMENT 504 30354+#define INDEX 505 30355+#define INDEXES 506 30356+#define INHERIT 507 30357+#define INHERITS 508 30358+#define INITIALLY 509 30359+#define INLINE_P 510 30360+#define INNER_P 511 30361+#define INOUT 512 30362+#define INPUT_P 513 30363+#define INSENSITIVE 514 30364+#define INSERT 515 30365+#define INSTEAD 516 30366+#define INT_P 517 30367+#define INTEGER 518 30368+#define INTERSECT 519 30369+#define INTERVAL 520 30370+#define INTO 521 30371+#define INVOKER 522 30372+#define IS 523 30373+#define ISNULL 524 30374+#define ISOLATION 525 30375+#define JOIN 526 30376+#define KEY 527 30377+#define LANGUAGE 528 30378+#define LARGE_P 529 30379+#define LAST_P 530 30380+#define LC_COLLATE_P 531 30381+#define LC_CTYPE_P 532 30382+#define LEADING 533 30383+#define LEAST 534 30384+#define LEFT 535 30385+#define LEVEL 536 30386+#define LIKE 537 30387+#define LIMIT 538 30388+#define LISTEN 539 30389+#define LOAD 540 30390+#define LOCAL 541 30391+#define LOCALTIME 542 30392+#define LOCALTIMESTAMP 543 30393+#define LOCATION 544 30394+#define LOCK_P 545 30395+#define LOGIN_P 546 30396+#define MAPPING 547 30397+#define MATCH 548 30398+#define MAXVALUE 549 30399+#define MINUTE_P 550 30400+#define MINVALUE 551 30401+#define MODE 552 30402+#define MONTH_P 553 30403+#define MOVE 554 30404+#define NAME_P 555 30405+#define NAMES 556 30406+#define NATIONAL 557 30407+#define NATURAL 558 30408+#define NCHAR 559 30409+#define NEXT 560 30410+#define NO 561 30411+#define NOCREATEDB 562 30412+#define NOCREATEROLE 563 30413+#define NOCREATEUSER 564 30414+#define NOINHERIT 565 30415+#define NOLOGIN_P 566 30416+#define NONE 567 30417+#define NOSUPERUSER 568 30418+#define NOT 569 30419+#define NOTHING 570 30420+#define NOTIFY 571 30421+#define NOTNULL 572 30422+#define NOWAIT 573 30423+#define NULL_P 574 30424+#define NULLIF 575 30425+#define NULLS_P 576 30426+#define NUMERIC 577 30427+#define OBJECT_P 578 30428+#define OF 579 30429+#define OFF 580 30430+#define OFFSET 581 30431+#define OIDS 582 30432+#define ON 583 30433+#define ONLY 584 30434+#define OPERATOR 585 30435+#define OPTION 586 30436+#define OPTIONS 587 30437+#define OR 588 30438+#define ORDER 589 30439+#define OUT_P 590 30440+#define OUTER_P 591 30441+#define OVER 592 30442+#define OVERLAPS 593 30443+#define OVERLAY 594 30444+#define OWNED 595 30445+#define OWNER 596 30446+#define PARSER 597 30447+#define PARTIAL 598 30448+#define PARTITION 599 30449+#define PASSWORD 600 30450+#define PLACING 601 30451+#define PLANS 602 30452+#define POSITION 603 30453+#define PRECEDING 604 30454+#define PRECISION 605 30455+#define PRESERVE 606 30456+#define PREPARE 607 30457+#define PREPARED 608 30458+#define PRIMARY 609 30459+#define PRIOR 610 30460+#define PRIVILEGES 611 30461+#define PROCEDURAL 612 30462+#define PROCEDURE 613 30463+#define QUOTE 614 30464+#define RANGE 615 30465+#define READ 616 30466+#define REAL 617 30467+#define REASSIGN 618 30468+#define RECHECK 619 30469+#define RECURSIVE 620 30470+#define REFERENCES 621 30471+#define REINDEX 622 30472+#define RELATIVE_P 623 30473+#define RELEASE 624 30474+#define RENAME 625 30475+#define REPEATABLE 626 30476+#define REPLACE 627 30477+#define REPLICA 628 30478+#define RESET 629 30479+#define RESTART 630 30480+#define RESTRICT 631 30481+#define RETURNING 632 30482+#define RETURNS 633 30483+#define REVOKE 634 30484+#define RIGHT 635 30485+#define ROLE 636 30486+#define ROLLBACK 637 30487+#define ROW 638 30488+#define ROWS 639 30489+#define RULE 640 30490+#define SAVEPOINT 641 30491+#define SCHEMA 642 30492+#define SCROLL 643 30493+#define SEARCH 644 30494+#define SECOND_P 645 30495+#define SECURITY 646 30496+#define SELECT 647 30497+#define SEQUENCE 648 30498+#define SEQUENCES 649 30499+#define SERIALIZABLE 650 30500+#define SERVER 651 30501+#define SESSION 652 30502+#define SESSION_USER 653 30503+#define SET 654 30504+#define SETOF 655 30505+#define SHARE 656 30506+#define SHOW 657 30507+#define SIMILAR 658 30508+#define SIMPLE 659 30509+#define SMALLINT 660 30510+#define SOME 661 30511+#define STABLE 662 30512+#define STANDALONE_P 663 30513+#define START 664 30514+#define STATEMENT 665 30515+#define STATISTICS 666 30516+#define STDIN 667 30517+#define STDOUT 668 30518+#define STORAGE 669 30519+#define STRICT_P 670 30520+#define STRIP_P 671 30521+#define SUBSTRING 672 30522+#define SUPERUSER_P 673 30523+#define SYMMETRIC 674 30524+#define SYSID 675 30525+#define SYSTEM_P 676 30526+#define TABLE 677 30527+#define TABLES 678 30528+#define TABLESPACE 679 30529+#define TEMP 680 30530+#define TEMPLATE 681 30531+#define TEMPORARY 682 30532+#define TEXT_P 683 30533+#define THEN 684 30534+#define TIME 685 30535+#define TIMESTAMP 686 30536+#define TO 687 30537+#define TRAILING 688 30538+#define TRANSACTION 689 30539+#define TREAT 690 30540+#define TRIGGER 691 30541+#define TRIM 692 30542+#define TRUE_P 693 30543+#define TRUNCATE 694 30544+#define TRUSTED 695 30545+#define TYPE_P 696 30546+#define UNBOUNDED 697 30547+#define UNCOMMITTED 698 30548+#define UNENCRYPTED 699 30549+#define UNION 700 30550+#define UNIQUE 701 30551+#define UNKNOWN 702 30552+#define UNLISTEN 703 30553+#define UNTIL 704 30554+#define UPDATE 705 30555+#define USER 706 30556+#define USING 707 30557+#define VACUUM 708 30558+#define VALID 709 30559+#define VALIDATOR 710 30560+#define VALUE_P 711 30561+#define VALUES 712 30562+#define VARCHAR 713 30563+#define VARIADIC 714 30564+#define VARYING 715 30565+#define VERBOSE 716 30566+#define VERSION_P 717 30567+#define VIEW 718 30568+#define VOLATILE 719 30569+#define WHEN 720 30570+#define WHERE 721 30571+#define WHITESPACE_P 722 30572+#define WINDOW 723 30573+#define WITH 724 30574+#define WITHOUT 725 30575+#define WORK 726 30576+#define WRAPPER 727 30577+#define WRITE 728 30578+#define XML_P 729 30579+#define XMLATTRIBUTES 730 30580+#define XMLCONCAT 731 30581+#define XMLELEMENT 732 30582+#define XMLFOREST 733 30583+#define XMLPARSE 734 30584+#define XMLPI 735 30585+#define XMLROOT 736 30586+#define XMLSERIALIZE 737 30587+#define YEAR_P 738 30588+#define YES_P 739 30589+#define ZONE 740 30590+#define NULLS_FIRST 741 30591+#define NULLS_LAST 742 30592+#define WITH_TIME 743 30593+#define POSTFIXOP 744 30594+#define UMINUS 745 30595+ 30596 30597 30598 30599 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 30600 typedef union YYSTYPE 30601-{ 30602- 30603-/* Line 1676 of yacc.c */ 30604 #line 471 "preproc.y" 30605- 30606+{ 30607 double dval; 30608 char *str; 30609 int ival; 30610@@ -551,15 +1038,13 @@ 30611 struct fetch_desc descriptor; 30612 struct su_symbol struct_union; 30613 struct prep prep; 30614- 30615- 30616- 30617-/* Line 1676 of yacc.c */ 30618-#line 559 "preproc.h" 30619-} YYSTYPE; 30620-# define YYSTYPE_IS_TRIVIAL 1 30621+} 30622+/* Line 1529 of yacc.c. */ 30623+#line 1044 "preproc.h" 30624+ YYSTYPE; 30625 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 30626 # define YYSTYPE_IS_DECLARED 1 30627+# define YYSTYPE_IS_TRIVIAL 1 30628 #endif 30629 30630 extern YYSTYPE base_yylval; 30631@@ -578,4 +1063,3 @@ 30632 #endif 30633 30634 extern YYLTYPE base_yylloc; 30635- 30636--- postgresql-9.0.12/src/backend/parser/gram.c 2013-02-04 13:44:21.000000000 -0800 30637+++ postgresql/src/backend/parser/gram.c 2013-03-19 20:10:04.000000000 -0700 30638@@ -1,23 +1,24 @@ 30639- 30640-/* A Bison parser, made by GNU Bison 2.4.1. */ 30641+/* A Bison parser, made by GNU Bison 2.3. */ 30642 30643 /* Skeleton implementation for Bison's Yacc-like parsers in C 30644- 30645- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 30646+ 30647+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 30648 Free Software Foundation, Inc. 30649- 30650- This program is free software: you can redistribute it and/or modify 30651+ 30652+ This program is free software; you can redistribute it and/or modify 30653 it under the terms of the GNU General Public License as published by 30654- the Free Software Foundation, either version 3 of the License, or 30655- (at your option) any later version. 30656- 30657+ the Free Software Foundation; either version 2, or (at your option) 30658+ any later version. 30659+ 30660 This program is distributed in the hope that it will be useful, 30661 but WITHOUT ANY WARRANTY; without even the implied warranty of 30662 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 30663 GNU General Public License for more details. 30664- 30665+ 30666 You should have received a copy of the GNU General Public License 30667- along with this program. If not, see <http://www.gnu.org/licenses/>. */ 30668+ along with this program; if not, write to the Free Software 30669+ Foundation, Inc., 51 Franklin Street, Fifth Floor, 30670+ Boston, MA 02110-1301, USA. */ 30671 30672 /* As a special exception, you may create a larger work that contains 30673 part or all of the Bison parser skeleton and distribute that work 30674@@ -28,7 +29,7 @@ 30675 special exception, which will cause the skeleton and the resulting 30676 Bison output files to be licensed under the GNU General Public 30677 License without this special exception. 30678- 30679+ 30680 This special exception was added by the Free Software Foundation in 30681 version 2.2 of Bison. */ 30682 30683@@ -46,7 +47,7 @@ 30684 #define YYBISON 1 30685 30686 /* Bison version. */ 30687-#define YYBISON_VERSION "2.4.1" 30688+#define YYBISON_VERSION "2.3" 30689 30690 /* Skeleton name. */ 30691 #define YYSKELETON_NAME "yacc.c" 30692@@ -54,186 +55,18 @@ 30693 /* Pure parsers. */ 30694 #define YYPURE 1 30695 30696-/* Push parsers. */ 30697-#define YYPUSH 0 30698- 30699-/* Pull parsers. */ 30700-#define YYPULL 1 30701- 30702 /* Using locations. */ 30703 #define YYLSP_NEEDED 1 30704 30705 /* Substitute the variable and function names. */ 30706-#define yyparse base_yyparse 30707-#define yylex base_yylex 30708-#define yyerror base_yyerror 30709-#define yylval base_yylval 30710-#define yychar base_yychar 30711-#define yydebug base_yydebug 30712-#define yynerrs base_yynerrs 30713-#define yylloc base_yylloc 30714- 30715-/* Copy the first part of user declarations. */ 30716- 30717-/* Line 189 of yacc.c */ 30718-#line 1 "gram.y" 30719- 30720- 30721-/*#define YYDEBUG 1*/ 30722-/*------------------------------------------------------------------------- 30723- * 30724- * gram.y 30725- * POSTGRESQL BISON rules/actions 30726- * 30727- * Portions Copyright (c) 1996-2010, PostgreSQL Global Development Group 30728- * Portions Copyright (c) 1994, Regents of the University of California 30729- * 30730- * 30731- * IDENTIFICATION 30732- * $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.713.2.1 2010/08/18 18:35:30 tgl Exp $ 30733- * 30734- * HISTORY 30735- * AUTHOR DATE MAJOR EVENT 30736- * Andrew Yu Sept, 1994 POSTQUEL to SQL conversion 30737- * Andrew Yu Oct, 1994 lispy code conversion 30738- * 30739- * NOTES 30740- * CAPITALS are used to represent terminal symbols. 30741- * non-capitals are used to represent non-terminals. 30742- * SQL92-specific syntax is separated from plain SQL/Postgres syntax 30743- * to help isolate the non-extensible portions of the parser. 30744- * 30745- * In general, nothing in this file should initiate database accesses 30746- * nor depend on changeable state (such as SET variables). If you do 30747- * database accesses, your code will fail when we have aborted the 30748- * current transaction and are just parsing commands to find the next 30749- * ROLLBACK or COMMIT. If you make use of SET variables, then you 30750- * will do the wrong thing in multi-query strings like this: 30751- * SET SQL_inheritance TO off; SELECT * FROM foo; 30752- * because the entire string is parsed by gram.y before the SET gets 30753- * executed. Anything that depends on the database or changeable state 30754- * should be handled during parse analysis so that it happens at the 30755- * right time not the wrong time. The handling of SQL_inheritance is 30756- * a good example. 30757- * 30758- * WARNINGS 30759- * If you use a list, make sure the datum is a node so that the printing 30760- * routines work. 30761- * 30762- * Sometimes we assign constants to makeStrings. Make sure we don't free 30763- * those. 30764- * 30765- *------------------------------------------------------------------------- 30766- */ 30767-#include "postgres.h" 30768- 30769-#include <ctype.h> 30770-#include <limits.h> 30771- 30772-#include "catalog/index.h" 30773-#include "catalog/namespace.h" 30774-#include "catalog/pg_trigger.h" 30775-#include "commands/defrem.h" 30776-#include "nodes/makefuncs.h" 30777-#include "nodes/nodeFuncs.h" 30778-#include "parser/gramparse.h" 30779-#include "parser/parser.h" 30780-#include "storage/lmgr.h" 30781-#include "utils/date.h" 30782-#include "utils/datetime.h" 30783-#include "utils/numeric.h" 30784-#include "utils/xml.h" 30785- 30786- 30787-/* Location tracking support --- simpler than bison's default */ 30788-#define YYLLOC_DEFAULT(Current, Rhs, N) \ 30789- do { \ 30790- if (N) \ 30791- (Current) = (Rhs)[1]; \ 30792- else \ 30793- (Current) = (Rhs)[0]; \ 30794- } while (0) 30795- 30796-/* 30797- * Bison doesn't allocate anything that needs to live across parser calls, 30798- * so we can easily have it use palloc instead of malloc. This prevents 30799- * memory leaks if we error out during parsing. Note this only works with 30800- * bison >= 2.0. However, in bison 1.875 the default is to use alloca() 30801- * if possible, so there's not really much problem anyhow, at least if 30802- * you're building with gcc. 30803- */ 30804-#define YYMALLOC palloc 30805-#define YYFREE pfree 30806- 30807-/* Private struct for the result of privilege_target production */ 30808-typedef struct PrivTarget 30809-{ 30810- GrantTargetType targtype; 30811- GrantObjectType objtype; 30812- List *objs; 30813-} PrivTarget; 30814- 30815- 30816-#define parser_yyerror(msg) scanner_yyerror(msg, yyscanner) 30817-#define parser_errposition(pos) scanner_errposition(pos, yyscanner) 30818- 30819-static void base_yyerror(YYLTYPE *yylloc, core_yyscan_t yyscanner, 30820- const char *msg); 30821-static Node *makeColumnRef(char *colname, List *indirection, 30822- int location, core_yyscan_t yyscanner); 30823-static Node *makeTypeCast(Node *arg, TypeName *typename, int location); 30824-static Node *makeStringConst(char *str, int location); 30825-static Node *makeStringConstCast(char *str, int location, TypeName *typename); 30826-static Node *makeIntConst(int val, int location); 30827-static Node *makeFloatConst(char *str, int location); 30828-static Node *makeBitStringConst(char *str, int location); 30829-static Node *makeNullAConst(int location); 30830-static Node *makeAConst(Value *v, int location); 30831-static Node *makeBoolAConst(bool state, int location); 30832-static FuncCall *makeOverlaps(List *largs, List *rargs, 30833- int location, core_yyscan_t yyscanner); 30834-static void check_qualified_name(List *names, core_yyscan_t yyscanner); 30835-static List *check_func_name(List *names, core_yyscan_t yyscanner); 30836-static List *check_indirection(List *indirection, core_yyscan_t yyscanner); 30837-static List *extractArgTypes(List *parameters); 30838-static SelectStmt *findLeftmostSelect(SelectStmt *node); 30839-static void insertSelectOptions(SelectStmt *stmt, 30840- List *sortClause, List *lockingClause, 30841- Node *limitOffset, Node *limitCount, 30842- WithClause *withClause, 30843- core_yyscan_t yyscanner); 30844-static Node *makeSetOp(SetOperation op, bool all, Node *larg, Node *rarg); 30845-static Node *doNegate(Node *n, int location); 30846-static void doNegateFloat(Value *v); 30847-static Node *makeAArrayExpr(List *elements, int location); 30848-static Node *makeXmlExpr(XmlExprOp op, char *name, List *named_args, 30849- List *args, int location); 30850-static List *mergeTableFuncParameters(List *func_args, List *columns); 30851-static TypeName *TableFuncTypeName(List *columns); 30852- 30853- 30854- 30855-/* Line 189 of yacc.c */ 30856-#line 218 "gram.c" 30857- 30858-/* Enabling traces. */ 30859-#ifndef YYDEBUG 30860-# define YYDEBUG 0 30861-#endif 30862- 30863-/* Enabling verbose error messages. */ 30864-#ifdef YYERROR_VERBOSE 30865-# undef YYERROR_VERBOSE 30866-# define YYERROR_VERBOSE 1 30867-#else 30868-# define YYERROR_VERBOSE 0 30869-#endif 30870- 30871-/* Enabling the token table. */ 30872-#ifndef YYTOKEN_TABLE 30873-# define YYTOKEN_TABLE 0 30874-#endif 30875- 30876+#define yyparse base_yyparse 30877+#define yylex base_yylex 30878+#define yyerror base_yyerror 30879+#define yylval base_yylval 30880+#define yychar base_yychar 30881+#define yydebug base_yydebug 30882+#define yynerrs base_yynerrs 30883+#define yylloc base_yylloc 30884 30885 /* Tokens. */ 30886 #ifndef YYTOKENTYPE 30887@@ -654,16 +487,582 @@ 30888 UMINUS = 668 30889 }; 30890 #endif 30891+/* Tokens. */ 30892+#define IDENT 258 30893+#define FCONST 259 30894+#define SCONST 260 30895+#define BCONST 261 30896+#define XCONST 262 30897+#define Op 263 30898+#define ICONST 264 30899+#define PARAM 265 30900+#define TYPECAST 266 30901+#define DOT_DOT 267 30902+#define COLON_EQUALS 268 30903+#define ABORT_P 269 30904+#define ABSOLUTE_P 270 30905+#define ACCESS 271 30906+#define ACTION 272 30907+#define ADD_P 273 30908+#define ADMIN 274 30909+#define AFTER 275 30910+#define AGGREGATE 276 30911+#define ALL 277 30912+#define ALSO 278 30913+#define ALTER 279 30914+#define ALWAYS 280 30915+#define ANALYSE 281 30916+#define ANALYZE 282 30917+#define AND 283 30918+#define ANY 284 30919+#define ARRAY 285 30920+#define AS 286 30921+#define ASC 287 30922+#define ASSERTION 288 30923+#define ASSIGNMENT 289 30924+#define ASYMMETRIC 290 30925+#define AT 291 30926+#define AUTHORIZATION 292 30927+#define BACKWARD 293 30928+#define BEFORE 294 30929+#define BEGIN_P 295 30930+#define BETWEEN 296 30931+#define BIGINT 297 30932+#define BINARY 298 30933+#define BIT 299 30934+#define BOOLEAN_P 300 30935+#define BOTH 301 30936+#define BY 302 30937+#define CACHE 303 30938+#define CALLED 304 30939+#define CASCADE 305 30940+#define CASCADED 306 30941+#define CASE 307 30942+#define CAST 308 30943+#define CATALOG_P 309 30944+#define CHAIN 310 30945+#define CHAR_P 311 30946+#define CHARACTER 312 30947+#define CHARACTERISTICS 313 30948+#define CHECK 314 30949+#define CHECKPOINT 315 30950+#define CLASS 316 30951+#define CLOSE 317 30952+#define CLUSTER 318 30953+#define COALESCE 319 30954+#define COLLATE 320 30955+#define COLUMN 321 30956+#define COMMENT 322 30957+#define COMMENTS 323 30958+#define COMMIT 324 30959+#define COMMITTED 325 30960+#define CONCURRENTLY 326 30961+#define CONFIGURATION 327 30962+#define CONNECTION 328 30963+#define CONSTRAINT 329 30964+#define CONSTRAINTS 330 30965+#define CONTENT_P 331 30966+#define CONTINUE_P 332 30967+#define CONVERSION_P 333 30968+#define COPY 334 30969+#define COST 335 30970+#define CREATE 336 30971+#define CREATEDB 337 30972+#define CREATEROLE 338 30973+#define CREATEUSER 339 30974+#define CROSS 340 30975+#define CSV 341 30976+#define CURRENT_P 342 30977+#define CURRENT_CATALOG 343 30978+#define CURRENT_DATE 344 30979+#define CURRENT_ROLE 345 30980+#define CURRENT_SCHEMA 346 30981+#define CURRENT_TIME 347 30982+#define CURRENT_TIMESTAMP 348 30983+#define CURRENT_USER 349 30984+#define CURSOR 350 30985+#define CYCLE 351 30986+#define DATA_P 352 30987+#define DATABASE 353 30988+#define DAY_P 354 30989+#define DEALLOCATE 355 30990+#define DEC 356 30991+#define DECIMAL_P 357 30992+#define DECLARE 358 30993+#define DEFAULT 359 30994+#define DEFAULTS 360 30995+#define DEFERRABLE 361 30996+#define DEFERRED 362 30997+#define DEFINER 363 30998+#define DELETE_P 364 30999+#define DELIMITER 365 31000+#define DELIMITERS 366 31001+#define DESC 367 31002+#define DICTIONARY 368 31003+#define DISABLE_P 369 31004+#define DISCARD 370 31005+#define DISTINCT 371 31006+#define DO 372 31007+#define DOCUMENT_P 373 31008+#define DOMAIN_P 374 31009+#define DOUBLE_P 375 31010+#define DROP 376 31011+#define EACH 377 31012+#define ELSE 378 31013+#define ENABLE_P 379 31014+#define ENCODING 380 31015+#define ENCRYPTED 381 31016+#define END_P 382 31017+#define ENUM_P 383 31018+#define ESCAPE 384 31019+#define EXCEPT 385 31020+#define EXCLUDE 386 31021+#define EXCLUDING 387 31022+#define EXCLUSIVE 388 31023+#define EXECUTE 389 31024+#define EXISTS 390 31025+#define EXPLAIN 391 31026+#define EXTERNAL 392 31027+#define EXTRACT 393 31028+#define FALSE_P 394 31029+#define FAMILY 395 31030+#define FETCH 396 31031+#define FIRST_P 397 31032+#define FLOAT_P 398 31033+#define FOLLOWING 399 31034+#define FOR 400 31035+#define FORCE 401 31036+#define FOREIGN 402 31037+#define FORWARD 403 31038+#define FREEZE 404 31039+#define FROM 405 31040+#define FULL 406 31041+#define FUNCTION 407 31042+#define FUNCTIONS 408 31043+#define GLOBAL 409 31044+#define GRANT 410 31045+#define GRANTED 411 31046+#define GREATEST 412 31047+#define GROUP_P 413 31048+#define HANDLER 414 31049+#define HAVING 415 31050+#define HEADER_P 416 31051+#define HOLD 417 31052+#define HOUR_P 418 31053+#define IDENTITY_P 419 31054+#define IF_P 420 31055+#define ILIKE 421 31056+#define IMMEDIATE 422 31057+#define IMMUTABLE 423 31058+#define IMPLICIT_P 424 31059+#define IN_P 425 31060+#define INCLUDING 426 31061+#define INCREMENT 427 31062+#define INDEX 428 31063+#define INDEXES 429 31064+#define INHERIT 430 31065+#define INHERITS 431 31066+#define INITIALLY 432 31067+#define INLINE_P 433 31068+#define INNER_P 434 31069+#define INOUT 435 31070+#define INPUT_P 436 31071+#define INSENSITIVE 437 31072+#define INSERT 438 31073+#define INSTEAD 439 31074+#define INT_P 440 31075+#define INTEGER 441 31076+#define INTERSECT 442 31077+#define INTERVAL 443 31078+#define INTO 444 31079+#define INVOKER 445 31080+#define IS 446 31081+#define ISNULL 447 31082+#define ISOLATION 448 31083+#define JOIN 449 31084+#define KEY 450 31085+#define LANGUAGE 451 31086+#define LARGE_P 452 31087+#define LAST_P 453 31088+#define LC_COLLATE_P 454 31089+#define LC_CTYPE_P 455 31090+#define LEADING 456 31091+#define LEAST 457 31092+#define LEFT 458 31093+#define LEVEL 459 31094+#define LIKE 460 31095+#define LIMIT 461 31096+#define LISTEN 462 31097+#define LOAD 463 31098+#define LOCAL 464 31099+#define LOCALTIME 465 31100+#define LOCALTIMESTAMP 466 31101+#define LOCATION 467 31102+#define LOCK_P 468 31103+#define LOGIN_P 469 31104+#define MAPPING 470 31105+#define MATCH 471 31106+#define MAXVALUE 472 31107+#define MINUTE_P 473 31108+#define MINVALUE 474 31109+#define MODE 475 31110+#define MONTH_P 476 31111+#define MOVE 477 31112+#define NAME_P 478 31113+#define NAMES 479 31114+#define NATIONAL 480 31115+#define NATURAL 481 31116+#define NCHAR 482 31117+#define NEXT 483 31118+#define NO 484 31119+#define NOCREATEDB 485 31120+#define NOCREATEROLE 486 31121+#define NOCREATEUSER 487 31122+#define NOINHERIT 488 31123+#define NOLOGIN_P 489 31124+#define NONE 490 31125+#define NOSUPERUSER 491 31126+#define NOT 492 31127+#define NOTHING 493 31128+#define NOTIFY 494 31129+#define NOTNULL 495 31130+#define NOWAIT 496 31131+#define NULL_P 497 31132+#define NULLIF 498 31133+#define NULLS_P 499 31134+#define NUMERIC 500 31135+#define OBJECT_P 501 31136+#define OF 502 31137+#define OFF 503 31138+#define OFFSET 504 31139+#define OIDS 505 31140+#define ON 506 31141+#define ONLY 507 31142+#define OPERATOR 508 31143+#define OPTION 509 31144+#define OPTIONS 510 31145+#define OR 511 31146+#define ORDER 512 31147+#define OUT_P 513 31148+#define OUTER_P 514 31149+#define OVER 515 31150+#define OVERLAPS 516 31151+#define OVERLAY 517 31152+#define OWNED 518 31153+#define OWNER 519 31154+#define PARSER 520 31155+#define PARTIAL 521 31156+#define PARTITION 522 31157+#define PASSWORD 523 31158+#define PLACING 524 31159+#define PLANS 525 31160+#define POSITION 526 31161+#define PRECEDING 527 31162+#define PRECISION 528 31163+#define PRESERVE 529 31164+#define PREPARE 530 31165+#define PREPARED 531 31166+#define PRIMARY 532 31167+#define PRIOR 533 31168+#define PRIVILEGES 534 31169+#define PROCEDURAL 535 31170+#define PROCEDURE 536 31171+#define QUOTE 537 31172+#define RANGE 538 31173+#define READ 539 31174+#define REAL 540 31175+#define REASSIGN 541 31176+#define RECHECK 542 31177+#define RECURSIVE 543 31178+#define REFERENCES 544 31179+#define REINDEX 545 31180+#define RELATIVE_P 546 31181+#define RELEASE 547 31182+#define RENAME 548 31183+#define REPEATABLE 549 31184+#define REPLACE 550 31185+#define REPLICA 551 31186+#define RESET 552 31187+#define RESTART 553 31188+#define RESTRICT 554 31189+#define RETURNING 555 31190+#define RETURNS 556 31191+#define REVOKE 557 31192+#define RIGHT 558 31193+#define ROLE 559 31194+#define ROLLBACK 560 31195+#define ROW 561 31196+#define ROWS 562 31197+#define RULE 563 31198+#define SAVEPOINT 564 31199+#define SCHEMA 565 31200+#define SCROLL 566 31201+#define SEARCH 567 31202+#define SECOND_P 568 31203+#define SECURITY 569 31204+#define SELECT 570 31205+#define SEQUENCE 571 31206+#define SEQUENCES 572 31207+#define SERIALIZABLE 573 31208+#define SERVER 574 31209+#define SESSION 575 31210+#define SESSION_USER 576 31211+#define SET 577 31212+#define SETOF 578 31213+#define SHARE 579 31214+#define SHOW 580 31215+#define SIMILAR 581 31216+#define SIMPLE 582 31217+#define SMALLINT 583 31218+#define SOME 584 31219+#define STABLE 585 31220+#define STANDALONE_P 586 31221+#define START 587 31222+#define STATEMENT 588 31223+#define STATISTICS 589 31224+#define STDIN 590 31225+#define STDOUT 591 31226+#define STORAGE 592 31227+#define STRICT_P 593 31228+#define STRIP_P 594 31229+#define SUBSTRING 595 31230+#define SUPERUSER_P 596 31231+#define SYMMETRIC 597 31232+#define SYSID 598 31233+#define SYSTEM_P 599 31234+#define TABLE 600 31235+#define TABLES 601 31236+#define TABLESPACE 602 31237+#define TEMP 603 31238+#define TEMPLATE 604 31239+#define TEMPORARY 605 31240+#define TEXT_P 606 31241+#define THEN 607 31242+#define TIME 608 31243+#define TIMESTAMP 609 31244+#define TO 610 31245+#define TRAILING 611 31246+#define TRANSACTION 612 31247+#define TREAT 613 31248+#define TRIGGER 614 31249+#define TRIM 615 31250+#define TRUE_P 616 31251+#define TRUNCATE 617 31252+#define TRUSTED 618 31253+#define TYPE_P 619 31254+#define UNBOUNDED 620 31255+#define UNCOMMITTED 621 31256+#define UNENCRYPTED 622 31257+#define UNION 623 31258+#define UNIQUE 624 31259+#define UNKNOWN 625 31260+#define UNLISTEN 626 31261+#define UNTIL 627 31262+#define UPDATE 628 31263+#define USER 629 31264+#define USING 630 31265+#define VACUUM 631 31266+#define VALID 632 31267+#define VALIDATOR 633 31268+#define VALUE_P 634 31269+#define VALUES 635 31270+#define VARCHAR 636 31271+#define VARIADIC 637 31272+#define VARYING 638 31273+#define VERBOSE 639 31274+#define VERSION_P 640 31275+#define VIEW 641 31276+#define VOLATILE 642 31277+#define WHEN 643 31278+#define WHERE 644 31279+#define WHITESPACE_P 645 31280+#define WINDOW 646 31281+#define WITH 647 31282+#define WITHOUT 648 31283+#define WORK 649 31284+#define WRAPPER 650 31285+#define WRITE 651 31286+#define XML_P 652 31287+#define XMLATTRIBUTES 653 31288+#define XMLCONCAT 654 31289+#define XMLELEMENT 655 31290+#define XMLFOREST 656 31291+#define XMLPARSE 657 31292+#define XMLPI 658 31293+#define XMLROOT 659 31294+#define XMLSERIALIZE 660 31295+#define YEAR_P 661 31296+#define YES_P 662 31297+#define ZONE 663 31298+#define NULLS_FIRST 664 31299+#define NULLS_LAST 665 31300+#define WITH_TIME 666 31301+#define POSTFIXOP 667 31302+#define UMINUS 668 31303 31304 31305 31306-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 31307-typedef union YYSTYPE 31308+ 31309+/* Copy the first part of user declarations. */ 31310+#line 1 "gram.y" 31311+ 31312+ 31313+/*#define YYDEBUG 1*/ 31314+/*------------------------------------------------------------------------- 31315+ * 31316+ * gram.y 31317+ * POSTGRESQL BISON rules/actions 31318+ * 31319+ * Portions Copyright (c) 1996-2010, PostgreSQL Global Development Group 31320+ * Portions Copyright (c) 1994, Regents of the University of California 31321+ * 31322+ * 31323+ * IDENTIFICATION 31324+ * $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.713.2.1 2010/08/18 18:35:30 tgl Exp $ 31325+ * 31326+ * HISTORY 31327+ * AUTHOR DATE MAJOR EVENT 31328+ * Andrew Yu Sept, 1994 POSTQUEL to SQL conversion 31329+ * Andrew Yu Oct, 1994 lispy code conversion 31330+ * 31331+ * NOTES 31332+ * CAPITALS are used to represent terminal symbols. 31333+ * non-capitals are used to represent non-terminals. 31334+ * SQL92-specific syntax is separated from plain SQL/Postgres syntax 31335+ * to help isolate the non-extensible portions of the parser. 31336+ * 31337+ * In general, nothing in this file should initiate database accesses 31338+ * nor depend on changeable state (such as SET variables). If you do 31339+ * database accesses, your code will fail when we have aborted the 31340+ * current transaction and are just parsing commands to find the next 31341+ * ROLLBACK or COMMIT. If you make use of SET variables, then you 31342+ * will do the wrong thing in multi-query strings like this: 31343+ * SET SQL_inheritance TO off; SELECT * FROM foo; 31344+ * because the entire string is parsed by gram.y before the SET gets 31345+ * executed. Anything that depends on the database or changeable state 31346+ * should be handled during parse analysis so that it happens at the 31347+ * right time not the wrong time. The handling of SQL_inheritance is 31348+ * a good example. 31349+ * 31350+ * WARNINGS 31351+ * If you use a list, make sure the datum is a node so that the printing 31352+ * routines work. 31353+ * 31354+ * Sometimes we assign constants to makeStrings. Make sure we don't free 31355+ * those. 31356+ * 31357+ *------------------------------------------------------------------------- 31358+ */ 31359+#include "postgres.h" 31360+ 31361+#include <ctype.h> 31362+#include <limits.h> 31363+ 31364+#include "catalog/index.h" 31365+#include "catalog/namespace.h" 31366+#include "catalog/pg_trigger.h" 31367+#include "commands/defrem.h" 31368+#include "nodes/makefuncs.h" 31369+#include "nodes/nodeFuncs.h" 31370+#include "parser/gramparse.h" 31371+#include "parser/parser.h" 31372+#include "storage/lmgr.h" 31373+#include "utils/date.h" 31374+#include "utils/datetime.h" 31375+#include "utils/numeric.h" 31376+#include "utils/xml.h" 31377+ 31378+ 31379+/* Location tracking support --- simpler than bison's default */ 31380+#define YYLLOC_DEFAULT(Current, Rhs, N) \ 31381+ do { \ 31382+ if (N) \ 31383+ (Current) = (Rhs)[1]; \ 31384+ else \ 31385+ (Current) = (Rhs)[0]; \ 31386+ } while (0) 31387+ 31388+/* 31389+ * Bison doesn't allocate anything that needs to live across parser calls, 31390+ * so we can easily have it use palloc instead of malloc. This prevents 31391+ * memory leaks if we error out during parsing. Note this only works with 31392+ * bison >= 2.0. However, in bison 1.875 the default is to use alloca() 31393+ * if possible, so there's not really much problem anyhow, at least if 31394+ * you're building with gcc. 31395+ */ 31396+#define YYMALLOC palloc 31397+#define YYFREE pfree 31398+ 31399+/* Private struct for the result of privilege_target production */ 31400+typedef struct PrivTarget 31401 { 31402+ GrantTargetType targtype; 31403+ GrantObjectType objtype; 31404+ List *objs; 31405+} PrivTarget; 31406 31407-/* Line 214 of yacc.c */ 31408-#line 146 "gram.y" 31409 31410+#define parser_yyerror(msg) scanner_yyerror(msg, yyscanner) 31411+#define parser_errposition(pos) scanner_errposition(pos, yyscanner) 31412+ 31413+static void base_yyerror(YYLTYPE *yylloc, core_yyscan_t yyscanner, 31414+ const char *msg); 31415+static Node *makeColumnRef(char *colname, List *indirection, 31416+ int location, core_yyscan_t yyscanner); 31417+static Node *makeTypeCast(Node *arg, TypeName *typename, int location); 31418+static Node *makeStringConst(char *str, int location); 31419+static Node *makeStringConstCast(char *str, int location, TypeName *typename); 31420+static Node *makeIntConst(int val, int location); 31421+static Node *makeFloatConst(char *str, int location); 31422+static Node *makeBitStringConst(char *str, int location); 31423+static Node *makeNullAConst(int location); 31424+static Node *makeAConst(Value *v, int location); 31425+static Node *makeBoolAConst(bool state, int location); 31426+static FuncCall *makeOverlaps(List *largs, List *rargs, 31427+ int location, core_yyscan_t yyscanner); 31428+static void check_qualified_name(List *names, core_yyscan_t yyscanner); 31429+static List *check_func_name(List *names, core_yyscan_t yyscanner); 31430+static List *check_indirection(List *indirection, core_yyscan_t yyscanner); 31431+static List *extractArgTypes(List *parameters); 31432+static SelectStmt *findLeftmostSelect(SelectStmt *node); 31433+static void insertSelectOptions(SelectStmt *stmt, 31434+ List *sortClause, List *lockingClause, 31435+ Node *limitOffset, Node *limitCount, 31436+ WithClause *withClause, 31437+ core_yyscan_t yyscanner); 31438+static Node *makeSetOp(SetOperation op, bool all, Node *larg, Node *rarg); 31439+static Node *doNegate(Node *n, int location); 31440+static void doNegateFloat(Value *v); 31441+static Node *makeAArrayExpr(List *elements, int location); 31442+static Node *makeXmlExpr(XmlExprOp op, char *name, List *named_args, 31443+ List *args, int location); 31444+static List *mergeTableFuncParameters(List *func_args, List *columns); 31445+static TypeName *TableFuncTypeName(List *columns); 31446+ 31447+ 31448+ 31449+/* Enabling traces. */ 31450+#ifndef YYDEBUG 31451+# define YYDEBUG 0 31452+#endif 31453+ 31454+/* Enabling verbose error messages. */ 31455+#ifdef YYERROR_VERBOSE 31456+# undef YYERROR_VERBOSE 31457+# define YYERROR_VERBOSE 1 31458+#else 31459+# define YYERROR_VERBOSE 0 31460+#endif 31461+ 31462+/* Enabling the token table. */ 31463+#ifndef YYTOKEN_TABLE 31464+# define YYTOKEN_TABLE 0 31465+#endif 31466+ 31467+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 31468+typedef union YYSTYPE 31469+#line 146 "gram.y" 31470+{ 31471 core_YYSTYPE core_yystype; 31472 /* these fields must match core_YYSTYPE: */ 31473 int ival; 31474@@ -698,15 +1097,13 @@ 31475 AccessPriv *accesspriv; 31476 InsertStmt *istmt; 31477 VariableSetStmt *vsetstmt; 31478- 31479- 31480- 31481-/* Line 214 of yacc.c */ 31482-#line 706 "gram.c" 31483-} YYSTYPE; 31484-# define YYSTYPE_IS_TRIVIAL 1 31485+} 31486+/* Line 193 of yacc.c. */ 31487+#line 1103 "gram" 31488+ YYSTYPE; 31489 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 31490 # define YYSTYPE_IS_DECLARED 1 31491+# define YYSTYPE_IS_TRIVIAL 1 31492 #endif 31493 31494 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED 31495@@ -726,8 +1123,8 @@ 31496 /* Copy the second part of user declarations. */ 31497 31498 31499-/* Line 264 of yacc.c */ 31500-#line 731 "gram.c" 31501+/* Line 216 of yacc.c. */ 31502+#line 1128 "gram" 31503 31504 #ifdef short 31505 # undef short 31506@@ -777,7 +1174,7 @@ 31507 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 31508 31509 #ifndef YY_ 31510-# if YYENABLE_NLS 31511+# if defined YYENABLE_NLS && YYENABLE_NLS 31512 # if ENABLE_NLS 31513 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 31514 # define YY_(msgid) dgettext ("bison-runtime", msgid) 31515@@ -802,14 +1199,14 @@ 31516 #if (defined __STDC__ || defined __C99__FUNC__ \ 31517 || defined __cplusplus || defined _MSC_VER) 31518 static int 31519-YYID (int yyi) 31520+YYID (int i) 31521 #else 31522 static int 31523-YYID (yyi) 31524- int yyi; 31525+YYID (i) 31526+ int i; 31527 #endif 31528 { 31529- return yyi; 31530+ return i; 31531 } 31532 #endif 31533 31534@@ -891,9 +1288,9 @@ 31535 /* A type that is properly aligned for any stack member. */ 31536 union yyalloc 31537 { 31538- yytype_int16 yyss_alloc; 31539- YYSTYPE yyvs_alloc; 31540- YYLTYPE yyls_alloc; 31541+ yytype_int16 yyss; 31542+ YYSTYPE yyvs; 31543+ YYLTYPE yyls; 31544 }; 31545 31546 /* The size of the maximum gap between one aligned stack and the next. */ 31547@@ -928,12 +1325,12 @@ 31548 elements in the stack, and YYPTR gives the new location of the 31549 stack. Advance YYPTR to a properly aligned location for the next 31550 stack. */ 31551-# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 31552+# define YYSTACK_RELOCATE(Stack) \ 31553 do \ 31554 { \ 31555 YYSIZE_T yynewbytes; \ 31556- YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 31557- Stack = &yyptr->Stack_alloc; \ 31558+ YYCOPY (&yyptr->Stack, Stack, yysize); \ 31559+ Stack = &yyptr->Stack; \ 31560 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 31561 yyptr += yynewbytes / sizeof (*yyptr); \ 31562 } \ 31563@@ -16994,7 +17391,7 @@ 31564 we won't break user code: when these are the locations we know. */ 31565 31566 #ifndef YY_LOCATION_PRINT 31567-# if YYLTYPE_IS_TRIVIAL 31568+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 31569 # define YY_LOCATION_PRINT(File, Loc) \ 31570 fprintf (File, "%d.%d-%d.%d", \ 31571 (Loc).first_line, (Loc).first_column, \ 31572@@ -17113,20 +17510,17 @@ 31573 #if (defined __STDC__ || defined __C99__FUNC__ \ 31574 || defined __cplusplus || defined _MSC_VER) 31575 static void 31576-yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 31577+yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) 31578 #else 31579 static void 31580-yy_stack_print (yybottom, yytop) 31581- yytype_int16 *yybottom; 31582- yytype_int16 *yytop; 31583+yy_stack_print (bottom, top) 31584+ yytype_int16 *bottom; 31585+ yytype_int16 *top; 31586 #endif 31587 { 31588 YYFPRINTF (stderr, "Stack now"); 31589- for (; yybottom <= yytop; yybottom++) 31590- { 31591- int yybot = *yybottom; 31592- YYFPRINTF (stderr, " %d", yybot); 31593- } 31594+ for (; bottom <= top; ++bottom) 31595+ YYFPRINTF (stderr, " %d", *bottom); 31596 YYFPRINTF (stderr, "\n"); 31597 } 31598 31599@@ -17162,11 +17556,11 @@ 31600 /* The symbols being reduced. */ 31601 for (yyi = 0; yyi < yynrhs; yyi++) 31602 { 31603- YYFPRINTF (stderr, " $%d = ", yyi + 1); 31604+ fprintf (stderr, " $%d = ", yyi + 1); 31605 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 31606 &(yyvsp[(yyi + 1) - (yynrhs)]) 31607 , &(yylsp[(yyi + 1) - (yynrhs)]) , yyscanner); 31608- YYFPRINTF (stderr, "\n"); 31609+ fprintf (stderr, "\n"); 31610 } 31611 } 31612 31613@@ -17450,8 +17844,10 @@ 31614 break; 31615 } 31616 } 31617+ 31618 31619 /* Prevent warnings from -Wmissing-prototypes. */ 31620+ 31621 #ifdef YYPARSE_PARAM 31622 #if defined __STDC__ || defined __cplusplus 31623 int yyparse (void *YYPARSE_PARAM); 31624@@ -17470,9 +17866,10 @@ 31625 31626 31627 31628-/*-------------------------. 31629-| yyparse or yypush_parse. | 31630-`-------------------------*/ 31631+ 31632+/*----------. 31633+| yyparse. | 31634+`----------*/ 31635 31636 #ifdef YYPARSE_PARAM 31637 #if (defined __STDC__ || defined __C99__FUNC__ \ 31638@@ -17496,59 +17893,24 @@ 31639 #endif 31640 #endif 31641 { 31642-/* The lookahead symbol. */ 31643+ /* The look-ahead symbol. */ 31644 int yychar; 31645 31646-/* The semantic value of the lookahead symbol. */ 31647+/* The semantic value of the look-ahead symbol. */ 31648 YYSTYPE yylval; 31649 31650-/* Location data for the lookahead symbol. */ 31651+/* Number of syntax errors so far. */ 31652+int yynerrs; 31653+/* Location data for the look-ahead symbol. */ 31654 YYLTYPE yylloc; 31655 31656- /* Number of syntax errors so far. */ 31657- int yynerrs; 31658- 31659- int yystate; 31660- /* Number of tokens to shift before error messages enabled. */ 31661- int yyerrstatus; 31662- 31663- /* The stacks and their tools: 31664- `yyss': related to states. 31665- `yyvs': related to semantic values. 31666- `yyls': related to locations. 31667- 31668- Refer to the stacks thru separate pointers, to allow yyoverflow 31669- to reallocate them elsewhere. */ 31670- 31671- /* The state stack. */ 31672- yytype_int16 yyssa[YYINITDEPTH]; 31673- yytype_int16 *yyss; 31674- yytype_int16 *yyssp; 31675- 31676- /* The semantic value stack. */ 31677- YYSTYPE yyvsa[YYINITDEPTH]; 31678- YYSTYPE *yyvs; 31679- YYSTYPE *yyvsp; 31680- 31681- /* The location stack. */ 31682- YYLTYPE yylsa[YYINITDEPTH]; 31683- YYLTYPE *yyls; 31684- YYLTYPE *yylsp; 31685- 31686- /* The locations where the error started and ended. */ 31687- YYLTYPE yyerror_range[2]; 31688- 31689- YYSIZE_T yystacksize; 31690- 31691+ int yystate; 31692 int yyn; 31693 int yyresult; 31694- /* Lookahead token as an internal (translated) token number. */ 31695- int yytoken; 31696- /* The variables used to return semantic value and location from the 31697- action routines. */ 31698- YYSTYPE yyval; 31699- YYLTYPE yyloc; 31700- 31701+ /* Number of tokens to shift before error messages enabled. */ 31702+ int yyerrstatus; 31703+ /* Look-ahead token as an internal (translated) token number. */ 31704+ int yytoken = 0; 31705 #if YYERROR_VERBOSE 31706 /* Buffer for error messages, and its allocated size. */ 31707 char yymsgbuf[128]; 31708@@ -17556,37 +17918,63 @@ 31709 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 31710 #endif 31711 31712+ /* Three stacks and their tools: 31713+ `yyss': related to states, 31714+ `yyvs': related to semantic values, 31715+ `yyls': related to locations. 31716+ 31717+ Refer to the stacks thru separate pointers, to allow yyoverflow 31718+ to reallocate them elsewhere. */ 31719+ 31720+ /* The state stack. */ 31721+ yytype_int16 yyssa[YYINITDEPTH]; 31722+ yytype_int16 *yyss = yyssa; 31723+ yytype_int16 *yyssp; 31724+ 31725+ /* The semantic value stack. */ 31726+ YYSTYPE yyvsa[YYINITDEPTH]; 31727+ YYSTYPE *yyvs = yyvsa; 31728+ YYSTYPE *yyvsp; 31729+ 31730+ /* The location stack. */ 31731+ YYLTYPE yylsa[YYINITDEPTH]; 31732+ YYLTYPE *yyls = yylsa; 31733+ YYLTYPE *yylsp; 31734+ /* The locations where the error started and ended. */ 31735+ YYLTYPE yyerror_range[2]; 31736+ 31737 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) 31738 31739+ YYSIZE_T yystacksize = YYINITDEPTH; 31740+ 31741+ /* The variables used to return semantic value and location from the 31742+ action routines. */ 31743+ YYSTYPE yyval; 31744+ YYLTYPE yyloc; 31745+ 31746 /* The number of symbols on the RHS of the reduced rule. 31747 Keep to zero when no symbol should be popped. */ 31748 int yylen = 0; 31749 31750- yytoken = 0; 31751- yyss = yyssa; 31752- yyvs = yyvsa; 31753- yyls = yylsa; 31754- yystacksize = YYINITDEPTH; 31755- 31756 YYDPRINTF ((stderr, "Starting parse\n")); 31757 31758 yystate = 0; 31759 yyerrstatus = 0; 31760 yynerrs = 0; 31761- yychar = YYEMPTY; /* Cause a token to be read. */ 31762+ yychar = YYEMPTY; /* Cause a token to be read. */ 31763 31764 /* Initialize stack pointers. 31765 Waste one element of value and location stack 31766 so that they stay on the same level as the state stack. 31767 The wasted elements are never initialized. */ 31768+ 31769 yyssp = yyss; 31770 yyvsp = yyvs; 31771 yylsp = yyls; 31772- 31773-#if YYLTYPE_IS_TRIVIAL 31774+#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 31775 /* Initialize the default location before parsing starts. */ 31776 yylloc.first_line = yylloc.last_line = 1; 31777- yylloc.first_column = yylloc.last_column = 1; 31778+ yylloc.first_column = yylloc.last_column = 0; 31779 #endif 31780 31781 goto yysetstate; 31782@@ -17625,7 +18013,6 @@ 31783 &yyvs1, yysize * sizeof (*yyvsp), 31784 &yyls1, yysize * sizeof (*yylsp), 31785 &yystacksize); 31786- 31787 yyls = yyls1; 31788 yyss = yyss1; 31789 yyvs = yyvs1; 31790@@ -17647,9 +18034,9 @@ 31791 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 31792 if (! yyptr) 31793 goto yyexhaustedlab; 31794- YYSTACK_RELOCATE (yyss_alloc, yyss); 31795- YYSTACK_RELOCATE (yyvs_alloc, yyvs); 31796- YYSTACK_RELOCATE (yyls_alloc, yyls); 31797+ YYSTACK_RELOCATE (yyss); 31798+ YYSTACK_RELOCATE (yyvs); 31799+ YYSTACK_RELOCATE (yyls); 31800 # undef YYSTACK_RELOCATE 31801 if (yyss1 != yyssa) 31802 YYSTACK_FREE (yyss1); 31803@@ -17670,9 +18057,6 @@ 31804 31805 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 31806 31807- if (yystate == YYFINAL) 31808- YYACCEPT; 31809- 31810 goto yybackup; 31811 31812 /*-----------. 31813@@ -17681,16 +18065,16 @@ 31814 yybackup: 31815 31816 /* Do appropriate processing given the current state. Read a 31817- lookahead token if we need one and don't already have one. */ 31818+ look-ahead token if we need one and don't already have one. */ 31819 31820- /* First try to decide what to do without reference to lookahead token. */ 31821+ /* First try to decide what to do without reference to look-ahead token. */ 31822 yyn = yypact[yystate]; 31823 if (yyn == YYPACT_NINF) 31824 goto yydefault; 31825 31826- /* Not known => get a lookahead token if don't already have one. */ 31827+ /* Not known => get a look-ahead token if don't already have one. */ 31828 31829- /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 31830+ /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 31831 if (yychar == YYEMPTY) 31832 { 31833 YYDPRINTF ((stderr, "Reading a token: ")); 31834@@ -17722,16 +18106,20 @@ 31835 goto yyreduce; 31836 } 31837 31838+ if (yyn == YYFINAL) 31839+ YYACCEPT; 31840+ 31841 /* Count tokens shifted since error; after three, turn off error 31842 status. */ 31843 if (yyerrstatus) 31844 yyerrstatus--; 31845 31846- /* Shift the lookahead token. */ 31847+ /* Shift the look-ahead token. */ 31848 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 31849 31850- /* Discard the shifted token. */ 31851- yychar = YYEMPTY; 31852+ /* Discard the shifted token unless it is eof. */ 31853+ if (yychar != YYEOF) 31854+ yychar = YYEMPTY; 31855 31856 yystate = yyn; 31857 *++yyvsp = yylval; 31858@@ -17772,8 +18160,6 @@ 31859 switch (yyn) 31860 { 31861 case 2: 31862- 31863-/* Line 1455 of yacc.c */ 31864 #line 624 "gram.y" 31865 { 31866 pg_yyget_extra(yyscanner)->parsetree = (yyvsp[(1) - (1)].list); 31867@@ -17781,8 +18167,6 @@ 31868 break; 31869 31870 case 3: 31871- 31872-/* Line 1455 of yacc.c */ 31873 #line 631 "gram.y" 31874 { 31875 if ((yyvsp[(3) - (3)].node) != NULL) 31876@@ -17793,8 +18177,6 @@ 31877 break; 31878 31879 case 4: 31880- 31881-/* Line 1455 of yacc.c */ 31882 #line 638 "gram.y" 31883 { 31884 if ((yyvsp[(1) - (1)].node) != NULL) 31885@@ -17805,15 +18187,11 @@ 31886 break; 31887 31888 case 107: 31889- 31890-/* Line 1455 of yacc.c */ 31891 #line 750 "gram.y" 31892 { (yyval.node) = NULL; ;} 31893 break; 31894 31895 case 108: 31896- 31897-/* Line 1455 of yacc.c */ 31898 #line 761 "gram.y" 31899 { 31900 CreateRoleStmt *n = makeNode(CreateRoleStmt); 31901@@ -17825,50 +18203,36 @@ 31902 break; 31903 31904 case 109: 31905- 31906-/* Line 1455 of yacc.c */ 31907 #line 771 "gram.y" 31908 {;} 31909 break; 31910 31911 case 110: 31912- 31913-/* Line 1455 of yacc.c */ 31914 #line 772 "gram.y" 31915 {;} 31916 break; 31917 31918 case 111: 31919- 31920-/* Line 1455 of yacc.c */ 31921 #line 781 "gram.y" 31922 { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} 31923 break; 31924 31925 case 112: 31926- 31927-/* Line 1455 of yacc.c */ 31928 #line 782 "gram.y" 31929 { (yyval.list) = NIL; ;} 31930 break; 31931 31932 case 113: 31933- 31934-/* Line 1455 of yacc.c */ 31935 #line 786 "gram.y" 31936 { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} 31937 break; 31938 31939 case 114: 31940- 31941-/* Line 1455 of yacc.c */ 31942 #line 787 "gram.y" 31943 { (yyval.list) = NIL; ;} 31944 break; 31945 31946 case 115: 31947- 31948-/* Line 1455 of yacc.c */ 31949 #line 792 "gram.y" 31950 { 31951 (yyval.defelt) = makeDefElem("password", 31952@@ -17877,8 +18241,6 @@ 31953 break; 31954 31955 case 116: 31956- 31957-/* Line 1455 of yacc.c */ 31958 #line 797 "gram.y" 31959 { 31960 (yyval.defelt) = makeDefElem("password", NULL); 31961@@ -17886,8 +18248,6 @@ 31962 break; 31963 31964 case 117: 31965- 31966-/* Line 1455 of yacc.c */ 31967 #line 801 "gram.y" 31968 { 31969 (yyval.defelt) = makeDefElem("encryptedPassword", 31970@@ -17896,8 +18256,6 @@ 31971 break; 31972 31973 case 118: 31974- 31975-/* Line 1455 of yacc.c */ 31976 #line 806 "gram.y" 31977 { 31978 (yyval.defelt) = makeDefElem("unencryptedPassword", 31979@@ -17906,8 +18264,6 @@ 31980 break; 31981 31982 case 119: 31983- 31984-/* Line 1455 of yacc.c */ 31985 #line 811 "gram.y" 31986 { 31987 (yyval.defelt) = makeDefElem("superuser", (Node *)makeInteger(TRUE)); 31988@@ -17915,8 +18271,6 @@ 31989 break; 31990 31991 case 120: 31992- 31993-/* Line 1455 of yacc.c */ 31994 #line 815 "gram.y" 31995 { 31996 (yyval.defelt) = makeDefElem("superuser", (Node *)makeInteger(FALSE)); 31997@@ -17924,8 +18278,6 @@ 31998 break; 31999 32000 case 121: 32001- 32002-/* Line 1455 of yacc.c */ 32003 #line 819 "gram.y" 32004 { 32005 (yyval.defelt) = makeDefElem("inherit", (Node *)makeInteger(TRUE)); 32006@@ -17933,8 +18285,6 @@ 32007 break; 32008 32009 case 122: 32010- 32011-/* Line 1455 of yacc.c */ 32012 #line 823 "gram.y" 32013 { 32014 (yyval.defelt) = makeDefElem("inherit", (Node *)makeInteger(FALSE)); 32015@@ -17942,8 +18292,6 @@ 32016 break; 32017 32018 case 123: 32019- 32020-/* Line 1455 of yacc.c */ 32021 #line 827 "gram.y" 32022 { 32023 (yyval.defelt) = makeDefElem("createdb", (Node *)makeInteger(TRUE)); 32024@@ -17951,8 +18299,6 @@ 32025 break; 32026 32027 case 124: 32028- 32029-/* Line 1455 of yacc.c */ 32030 #line 831 "gram.y" 32031 { 32032 (yyval.defelt) = makeDefElem("createdb", (Node *)makeInteger(FALSE)); 32033@@ -17960,8 +18306,6 @@ 32034 break; 32035 32036 case 125: 32037- 32038-/* Line 1455 of yacc.c */ 32039 #line 835 "gram.y" 32040 { 32041 (yyval.defelt) = makeDefElem("createrole", (Node *)makeInteger(TRUE)); 32042@@ -17969,8 +18313,6 @@ 32043 break; 32044 32045 case 126: 32046- 32047-/* Line 1455 of yacc.c */ 32048 #line 839 "gram.y" 32049 { 32050 (yyval.defelt) = makeDefElem("createrole", (Node *)makeInteger(FALSE)); 32051@@ -17978,8 +18320,6 @@ 32052 break; 32053 32054 case 127: 32055- 32056-/* Line 1455 of yacc.c */ 32057 #line 843 "gram.y" 32058 { 32059 /* For backwards compatibility, synonym for SUPERUSER */ 32060@@ -17988,8 +18328,6 @@ 32061 break; 32062 32063 case 128: 32064- 32065-/* Line 1455 of yacc.c */ 32066 #line 848 "gram.y" 32067 { 32068 (yyval.defelt) = makeDefElem("superuser", (Node *)makeInteger(FALSE)); 32069@@ -17997,8 +18335,6 @@ 32070 break; 32071 32072 case 129: 32073- 32074-/* Line 1455 of yacc.c */ 32075 #line 852 "gram.y" 32076 { 32077 (yyval.defelt) = makeDefElem("canlogin", (Node *)makeInteger(TRUE)); 32078@@ -18006,8 +18342,6 @@ 32079 break; 32080 32081 case 130: 32082- 32083-/* Line 1455 of yacc.c */ 32084 #line 856 "gram.y" 32085 { 32086 (yyval.defelt) = makeDefElem("canlogin", (Node *)makeInteger(FALSE)); 32087@@ -18015,8 +18349,6 @@ 32088 break; 32089 32090 case 131: 32091- 32092-/* Line 1455 of yacc.c */ 32093 #line 860 "gram.y" 32094 { 32095 (yyval.defelt) = makeDefElem("connectionlimit", (Node *)makeInteger((yyvsp[(3) - (3)].ival))); 32096@@ -18024,8 +18356,6 @@ 32097 break; 32098 32099 case 132: 32100- 32101-/* Line 1455 of yacc.c */ 32102 #line 864 "gram.y" 32103 { 32104 (yyval.defelt) = makeDefElem("validUntil", (Node *)makeString((yyvsp[(3) - (3)].str))); 32105@@ -18033,8 +18363,6 @@ 32106 break; 32107 32108 case 133: 32109- 32110-/* Line 1455 of yacc.c */ 32111 #line 869 "gram.y" 32112 { 32113 (yyval.defelt) = makeDefElem("rolemembers", (Node *)(yyvsp[(2) - (2)].list)); 32114@@ -18042,15 +18370,11 @@ 32115 break; 32116 32117 case 134: 32118- 32119-/* Line 1455 of yacc.c */ 32120 #line 875 "gram.y" 32121 { (yyval.defelt) = (yyvsp[(1) - (1)].defelt); ;} 32122 break; 32123 32124 case 135: 32125- 32126-/* Line 1455 of yacc.c */ 32127 #line 878 "gram.y" 32128 { 32129 (yyval.defelt) = makeDefElem("sysid", (Node *)makeInteger((yyvsp[(2) - (2)].ival))); 32130@@ -18058,8 +18382,6 @@ 32131 break; 32132 32133 case 136: 32134- 32135-/* Line 1455 of yacc.c */ 32136 #line 882 "gram.y" 32137 { 32138 (yyval.defelt) = makeDefElem("adminmembers", (Node *)(yyvsp[(2) - (2)].list)); 32139@@ -18067,8 +18389,6 @@ 32140 break; 32141 32142 case 137: 32143- 32144-/* Line 1455 of yacc.c */ 32145 #line 886 "gram.y" 32146 { 32147 (yyval.defelt) = makeDefElem("rolemembers", (Node *)(yyvsp[(2) - (2)].list)); 32148@@ -18076,8 +18396,6 @@ 32149 break; 32150 32151 case 138: 32152- 32153-/* Line 1455 of yacc.c */ 32154 #line 890 "gram.y" 32155 { 32156 (yyval.defelt) = makeDefElem("addroleto", (Node *)(yyvsp[(3) - (3)].list)); 32157@@ -18085,8 +18403,6 @@ 32158 break; 32159 32160 case 139: 32161- 32162-/* Line 1455 of yacc.c */ 32163 #line 894 "gram.y" 32164 { 32165 (yyval.defelt) = makeDefElem("addroleto", (Node *)(yyvsp[(3) - (3)].list)); 32166@@ -18094,8 +18410,6 @@ 32167 break; 32168 32169 case 140: 32170- 32171-/* Line 1455 of yacc.c */ 32172 #line 908 "gram.y" 32173 { 32174 CreateRoleStmt *n = makeNode(CreateRoleStmt); 32175@@ -18107,8 +18421,6 @@ 32176 break; 32177 32178 case 141: 32179- 32180-/* Line 1455 of yacc.c */ 32181 #line 926 "gram.y" 32182 { 32183 AlterRoleStmt *n = makeNode(AlterRoleStmt); 32184@@ -18120,22 +18432,16 @@ 32185 break; 32186 32187 case 142: 32188- 32189-/* Line 1455 of yacc.c */ 32190 #line 936 "gram.y" 32191 { (yyval.str) = NULL; ;} 32192 break; 32193 32194 case 143: 32195- 32196-/* Line 1455 of yacc.c */ 32197 #line 937 "gram.y" 32198 { (yyval.str) = (yyvsp[(3) - (3)].str); ;} 32199 break; 32200 32201 case 144: 32202- 32203-/* Line 1455 of yacc.c */ 32204 #line 942 "gram.y" 32205 { 32206 AlterRoleSetStmt *n = makeNode(AlterRoleSetStmt); 32207@@ -18147,8 +18453,6 @@ 32208 break; 32209 32210 case 145: 32211- 32212-/* Line 1455 of yacc.c */ 32213 #line 960 "gram.y" 32214 { 32215 AlterRoleStmt *n = makeNode(AlterRoleStmt); 32216@@ -18160,8 +18464,6 @@ 32217 break; 32218 32219 case 146: 32220- 32221-/* Line 1455 of yacc.c */ 32222 #line 972 "gram.y" 32223 { 32224 AlterRoleSetStmt *n = makeNode(AlterRoleSetStmt); 32225@@ -18173,8 +18475,6 @@ 32226 break; 32227 32228 case 147: 32229- 32230-/* Line 1455 of yacc.c */ 32231 #line 993 "gram.y" 32232 { 32233 DropRoleStmt *n = makeNode(DropRoleStmt); 32234@@ -18185,8 +18485,6 @@ 32235 break; 32236 32237 case 148: 32238- 32239-/* Line 1455 of yacc.c */ 32240 #line 1000 "gram.y" 32241 { 32242 DropRoleStmt *n = makeNode(DropRoleStmt); 32243@@ -18197,8 +18495,6 @@ 32244 break; 32245 32246 case 149: 32247- 32248-/* Line 1455 of yacc.c */ 32249 #line 1019 "gram.y" 32250 { 32251 DropRoleStmt *n = makeNode(DropRoleStmt); 32252@@ -18209,8 +18505,6 @@ 32253 break; 32254 32255 case 150: 32256- 32257-/* Line 1455 of yacc.c */ 32258 #line 1026 "gram.y" 32259 { 32260 DropRoleStmt *n = makeNode(DropRoleStmt); 32261@@ -18221,8 +18515,6 @@ 32262 break; 32263 32264 case 151: 32265- 32266-/* Line 1455 of yacc.c */ 32267 #line 1043 "gram.y" 32268 { 32269 CreateRoleStmt *n = makeNode(CreateRoleStmt); 32270@@ -18234,8 +18526,6 @@ 32271 break; 32272 32273 case 152: 32274- 32275-/* Line 1455 of yacc.c */ 32276 #line 1061 "gram.y" 32277 { 32278 AlterRoleStmt *n = makeNode(AlterRoleStmt); 32279@@ -18248,22 +18538,16 @@ 32280 break; 32281 32282 case 153: 32283- 32284-/* Line 1455 of yacc.c */ 32285 #line 1071 "gram.y" 32286 { (yyval.ival) = +1; ;} 32287 break; 32288 32289 case 154: 32290- 32291-/* Line 1455 of yacc.c */ 32292 #line 1072 "gram.y" 32293 { (yyval.ival) = -1; ;} 32294 break; 32295 32296 case 155: 32297- 32298-/* Line 1455 of yacc.c */ 32299 #line 1085 "gram.y" 32300 { 32301 DropRoleStmt *n = makeNode(DropRoleStmt); 32302@@ -18274,8 +18558,6 @@ 32303 break; 32304 32305 case 156: 32306- 32307-/* Line 1455 of yacc.c */ 32308 #line 1092 "gram.y" 32309 { 32310 DropRoleStmt *n = makeNode(DropRoleStmt); 32311@@ -18286,8 +18568,6 @@ 32312 break; 32313 32314 case 157: 32315- 32316-/* Line 1455 of yacc.c */ 32317 #line 1109 "gram.y" 32318 { 32319 CreateSchemaStmt *n = makeNode(CreateSchemaStmt); 32320@@ -18303,8 +18583,6 @@ 32321 break; 32322 32323 case 158: 32324- 32325-/* Line 1455 of yacc.c */ 32326 #line 1121 "gram.y" 32327 { 32328 CreateSchemaStmt *n = makeNode(CreateSchemaStmt); 32329@@ -18317,36 +18595,26 @@ 32330 break; 32331 32332 case 159: 32333- 32334-/* Line 1455 of yacc.c */ 32335 #line 1132 "gram.y" 32336 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 32337 break; 32338 32339 case 160: 32340- 32341-/* Line 1455 of yacc.c */ 32342 #line 1133 "gram.y" 32343 { (yyval.str) = NULL; ;} 32344 break; 32345 32346 case 161: 32347- 32348-/* Line 1455 of yacc.c */ 32349 #line 1137 "gram.y" 32350 { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} 32351 break; 32352 32353 case 162: 32354- 32355-/* Line 1455 of yacc.c */ 32356 #line 1138 "gram.y" 32357 { (yyval.list) = NIL; ;} 32358 break; 32359 32360 case 169: 32361- 32362-/* Line 1455 of yacc.c */ 32363 #line 1166 "gram.y" 32364 { 32365 VariableSetStmt *n = (yyvsp[(2) - (2)].vsetstmt); 32366@@ -18356,8 +18624,6 @@ 32367 break; 32368 32369 case 170: 32370- 32371-/* Line 1455 of yacc.c */ 32372 #line 1172 "gram.y" 32373 { 32374 VariableSetStmt *n = (yyvsp[(3) - (3)].vsetstmt); 32375@@ -18367,8 +18633,6 @@ 32376 break; 32377 32378 case 171: 32379- 32380-/* Line 1455 of yacc.c */ 32381 #line 1178 "gram.y" 32382 { 32383 VariableSetStmt *n = (yyvsp[(3) - (3)].vsetstmt); 32384@@ -18378,8 +18642,6 @@ 32385 break; 32386 32387 case 172: 32388- 32389-/* Line 1455 of yacc.c */ 32390 #line 1187 "gram.y" 32391 { 32392 VariableSetStmt *n = makeNode(VariableSetStmt); 32393@@ -18391,8 +18653,6 @@ 32394 break; 32395 32396 case 173: 32397- 32398-/* Line 1455 of yacc.c */ 32399 #line 1195 "gram.y" 32400 { 32401 VariableSetStmt *n = makeNode(VariableSetStmt); 32402@@ -18404,8 +18664,6 @@ 32403 break; 32404 32405 case 174: 32406- 32407-/* Line 1455 of yacc.c */ 32408 #line 1203 "gram.y" 32409 { 32410 VariableSetStmt *n = makeNode(VariableSetStmt); 32411@@ -18416,8 +18674,6 @@ 32412 break; 32413 32414 case 175: 32415- 32416-/* Line 1455 of yacc.c */ 32417 #line 1210 "gram.y" 32418 { 32419 VariableSetStmt *n = makeNode(VariableSetStmt); 32420@@ -18428,8 +18684,6 @@ 32421 break; 32422 32423 case 176: 32424- 32425-/* Line 1455 of yacc.c */ 32426 #line 1217 "gram.y" 32427 { 32428 VariableSetStmt *n = makeNode(VariableSetStmt); 32429@@ -18440,8 +18694,6 @@ 32430 break; 32431 32432 case 177: 32433- 32434-/* Line 1455 of yacc.c */ 32435 #line 1225 "gram.y" 32436 { 32437 VariableSetStmt *n = makeNode(VariableSetStmt); 32438@@ -18456,8 +18708,6 @@ 32439 break; 32440 32441 case 178: 32442- 32443-/* Line 1455 of yacc.c */ 32444 #line 1236 "gram.y" 32445 { 32446 VariableSetStmt *n = makeNode(VariableSetStmt); 32447@@ -18469,8 +18719,6 @@ 32448 break; 32449 32450 case 179: 32451- 32452-/* Line 1455 of yacc.c */ 32453 #line 1244 "gram.y" 32454 { 32455 VariableSetStmt *n = makeNode(VariableSetStmt); 32456@@ -18482,8 +18730,6 @@ 32457 break; 32458 32459 case 180: 32460- 32461-/* Line 1455 of yacc.c */ 32462 #line 1252 "gram.y" 32463 { 32464 ereport(ERROR, 32465@@ -18495,8 +18741,6 @@ 32466 break; 32467 32468 case 181: 32469- 32470-/* Line 1455 of yacc.c */ 32471 #line 1260 "gram.y" 32472 { 32473 VariableSetStmt *n = makeNode(VariableSetStmt); 32474@@ -18508,8 +18752,6 @@ 32475 break; 32476 32477 case 182: 32478- 32479-/* Line 1455 of yacc.c */ 32480 #line 1268 "gram.y" 32481 { 32482 VariableSetStmt *n = makeNode(VariableSetStmt); 32483@@ -18524,8 +18766,6 @@ 32484 break; 32485 32486 case 183: 32487- 32488-/* Line 1455 of yacc.c */ 32489 #line 1279 "gram.y" 32490 { 32491 VariableSetStmt *n = makeNode(VariableSetStmt); 32492@@ -18537,8 +18777,6 @@ 32493 break; 32494 32495 case 184: 32496- 32497-/* Line 1455 of yacc.c */ 32498 #line 1287 "gram.y" 32499 { 32500 VariableSetStmt *n = makeNode(VariableSetStmt); 32501@@ -18550,8 +18788,6 @@ 32502 break; 32503 32504 case 185: 32505- 32506-/* Line 1455 of yacc.c */ 32507 #line 1295 "gram.y" 32508 { 32509 VariableSetStmt *n = makeNode(VariableSetStmt); 32510@@ -18562,8 +18798,6 @@ 32511 break; 32512 32513 case 186: 32514- 32515-/* Line 1455 of yacc.c */ 32516 #line 1302 "gram.y" 32517 { 32518 VariableSetStmt *n = makeNode(VariableSetStmt); 32519@@ -18575,15 +18809,11 @@ 32520 break; 32521 32522 case 187: 32523- 32524-/* Line 1455 of yacc.c */ 32525 #line 1311 "gram.y" 32526 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 32527 break; 32528 32529 case 188: 32530- 32531-/* Line 1455 of yacc.c */ 32532 #line 1313 "gram.y" 32533 { 32534 (yyval.str) = palloc(strlen((yyvsp[(1) - (3)].str)) + strlen((yyvsp[(3) - (3)].str)) + 2); 32535@@ -18592,92 +18822,66 @@ 32536 break; 32537 32538 case 189: 32539- 32540-/* Line 1455 of yacc.c */ 32541 #line 1319 "gram.y" 32542 { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} 32543 break; 32544 32545 case 190: 32546- 32547-/* Line 1455 of yacc.c */ 32548 #line 1320 "gram.y" 32549 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} 32550 break; 32551 32552 case 191: 32553- 32554-/* Line 1455 of yacc.c */ 32555 #line 1324 "gram.y" 32556 { (yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); ;} 32557 break; 32558 32559 case 192: 32560- 32561-/* Line 1455 of yacc.c */ 32562 #line 1326 "gram.y" 32563 { (yyval.node) = makeAConst((yyvsp[(1) - (1)].value), (yylsp[(1) - (1)])); ;} 32564 break; 32565 32566 case 193: 32567- 32568-/* Line 1455 of yacc.c */ 32569 #line 1329 "gram.y" 32570 { (yyval.str) = "read uncommitted"; ;} 32571 break; 32572 32573 case 194: 32574- 32575-/* Line 1455 of yacc.c */ 32576 #line 1330 "gram.y" 32577 { (yyval.str) = "read committed"; ;} 32578 break; 32579 32580 case 195: 32581- 32582-/* Line 1455 of yacc.c */ 32583 #line 1331 "gram.y" 32584 { (yyval.str) = "repeatable read"; ;} 32585 break; 32586 32587 case 196: 32588- 32589-/* Line 1455 of yacc.c */ 32590 #line 1332 "gram.y" 32591 { (yyval.str) = "serializable"; ;} 32592 break; 32593 32594 case 197: 32595- 32596-/* Line 1455 of yacc.c */ 32597 #line 1336 "gram.y" 32598 { (yyval.str) = "true"; ;} 32599 break; 32600 32601 case 198: 32602- 32603-/* Line 1455 of yacc.c */ 32604 #line 1337 "gram.y" 32605 { (yyval.str) = "false"; ;} 32606 break; 32607 32608 case 199: 32609- 32610-/* Line 1455 of yacc.c */ 32611 #line 1338 "gram.y" 32612 { (yyval.str) = "on"; ;} 32613 break; 32614 32615 case 200: 32616- 32617-/* Line 1455 of yacc.c */ 32618 #line 1344 "gram.y" 32619 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 32620 break; 32621 32622 case 201: 32623- 32624-/* Line 1455 of yacc.c */ 32625 #line 1357 "gram.y" 32626 { 32627 (yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); 32628@@ -18685,8 +18889,6 @@ 32629 break; 32630 32631 case 202: 32632- 32633-/* Line 1455 of yacc.c */ 32634 #line 1361 "gram.y" 32635 { 32636 (yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); 32637@@ -18694,8 +18896,6 @@ 32638 break; 32639 32640 case 203: 32641- 32642-/* Line 1455 of yacc.c */ 32643 #line 1365 "gram.y" 32644 { 32645 TypeName *t = (yyvsp[(1) - (3)].typnam); 32646@@ -18714,8 +18914,6 @@ 32647 break; 32648 32649 case 204: 32650- 32651-/* Line 1455 of yacc.c */ 32652 #line 1380 "gram.y" 32653 { 32654 TypeName *t = (yyvsp[(1) - (6)].typnam); 32655@@ -18742,64 +18940,46 @@ 32656 break; 32657 32658 case 205: 32659- 32660-/* Line 1455 of yacc.c */ 32661 #line 1402 "gram.y" 32662 { (yyval.node) = makeAConst((yyvsp[(1) - (1)].value), (yylsp[(1) - (1)])); ;} 32663 break; 32664 32665 case 206: 32666- 32667-/* Line 1455 of yacc.c */ 32668 #line 1403 "gram.y" 32669 { (yyval.node) = NULL; ;} 32670 break; 32671 32672 case 207: 32673- 32674-/* Line 1455 of yacc.c */ 32675 #line 1404 "gram.y" 32676 { (yyval.node) = NULL; ;} 32677 break; 32678 32679 case 208: 32680- 32681-/* Line 1455 of yacc.c */ 32682 #line 1408 "gram.y" 32683 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 32684 break; 32685 32686 case 209: 32687- 32688-/* Line 1455 of yacc.c */ 32689 #line 1409 "gram.y" 32690 { (yyval.str) = NULL; ;} 32691 break; 32692 32693 case 210: 32694- 32695-/* Line 1455 of yacc.c */ 32696 #line 1410 "gram.y" 32697 { (yyval.str) = NULL; ;} 32698 break; 32699 32700 case 211: 32701- 32702-/* Line 1455 of yacc.c */ 32703 #line 1414 "gram.y" 32704 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 32705 break; 32706 32707 case 212: 32708- 32709-/* Line 1455 of yacc.c */ 32710 #line 1415 "gram.y" 32711 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 32712 break; 32713 32714 case 213: 32715- 32716-/* Line 1455 of yacc.c */ 32717 #line 1420 "gram.y" 32718 { 32719 VariableSetStmt *n = makeNode(VariableSetStmt); 32720@@ -18810,8 +18990,6 @@ 32721 break; 32722 32723 case 214: 32724- 32725-/* Line 1455 of yacc.c */ 32726 #line 1427 "gram.y" 32727 { 32728 VariableSetStmt *n = makeNode(VariableSetStmt); 32729@@ -18822,8 +19000,6 @@ 32730 break; 32731 32732 case 215: 32733- 32734-/* Line 1455 of yacc.c */ 32735 #line 1434 "gram.y" 32736 { 32737 VariableSetStmt *n = makeNode(VariableSetStmt); 32738@@ -18834,8 +19010,6 @@ 32739 break; 32740 32741 case 216: 32742- 32743-/* Line 1455 of yacc.c */ 32744 #line 1441 "gram.y" 32745 { 32746 VariableSetStmt *n = makeNode(VariableSetStmt); 32747@@ -18846,8 +19020,6 @@ 32748 break; 32749 32750 case 217: 32751- 32752-/* Line 1455 of yacc.c */ 32753 #line 1448 "gram.y" 32754 { 32755 VariableSetStmt *n = makeNode(VariableSetStmt); 32756@@ -18857,22 +19029,16 @@ 32757 break; 32758 32759 case 218: 32760- 32761-/* Line 1455 of yacc.c */ 32762 #line 1457 "gram.y" 32763 { (yyval.vsetstmt) = (yyvsp[(2) - (2)].vsetstmt); ;} 32764 break; 32765 32766 case 219: 32767- 32768-/* Line 1455 of yacc.c */ 32769 #line 1458 "gram.y" 32770 { (yyval.vsetstmt) = (VariableSetStmt *) (yyvsp[(1) - (1)].node); ;} 32771 break; 32772 32773 case 220: 32774- 32775-/* Line 1455 of yacc.c */ 32776 #line 1464 "gram.y" 32777 { 32778 VariableShowStmt *n = makeNode(VariableShowStmt); 32779@@ -18882,8 +19048,6 @@ 32780 break; 32781 32782 case 221: 32783- 32784-/* Line 1455 of yacc.c */ 32785 #line 1470 "gram.y" 32786 { 32787 VariableShowStmt *n = makeNode(VariableShowStmt); 32788@@ -18893,8 +19057,6 @@ 32789 break; 32790 32791 case 222: 32792- 32793-/* Line 1455 of yacc.c */ 32794 #line 1476 "gram.y" 32795 { 32796 VariableShowStmt *n = makeNode(VariableShowStmt); 32797@@ -18904,8 +19066,6 @@ 32798 break; 32799 32800 case 223: 32801- 32802-/* Line 1455 of yacc.c */ 32803 #line 1482 "gram.y" 32804 { 32805 VariableShowStmt *n = makeNode(VariableShowStmt); 32806@@ -18915,8 +19075,6 @@ 32807 break; 32808 32809 case 224: 32810- 32811-/* Line 1455 of yacc.c */ 32812 #line 1488 "gram.y" 32813 { 32814 VariableShowStmt *n = makeNode(VariableShowStmt); 32815@@ -18926,8 +19084,6 @@ 32816 break; 32817 32818 case 225: 32819- 32820-/* Line 1455 of yacc.c */ 32821 #line 1498 "gram.y" 32822 { 32823 ConstraintsSetStmt *n = makeNode(ConstraintsSetStmt); 32824@@ -18938,36 +19094,26 @@ 32825 break; 32826 32827 case 226: 32828- 32829-/* Line 1455 of yacc.c */ 32830 #line 1507 "gram.y" 32831 { (yyval.list) = NIL; ;} 32832 break; 32833 32834 case 227: 32835- 32836-/* Line 1455 of yacc.c */ 32837 #line 1508 "gram.y" 32838 { (yyval.list) = (yyvsp[(1) - (1)].list); ;} 32839 break; 32840 32841 case 228: 32842- 32843-/* Line 1455 of yacc.c */ 32844 #line 1512 "gram.y" 32845 { (yyval.boolean) = TRUE; ;} 32846 break; 32847 32848 case 229: 32849- 32850-/* Line 1455 of yacc.c */ 32851 #line 1513 "gram.y" 32852 { (yyval.boolean) = FALSE; ;} 32853 break; 32854 32855 case 230: 32856- 32857-/* Line 1455 of yacc.c */ 32858 #line 1522 "gram.y" 32859 { 32860 CheckPointStmt *n = makeNode(CheckPointStmt); 32861@@ -18976,8 +19122,6 @@ 32862 break; 32863 32864 case 231: 32865- 32866-/* Line 1455 of yacc.c */ 32867 #line 1537 "gram.y" 32868 { 32869 DiscardStmt *n = makeNode(DiscardStmt); 32870@@ -18987,8 +19131,6 @@ 32871 break; 32872 32873 case 232: 32874- 32875-/* Line 1455 of yacc.c */ 32876 #line 1543 "gram.y" 32877 { 32878 DiscardStmt *n = makeNode(DiscardStmt); 32879@@ -18998,8 +19140,6 @@ 32880 break; 32881 32882 case 233: 32883- 32884-/* Line 1455 of yacc.c */ 32885 #line 1549 "gram.y" 32886 { 32887 DiscardStmt *n = makeNode(DiscardStmt); 32888@@ -19009,8 +19149,6 @@ 32889 break; 32890 32891 case 234: 32892- 32893-/* Line 1455 of yacc.c */ 32894 #line 1555 "gram.y" 32895 { 32896 DiscardStmt *n = makeNode(DiscardStmt); 32897@@ -19020,8 +19158,6 @@ 32898 break; 32899 32900 case 235: 32901- 32902-/* Line 1455 of yacc.c */ 32903 #line 1573 "gram.y" 32904 { 32905 AlterTableStmt *n = makeNode(AlterTableStmt); 32906@@ -19033,8 +19169,6 @@ 32907 break; 32908 32909 case 236: 32910- 32911-/* Line 1455 of yacc.c */ 32912 #line 1581 "gram.y" 32913 { 32914 AlterTableStmt *n = makeNode(AlterTableStmt); 32915@@ -19046,8 +19180,6 @@ 32916 break; 32917 32918 case 237: 32919- 32920-/* Line 1455 of yacc.c */ 32921 #line 1589 "gram.y" 32922 { 32923 AlterTableStmt *n = makeNode(AlterTableStmt); 32924@@ -19059,8 +19191,6 @@ 32925 break; 32926 32927 case 238: 32928- 32929-/* Line 1455 of yacc.c */ 32930 #line 1597 "gram.y" 32931 { 32932 AlterTableStmt *n = makeNode(AlterTableStmt); 32933@@ -19072,22 +19202,16 @@ 32934 break; 32935 32936 case 239: 32937- 32938-/* Line 1455 of yacc.c */ 32939 #line 1607 "gram.y" 32940 { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} 32941 break; 32942 32943 case 240: 32944- 32945-/* Line 1455 of yacc.c */ 32946 #line 1608 "gram.y" 32947 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} 32948 break; 32949 32950 case 241: 32951- 32952-/* Line 1455 of yacc.c */ 32953 #line 1614 "gram.y" 32954 { 32955 AlterTableCmd *n = makeNode(AlterTableCmd); 32956@@ -19098,8 +19222,6 @@ 32957 break; 32958 32959 case 242: 32960- 32961-/* Line 1455 of yacc.c */ 32962 #line 1622 "gram.y" 32963 { 32964 AlterTableCmd *n = makeNode(AlterTableCmd); 32965@@ -19110,8 +19232,6 @@ 32966 break; 32967 32968 case 243: 32969- 32970-/* Line 1455 of yacc.c */ 32971 #line 1630 "gram.y" 32972 { 32973 AlterTableCmd *n = makeNode(AlterTableCmd); 32974@@ -19123,8 +19243,6 @@ 32975 break; 32976 32977 case 244: 32978- 32979-/* Line 1455 of yacc.c */ 32980 #line 1639 "gram.y" 32981 { 32982 AlterTableCmd *n = makeNode(AlterTableCmd); 32983@@ -19135,8 +19253,6 @@ 32984 break; 32985 32986 case 245: 32987- 32988-/* Line 1455 of yacc.c */ 32989 #line 1647 "gram.y" 32990 { 32991 AlterTableCmd *n = makeNode(AlterTableCmd); 32992@@ -19147,8 +19263,6 @@ 32993 break; 32994 32995 case 246: 32996- 32997-/* Line 1455 of yacc.c */ 32998 #line 1655 "gram.y" 32999 { 33000 AlterTableCmd *n = makeNode(AlterTableCmd); 33001@@ -19160,8 +19274,6 @@ 33002 break; 33003 33004 case 247: 33005- 33006-/* Line 1455 of yacc.c */ 33007 #line 1664 "gram.y" 33008 { 33009 AlterTableCmd *n = makeNode(AlterTableCmd); 33010@@ -19173,8 +19285,6 @@ 33011 break; 33012 33013 case 248: 33014- 33015-/* Line 1455 of yacc.c */ 33016 #line 1673 "gram.y" 33017 { 33018 AlterTableCmd *n = makeNode(AlterTableCmd); 33019@@ -19186,8 +19296,6 @@ 33020 break; 33021 33022 case 249: 33023- 33024-/* Line 1455 of yacc.c */ 33025 #line 1682 "gram.y" 33026 { 33027 AlterTableCmd *n = makeNode(AlterTableCmd); 33028@@ -19199,8 +19307,6 @@ 33029 break; 33030 33031 case 250: 33032- 33033-/* Line 1455 of yacc.c */ 33034 #line 1691 "gram.y" 33035 { 33036 AlterTableCmd *n = makeNode(AlterTableCmd); 33037@@ -19213,8 +19319,6 @@ 33038 break; 33039 33040 case 251: 33041- 33042-/* Line 1455 of yacc.c */ 33043 #line 1701 "gram.y" 33044 { 33045 AlterTableCmd *n = makeNode(AlterTableCmd); 33046@@ -19227,8 +19331,6 @@ 33047 break; 33048 33049 case 252: 33050- 33051-/* Line 1455 of yacc.c */ 33052 #line 1714 "gram.y" 33053 { 33054 AlterTableCmd *n = makeNode(AlterTableCmd); 33055@@ -19241,8 +19343,6 @@ 33056 break; 33057 33058 case 253: 33059- 33060-/* Line 1455 of yacc.c */ 33061 #line 1724 "gram.y" 33062 { 33063 AlterTableCmd *n = makeNode(AlterTableCmd); 33064@@ -19253,8 +19353,6 @@ 33065 break; 33066 33067 case 254: 33068- 33069-/* Line 1455 of yacc.c */ 33070 #line 1732 "gram.y" 33071 { 33072 AlterTableCmd *n = makeNode(AlterTableCmd); 33073@@ -19267,8 +19365,6 @@ 33074 break; 33075 33076 case 255: 33077- 33078-/* Line 1455 of yacc.c */ 33079 #line 1742 "gram.y" 33080 { 33081 AlterTableCmd *n = makeNode(AlterTableCmd); 33082@@ -19281,8 +19377,6 @@ 33083 break; 33084 33085 case 256: 33086- 33087-/* Line 1455 of yacc.c */ 33088 #line 1752 "gram.y" 33089 { 33090 AlterTableCmd *n = makeNode(AlterTableCmd); 33091@@ -19292,8 +19386,6 @@ 33092 break; 33093 33094 case 257: 33095- 33096-/* Line 1455 of yacc.c */ 33097 #line 1759 "gram.y" 33098 { 33099 AlterTableCmd *n = makeNode(AlterTableCmd); 33100@@ -19303,8 +19395,6 @@ 33101 break; 33102 33103 case 258: 33104- 33105-/* Line 1455 of yacc.c */ 33106 #line 1766 "gram.y" 33107 { 33108 AlterTableCmd *n = makeNode(AlterTableCmd); 33109@@ -19315,8 +19405,6 @@ 33110 break; 33111 33112 case 259: 33113- 33114-/* Line 1455 of yacc.c */ 33115 #line 1774 "gram.y" 33116 { 33117 AlterTableCmd *n = makeNode(AlterTableCmd); 33118@@ -19327,8 +19415,6 @@ 33119 break; 33120 33121 case 260: 33122- 33123-/* Line 1455 of yacc.c */ 33124 #line 1782 "gram.y" 33125 { 33126 AlterTableCmd *n = makeNode(AlterTableCmd); 33127@@ -19339,8 +19425,6 @@ 33128 break; 33129 33130 case 261: 33131- 33132-/* Line 1455 of yacc.c */ 33133 #line 1790 "gram.y" 33134 { 33135 AlterTableCmd *n = makeNode(AlterTableCmd); 33136@@ -19351,8 +19435,6 @@ 33137 break; 33138 33139 case 262: 33140- 33141-/* Line 1455 of yacc.c */ 33142 #line 1798 "gram.y" 33143 { 33144 AlterTableCmd *n = makeNode(AlterTableCmd); 33145@@ -19363,8 +19445,6 @@ 33146 break; 33147 33148 case 263: 33149- 33150-/* Line 1455 of yacc.c */ 33151 #line 1806 "gram.y" 33152 { 33153 AlterTableCmd *n = makeNode(AlterTableCmd); 33154@@ -19374,8 +19454,6 @@ 33155 break; 33156 33157 case 264: 33158- 33159-/* Line 1455 of yacc.c */ 33160 #line 1813 "gram.y" 33161 { 33162 AlterTableCmd *n = makeNode(AlterTableCmd); 33163@@ -19385,8 +19463,6 @@ 33164 break; 33165 33166 case 265: 33167- 33168-/* Line 1455 of yacc.c */ 33169 #line 1820 "gram.y" 33170 { 33171 AlterTableCmd *n = makeNode(AlterTableCmd); 33172@@ -19397,8 +19473,6 @@ 33173 break; 33174 33175 case 266: 33176- 33177-/* Line 1455 of yacc.c */ 33178 #line 1828 "gram.y" 33179 { 33180 AlterTableCmd *n = makeNode(AlterTableCmd); 33181@@ -19408,8 +19482,6 @@ 33182 break; 33183 33184 case 267: 33185- 33186-/* Line 1455 of yacc.c */ 33187 #line 1835 "gram.y" 33188 { 33189 AlterTableCmd *n = makeNode(AlterTableCmd); 33190@@ -19419,8 +19491,6 @@ 33191 break; 33192 33193 case 268: 33194- 33195-/* Line 1455 of yacc.c */ 33196 #line 1842 "gram.y" 33197 { 33198 AlterTableCmd *n = makeNode(AlterTableCmd); 33199@@ -19431,8 +19501,6 @@ 33200 break; 33201 33202 case 269: 33203- 33204-/* Line 1455 of yacc.c */ 33205 #line 1850 "gram.y" 33206 { 33207 AlterTableCmd *n = makeNode(AlterTableCmd); 33208@@ -19443,8 +19511,6 @@ 33209 break; 33210 33211 case 270: 33212- 33213-/* Line 1455 of yacc.c */ 33214 #line 1858 "gram.y" 33215 { 33216 AlterTableCmd *n = makeNode(AlterTableCmd); 33217@@ -19455,8 +19521,6 @@ 33218 break; 33219 33220 case 271: 33221- 33222-/* Line 1455 of yacc.c */ 33223 #line 1866 "gram.y" 33224 { 33225 AlterTableCmd *n = makeNode(AlterTableCmd); 33226@@ -19467,8 +19531,6 @@ 33227 break; 33228 33229 case 272: 33230- 33231-/* Line 1455 of yacc.c */ 33232 #line 1874 "gram.y" 33233 { 33234 AlterTableCmd *n = makeNode(AlterTableCmd); 33235@@ -19479,8 +19541,6 @@ 33236 break; 33237 33238 case 273: 33239- 33240-/* Line 1455 of yacc.c */ 33241 #line 1882 "gram.y" 33242 { 33243 AlterTableCmd *n = makeNode(AlterTableCmd); 33244@@ -19491,8 +19551,6 @@ 33245 break; 33246 33247 case 274: 33248- 33249-/* Line 1455 of yacc.c */ 33250 #line 1890 "gram.y" 33251 { 33252 AlterTableCmd *n = makeNode(AlterTableCmd); 33253@@ -19503,8 +19561,6 @@ 33254 break; 33255 33256 case 275: 33257- 33258-/* Line 1455 of yacc.c */ 33259 #line 1898 "gram.y" 33260 { 33261 AlterTableCmd *n = makeNode(AlterTableCmd); 33262@@ -19515,8 +19571,6 @@ 33263 break; 33264 33265 case 276: 33266- 33267-/* Line 1455 of yacc.c */ 33268 #line 1906 "gram.y" 33269 { 33270 AlterTableCmd *n = makeNode(AlterTableCmd); 33271@@ -19527,8 +19581,6 @@ 33272 break; 33273 33274 case 277: 33275- 33276-/* Line 1455 of yacc.c */ 33277 #line 1914 "gram.y" 33278 { 33279 AlterTableCmd *n = makeNode(AlterTableCmd); 33280@@ -19539,92 +19591,66 @@ 33281 break; 33282 33283 case 278: 33284- 33285-/* Line 1455 of yacc.c */ 33286 #line 1923 "gram.y" 33287 { (yyval.node) = (yyvsp[(3) - (3)].node); ;} 33288 break; 33289 33290 case 279: 33291- 33292-/* Line 1455 of yacc.c */ 33293 #line 1924 "gram.y" 33294 { (yyval.node) = NULL; ;} 33295 break; 33296 33297 case 280: 33298- 33299-/* Line 1455 of yacc.c */ 33300 #line 1928 "gram.y" 33301 { (yyval.dbehavior) = DROP_CASCADE; ;} 33302 break; 33303 33304 case 281: 33305- 33306-/* Line 1455 of yacc.c */ 33307 #line 1929 "gram.y" 33308 { (yyval.dbehavior) = DROP_RESTRICT; ;} 33309 break; 33310 33311 case 282: 33312- 33313-/* Line 1455 of yacc.c */ 33314 #line 1930 "gram.y" 33315 { (yyval.dbehavior) = DROP_RESTRICT; /* default */ ;} 33316 break; 33317 33318 case 283: 33319- 33320-/* Line 1455 of yacc.c */ 33321 #line 1934 "gram.y" 33322 { (yyval.node) = (yyvsp[(2) - (2)].node); ;} 33323 break; 33324 33325 case 284: 33326- 33327-/* Line 1455 of yacc.c */ 33328 #line 1935 "gram.y" 33329 { (yyval.node) = NULL; ;} 33330 break; 33331 33332 case 285: 33333- 33334-/* Line 1455 of yacc.c */ 33335 #line 1939 "gram.y" 33336 { (yyval.list) = (yyvsp[(2) - (3)].list); ;} 33337 break; 33338 33339 case 286: 33340- 33341-/* Line 1455 of yacc.c */ 33342 #line 1942 "gram.y" 33343 { (yyval.list) = (yyvsp[(2) - (2)].list); ;} 33344 break; 33345 33346 case 287: 33347- 33348-/* Line 1455 of yacc.c */ 33349 #line 1943 "gram.y" 33350 { (yyval.list) = NIL; ;} 33351 break; 33352 33353 case 288: 33354- 33355-/* Line 1455 of yacc.c */ 33356 #line 1947 "gram.y" 33357 { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} 33358 break; 33359 33360 case 289: 33361- 33362-/* Line 1455 of yacc.c */ 33363 #line 1948 "gram.y" 33364 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); ;} 33365 break; 33366 33367 case 290: 33368- 33369-/* Line 1455 of yacc.c */ 33370 #line 1954 "gram.y" 33371 { 33372 (yyval.defelt) = makeDefElem((yyvsp[(1) - (3)].str), (Node *) (yyvsp[(3) - (3)].node)); 33373@@ -19632,8 +19658,6 @@ 33374 break; 33375 33376 case 291: 33377- 33378-/* Line 1455 of yacc.c */ 33379 #line 1958 "gram.y" 33380 { 33381 (yyval.defelt) = makeDefElem((yyvsp[(1) - (1)].str), NULL); 33382@@ -19641,8 +19665,6 @@ 33383 break; 33384 33385 case 292: 33386- 33387-/* Line 1455 of yacc.c */ 33388 #line 1962 "gram.y" 33389 { 33390 (yyval.defelt) = makeDefElemExtended((yyvsp[(1) - (5)].str), (yyvsp[(3) - (5)].str), (Node *) (yyvsp[(5) - (5)].node), 33391@@ -19651,8 +19673,6 @@ 33392 break; 33393 33394 case 293: 33395- 33396-/* Line 1455 of yacc.c */ 33397 #line 1967 "gram.y" 33398 { 33399 (yyval.defelt) = makeDefElemExtended((yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str), NULL, DEFELEM_UNSPEC); 33400@@ -19660,8 +19680,6 @@ 33401 break; 33402 33403 case 294: 33404- 33405-/* Line 1455 of yacc.c */ 33406 #line 1982 "gram.y" 33407 { 33408 ClosePortalStmt *n = makeNode(ClosePortalStmt); 33409@@ -19671,8 +19689,6 @@ 33410 break; 33411 33412 case 295: 33413- 33414-/* Line 1455 of yacc.c */ 33415 #line 1988 "gram.y" 33416 { 33417 ClosePortalStmt *n = makeNode(ClosePortalStmt); 33418@@ -19682,8 +19698,6 @@ 33419 break; 33420 33421 case 296: 33422- 33423-/* Line 1455 of yacc.c */ 33424 #line 2016 "gram.y" 33425 { 33426 CopyStmt *n = makeNode(CopyStmt); 33427@@ -19708,8 +19722,6 @@ 33428 break; 33429 33430 case 297: 33431- 33432-/* Line 1455 of yacc.c */ 33433 #line 2037 "gram.y" 33434 { 33435 CopyStmt *n = makeNode(CopyStmt); 33436@@ -19724,71 +19736,51 @@ 33437 break; 33438 33439 case 298: 33440- 33441-/* Line 1455 of yacc.c */ 33442 #line 2050 "gram.y" 33443 { (yyval.boolean) = TRUE; ;} 33444 break; 33445 33446 case 299: 33447- 33448-/* Line 1455 of yacc.c */ 33449 #line 2051 "gram.y" 33450 { (yyval.boolean) = FALSE; ;} 33451 break; 33452 33453 case 300: 33454- 33455-/* Line 1455 of yacc.c */ 33456 #line 2060 "gram.y" 33457 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 33458 break; 33459 33460 case 301: 33461- 33462-/* Line 1455 of yacc.c */ 33463 #line 2061 "gram.y" 33464 { (yyval.str) = NULL; ;} 33465 break; 33466 33467 case 302: 33468- 33469-/* Line 1455 of yacc.c */ 33470 #line 2062 "gram.y" 33471 { (yyval.str) = NULL; ;} 33472 break; 33473 33474 case 303: 33475- 33476-/* Line 1455 of yacc.c */ 33477 #line 2065 "gram.y" 33478 { (yyval.list) = (yyvsp[(1) - (1)].list); ;} 33479 break; 33480 33481 case 304: 33482- 33483-/* Line 1455 of yacc.c */ 33484 #line 2066 "gram.y" 33485 { (yyval.list) = (yyvsp[(2) - (3)].list); ;} 33486 break; 33487 33488 case 305: 33489- 33490-/* Line 1455 of yacc.c */ 33491 #line 2071 "gram.y" 33492 { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} 33493 break; 33494 33495 case 306: 33496- 33497-/* Line 1455 of yacc.c */ 33498 #line 2072 "gram.y" 33499 { (yyval.list) = NIL; ;} 33500 break; 33501 33502 case 307: 33503- 33504-/* Line 1455 of yacc.c */ 33505 #line 2077 "gram.y" 33506 { 33507 (yyval.defelt) = makeDefElem("format", (Node *)makeString("binary")); 33508@@ -19796,8 +19788,6 @@ 33509 break; 33510 33511 case 308: 33512- 33513-/* Line 1455 of yacc.c */ 33514 #line 2081 "gram.y" 33515 { 33516 (yyval.defelt) = makeDefElem("oids", (Node *)makeInteger(TRUE)); 33517@@ -19805,8 +19795,6 @@ 33518 break; 33519 33520 case 309: 33521- 33522-/* Line 1455 of yacc.c */ 33523 #line 2085 "gram.y" 33524 { 33525 (yyval.defelt) = makeDefElem("delimiter", (Node *)makeString((yyvsp[(3) - (3)].str))); 33526@@ -19814,8 +19802,6 @@ 33527 break; 33528 33529 case 310: 33530- 33531-/* Line 1455 of yacc.c */ 33532 #line 2089 "gram.y" 33533 { 33534 (yyval.defelt) = makeDefElem("null", (Node *)makeString((yyvsp[(3) - (3)].str))); 33535@@ -19823,8 +19809,6 @@ 33536 break; 33537 33538 case 311: 33539- 33540-/* Line 1455 of yacc.c */ 33541 #line 2093 "gram.y" 33542 { 33543 (yyval.defelt) = makeDefElem("format", (Node *)makeString("csv")); 33544@@ -19832,8 +19816,6 @@ 33545 break; 33546 33547 case 312: 33548- 33549-/* Line 1455 of yacc.c */ 33550 #line 2097 "gram.y" 33551 { 33552 (yyval.defelt) = makeDefElem("header", (Node *)makeInteger(TRUE)); 33553@@ -19841,8 +19823,6 @@ 33554 break; 33555 33556 case 313: 33557- 33558-/* Line 1455 of yacc.c */ 33559 #line 2101 "gram.y" 33560 { 33561 (yyval.defelt) = makeDefElem("quote", (Node *)makeString((yyvsp[(3) - (3)].str))); 33562@@ -19850,8 +19830,6 @@ 33563 break; 33564 33565 case 314: 33566- 33567-/* Line 1455 of yacc.c */ 33568 #line 2105 "gram.y" 33569 { 33570 (yyval.defelt) = makeDefElem("escape", (Node *)makeString((yyvsp[(3) - (3)].str))); 33571@@ -19859,8 +19837,6 @@ 33572 break; 33573 33574 case 315: 33575- 33576-/* Line 1455 of yacc.c */ 33577 #line 2109 "gram.y" 33578 { 33579 (yyval.defelt) = makeDefElem("force_quote", (Node *)(yyvsp[(3) - (3)].list)); 33580@@ -19868,8 +19844,6 @@ 33581 break; 33582 33583 case 316: 33584- 33585-/* Line 1455 of yacc.c */ 33586 #line 2113 "gram.y" 33587 { 33588 (yyval.defelt) = makeDefElem("force_quote", (Node *)makeNode(A_Star)); 33589@@ -19877,8 +19851,6 @@ 33590 break; 33591 33592 case 317: 33593- 33594-/* Line 1455 of yacc.c */ 33595 #line 2117 "gram.y" 33596 { 33597 (yyval.defelt) = makeDefElem("force_not_null", (Node *)(yyvsp[(4) - (4)].list)); 33598@@ -19886,8 +19858,6 @@ 33599 break; 33600 33601 case 318: 33602- 33603-/* Line 1455 of yacc.c */ 33604 #line 2126 "gram.y" 33605 { 33606 (yyval.defelt) = makeDefElem("format", (Node *)makeString("binary")); 33607@@ -19895,15 +19865,11 @@ 33608 break; 33609 33610 case 319: 33611- 33612-/* Line 1455 of yacc.c */ 33613 #line 2129 "gram.y" 33614 { (yyval.defelt) = NULL; ;} 33615 break; 33616 33617 case 320: 33618- 33619-/* Line 1455 of yacc.c */ 33620 #line 2134 "gram.y" 33621 { 33622 (yyval.defelt) = makeDefElem("oids", (Node *)makeInteger(TRUE)); 33623@@ -19911,15 +19877,11 @@ 33624 break; 33625 33626 case 321: 33627- 33628-/* Line 1455 of yacc.c */ 33629 #line 2137 "gram.y" 33630 { (yyval.defelt) = NULL; ;} 33631 break; 33632 33633 case 322: 33634- 33635-/* Line 1455 of yacc.c */ 33636 #line 2142 "gram.y" 33637 { 33638 (yyval.defelt) = makeDefElem("delimiter", (Node *)makeString((yyvsp[(3) - (3)].str))); 33639@@ -19927,29 +19889,21 @@ 33640 break; 33641 33642 case 323: 33643- 33644-/* Line 1455 of yacc.c */ 33645 #line 2145 "gram.y" 33646 { (yyval.defelt) = NULL; ;} 33647 break; 33648 33649 case 324: 33650- 33651-/* Line 1455 of yacc.c */ 33652 #line 2149 "gram.y" 33653 {;} 33654 break; 33655 33656 case 325: 33657- 33658-/* Line 1455 of yacc.c */ 33659 #line 2150 "gram.y" 33660 {;} 33661 break; 33662 33663 case 326: 33664- 33665-/* Line 1455 of yacc.c */ 33666 #line 2156 "gram.y" 33667 { 33668 (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); 33669@@ -19957,8 +19911,6 @@ 33670 break; 33671 33672 case 327: 33673- 33674-/* Line 1455 of yacc.c */ 33675 #line 2160 "gram.y" 33676 { 33677 (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); 33678@@ -19966,8 +19918,6 @@ 33679 break; 33680 33681 case 328: 33682- 33683-/* Line 1455 of yacc.c */ 33684 #line 2167 "gram.y" 33685 { 33686 (yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node)); 33687@@ -19975,43 +19925,31 @@ 33688 break; 33689 33690 case 329: 33691- 33692-/* Line 1455 of yacc.c */ 33693 #line 2173 "gram.y" 33694 { (yyval.node) = (Node *) makeString((yyvsp[(1) - (1)].str)); ;} 33695 break; 33696 33697 case 330: 33698- 33699-/* Line 1455 of yacc.c */ 33700 #line 2174 "gram.y" 33701 { (yyval.node) = (Node *) (yyvsp[(1) - (1)].value); ;} 33702 break; 33703 33704 case 331: 33705- 33706-/* Line 1455 of yacc.c */ 33707 #line 2175 "gram.y" 33708 { (yyval.node) = (Node *) makeNode(A_Star); ;} 33709 break; 33710 33711 case 332: 33712- 33713-/* Line 1455 of yacc.c */ 33714 #line 2176 "gram.y" 33715 { (yyval.node) = (Node *) (yyvsp[(2) - (3)].list); ;} 33716 break; 33717 33718 case 333: 33719- 33720-/* Line 1455 of yacc.c */ 33721 #line 2177 "gram.y" 33722 { (yyval.node) = NULL; ;} 33723 break; 33724 33725 case 334: 33726- 33727-/* Line 1455 of yacc.c */ 33728 #line 2182 "gram.y" 33729 { 33730 (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); 33731@@ -20019,8 +19957,6 @@ 33732 break; 33733 33734 case 335: 33735- 33736-/* Line 1455 of yacc.c */ 33737 #line 2186 "gram.y" 33738 { 33739 (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 33740@@ -20028,15 +19964,11 @@ 33741 break; 33742 33743 case 336: 33744- 33745-/* Line 1455 of yacc.c */ 33746 #line 2193 "gram.y" 33747 { (yyval.node) = (Node *) makeString((yyvsp[(1) - (1)].str)); ;} 33748 break; 33749 33750 case 337: 33751- 33752-/* Line 1455 of yacc.c */ 33753 #line 2206 "gram.y" 33754 { 33755 CreateStmt *n = makeNode(CreateStmt); 33756@@ -20053,8 +19985,6 @@ 33757 break; 33758 33759 case 338: 33760- 33761-/* Line 1455 of yacc.c */ 33762 #line 2220 "gram.y" 33763 { 33764 CreateStmt *n = makeNode(CreateStmt); 33765@@ -20072,85 +20002,61 @@ 33766 break; 33767 33768 case 339: 33769- 33770-/* Line 1455 of yacc.c */ 33771 #line 2242 "gram.y" 33772 { (yyval.boolean) = TRUE; ;} 33773 break; 33774 33775 case 340: 33776- 33777-/* Line 1455 of yacc.c */ 33778 #line 2243 "gram.y" 33779 { (yyval.boolean) = TRUE; ;} 33780 break; 33781 33782 case 341: 33783- 33784-/* Line 1455 of yacc.c */ 33785 #line 2244 "gram.y" 33786 { (yyval.boolean) = TRUE; ;} 33787 break; 33788 33789 case 342: 33790- 33791-/* Line 1455 of yacc.c */ 33792 #line 2245 "gram.y" 33793 { (yyval.boolean) = TRUE; ;} 33794 break; 33795 33796 case 343: 33797- 33798-/* Line 1455 of yacc.c */ 33799 #line 2246 "gram.y" 33800 { (yyval.boolean) = TRUE; ;} 33801 break; 33802 33803 case 344: 33804- 33805-/* Line 1455 of yacc.c */ 33806 #line 2247 "gram.y" 33807 { (yyval.boolean) = TRUE; ;} 33808 break; 33809 33810 case 345: 33811- 33812-/* Line 1455 of yacc.c */ 33813 #line 2248 "gram.y" 33814 { (yyval.boolean) = FALSE; ;} 33815 break; 33816 33817 case 346: 33818- 33819-/* Line 1455 of yacc.c */ 33820 #line 2252 "gram.y" 33821 { (yyval.list) = (yyvsp[(1) - (1)].list); ;} 33822 break; 33823 33824 case 347: 33825- 33826-/* Line 1455 of yacc.c */ 33827 #line 2253 "gram.y" 33828 { (yyval.list) = NIL; ;} 33829 break; 33830 33831 case 348: 33832- 33833-/* Line 1455 of yacc.c */ 33834 #line 2257 "gram.y" 33835 { (yyval.list) = (yyvsp[(2) - (3)].list); ;} 33836 break; 33837 33838 case 349: 33839- 33840-/* Line 1455 of yacc.c */ 33841 #line 2258 "gram.y" 33842 { (yyval.list) = NIL; ;} 33843 break; 33844 33845 case 350: 33846- 33847-/* Line 1455 of yacc.c */ 33848 #line 2263 "gram.y" 33849 { 33850 (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); 33851@@ -20158,8 +20064,6 @@ 33852 break; 33853 33854 case 351: 33855- 33856-/* Line 1455 of yacc.c */ 33857 #line 2267 "gram.y" 33858 { 33859 (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 33860@@ -20167,8 +20071,6 @@ 33861 break; 33862 33863 case 352: 33864- 33865-/* Line 1455 of yacc.c */ 33866 #line 2274 "gram.y" 33867 { 33868 (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); 33869@@ -20176,8 +20078,6 @@ 33870 break; 33871 33872 case 353: 33873- 33874-/* Line 1455 of yacc.c */ 33875 #line 2278 "gram.y" 33876 { 33877 (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 33878@@ -20185,43 +20085,31 @@ 33879 break; 33880 33881 case 354: 33882- 33883-/* Line 1455 of yacc.c */ 33884 #line 2284 "gram.y" 33885 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 33886 break; 33887 33888 case 355: 33889- 33890-/* Line 1455 of yacc.c */ 33891 #line 2285 "gram.y" 33892 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 33893 break; 33894 33895 case 356: 33896- 33897-/* Line 1455 of yacc.c */ 33898 #line 2286 "gram.y" 33899 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 33900 break; 33901 33902 case 357: 33903- 33904-/* Line 1455 of yacc.c */ 33905 #line 2290 "gram.y" 33906 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 33907 break; 33908 33909 case 358: 33910- 33911-/* Line 1455 of yacc.c */ 33912 #line 2291 "gram.y" 33913 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 33914 break; 33915 33916 case 359: 33917- 33918-/* Line 1455 of yacc.c */ 33919 #line 2295 "gram.y" 33920 { 33921 ColumnDef *n = makeNode(ColumnDef); 33922@@ -20234,8 +20122,6 @@ 33923 break; 33924 33925 case 360: 33926- 33927-/* Line 1455 of yacc.c */ 33928 #line 2306 "gram.y" 33929 { 33930 ColumnDef *n = makeNode(ColumnDef); 33931@@ -20247,22 +20133,16 @@ 33932 break; 33933 33934 case 361: 33935- 33936-/* Line 1455 of yacc.c */ 33937 #line 2316 "gram.y" 33938 { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} 33939 break; 33940 33941 case 362: 33942- 33943-/* Line 1455 of yacc.c */ 33944 #line 2317 "gram.y" 33945 { (yyval.list) = NIL; ;} 33946 break; 33947 33948 case 363: 33949- 33950-/* Line 1455 of yacc.c */ 33951 #line 2322 "gram.y" 33952 { 33953 Constraint *n = (Constraint *) (yyvsp[(3) - (3)].node); 33954@@ -20274,22 +20154,16 @@ 33955 break; 33956 33957 case 364: 33958- 33959-/* Line 1455 of yacc.c */ 33960 #line 2329 "gram.y" 33961 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 33962 break; 33963 33964 case 365: 33965- 33966-/* Line 1455 of yacc.c */ 33967 #line 2330 "gram.y" 33968 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 33969 break; 33970 33971 case 366: 33972- 33973-/* Line 1455 of yacc.c */ 33974 #line 2350 "gram.y" 33975 { 33976 Constraint *n = makeNode(Constraint); 33977@@ -20300,8 +20174,6 @@ 33978 break; 33979 33980 case 367: 33981- 33982-/* Line 1455 of yacc.c */ 33983 #line 2357 "gram.y" 33984 { 33985 Constraint *n = makeNode(Constraint); 33986@@ -20312,8 +20184,6 @@ 33987 break; 33988 33989 case 368: 33990- 33991-/* Line 1455 of yacc.c */ 33992 #line 2364 "gram.y" 33993 { 33994 Constraint *n = makeNode(Constraint); 33995@@ -20327,8 +20197,6 @@ 33996 break; 33997 33998 case 369: 33999- 34000-/* Line 1455 of yacc.c */ 34001 #line 2374 "gram.y" 34002 { 34003 Constraint *n = makeNode(Constraint); 34004@@ -20342,8 +20210,6 @@ 34005 break; 34006 34007 case 370: 34008- 34009-/* Line 1455 of yacc.c */ 34010 #line 2384 "gram.y" 34011 { 34012 Constraint *n = makeNode(Constraint); 34013@@ -20356,8 +20222,6 @@ 34014 break; 34015 34016 case 371: 34017- 34018-/* Line 1455 of yacc.c */ 34019 #line 2393 "gram.y" 34020 { 34021 Constraint *n = makeNode(Constraint); 34022@@ -20370,8 +20234,6 @@ 34023 break; 34024 34025 case 372: 34026- 34027-/* Line 1455 of yacc.c */ 34028 #line 2402 "gram.y" 34029 { 34030 Constraint *n = makeNode(Constraint); 34031@@ -20389,8 +20251,6 @@ 34032 break; 34033 34034 case 373: 34035- 34036-/* Line 1455 of yacc.c */ 34037 #line 2431 "gram.y" 34038 { 34039 Constraint *n = makeNode(Constraint); 34040@@ -20401,8 +20261,6 @@ 34041 break; 34042 34043 case 374: 34044- 34045-/* Line 1455 of yacc.c */ 34046 #line 2438 "gram.y" 34047 { 34048 Constraint *n = makeNode(Constraint); 34049@@ -20413,8 +20271,6 @@ 34050 break; 34051 34052 case 375: 34053- 34054-/* Line 1455 of yacc.c */ 34055 #line 2445 "gram.y" 34056 { 34057 Constraint *n = makeNode(Constraint); 34058@@ -20425,8 +20281,6 @@ 34059 break; 34060 34061 case 376: 34062- 34063-/* Line 1455 of yacc.c */ 34064 #line 2452 "gram.y" 34065 { 34066 Constraint *n = makeNode(Constraint); 34067@@ -20437,8 +20291,6 @@ 34068 break; 34069 34070 case 377: 34071- 34072-/* Line 1455 of yacc.c */ 34073 #line 2471 "gram.y" 34074 { 34075 InhRelation *n = makeNode(InhRelation); 34076@@ -20449,71 +20301,51 @@ 34077 break; 34078 34079 case 378: 34080- 34081-/* Line 1455 of yacc.c */ 34082 #line 2480 "gram.y" 34083 { (yyval.ival) = (yyvsp[(1) - (3)].ival) | (yyvsp[(3) - (3)].ival); ;} 34084 break; 34085 34086 case 379: 34087- 34088-/* Line 1455 of yacc.c */ 34089 #line 2481 "gram.y" 34090 { (yyval.ival) = (yyvsp[(1) - (3)].ival) & ~(yyvsp[(3) - (3)].ival); ;} 34091 break; 34092 34093 case 380: 34094- 34095-/* Line 1455 of yacc.c */ 34096 #line 2482 "gram.y" 34097 { (yyval.ival) = 0; ;} 34098 break; 34099 34100 case 381: 34101- 34102-/* Line 1455 of yacc.c */ 34103 #line 2486 "gram.y" 34104 { (yyval.ival) = CREATE_TABLE_LIKE_DEFAULTS; ;} 34105 break; 34106 34107 case 382: 34108- 34109-/* Line 1455 of yacc.c */ 34110 #line 2487 "gram.y" 34111 { (yyval.ival) = CREATE_TABLE_LIKE_CONSTRAINTS; ;} 34112 break; 34113 34114 case 383: 34115- 34116-/* Line 1455 of yacc.c */ 34117 #line 2488 "gram.y" 34118 { (yyval.ival) = CREATE_TABLE_LIKE_INDEXES; ;} 34119 break; 34120 34121 case 384: 34122- 34123-/* Line 1455 of yacc.c */ 34124 #line 2489 "gram.y" 34125 { (yyval.ival) = CREATE_TABLE_LIKE_STORAGE; ;} 34126 break; 34127 34128 case 385: 34129- 34130-/* Line 1455 of yacc.c */ 34131 #line 2490 "gram.y" 34132 { (yyval.ival) = CREATE_TABLE_LIKE_COMMENTS; ;} 34133 break; 34134 34135 case 386: 34136- 34137-/* Line 1455 of yacc.c */ 34138 #line 2491 "gram.y" 34139 { (yyval.ival) = CREATE_TABLE_LIKE_ALL; ;} 34140 break; 34141 34142 case 387: 34143- 34144-/* Line 1455 of yacc.c */ 34145 #line 2501 "gram.y" 34146 { 34147 Constraint *n = (Constraint *) (yyvsp[(3) - (3)].node); 34148@@ -20525,15 +20357,11 @@ 34149 break; 34150 34151 case 388: 34152- 34153-/* Line 1455 of yacc.c */ 34154 #line 2508 "gram.y" 34155 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 34156 break; 34157 34158 case 389: 34159- 34160-/* Line 1455 of yacc.c */ 34161 #line 2513 "gram.y" 34162 { 34163 Constraint *n = makeNode(Constraint); 34164@@ -20551,8 +20379,6 @@ 34165 break; 34166 34167 case 390: 34168- 34169-/* Line 1455 of yacc.c */ 34170 #line 2528 "gram.y" 34171 { 34172 Constraint *n = makeNode(Constraint); 34173@@ -20568,8 +20394,6 @@ 34174 break; 34175 34176 case 391: 34177- 34178-/* Line 1455 of yacc.c */ 34179 #line 2541 "gram.y" 34180 { 34181 Constraint *n = makeNode(Constraint); 34182@@ -20585,8 +20409,6 @@ 34183 break; 34184 34185 case 392: 34186- 34187-/* Line 1455 of yacc.c */ 34188 #line 2555 "gram.y" 34189 { 34190 Constraint *n = makeNode(Constraint); 34191@@ -20604,8 +20426,6 @@ 34192 break; 34193 34194 case 393: 34195- 34196-/* Line 1455 of yacc.c */ 34197 #line 2570 "gram.y" 34198 { 34199 Constraint *n = makeNode(Constraint); 34200@@ -20625,36 +20445,26 @@ 34201 break; 34202 34203 case 394: 34204- 34205-/* Line 1455 of yacc.c */ 34206 #line 2588 "gram.y" 34207 { (yyval.list) = (yyvsp[(2) - (3)].list); ;} 34208 break; 34209 34210 case 395: 34211- 34212-/* Line 1455 of yacc.c */ 34213 #line 2589 "gram.y" 34214 { (yyval.list) = NIL; ;} 34215 break; 34216 34217 case 396: 34218- 34219-/* Line 1455 of yacc.c */ 34220 #line 2593 "gram.y" 34221 { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} 34222 break; 34223 34224 case 397: 34225- 34226-/* Line 1455 of yacc.c */ 34227 #line 2594 "gram.y" 34228 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} 34229 break; 34230 34231 case 398: 34232- 34233-/* Line 1455 of yacc.c */ 34234 #line 2598 "gram.y" 34235 { 34236 (yyval.node) = (Node *) makeString((yyvsp[(1) - (1)].str)); 34237@@ -20662,8 +20472,6 @@ 34238 break; 34239 34240 case 399: 34241- 34242-/* Line 1455 of yacc.c */ 34243 #line 2604 "gram.y" 34244 { 34245 (yyval.ival) = FKCONSTR_MATCH_FULL; 34246@@ -20671,8 +20479,6 @@ 34247 break; 34248 34249 case 400: 34250- 34251-/* Line 1455 of yacc.c */ 34252 #line 2608 "gram.y" 34253 { 34254 ereport(ERROR, 34255@@ -20684,8 +20490,6 @@ 34256 break; 34257 34258 case 401: 34259- 34260-/* Line 1455 of yacc.c */ 34261 #line 2616 "gram.y" 34262 { 34263 (yyval.ival) = FKCONSTR_MATCH_UNSPECIFIED; 34264@@ -20693,8 +20497,6 @@ 34265 break; 34266 34267 case 402: 34268- 34269-/* Line 1455 of yacc.c */ 34270 #line 2620 "gram.y" 34271 { 34272 (yyval.ival) = FKCONSTR_MATCH_UNSPECIFIED; 34273@@ -20702,22 +20504,16 @@ 34274 break; 34275 34276 case 403: 34277- 34278-/* Line 1455 of yacc.c */ 34279 #line 2626 "gram.y" 34280 { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} 34281 break; 34282 34283 case 404: 34284- 34285-/* Line 1455 of yacc.c */ 34286 #line 2628 "gram.y" 34287 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} 34288 break; 34289 34290 case 405: 34291- 34292-/* Line 1455 of yacc.c */ 34293 #line 2632 "gram.y" 34294 { 34295 (yyval.list) = list_make2((yyvsp[(1) - (3)].ielem), (yyvsp[(3) - (3)].list)); 34296@@ -20725,8 +20521,6 @@ 34297 break; 34298 34299 case 406: 34300- 34301-/* Line 1455 of yacc.c */ 34302 #line 2637 "gram.y" 34303 { 34304 (yyval.list) = list_make2((yyvsp[(1) - (6)].ielem), (yyvsp[(5) - (6)].list)); 34305@@ -20734,204 +20528,146 @@ 34306 break; 34307 34308 case 407: 34309- 34310-/* Line 1455 of yacc.c */ 34311 #line 2643 "gram.y" 34312 { (yyval.node) = (yyvsp[(3) - (4)].node); ;} 34313 break; 34314 34315 case 408: 34316- 34317-/* Line 1455 of yacc.c */ 34318 #line 2644 "gram.y" 34319 { (yyval.node) = NULL; ;} 34320 break; 34321 34322 case 409: 34323- 34324-/* Line 1455 of yacc.c */ 34325 #line 2655 "gram.y" 34326 { (yyval.ival) = ((yyvsp[(1) - (1)].ival) << 8) | (FKCONSTR_ACTION_NOACTION & 0xFF); ;} 34327 break; 34328 34329 case 410: 34330- 34331-/* Line 1455 of yacc.c */ 34332 #line 2657 "gram.y" 34333 { (yyval.ival) = (FKCONSTR_ACTION_NOACTION << 8) | ((yyvsp[(1) - (1)].ival) & 0xFF); ;} 34334 break; 34335 34336 case 411: 34337- 34338-/* Line 1455 of yacc.c */ 34339 #line 2659 "gram.y" 34340 { (yyval.ival) = ((yyvsp[(1) - (2)].ival) << 8) | ((yyvsp[(2) - (2)].ival) & 0xFF); ;} 34341 break; 34342 34343 case 412: 34344- 34345-/* Line 1455 of yacc.c */ 34346 #line 2661 "gram.y" 34347 { (yyval.ival) = ((yyvsp[(2) - (2)].ival) << 8) | ((yyvsp[(1) - (2)].ival) & 0xFF); ;} 34348 break; 34349 34350 case 413: 34351- 34352-/* Line 1455 of yacc.c */ 34353 #line 2663 "gram.y" 34354 { (yyval.ival) = (FKCONSTR_ACTION_NOACTION << 8) | (FKCONSTR_ACTION_NOACTION & 0xFF); ;} 34355 break; 34356 34357 case 414: 34358- 34359-/* Line 1455 of yacc.c */ 34360 #line 2666 "gram.y" 34361 { (yyval.ival) = (yyvsp[(3) - (3)].ival); ;} 34362 break; 34363 34364 case 415: 34365- 34366-/* Line 1455 of yacc.c */ 34367 #line 2669 "gram.y" 34368 { (yyval.ival) = (yyvsp[(3) - (3)].ival); ;} 34369 break; 34370 34371 case 416: 34372- 34373-/* Line 1455 of yacc.c */ 34374 #line 2673 "gram.y" 34375 { (yyval.ival) = FKCONSTR_ACTION_NOACTION; ;} 34376 break; 34377 34378 case 417: 34379- 34380-/* Line 1455 of yacc.c */ 34381 #line 2674 "gram.y" 34382 { (yyval.ival) = FKCONSTR_ACTION_RESTRICT; ;} 34383 break; 34384 34385 case 418: 34386- 34387-/* Line 1455 of yacc.c */ 34388 #line 2675 "gram.y" 34389 { (yyval.ival) = FKCONSTR_ACTION_CASCADE; ;} 34390 break; 34391 34392 case 419: 34393- 34394-/* Line 1455 of yacc.c */ 34395 #line 2676 "gram.y" 34396 { (yyval.ival) = FKCONSTR_ACTION_SETNULL; ;} 34397 break; 34398 34399 case 420: 34400- 34401-/* Line 1455 of yacc.c */ 34402 #line 2677 "gram.y" 34403 { (yyval.ival) = FKCONSTR_ACTION_SETDEFAULT; ;} 34404 break; 34405 34406 case 421: 34407- 34408-/* Line 1455 of yacc.c */ 34409 #line 2680 "gram.y" 34410 { (yyval.list) = (yyvsp[(3) - (4)].list); ;} 34411 break; 34412 34413 case 422: 34414- 34415-/* Line 1455 of yacc.c */ 34416 #line 2681 "gram.y" 34417 { (yyval.list) = NIL; ;} 34418 break; 34419 34420 case 423: 34421- 34422-/* Line 1455 of yacc.c */ 34423 #line 2686 "gram.y" 34424 { (yyval.list) = (yyvsp[(2) - (2)].list); ;} 34425 break; 34426 34427 case 424: 34428- 34429-/* Line 1455 of yacc.c */ 34430 #line 2687 "gram.y" 34431 { (yyval.list) = list_make1(defWithOids(true)); ;} 34432 break; 34433 34434 case 425: 34435- 34436-/* Line 1455 of yacc.c */ 34437 #line 2688 "gram.y" 34438 { (yyval.list) = list_make1(defWithOids(false)); ;} 34439 break; 34440 34441 case 426: 34442- 34443-/* Line 1455 of yacc.c */ 34444 #line 2689 "gram.y" 34445 { (yyval.list) = NIL; ;} 34446 break; 34447 34448 case 427: 34449- 34450-/* Line 1455 of yacc.c */ 34451 #line 2692 "gram.y" 34452 { (yyval.oncommit) = ONCOMMIT_DROP; ;} 34453 break; 34454 34455 case 428: 34456- 34457-/* Line 1455 of yacc.c */ 34458 #line 2693 "gram.y" 34459 { (yyval.oncommit) = ONCOMMIT_DELETE_ROWS; ;} 34460 break; 34461 34462 case 429: 34463- 34464-/* Line 1455 of yacc.c */ 34465 #line 2694 "gram.y" 34466 { (yyval.oncommit) = ONCOMMIT_PRESERVE_ROWS; ;} 34467 break; 34468 34469 case 430: 34470- 34471-/* Line 1455 of yacc.c */ 34472 #line 2695 "gram.y" 34473 { (yyval.oncommit) = ONCOMMIT_NOOP; ;} 34474 break; 34475 34476 case 431: 34477- 34478-/* Line 1455 of yacc.c */ 34479 #line 2698 "gram.y" 34480 { (yyval.str) = (yyvsp[(2) - (2)].str); ;} 34481 break; 34482 34483 case 432: 34484- 34485-/* Line 1455 of yacc.c */ 34486 #line 2699 "gram.y" 34487 { (yyval.str) = NULL; ;} 34488 break; 34489 34490 case 433: 34491- 34492-/* Line 1455 of yacc.c */ 34493 #line 2702 "gram.y" 34494 { (yyval.str) = (yyvsp[(4) - (4)].str); ;} 34495 break; 34496 34497 case 434: 34498- 34499-/* Line 1455 of yacc.c */ 34500 #line 2703 "gram.y" 34501 { (yyval.str) = NULL; ;} 34502 break; 34503 34504 case 435: 34505- 34506-/* Line 1455 of yacc.c */ 34507 #line 2714 "gram.y" 34508 { 34509 /* 34510@@ -20957,8 +20693,6 @@ 34511 break; 34512 34513 case 436: 34514- 34515-/* Line 1455 of yacc.c */ 34516 #line 2739 "gram.y" 34517 { 34518 (yyval.into) = makeNode(IntoClause); 34519@@ -20971,36 +20705,26 @@ 34520 break; 34521 34522 case 437: 34523- 34524-/* Line 1455 of yacc.c */ 34525 #line 2750 "gram.y" 34526 { (yyval.list) = (yyvsp[(2) - (3)].list); ;} 34527 break; 34528 34529 case 438: 34530- 34531-/* Line 1455 of yacc.c */ 34532 #line 2751 "gram.y" 34533 { (yyval.list) = NIL; ;} 34534 break; 34535 34536 case 439: 34537- 34538-/* Line 1455 of yacc.c */ 34539 #line 2755 "gram.y" 34540 { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} 34541 break; 34542 34543 case 440: 34544- 34545-/* Line 1455 of yacc.c */ 34546 #line 2756 "gram.y" 34547 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} 34548 break; 34549 34550 case 441: 34551- 34552-/* Line 1455 of yacc.c */ 34553 #line 2761 "gram.y" 34554 { 34555 ColumnDef *n = makeNode(ColumnDef); 34556@@ -21017,29 +20741,21 @@ 34557 break; 34558 34559 case 442: 34560- 34561-/* Line 1455 of yacc.c */ 34562 #line 2776 "gram.y" 34563 { (yyval.boolean) = TRUE; ;} 34564 break; 34565 34566 case 443: 34567- 34568-/* Line 1455 of yacc.c */ 34569 #line 2777 "gram.y" 34570 { (yyval.boolean) = FALSE; ;} 34571 break; 34572 34573 case 444: 34574- 34575-/* Line 1455 of yacc.c */ 34576 #line 2778 "gram.y" 34577 { (yyval.boolean) = TRUE; ;} 34578 break; 34579 34580 case 445: 34581- 34582-/* Line 1455 of yacc.c */ 34583 #line 2792 "gram.y" 34584 { 34585 CreateSeqStmt *n = makeNode(CreateSeqStmt); 34586@@ -21052,8 +20768,6 @@ 34587 break; 34588 34589 case 446: 34590- 34591-/* Line 1455 of yacc.c */ 34592 #line 2804 "gram.y" 34593 { 34594 AlterSeqStmt *n = makeNode(AlterSeqStmt); 34595@@ -21064,36 +20778,26 @@ 34596 break; 34597 34598 case 447: 34599- 34600-/* Line 1455 of yacc.c */ 34601 #line 2812 "gram.y" 34602 { (yyval.list) = (yyvsp[(1) - (1)].list); ;} 34603 break; 34604 34605 case 448: 34606- 34607-/* Line 1455 of yacc.c */ 34608 #line 2813 "gram.y" 34609 { (yyval.list) = NIL; ;} 34610 break; 34611 34612 case 449: 34613- 34614-/* Line 1455 of yacc.c */ 34615 #line 2816 "gram.y" 34616 { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} 34617 break; 34618 34619 case 450: 34620- 34621-/* Line 1455 of yacc.c */ 34622 #line 2817 "gram.y" 34623 { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} 34624 break; 34625 34626 case 451: 34627- 34628-/* Line 1455 of yacc.c */ 34629 #line 2821 "gram.y" 34630 { 34631 (yyval.defelt) = makeDefElem("cache", (Node *)(yyvsp[(2) - (2)].value)); 34632@@ -21101,8 +20805,6 @@ 34633 break; 34634 34635 case 452: 34636- 34637-/* Line 1455 of yacc.c */ 34638 #line 2825 "gram.y" 34639 { 34640 (yyval.defelt) = makeDefElem("cycle", (Node *)makeInteger(TRUE)); 34641@@ -21110,8 +20812,6 @@ 34642 break; 34643 34644 case 453: 34645- 34646-/* Line 1455 of yacc.c */ 34647 #line 2829 "gram.y" 34648 { 34649 (yyval.defelt) = makeDefElem("cycle", (Node *)makeInteger(FALSE)); 34650@@ -21119,8 +20819,6 @@ 34651 break; 34652 34653 case 454: 34654- 34655-/* Line 1455 of yacc.c */ 34656 #line 2833 "gram.y" 34657 { 34658 (yyval.defelt) = makeDefElem("increment", (Node *)(yyvsp[(3) - (3)].value)); 34659@@ -21128,8 +20826,6 @@ 34660 break; 34661 34662 case 455: 34663- 34664-/* Line 1455 of yacc.c */ 34665 #line 2837 "gram.y" 34666 { 34667 (yyval.defelt) = makeDefElem("maxvalue", (Node *)(yyvsp[(2) - (2)].value)); 34668@@ -21137,8 +20833,6 @@ 34669 break; 34670 34671 case 456: 34672- 34673-/* Line 1455 of yacc.c */ 34674 #line 2841 "gram.y" 34675 { 34676 (yyval.defelt) = makeDefElem("minvalue", (Node *)(yyvsp[(2) - (2)].value)); 34677@@ -21146,8 +20840,6 @@ 34678 break; 34679 34680 case 457: 34681- 34682-/* Line 1455 of yacc.c */ 34683 #line 2845 "gram.y" 34684 { 34685 (yyval.defelt) = makeDefElem("maxvalue", NULL); 34686@@ -21155,8 +20847,6 @@ 34687 break; 34688 34689 case 458: 34690- 34691-/* Line 1455 of yacc.c */ 34692 #line 2849 "gram.y" 34693 { 34694 (yyval.defelt) = makeDefElem("minvalue", NULL); 34695@@ -21164,8 +20854,6 @@ 34696 break; 34697 34698 case 459: 34699- 34700-/* Line 1455 of yacc.c */ 34701 #line 2853 "gram.y" 34702 { 34703 (yyval.defelt) = makeDefElem("owned_by", (Node *)(yyvsp[(3) - (3)].list)); 34704@@ -21173,8 +20861,6 @@ 34705 break; 34706 34707 case 460: 34708- 34709-/* Line 1455 of yacc.c */ 34710 #line 2857 "gram.y" 34711 { 34712 (yyval.defelt) = makeDefElem("start", (Node *)(yyvsp[(3) - (3)].value)); 34713@@ -21182,8 +20868,6 @@ 34714 break; 34715 34716 case 461: 34717- 34718-/* Line 1455 of yacc.c */ 34719 #line 2861 "gram.y" 34720 { 34721 (yyval.defelt) = makeDefElem("restart", NULL); 34722@@ -21191,8 +20875,6 @@ 34723 break; 34724 34725 case 462: 34726- 34727-/* Line 1455 of yacc.c */ 34728 #line 2865 "gram.y" 34729 { 34730 (yyval.defelt) = makeDefElem("restart", (Node *)(yyvsp[(3) - (3)].value)); 34731@@ -21200,29 +20882,21 @@ 34732 break; 34733 34734 case 463: 34735- 34736-/* Line 1455 of yacc.c */ 34737 #line 2870 "gram.y" 34738 {;} 34739 break; 34740 34741 case 464: 34742- 34743-/* Line 1455 of yacc.c */ 34744 #line 2871 "gram.y" 34745 {;} 34746 break; 34747 34748 case 465: 34749- 34750-/* Line 1455 of yacc.c */ 34751 #line 2875 "gram.y" 34752 { (yyval.value) = makeFloat((yyvsp[(1) - (1)].str)); ;} 34753 break; 34754 34755 case 466: 34756- 34757-/* Line 1455 of yacc.c */ 34758 #line 2877 "gram.y" 34759 { 34760 (yyval.value) = makeFloat((yyvsp[(2) - (2)].str)); 34761@@ -21231,29 +20905,21 @@ 34762 break; 34763 34764 case 467: 34765- 34766-/* Line 1455 of yacc.c */ 34767 #line 2881 "gram.y" 34768 { (yyval.value) = makeInteger((yyvsp[(1) - (1)].ival)); ;} 34769 break; 34770 34771 case 468: 34772- 34773-/* Line 1455 of yacc.c */ 34774 #line 2884 "gram.y" 34775 { (yyval.list) = list_make1((yyvsp[(1) - (1)].value)); ;} 34776 break; 34777 34778 case 469: 34779- 34780-/* Line 1455 of yacc.c */ 34781 #line 2885 "gram.y" 34782 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].value)); ;} 34783 break; 34784 34785 case 470: 34786- 34787-/* Line 1455 of yacc.c */ 34788 #line 2898 "gram.y" 34789 { 34790 CreatePLangStmt *n = makeNode(CreatePLangStmt); 34791@@ -21269,8 +20935,6 @@ 34792 break; 34793 34794 case 471: 34795- 34796-/* Line 1455 of yacc.c */ 34797 #line 2911 "gram.y" 34798 { 34799 CreatePLangStmt *n = makeNode(CreatePLangStmt); 34800@@ -21285,78 +20949,56 @@ 34801 break; 34802 34803 case 472: 34804- 34805-/* Line 1455 of yacc.c */ 34806 #line 2924 "gram.y" 34807 { (yyval.boolean) = TRUE; ;} 34808 break; 34809 34810 case 473: 34811- 34812-/* Line 1455 of yacc.c */ 34813 #line 2925 "gram.y" 34814 { (yyval.boolean) = FALSE; ;} 34815 break; 34816 34817 case 474: 34818- 34819-/* Line 1455 of yacc.c */ 34820 #line 2933 "gram.y" 34821 { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} 34822 break; 34823 34824 case 475: 34825- 34826-/* Line 1455 of yacc.c */ 34827 #line 2934 "gram.y" 34828 { (yyval.list) = lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)); ;} 34829 break; 34830 34831 case 476: 34832- 34833-/* Line 1455 of yacc.c */ 34834 #line 2938 "gram.y" 34835 { (yyval.list) = (yyvsp[(2) - (2)].list); ;} 34836 break; 34837 34838 case 477: 34839- 34840-/* Line 1455 of yacc.c */ 34841 #line 2939 "gram.y" 34842 { (yyval.list) = NIL; ;} 34843 break; 34844 34845 case 478: 34846- 34847-/* Line 1455 of yacc.c */ 34848 #line 2943 "gram.y" 34849 { (yyval.list) = (yyvsp[(2) - (2)].list); ;} 34850 break; 34851 34852 case 479: 34853- 34854-/* Line 1455 of yacc.c */ 34855 #line 2944 "gram.y" 34856 { (yyval.list) = NIL; ;} 34857 break; 34858 34859 case 480: 34860- 34861-/* Line 1455 of yacc.c */ 34862 #line 2948 "gram.y" 34863 { (yyval.list) = (yyvsp[(1) - (1)].list); ;} 34864 break; 34865 34866 case 481: 34867- 34868-/* Line 1455 of yacc.c */ 34869 #line 2949 "gram.y" 34870 { (yyval.list) = NIL; ;} 34871 break; 34872 34873 case 482: 34874- 34875-/* Line 1455 of yacc.c */ 34876 #line 2954 "gram.y" 34877 { 34878 DropPLangStmt *n = makeNode(DropPLangStmt); 34879@@ -21368,8 +21010,6 @@ 34880 break; 34881 34882 case 483: 34883- 34884-/* Line 1455 of yacc.c */ 34885 #line 2962 "gram.y" 34886 { 34887 DropPLangStmt *n = makeNode(DropPLangStmt); 34888@@ -21381,22 +21021,16 @@ 34889 break; 34890 34891 case 484: 34892- 34893-/* Line 1455 of yacc.c */ 34894 #line 2972 "gram.y" 34895 {;} 34896 break; 34897 34898 case 485: 34899- 34900-/* Line 1455 of yacc.c */ 34901 #line 2973 "gram.y" 34902 {;} 34903 break; 34904 34905 case 486: 34906- 34907-/* Line 1455 of yacc.c */ 34908 #line 2984 "gram.y" 34909 { 34910 CreateTableSpaceStmt *n = makeNode(CreateTableSpaceStmt); 34911@@ -21408,22 +21042,16 @@ 34912 break; 34913 34914 case 487: 34915- 34916-/* Line 1455 of yacc.c */ 34917 #line 2993 "gram.y" 34918 { (yyval.str) = (yyvsp[(2) - (2)].str); ;} 34919 break; 34920 34921 case 488: 34922- 34923-/* Line 1455 of yacc.c */ 34924 #line 2994 "gram.y" 34925 { (yyval.str) = NULL; ;} 34926 break; 34927 34928 case 489: 34929- 34930-/* Line 1455 of yacc.c */ 34931 #line 3008 "gram.y" 34932 { 34933 DropTableSpaceStmt *n = makeNode(DropTableSpaceStmt); 34934@@ -21434,8 +21062,6 @@ 34935 break; 34936 34937 case 490: 34938- 34939-/* Line 1455 of yacc.c */ 34940 #line 3015 "gram.y" 34941 { 34942 DropTableSpaceStmt *n = makeNode(DropTableSpaceStmt); 34943@@ -21446,8 +21072,6 @@ 34944 break; 34945 34946 case 491: 34947- 34948-/* Line 1455 of yacc.c */ 34949 #line 3031 "gram.y" 34950 { 34951 CreateFdwStmt *n = makeNode(CreateFdwStmt); 34952@@ -21459,8 +21083,6 @@ 34953 break; 34954 34955 case 492: 34956- 34957-/* Line 1455 of yacc.c */ 34958 #line 3048 "gram.y" 34959 { 34960 DropFdwStmt *n = makeNode(DropFdwStmt); 34961@@ -21472,8 +21094,6 @@ 34962 break; 34963 34964 case 493: 34965- 34966-/* Line 1455 of yacc.c */ 34967 #line 3056 "gram.y" 34968 { 34969 DropFdwStmt *n = makeNode(DropFdwStmt); 34970@@ -21485,8 +21105,6 @@ 34971 break; 34972 34973 case 494: 34974- 34975-/* Line 1455 of yacc.c */ 34976 #line 3073 "gram.y" 34977 { 34978 AlterFdwStmt *n = makeNode(AlterFdwStmt); 34979@@ -21499,8 +21117,6 @@ 34980 break; 34981 34982 case 495: 34983- 34984-/* Line 1455 of yacc.c */ 34985 #line 3082 "gram.y" 34986 { 34987 AlterFdwStmt *n = makeNode(AlterFdwStmt); 34988@@ -21512,8 +21128,6 @@ 34989 break; 34990 34991 case 496: 34992- 34993-/* Line 1455 of yacc.c */ 34994 #line 3090 "gram.y" 34995 { 34996 AlterFdwStmt *n = makeNode(AlterFdwStmt); 34997@@ -21524,22 +21138,16 @@ 34998 break; 34999 35000 case 497: 35001- 35002-/* Line 1455 of yacc.c */ 35003 #line 3100 "gram.y" 35004 { (yyval.list) = (yyvsp[(3) - (4)].list); ;} 35005 break; 35006 35007 case 498: 35008- 35009-/* Line 1455 of yacc.c */ 35010 #line 3101 "gram.y" 35011 { (yyval.list) = NIL; ;} 35012 break; 35013 35014 case 499: 35015- 35016-/* Line 1455 of yacc.c */ 35017 #line 3106 "gram.y" 35018 { 35019 (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); 35020@@ -21547,8 +21155,6 @@ 35021 break; 35022 35023 case 500: 35024- 35025-/* Line 1455 of yacc.c */ 35026 #line 3110 "gram.y" 35027 { 35028 (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); 35029@@ -21556,15 +21162,11 @@ 35030 break; 35031 35032 case 501: 35033- 35034-/* Line 1455 of yacc.c */ 35035 #line 3117 "gram.y" 35036 { (yyval.list) = (yyvsp[(3) - (4)].list); ;} 35037 break; 35038 35039 case 502: 35040- 35041-/* Line 1455 of yacc.c */ 35042 #line 3122 "gram.y" 35043 { 35044 (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); 35045@@ -21572,8 +21174,6 @@ 35046 break; 35047 35048 case 503: 35049- 35050-/* Line 1455 of yacc.c */ 35051 #line 3126 "gram.y" 35052 { 35053 (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); 35054@@ -21581,8 +21181,6 @@ 35055 break; 35056 35057 case 504: 35058- 35059-/* Line 1455 of yacc.c */ 35060 #line 3133 "gram.y" 35061 { 35062 (yyval.defelt) = (yyvsp[(1) - (1)].defelt); 35063@@ -21590,8 +21188,6 @@ 35064 break; 35065 35066 case 505: 35067- 35068-/* Line 1455 of yacc.c */ 35069 #line 3137 "gram.y" 35070 { 35071 (yyval.defelt) = (yyvsp[(2) - (2)].defelt); 35072@@ -21600,8 +21196,6 @@ 35073 break; 35074 35075 case 506: 35076- 35077-/* Line 1455 of yacc.c */ 35078 #line 3142 "gram.y" 35079 { 35080 (yyval.defelt) = (yyvsp[(2) - (2)].defelt); 35081@@ -21610,8 +21204,6 @@ 35082 break; 35083 35084 case 507: 35085- 35086-/* Line 1455 of yacc.c */ 35087 #line 3147 "gram.y" 35088 { 35089 (yyval.defelt) = makeDefElemExtended(NULL, (yyvsp[(2) - (2)].str), NULL, DEFELEM_DROP); 35090@@ -21619,8 +21211,6 @@ 35091 break; 35092 35093 case 508: 35094- 35095-/* Line 1455 of yacc.c */ 35096 #line 3154 "gram.y" 35097 { 35098 (yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node)); 35099@@ -21628,22 +21218,16 @@ 35100 break; 35101 35102 case 509: 35103- 35104-/* Line 1455 of yacc.c */ 35105 #line 3160 "gram.y" 35106 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 35107 break; 35108 35109 case 510: 35110- 35111-/* Line 1455 of yacc.c */ 35112 #line 3165 "gram.y" 35113 { (yyval.node) = (Node *) makeString((yyvsp[(1) - (1)].str)); ;} 35114 break; 35115 35116 case 511: 35117- 35118-/* Line 1455 of yacc.c */ 35119 #line 3177 "gram.y" 35120 { 35121 CreateForeignServerStmt *n = makeNode(CreateForeignServerStmt); 35122@@ -21657,50 +21241,36 @@ 35123 break; 35124 35125 case 512: 35126- 35127-/* Line 1455 of yacc.c */ 35128 #line 3189 "gram.y" 35129 { (yyval.str) = (yyvsp[(2) - (2)].str); ;} 35130 break; 35131 35132 case 513: 35133- 35134-/* Line 1455 of yacc.c */ 35135 #line 3190 "gram.y" 35136 { (yyval.str) = NULL; ;} 35137 break; 35138 35139 case 514: 35140- 35141-/* Line 1455 of yacc.c */ 35142 #line 3195 "gram.y" 35143 { (yyval.str) = (yyvsp[(2) - (2)].str); ;} 35144 break; 35145 35146 case 515: 35147- 35148-/* Line 1455 of yacc.c */ 35149 #line 3196 "gram.y" 35150 { (yyval.str) = NULL; ;} 35151 break; 35152 35153 case 516: 35154- 35155-/* Line 1455 of yacc.c */ 35156 #line 3200 "gram.y" 35157 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 35158 break; 35159 35160 case 517: 35161- 35162-/* Line 1455 of yacc.c */ 35163 #line 3201 "gram.y" 35164 { (yyval.str) = NULL; ;} 35165 break; 35166 35167 case 518: 35168- 35169-/* Line 1455 of yacc.c */ 35170 #line 3212 "gram.y" 35171 { 35172 DropForeignServerStmt *n = makeNode(DropForeignServerStmt); 35173@@ -21712,8 +21282,6 @@ 35174 break; 35175 35176 case 519: 35177- 35178-/* Line 1455 of yacc.c */ 35179 #line 3220 "gram.y" 35180 { 35181 DropForeignServerStmt *n = makeNode(DropForeignServerStmt); 35182@@ -21725,8 +21293,6 @@ 35183 break; 35184 35185 case 520: 35186- 35187-/* Line 1455 of yacc.c */ 35188 #line 3237 "gram.y" 35189 { 35190 AlterForeignServerStmt *n = makeNode(AlterForeignServerStmt); 35191@@ -21739,8 +21305,6 @@ 35192 break; 35193 35194 case 521: 35195- 35196-/* Line 1455 of yacc.c */ 35197 #line 3246 "gram.y" 35198 { 35199 AlterForeignServerStmt *n = makeNode(AlterForeignServerStmt); 35200@@ -21752,8 +21316,6 @@ 35201 break; 35202 35203 case 522: 35204- 35205-/* Line 1455 of yacc.c */ 35206 #line 3254 "gram.y" 35207 { 35208 AlterForeignServerStmt *n = makeNode(AlterForeignServerStmt); 35209@@ -21764,8 +21326,6 @@ 35210 break; 35211 35212 case 523: 35213- 35214-/* Line 1455 of yacc.c */ 35215 #line 3270 "gram.y" 35216 { 35217 CreateUserMappingStmt *n = makeNode(CreateUserMappingStmt); 35218@@ -21777,29 +21337,21 @@ 35219 break; 35220 35221 case 524: 35222- 35223-/* Line 1455 of yacc.c */ 35224 #line 3281 "gram.y" 35225 { (yyval.str) = "current_user"; ;} 35226 break; 35227 35228 case 525: 35229- 35230-/* Line 1455 of yacc.c */ 35231 #line 3282 "gram.y" 35232 { (yyval.str) = "current_user"; ;} 35233 break; 35234 35235 case 526: 35236- 35237-/* Line 1455 of yacc.c */ 35238 #line 3283 "gram.y" 35239 { (yyval.str) = (strcmp((yyvsp[(1) - (1)].str), "public") == 0) ? NULL : (yyvsp[(1) - (1)].str); ;} 35240 break; 35241 35242 case 527: 35243- 35244-/* Line 1455 of yacc.c */ 35245 #line 3294 "gram.y" 35246 { 35247 DropUserMappingStmt *n = makeNode(DropUserMappingStmt); 35248@@ -21811,8 +21363,6 @@ 35249 break; 35250 35251 case 528: 35252- 35253-/* Line 1455 of yacc.c */ 35254 #line 3302 "gram.y" 35255 { 35256 DropUserMappingStmt *n = makeNode(DropUserMappingStmt); 35257@@ -21824,8 +21374,6 @@ 35258 break; 35259 35260 case 529: 35261- 35262-/* Line 1455 of yacc.c */ 35263 #line 3319 "gram.y" 35264 { 35265 AlterUserMappingStmt *n = makeNode(AlterUserMappingStmt); 35266@@ -21837,8 +21385,6 @@ 35267 break; 35268 35269 case 530: 35270- 35271-/* Line 1455 of yacc.c */ 35272 #line 3340 "gram.y" 35273 { 35274 CreateTrigStmt *n = makeNode(CreateTrigStmt); 35275@@ -21860,8 +21406,6 @@ 35276 break; 35277 35278 case 531: 35279- 35280-/* Line 1455 of yacc.c */ 35281 #line 3361 "gram.y" 35282 { 35283 CreateTrigStmt *n = makeNode(CreateTrigStmt); 35284@@ -21883,29 +21427,21 @@ 35285 break; 35286 35287 case 532: 35288- 35289-/* Line 1455 of yacc.c */ 35290 #line 3381 "gram.y" 35291 { (yyval.boolean) = TRUE; ;} 35292 break; 35293 35294 case 533: 35295- 35296-/* Line 1455 of yacc.c */ 35297 #line 3382 "gram.y" 35298 { (yyval.boolean) = FALSE; ;} 35299 break; 35300 35301 case 534: 35302- 35303-/* Line 1455 of yacc.c */ 35304 #line 3387 "gram.y" 35305 { (yyval.list) = (yyvsp[(1) - (1)].list); ;} 35306 break; 35307 35308 case 535: 35309- 35310-/* Line 1455 of yacc.c */ 35311 #line 3389 "gram.y" 35312 { 35313 int events1 = intVal(linitial((yyvsp[(1) - (3)].list))); 35314@@ -21928,43 +21464,31 @@ 35315 break; 35316 35317 case 536: 35318- 35319-/* Line 1455 of yacc.c */ 35320 #line 3411 "gram.y" 35321 { (yyval.list) = list_make2(makeInteger(TRIGGER_TYPE_INSERT), NIL); ;} 35322 break; 35323 35324 case 537: 35325- 35326-/* Line 1455 of yacc.c */ 35327 #line 3413 "gram.y" 35328 { (yyval.list) = list_make2(makeInteger(TRIGGER_TYPE_DELETE), NIL); ;} 35329 break; 35330 35331 case 538: 35332- 35333-/* Line 1455 of yacc.c */ 35334 #line 3415 "gram.y" 35335 { (yyval.list) = list_make2(makeInteger(TRIGGER_TYPE_UPDATE), NIL); ;} 35336 break; 35337 35338 case 539: 35339- 35340-/* Line 1455 of yacc.c */ 35341 #line 3417 "gram.y" 35342 { (yyval.list) = list_make2(makeInteger(TRIGGER_TYPE_UPDATE), (yyvsp[(3) - (3)].list)); ;} 35343 break; 35344 35345 case 540: 35346- 35347-/* Line 1455 of yacc.c */ 35348 #line 3419 "gram.y" 35349 { (yyval.list) = list_make2(makeInteger(TRIGGER_TYPE_TRUNCATE), NIL); ;} 35350 break; 35351 35352 case 541: 35353- 35354-/* Line 1455 of yacc.c */ 35355 #line 3424 "gram.y" 35356 { 35357 (yyval.boolean) = (yyvsp[(3) - (3)].boolean); 35358@@ -21972,8 +21496,6 @@ 35359 break; 35360 35361 case 542: 35362- 35363-/* Line 1455 of yacc.c */ 35364 #line 3428 "gram.y" 35365 { 35366 /* 35367@@ -21985,71 +21507,51 @@ 35368 break; 35369 35370 case 543: 35371- 35372-/* Line 1455 of yacc.c */ 35373 #line 3438 "gram.y" 35374 {;} 35375 break; 35376 35377 case 544: 35378- 35379-/* Line 1455 of yacc.c */ 35380 #line 3439 "gram.y" 35381 {;} 35382 break; 35383 35384 case 545: 35385- 35386-/* Line 1455 of yacc.c */ 35387 #line 3443 "gram.y" 35388 { (yyval.boolean) = TRUE; ;} 35389 break; 35390 35391 case 546: 35392- 35393-/* Line 1455 of yacc.c */ 35394 #line 3444 "gram.y" 35395 { (yyval.boolean) = FALSE; ;} 35396 break; 35397 35398 case 547: 35399- 35400-/* Line 1455 of yacc.c */ 35401 #line 3448 "gram.y" 35402 { (yyval.node) = (yyvsp[(3) - (4)].node); ;} 35403 break; 35404 35405 case 548: 35406- 35407-/* Line 1455 of yacc.c */ 35408 #line 3449 "gram.y" 35409 { (yyval.node) = NULL; ;} 35410 break; 35411 35412 case 549: 35413- 35414-/* Line 1455 of yacc.c */ 35415 #line 3453 "gram.y" 35416 { (yyval.list) = list_make1((yyvsp[(1) - (1)].value)); ;} 35417 break; 35418 35419 case 550: 35420- 35421-/* Line 1455 of yacc.c */ 35422 #line 3454 "gram.y" 35423 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].value)); ;} 35424 break; 35425 35426 case 551: 35427- 35428-/* Line 1455 of yacc.c */ 35429 #line 3455 "gram.y" 35430 { (yyval.list) = NIL; ;} 35431 break; 35432 35433 case 552: 35434- 35435-/* Line 1455 of yacc.c */ 35436 #line 3460 "gram.y" 35437 { 35438 char buf[64]; 35439@@ -22059,64 +21561,46 @@ 35440 break; 35441 35442 case 553: 35443- 35444-/* Line 1455 of yacc.c */ 35445 #line 3465 "gram.y" 35446 { (yyval.value) = makeString((yyvsp[(1) - (1)].str)); ;} 35447 break; 35448 35449 case 554: 35450- 35451-/* Line 1455 of yacc.c */ 35452 #line 3466 "gram.y" 35453 { (yyval.value) = makeString((yyvsp[(1) - (1)].str)); ;} 35454 break; 35455 35456 case 555: 35457- 35458-/* Line 1455 of yacc.c */ 35459 #line 3467 "gram.y" 35460 { (yyval.value) = makeString((yyvsp[(1) - (1)].str)); ;} 35461 break; 35462 35463 case 556: 35464- 35465-/* Line 1455 of yacc.c */ 35466 #line 3468 "gram.y" 35467 { (yyval.value) = makeString((yyvsp[(1) - (1)].str)); ;} 35468 break; 35469 35470 case 557: 35471- 35472-/* Line 1455 of yacc.c */ 35473 #line 3469 "gram.y" 35474 { (yyval.value) = makeString((yyvsp[(1) - (1)].str)); ;} 35475 break; 35476 35477 case 558: 35478- 35479-/* Line 1455 of yacc.c */ 35480 #line 3473 "gram.y" 35481 { (yyval.range) = (yyvsp[(2) - (2)].range); ;} 35482 break; 35483 35484 case 559: 35485- 35486-/* Line 1455 of yacc.c */ 35487 #line 3474 "gram.y" 35488 { (yyval.range) = NULL; ;} 35489 break; 35490 35491 case 560: 35492- 35493-/* Line 1455 of yacc.c */ 35494 #line 3479 "gram.y" 35495 { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;} 35496 break; 35497 35498 case 561: 35499- 35500-/* Line 1455 of yacc.c */ 35501 #line 3481 "gram.y" 35502 { 35503 if ((yyvsp[(1) - (2)].ival) == 0 && (yyvsp[(2) - (2)].ival) != 0) 35504@@ -22129,8 +21613,6 @@ 35505 break; 35506 35507 case 562: 35508- 35509-/* Line 1455 of yacc.c */ 35510 #line 3490 "gram.y" 35511 { 35512 if ((yyvsp[(1) - (1)].ival) != 0) 35513@@ -22141,8 +21623,6 @@ 35514 break; 35515 35516 case 563: 35517- 35518-/* Line 1455 of yacc.c */ 35519 #line 3497 "gram.y" 35520 { 35521 if ((yyvsp[(2) - (2)].ival) == 0 && (yyvsp[(1) - (2)].ival) != 0) 35522@@ -22155,43 +21635,31 @@ 35523 break; 35524 35525 case 564: 35526- 35527-/* Line 1455 of yacc.c */ 35528 #line 3506 "gram.y" 35529 { (yyval.ival) = 0; ;} 35530 break; 35531 35532 case 565: 35533- 35534-/* Line 1455 of yacc.c */ 35535 #line 3510 "gram.y" 35536 { (yyval.ival) = 0; ;} 35537 break; 35538 35539 case 566: 35540- 35541-/* Line 1455 of yacc.c */ 35542 #line 3511 "gram.y" 35543 { (yyval.ival) = 1; ;} 35544 break; 35545 35546 case 567: 35547- 35548-/* Line 1455 of yacc.c */ 35549 #line 3515 "gram.y" 35550 { (yyval.ival) = 0; ;} 35551 break; 35552 35553 case 568: 35554- 35555-/* Line 1455 of yacc.c */ 35556 #line 3516 "gram.y" 35557 { (yyval.ival) = 2; ;} 35558 break; 35559 35560 case 569: 35561- 35562-/* Line 1455 of yacc.c */ 35563 #line 3522 "gram.y" 35564 { 35565 DropPropertyStmt *n = makeNode(DropPropertyStmt); 35566@@ -22205,8 +21673,6 @@ 35567 break; 35568 35569 case 570: 35570- 35571-/* Line 1455 of yacc.c */ 35572 #line 3532 "gram.y" 35573 { 35574 DropPropertyStmt *n = makeNode(DropPropertyStmt); 35575@@ -22220,8 +21686,6 @@ 35576 break; 35577 35578 case 571: 35579- 35580-/* Line 1455 of yacc.c */ 35581 #line 3555 "gram.y" 35582 { 35583 CreateTrigStmt *n = makeNode(CreateTrigStmt); 35584@@ -22240,8 +21704,6 @@ 35585 break; 35586 35587 case 572: 35588- 35589-/* Line 1455 of yacc.c */ 35590 #line 3573 "gram.y" 35591 { 35592 DropPropertyStmt *n = makeNode(DropPropertyStmt); 35593@@ -22257,8 +21719,6 @@ 35594 break; 35595 35596 case 573: 35597- 35598-/* Line 1455 of yacc.c */ 35599 #line 3596 "gram.y" 35600 { 35601 DefineStmt *n = makeNode(DefineStmt); 35602@@ -22272,8 +21732,6 @@ 35603 break; 35604 35605 case 574: 35606- 35607-/* Line 1455 of yacc.c */ 35608 #line 3606 "gram.y" 35609 { 35610 /* old-style (pre-8.2) syntax for CREATE AGGREGATE */ 35611@@ -22288,8 +21746,6 @@ 35612 break; 35613 35614 case 575: 35615- 35616-/* Line 1455 of yacc.c */ 35617 #line 3617 "gram.y" 35618 { 35619 DefineStmt *n = makeNode(DefineStmt); 35620@@ -22303,8 +21759,6 @@ 35621 break; 35622 35623 case 576: 35624- 35625-/* Line 1455 of yacc.c */ 35626 #line 3627 "gram.y" 35627 { 35628 DefineStmt *n = makeNode(DefineStmt); 35629@@ -22318,8 +21772,6 @@ 35630 break; 35631 35632 case 577: 35633- 35634-/* Line 1455 of yacc.c */ 35635 #line 3637 "gram.y" 35636 { 35637 /* Shell type (identified by lack of definition) */ 35638@@ -22334,8 +21786,6 @@ 35639 break; 35640 35641 case 578: 35642- 35643-/* Line 1455 of yacc.c */ 35644 #line 3648 "gram.y" 35645 { 35646 CompositeTypeStmt *n = makeNode(CompositeTypeStmt); 35647@@ -22375,8 +21825,6 @@ 35648 break; 35649 35650 case 579: 35651- 35652-/* Line 1455 of yacc.c */ 35653 #line 3684 "gram.y" 35654 { 35655 CreateEnumStmt *n = makeNode(CreateEnumStmt); 35656@@ -22387,8 +21835,6 @@ 35657 break; 35658 35659 case 580: 35660- 35661-/* Line 1455 of yacc.c */ 35662 #line 3691 "gram.y" 35663 { 35664 DefineStmt *n = makeNode(DefineStmt); 35665@@ -22401,8 +21847,6 @@ 35666 break; 35667 35668 case 581: 35669- 35670-/* Line 1455 of yacc.c */ 35671 #line 3700 "gram.y" 35672 { 35673 DefineStmt *n = makeNode(DefineStmt); 35674@@ -22415,8 +21859,6 @@ 35675 break; 35676 35677 case 582: 35678- 35679-/* Line 1455 of yacc.c */ 35680 #line 3709 "gram.y" 35681 { 35682 DefineStmt *n = makeNode(DefineStmt); 35683@@ -22429,8 +21871,6 @@ 35684 break; 35685 35686 case 583: 35687- 35688-/* Line 1455 of yacc.c */ 35689 #line 3718 "gram.y" 35690 { 35691 DefineStmt *n = makeNode(DefineStmt); 35692@@ -22443,29 +21883,21 @@ 35693 break; 35694 35695 case 584: 35696- 35697-/* Line 1455 of yacc.c */ 35698 #line 3728 "gram.y" 35699 { (yyval.list) = (yyvsp[(2) - (3)].list); ;} 35700 break; 35701 35702 case 585: 35703- 35704-/* Line 1455 of yacc.c */ 35705 #line 3731 "gram.y" 35706 { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} 35707 break; 35708 35709 case 586: 35710- 35711-/* Line 1455 of yacc.c */ 35712 #line 3732 "gram.y" 35713 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); ;} 35714 break; 35715 35716 case 587: 35717- 35718-/* Line 1455 of yacc.c */ 35719 #line 3736 "gram.y" 35720 { 35721 (yyval.defelt) = makeDefElem((yyvsp[(1) - (3)].str), (Node *) (yyvsp[(3) - (3)].node)); 35722@@ -22473,8 +21905,6 @@ 35723 break; 35724 35725 case 588: 35726- 35727-/* Line 1455 of yacc.c */ 35728 #line 3740 "gram.y" 35729 { 35730 (yyval.defelt) = makeDefElem((yyvsp[(1) - (1)].str), NULL); 35731@@ -22482,78 +21912,56 @@ 35732 break; 35733 35734 case 589: 35735- 35736-/* Line 1455 of yacc.c */ 35737 #line 3746 "gram.y" 35738 { (yyval.node) = (Node *)(yyvsp[(1) - (1)].typnam); ;} 35739 break; 35740 35741 case 590: 35742- 35743-/* Line 1455 of yacc.c */ 35744 #line 3747 "gram.y" 35745 { (yyval.node) = (Node *)makeString(pstrdup((yyvsp[(1) - (1)].keyword))); ;} 35746 break; 35747 35748 case 591: 35749- 35750-/* Line 1455 of yacc.c */ 35751 #line 3748 "gram.y" 35752 { (yyval.node) = (Node *)(yyvsp[(1) - (1)].list); ;} 35753 break; 35754 35755 case 592: 35756- 35757-/* Line 1455 of yacc.c */ 35758 #line 3749 "gram.y" 35759 { (yyval.node) = (Node *)(yyvsp[(1) - (1)].value); ;} 35760 break; 35761 35762 case 593: 35763- 35764-/* Line 1455 of yacc.c */ 35765 #line 3750 "gram.y" 35766 { (yyval.node) = (Node *)makeString((yyvsp[(1) - (1)].str)); ;} 35767 break; 35768 35769 case 594: 35770- 35771-/* Line 1455 of yacc.c */ 35772 #line 3753 "gram.y" 35773 { (yyval.list) = (yyvsp[(2) - (3)].list); ;} 35774 break; 35775 35776 case 595: 35777- 35778-/* Line 1455 of yacc.c */ 35779 #line 3754 "gram.y" 35780 { (yyval.list) = NIL; ;} 35781 break; 35782 35783 case 596: 35784- 35785-/* Line 1455 of yacc.c */ 35786 #line 3757 "gram.y" 35787 { (yyval.list) = (yyvsp[(2) - (3)].list); ;} 35788 break; 35789 35790 case 597: 35791- 35792-/* Line 1455 of yacc.c */ 35793 #line 3760 "gram.y" 35794 { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} 35795 break; 35796 35797 case 598: 35798- 35799-/* Line 1455 of yacc.c */ 35800 #line 3761 "gram.y" 35801 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); ;} 35802 break; 35803 35804 case 599: 35805- 35806-/* Line 1455 of yacc.c */ 35807 #line 3770 "gram.y" 35808 { 35809 (yyval.defelt) = makeDefElem((yyvsp[(1) - (3)].str), (Node *)(yyvsp[(3) - (3)].node)); 35810@@ -22561,36 +21969,26 @@ 35811 break; 35812 35813 case 600: 35814- 35815-/* Line 1455 of yacc.c */ 35816 #line 3776 "gram.y" 35817 { (yyval.list) = (yyvsp[(1) - (1)].list); ;} 35818 break; 35819 35820 case 601: 35821- 35822-/* Line 1455 of yacc.c */ 35823 #line 3777 "gram.y" 35824 { (yyval.list) = NIL; ;} 35825 break; 35826 35827 case 602: 35828- 35829-/* Line 1455 of yacc.c */ 35830 #line 3781 "gram.y" 35831 { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} 35832 break; 35833 35834 case 603: 35835- 35836-/* Line 1455 of yacc.c */ 35837 #line 3783 "gram.y" 35838 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;} 35839 break; 35840 35841 case 604: 35842- 35843-/* Line 1455 of yacc.c */ 35844 #line 3801 "gram.y" 35845 { 35846 CreateOpClassStmt *n = makeNode(CreateOpClassStmt); 35847@@ -22605,22 +22003,16 @@ 35848 break; 35849 35850 case 605: 35851- 35852-/* Line 1455 of yacc.c */ 35853 #line 3814 "gram.y" 35854 { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} 35855 break; 35856 35857 case 606: 35858- 35859-/* Line 1455 of yacc.c */ 35860 #line 3815 "gram.y" 35861 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} 35862 break; 35863 35864 case 607: 35865- 35866-/* Line 1455 of yacc.c */ 35867 #line 3820 "gram.y" 35868 { 35869 CreateOpClassItem *n = makeNode(CreateOpClassItem); 35870@@ -22633,8 +22025,6 @@ 35871 break; 35872 35873 case 608: 35874- 35875-/* Line 1455 of yacc.c */ 35876 #line 3829 "gram.y" 35877 { 35878 CreateOpClassItem *n = makeNode(CreateOpClassItem); 35879@@ -22647,8 +22037,6 @@ 35880 break; 35881 35882 case 609: 35883- 35884-/* Line 1455 of yacc.c */ 35885 #line 3838 "gram.y" 35886 { 35887 CreateOpClassItem *n = makeNode(CreateOpClassItem); 35888@@ -22661,8 +22049,6 @@ 35889 break; 35890 35891 case 610: 35892- 35893-/* Line 1455 of yacc.c */ 35894 #line 3847 "gram.y" 35895 { 35896 CreateOpClassItem *n = makeNode(CreateOpClassItem); 35897@@ -22676,8 +22062,6 @@ 35898 break; 35899 35900 case 611: 35901- 35902-/* Line 1455 of yacc.c */ 35903 #line 3857 "gram.y" 35904 { 35905 CreateOpClassItem *n = makeNode(CreateOpClassItem); 35906@@ -22688,36 +22072,26 @@ 35907 break; 35908 35909 case 612: 35910- 35911-/* Line 1455 of yacc.c */ 35912 #line 3865 "gram.y" 35913 { (yyval.boolean) = TRUE; ;} 35914 break; 35915 35916 case 613: 35917- 35918-/* Line 1455 of yacc.c */ 35919 #line 3866 "gram.y" 35920 { (yyval.boolean) = FALSE; ;} 35921 break; 35922 35923 case 614: 35924- 35925-/* Line 1455 of yacc.c */ 35926 #line 3869 "gram.y" 35927 { (yyval.list) = (yyvsp[(2) - (2)].list); ;} 35928 break; 35929 35930 case 615: 35931- 35932-/* Line 1455 of yacc.c */ 35933 #line 3870 "gram.y" 35934 { (yyval.list) = NIL; ;} 35935 break; 35936 35937 case 616: 35938- 35939-/* Line 1455 of yacc.c */ 35940 #line 3874 "gram.y" 35941 { 35942 /* 35943@@ -22735,15 +22109,11 @@ 35944 break; 35945 35946 case 617: 35947- 35948-/* Line 1455 of yacc.c */ 35949 #line 3887 "gram.y" 35950 { (yyval.boolean) = FALSE; ;} 35951 break; 35952 35953 case 618: 35954- 35955-/* Line 1455 of yacc.c */ 35956 #line 3893 "gram.y" 35957 { 35958 CreateOpFamilyStmt *n = makeNode(CreateOpFamilyStmt); 35959@@ -22754,8 +22124,6 @@ 35960 break; 35961 35962 case 619: 35963- 35964-/* Line 1455 of yacc.c */ 35965 #line 3903 "gram.y" 35966 { 35967 AlterOpFamilyStmt *n = makeNode(AlterOpFamilyStmt); 35968@@ -22768,8 +22136,6 @@ 35969 break; 35970 35971 case 620: 35972- 35973-/* Line 1455 of yacc.c */ 35974 #line 3912 "gram.y" 35975 { 35976 AlterOpFamilyStmt *n = makeNode(AlterOpFamilyStmt); 35977@@ -22782,22 +22148,16 @@ 35978 break; 35979 35980 case 621: 35981- 35982-/* Line 1455 of yacc.c */ 35983 #line 3923 "gram.y" 35984 { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} 35985 break; 35986 35987 case 622: 35988- 35989-/* Line 1455 of yacc.c */ 35990 #line 3924 "gram.y" 35991 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} 35992 break; 35993 35994 case 623: 35995- 35996-/* Line 1455 of yacc.c */ 35997 #line 3929 "gram.y" 35998 { 35999 CreateOpClassItem *n = makeNode(CreateOpClassItem); 36000@@ -22809,8 +22169,6 @@ 36001 break; 36002 36003 case 624: 36004- 36005-/* Line 1455 of yacc.c */ 36006 #line 3937 "gram.y" 36007 { 36008 CreateOpClassItem *n = makeNode(CreateOpClassItem); 36009@@ -22822,8 +22180,6 @@ 36010 break; 36011 36012 case 625: 36013- 36014-/* Line 1455 of yacc.c */ 36015 #line 3949 "gram.y" 36016 { 36017 RemoveOpClassStmt *n = makeNode(RemoveOpClassStmt); 36018@@ -22836,8 +22192,6 @@ 36019 break; 36020 36021 case 626: 36022- 36023-/* Line 1455 of yacc.c */ 36024 #line 3958 "gram.y" 36025 { 36026 RemoveOpClassStmt *n = makeNode(RemoveOpClassStmt); 36027@@ -22850,8 +22204,6 @@ 36028 break; 36029 36030 case 627: 36031- 36032-/* Line 1455 of yacc.c */ 36033 #line 3970 "gram.y" 36034 { 36035 RemoveOpFamilyStmt *n = makeNode(RemoveOpFamilyStmt); 36036@@ -22864,8 +22216,6 @@ 36037 break; 36038 36039 case 628: 36040- 36041-/* Line 1455 of yacc.c */ 36042 #line 3979 "gram.y" 36043 { 36044 RemoveOpFamilyStmt *n = makeNode(RemoveOpFamilyStmt); 36045@@ -22878,8 +22228,6 @@ 36046 break; 36047 36048 case 629: 36049- 36050-/* Line 1455 of yacc.c */ 36051 #line 4000 "gram.y" 36052 { 36053 DropOwnedStmt *n = makeNode(DropOwnedStmt); 36054@@ -22890,8 +22238,6 @@ 36055 break; 36056 36057 case 630: 36058- 36059-/* Line 1455 of yacc.c */ 36060 #line 4010 "gram.y" 36061 { 36062 ReassignOwnedStmt *n = makeNode(ReassignOwnedStmt); 36063@@ -22902,8 +22248,6 @@ 36064 break; 36065 36066 case 631: 36067- 36068-/* Line 1455 of yacc.c */ 36069 #line 4028 "gram.y" 36070 { 36071 DropStmt *n = makeNode(DropStmt); 36072@@ -22916,8 +22260,6 @@ 36073 break; 36074 36075 case 632: 36076- 36077-/* Line 1455 of yacc.c */ 36078 #line 4037 "gram.y" 36079 { 36080 DropStmt *n = makeNode(DropStmt); 36081@@ -22930,134 +22272,96 @@ 36082 break; 36083 36084 case 633: 36085- 36086-/* Line 1455 of yacc.c */ 36087 #line 4048 "gram.y" 36088 { (yyval.objtype) = OBJECT_TABLE; ;} 36089 break; 36090 36091 case 634: 36092- 36093-/* Line 1455 of yacc.c */ 36094 #line 4049 "gram.y" 36095 { (yyval.objtype) = OBJECT_SEQUENCE; ;} 36096 break; 36097 36098 case 635: 36099- 36100-/* Line 1455 of yacc.c */ 36101 #line 4050 "gram.y" 36102 { (yyval.objtype) = OBJECT_VIEW; ;} 36103 break; 36104 36105 case 636: 36106- 36107-/* Line 1455 of yacc.c */ 36108 #line 4051 "gram.y" 36109 { (yyval.objtype) = OBJECT_INDEX; ;} 36110 break; 36111 36112 case 637: 36113- 36114-/* Line 1455 of yacc.c */ 36115 #line 4052 "gram.y" 36116 { (yyval.objtype) = OBJECT_TYPE; ;} 36117 break; 36118 36119 case 638: 36120- 36121-/* Line 1455 of yacc.c */ 36122 #line 4053 "gram.y" 36123 { (yyval.objtype) = OBJECT_DOMAIN; ;} 36124 break; 36125 36126 case 639: 36127- 36128-/* Line 1455 of yacc.c */ 36129 #line 4054 "gram.y" 36130 { (yyval.objtype) = OBJECT_CONVERSION; ;} 36131 break; 36132 36133 case 640: 36134- 36135-/* Line 1455 of yacc.c */ 36136 #line 4055 "gram.y" 36137 { (yyval.objtype) = OBJECT_SCHEMA; ;} 36138 break; 36139 36140 case 641: 36141- 36142-/* Line 1455 of yacc.c */ 36143 #line 4056 "gram.y" 36144 { (yyval.objtype) = OBJECT_TSPARSER; ;} 36145 break; 36146 36147 case 642: 36148- 36149-/* Line 1455 of yacc.c */ 36150 #line 4057 "gram.y" 36151 { (yyval.objtype) = OBJECT_TSDICTIONARY; ;} 36152 break; 36153 36154 case 643: 36155- 36156-/* Line 1455 of yacc.c */ 36157 #line 4058 "gram.y" 36158 { (yyval.objtype) = OBJECT_TSTEMPLATE; ;} 36159 break; 36160 36161 case 644: 36162- 36163-/* Line 1455 of yacc.c */ 36164 #line 4059 "gram.y" 36165 { (yyval.objtype) = OBJECT_TSCONFIGURATION; ;} 36166 break; 36167 36168 case 645: 36169- 36170-/* Line 1455 of yacc.c */ 36171 #line 4063 "gram.y" 36172 { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} 36173 break; 36174 36175 case 646: 36176- 36177-/* Line 1455 of yacc.c */ 36178 #line 4064 "gram.y" 36179 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} 36180 break; 36181 36182 case 647: 36183- 36184-/* Line 1455 of yacc.c */ 36185 #line 4067 "gram.y" 36186 { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} 36187 break; 36188 36189 case 648: 36190- 36191-/* Line 1455 of yacc.c */ 36192 #line 4068 "gram.y" 36193 { (yyval.list) = lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)); ;} 36194 break; 36195 36196 case 649: 36197- 36198-/* Line 1455 of yacc.c */ 36199 #line 4072 "gram.y" 36200 { (yyval.list) = list_make1(makeString((yyvsp[(2) - (2)].str))); ;} 36201 break; 36202 36203 case 650: 36204- 36205-/* Line 1455 of yacc.c */ 36206 #line 4074 "gram.y" 36207 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;} 36208 break; 36209 36210 case 651: 36211- 36212-/* Line 1455 of yacc.c */ 36213 #line 4087 "gram.y" 36214 { 36215 TruncateStmt *n = makeNode(TruncateStmt); 36216@@ -23069,29 +22373,21 @@ 36217 break; 36218 36219 case 652: 36220- 36221-/* Line 1455 of yacc.c */ 36222 #line 4097 "gram.y" 36223 { (yyval.boolean) = false; ;} 36224 break; 36225 36226 case 653: 36227- 36228-/* Line 1455 of yacc.c */ 36229 #line 4098 "gram.y" 36230 { (yyval.boolean) = true; ;} 36231 break; 36232 36233 case 654: 36234- 36235-/* Line 1455 of yacc.c */ 36236 #line 4099 "gram.y" 36237 { (yyval.boolean) = false; ;} 36238 break; 36239 36240 case 655: 36241- 36242-/* Line 1455 of yacc.c */ 36243 #line 4125 "gram.y" 36244 { 36245 CommentStmt *n = makeNode(CommentStmt); 36246@@ -23104,8 +22400,6 @@ 36247 break; 36248 36249 case 656: 36250- 36251-/* Line 1455 of yacc.c */ 36252 #line 4134 "gram.y" 36253 { 36254 CommentStmt *n = makeNode(CommentStmt); 36255@@ -23118,8 +22412,6 @@ 36256 break; 36257 36258 case 657: 36259- 36260-/* Line 1455 of yacc.c */ 36261 #line 4143 "gram.y" 36262 { 36263 CommentStmt *n = makeNode(CommentStmt); 36264@@ -23132,8 +22424,6 @@ 36265 break; 36266 36267 case 658: 36268- 36269-/* Line 1455 of yacc.c */ 36270 #line 4152 "gram.y" 36271 { 36272 CommentStmt *n = makeNode(CommentStmt); 36273@@ -23146,8 +22436,6 @@ 36274 break; 36275 36276 case 659: 36277- 36278-/* Line 1455 of yacc.c */ 36279 #line 4161 "gram.y" 36280 { 36281 CommentStmt *n = makeNode(CommentStmt); 36282@@ -23160,8 +22448,6 @@ 36283 break; 36284 36285 case 660: 36286- 36287-/* Line 1455 of yacc.c */ 36288 #line 4170 "gram.y" 36289 { 36290 CommentStmt *n = makeNode(CommentStmt); 36291@@ -23174,8 +22460,6 @@ 36292 break; 36293 36294 case 661: 36295- 36296-/* Line 1455 of yacc.c */ 36297 #line 4179 "gram.y" 36298 { 36299 /* Obsolete syntax supported for awhile for compatibility */ 36300@@ -23189,8 +22473,6 @@ 36301 break; 36302 36303 case 662: 36304- 36305-/* Line 1455 of yacc.c */ 36306 #line 4189 "gram.y" 36307 { 36308 CommentStmt *n = makeNode(CommentStmt); 36309@@ -23203,8 +22485,6 @@ 36310 break; 36311 36312 case 663: 36313- 36314-/* Line 1455 of yacc.c */ 36315 #line 4198 "gram.y" 36316 { 36317 CommentStmt *n = makeNode(CommentStmt); 36318@@ -23217,8 +22497,6 @@ 36319 break; 36320 36321 case 664: 36322- 36323-/* Line 1455 of yacc.c */ 36324 #line 4207 "gram.y" 36325 { 36326 CommentStmt *n = makeNode(CommentStmt); 36327@@ -23231,8 +22509,6 @@ 36328 break; 36329 36330 case 665: 36331- 36332-/* Line 1455 of yacc.c */ 36333 #line 4216 "gram.y" 36334 { 36335 CommentStmt *n = makeNode(CommentStmt); 36336@@ -23245,8 +22521,6 @@ 36337 break; 36338 36339 case 666: 36340- 36341-/* Line 1455 of yacc.c */ 36342 #line 4225 "gram.y" 36343 { 36344 CommentStmt *n = makeNode(CommentStmt); 36345@@ -23259,8 +22533,6 @@ 36346 break; 36347 36348 case 667: 36349- 36350-/* Line 1455 of yacc.c */ 36351 #line 4234 "gram.y" 36352 { 36353 CommentStmt *n = makeNode(CommentStmt); 36354@@ -23273,8 +22545,6 @@ 36355 break; 36356 36357 case 668: 36358- 36359-/* Line 1455 of yacc.c */ 36360 #line 4243 "gram.y" 36361 { 36362 CommentStmt *n = makeNode(CommentStmt); 36363@@ -23286,8 +22556,6 @@ 36364 break; 36365 36366 case 669: 36367- 36368-/* Line 1455 of yacc.c */ 36369 #line 4251 "gram.y" 36370 { 36371 CommentStmt *n = makeNode(CommentStmt); 36372@@ -23299,8 +22567,6 @@ 36373 break; 36374 36375 case 670: 36376- 36377-/* Line 1455 of yacc.c */ 36378 #line 4259 "gram.y" 36379 { 36380 CommentStmt *n = makeNode(CommentStmt); 36381@@ -23312,8 +22578,6 @@ 36382 break; 36383 36384 case 671: 36385- 36386-/* Line 1455 of yacc.c */ 36387 #line 4267 "gram.y" 36388 { 36389 CommentStmt *n = makeNode(CommentStmt); 36390@@ -23325,106 +22589,76 @@ 36391 break; 36392 36393 case 672: 36394- 36395-/* Line 1455 of yacc.c */ 36396 #line 4277 "gram.y" 36397 { (yyval.objtype) = OBJECT_COLUMN; ;} 36398 break; 36399 36400 case 673: 36401- 36402-/* Line 1455 of yacc.c */ 36403 #line 4278 "gram.y" 36404 { (yyval.objtype) = OBJECT_DATABASE; ;} 36405 break; 36406 36407 case 674: 36408- 36409-/* Line 1455 of yacc.c */ 36410 #line 4279 "gram.y" 36411 { (yyval.objtype) = OBJECT_SCHEMA; ;} 36412 break; 36413 36414 case 675: 36415- 36416-/* Line 1455 of yacc.c */ 36417 #line 4280 "gram.y" 36418 { (yyval.objtype) = OBJECT_INDEX; ;} 36419 break; 36420 36421 case 676: 36422- 36423-/* Line 1455 of yacc.c */ 36424 #line 4281 "gram.y" 36425 { (yyval.objtype) = OBJECT_SEQUENCE; ;} 36426 break; 36427 36428 case 677: 36429- 36430-/* Line 1455 of yacc.c */ 36431 #line 4282 "gram.y" 36432 { (yyval.objtype) = OBJECT_TABLE; ;} 36433 break; 36434 36435 case 678: 36436- 36437-/* Line 1455 of yacc.c */ 36438 #line 4283 "gram.y" 36439 { (yyval.objtype) = OBJECT_TYPE; ;} 36440 break; 36441 36442 case 679: 36443- 36444-/* Line 1455 of yacc.c */ 36445 #line 4284 "gram.y" 36446 { (yyval.objtype) = OBJECT_TYPE; ;} 36447 break; 36448 36449 case 680: 36450- 36451-/* Line 1455 of yacc.c */ 36452 #line 4285 "gram.y" 36453 { (yyval.objtype) = OBJECT_VIEW; ;} 36454 break; 36455 36456 case 681: 36457- 36458-/* Line 1455 of yacc.c */ 36459 #line 4286 "gram.y" 36460 { (yyval.objtype) = OBJECT_CONVERSION; ;} 36461 break; 36462 36463 case 682: 36464- 36465-/* Line 1455 of yacc.c */ 36466 #line 4287 "gram.y" 36467 { (yyval.objtype) = OBJECT_TABLESPACE; ;} 36468 break; 36469 36470 case 683: 36471- 36472-/* Line 1455 of yacc.c */ 36473 #line 4288 "gram.y" 36474 { (yyval.objtype) = OBJECT_ROLE; ;} 36475 break; 36476 36477 case 684: 36478- 36479-/* Line 1455 of yacc.c */ 36480 #line 4292 "gram.y" 36481 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 36482 break; 36483 36484 case 685: 36485- 36486-/* Line 1455 of yacc.c */ 36487 #line 4293 "gram.y" 36488 { (yyval.str) = NULL; ;} 36489 break; 36490 36491 case 686: 36492- 36493-/* Line 1455 of yacc.c */ 36494 #line 4304 "gram.y" 36495 { 36496 FetchStmt *n = (FetchStmt *) (yyvsp[(2) - (2)].node); 36497@@ -23434,8 +22668,6 @@ 36498 break; 36499 36500 case 687: 36501- 36502-/* Line 1455 of yacc.c */ 36503 #line 4310 "gram.y" 36504 { 36505 FetchStmt *n = (FetchStmt *) (yyvsp[(2) - (2)].node); 36506@@ -23445,8 +22677,6 @@ 36507 break; 36508 36509 case 688: 36510- 36511-/* Line 1455 of yacc.c */ 36512 #line 4318 "gram.y" 36513 { 36514 FetchStmt *n = makeNode(FetchStmt); 36515@@ -23458,8 +22688,6 @@ 36516 break; 36517 36518 case 689: 36519- 36520-/* Line 1455 of yacc.c */ 36521 #line 4326 "gram.y" 36522 { 36523 FetchStmt *n = makeNode(FetchStmt); 36524@@ -23471,8 +22699,6 @@ 36525 break; 36526 36527 case 690: 36528- 36529-/* Line 1455 of yacc.c */ 36530 #line 4334 "gram.y" 36531 { 36532 FetchStmt *n = makeNode(FetchStmt); 36533@@ -23484,8 +22710,6 @@ 36534 break; 36535 36536 case 691: 36537- 36538-/* Line 1455 of yacc.c */ 36539 #line 4342 "gram.y" 36540 { 36541 FetchStmt *n = makeNode(FetchStmt); 36542@@ -23497,8 +22721,6 @@ 36543 break; 36544 36545 case 692: 36546- 36547-/* Line 1455 of yacc.c */ 36548 #line 4350 "gram.y" 36549 { 36550 FetchStmt *n = makeNode(FetchStmt); 36551@@ -23510,8 +22732,6 @@ 36552 break; 36553 36554 case 693: 36555- 36556-/* Line 1455 of yacc.c */ 36557 #line 4358 "gram.y" 36558 { 36559 FetchStmt *n = makeNode(FetchStmt); 36560@@ -23523,8 +22743,6 @@ 36561 break; 36562 36563 case 694: 36564- 36565-/* Line 1455 of yacc.c */ 36566 #line 4366 "gram.y" 36567 { 36568 FetchStmt *n = makeNode(FetchStmt); 36569@@ -23536,8 +22754,6 @@ 36570 break; 36571 36572 case 695: 36573- 36574-/* Line 1455 of yacc.c */ 36575 #line 4374 "gram.y" 36576 { 36577 FetchStmt *n = makeNode(FetchStmt); 36578@@ -23549,8 +22765,6 @@ 36579 break; 36580 36581 case 696: 36582- 36583-/* Line 1455 of yacc.c */ 36584 #line 4382 "gram.y" 36585 { 36586 FetchStmt *n = makeNode(FetchStmt); 36587@@ -23562,8 +22776,6 @@ 36588 break; 36589 36590 case 697: 36591- 36592-/* Line 1455 of yacc.c */ 36593 #line 4390 "gram.y" 36594 { 36595 FetchStmt *n = makeNode(FetchStmt); 36596@@ -23575,8 +22787,6 @@ 36597 break; 36598 36599 case 698: 36600- 36601-/* Line 1455 of yacc.c */ 36602 #line 4398 "gram.y" 36603 { 36604 FetchStmt *n = makeNode(FetchStmt); 36605@@ -23588,8 +22798,6 @@ 36606 break; 36607 36608 case 699: 36609- 36610-/* Line 1455 of yacc.c */ 36611 #line 4406 "gram.y" 36612 { 36613 FetchStmt *n = makeNode(FetchStmt); 36614@@ -23601,8 +22809,6 @@ 36615 break; 36616 36617 case 700: 36618- 36619-/* Line 1455 of yacc.c */ 36620 #line 4414 "gram.y" 36621 { 36622 FetchStmt *n = makeNode(FetchStmt); 36623@@ -23614,8 +22820,6 @@ 36624 break; 36625 36626 case 701: 36627- 36628-/* Line 1455 of yacc.c */ 36629 #line 4422 "gram.y" 36630 { 36631 FetchStmt *n = makeNode(FetchStmt); 36632@@ -23627,8 +22831,6 @@ 36633 break; 36634 36635 case 702: 36636- 36637-/* Line 1455 of yacc.c */ 36638 #line 4430 "gram.y" 36639 { 36640 FetchStmt *n = makeNode(FetchStmt); 36641@@ -23640,8 +22842,6 @@ 36642 break; 36643 36644 case 703: 36645- 36646-/* Line 1455 of yacc.c */ 36647 #line 4438 "gram.y" 36648 { 36649 FetchStmt *n = makeNode(FetchStmt); 36650@@ -23653,36 +22853,26 @@ 36651 break; 36652 36653 case 704: 36654- 36655-/* Line 1455 of yacc.c */ 36656 #line 4447 "gram.y" 36657 {;} 36658 break; 36659 36660 case 705: 36661- 36662-/* Line 1455 of yacc.c */ 36663 #line 4448 "gram.y" 36664 {;} 36665 break; 36666 36667 case 706: 36668- 36669-/* Line 1455 of yacc.c */ 36670 #line 4451 "gram.y" 36671 {;} 36672 break; 36673 36674 case 707: 36675- 36676-/* Line 1455 of yacc.c */ 36677 #line 4452 "gram.y" 36678 {;} 36679 break; 36680 36681 case 708: 36682- 36683-/* Line 1455 of yacc.c */ 36684 #line 4464 "gram.y" 36685 { 36686 GrantStmt *n = makeNode(GrantStmt); 36687@@ -23698,8 +22888,6 @@ 36688 break; 36689 36690 case 709: 36691- 36692-/* Line 1455 of yacc.c */ 36693 #line 4480 "gram.y" 36694 { 36695 GrantStmt *n = makeNode(GrantStmt); 36696@@ -23716,8 +22904,6 @@ 36697 break; 36698 36699 case 710: 36700- 36701-/* Line 1455 of yacc.c */ 36702 #line 4494 "gram.y" 36703 { 36704 GrantStmt *n = makeNode(GrantStmt); 36705@@ -23734,29 +22920,21 @@ 36706 break; 36707 36708 case 711: 36709- 36710-/* Line 1455 of yacc.c */ 36711 #line 4519 "gram.y" 36712 { (yyval.list) = (yyvsp[(1) - (1)].list); ;} 36713 break; 36714 36715 case 712: 36716- 36717-/* Line 1455 of yacc.c */ 36718 #line 4521 "gram.y" 36719 { (yyval.list) = NIL; ;} 36720 break; 36721 36722 case 713: 36723- 36724-/* Line 1455 of yacc.c */ 36725 #line 4523 "gram.y" 36726 { (yyval.list) = NIL; ;} 36727 break; 36728 36729 case 714: 36730- 36731-/* Line 1455 of yacc.c */ 36732 #line 4525 "gram.y" 36733 { 36734 AccessPriv *n = makeNode(AccessPriv); 36735@@ -23767,8 +22945,6 @@ 36736 break; 36737 36738 case 715: 36739- 36740-/* Line 1455 of yacc.c */ 36741 #line 4532 "gram.y" 36742 { 36743 AccessPriv *n = makeNode(AccessPriv); 36744@@ -23779,22 +22955,16 @@ 36745 break; 36746 36747 case 716: 36748- 36749-/* Line 1455 of yacc.c */ 36750 #line 4540 "gram.y" 36751 { (yyval.list) = list_make1((yyvsp[(1) - (1)].accesspriv)); ;} 36752 break; 36753 36754 case 717: 36755- 36756-/* Line 1455 of yacc.c */ 36757 #line 4541 "gram.y" 36758 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].accesspriv)); ;} 36759 break; 36760 36761 case 718: 36762- 36763-/* Line 1455 of yacc.c */ 36764 #line 4545 "gram.y" 36765 { 36766 AccessPriv *n = makeNode(AccessPriv); 36767@@ -23805,8 +22975,6 @@ 36768 break; 36769 36770 case 719: 36771- 36772-/* Line 1455 of yacc.c */ 36773 #line 4552 "gram.y" 36774 { 36775 AccessPriv *n = makeNode(AccessPriv); 36776@@ -23817,8 +22985,6 @@ 36777 break; 36778 36779 case 720: 36780- 36781-/* Line 1455 of yacc.c */ 36782 #line 4559 "gram.y" 36783 { 36784 AccessPriv *n = makeNode(AccessPriv); 36785@@ -23829,8 +22995,6 @@ 36786 break; 36787 36788 case 721: 36789- 36790-/* Line 1455 of yacc.c */ 36791 #line 4566 "gram.y" 36792 { 36793 AccessPriv *n = makeNode(AccessPriv); 36794@@ -23841,8 +23005,6 @@ 36795 break; 36796 36797 case 722: 36798- 36799-/* Line 1455 of yacc.c */ 36800 #line 4580 "gram.y" 36801 { 36802 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget)); 36803@@ -23854,8 +23016,6 @@ 36804 break; 36805 36806 case 723: 36807- 36808-/* Line 1455 of yacc.c */ 36809 #line 4588 "gram.y" 36810 { 36811 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget)); 36812@@ -23867,8 +23027,6 @@ 36813 break; 36814 36815 case 724: 36816- 36817-/* Line 1455 of yacc.c */ 36818 #line 4596 "gram.y" 36819 { 36820 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget)); 36821@@ -23880,8 +23038,6 @@ 36822 break; 36823 36824 case 725: 36825- 36826-/* Line 1455 of yacc.c */ 36827 #line 4604 "gram.y" 36828 { 36829 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget)); 36830@@ -23893,8 +23049,6 @@ 36831 break; 36832 36833 case 726: 36834- 36835-/* Line 1455 of yacc.c */ 36836 #line 4612 "gram.y" 36837 { 36838 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget)); 36839@@ -23906,8 +23060,6 @@ 36840 break; 36841 36842 case 727: 36843- 36844-/* Line 1455 of yacc.c */ 36845 #line 4620 "gram.y" 36846 { 36847 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget)); 36848@@ -23919,8 +23071,6 @@ 36849 break; 36850 36851 case 728: 36852- 36853-/* Line 1455 of yacc.c */ 36854 #line 4628 "gram.y" 36855 { 36856 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget)); 36857@@ -23932,8 +23082,6 @@ 36858 break; 36859 36860 case 729: 36861- 36862-/* Line 1455 of yacc.c */ 36863 #line 4636 "gram.y" 36864 { 36865 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget)); 36866@@ -23945,8 +23093,6 @@ 36867 break; 36868 36869 case 730: 36870- 36871-/* Line 1455 of yacc.c */ 36872 #line 4644 "gram.y" 36873 { 36874 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget)); 36875@@ -23958,8 +23104,6 @@ 36876 break; 36877 36878 case 731: 36879- 36880-/* Line 1455 of yacc.c */ 36881 #line 4652 "gram.y" 36882 { 36883 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget)); 36884@@ -23971,8 +23115,6 @@ 36885 break; 36886 36887 case 732: 36888- 36889-/* Line 1455 of yacc.c */ 36890 #line 4660 "gram.y" 36891 { 36892 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget)); 36893@@ -23984,8 +23126,6 @@ 36894 break; 36895 36896 case 733: 36897- 36898-/* Line 1455 of yacc.c */ 36899 #line 4668 "gram.y" 36900 { 36901 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget)); 36902@@ -23997,8 +23137,6 @@ 36903 break; 36904 36905 case 734: 36906- 36907-/* Line 1455 of yacc.c */ 36908 #line 4676 "gram.y" 36909 { 36910 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget)); 36911@@ -24010,8 +23148,6 @@ 36912 break; 36913 36914 case 735: 36915- 36916-/* Line 1455 of yacc.c */ 36917 #line 4684 "gram.y" 36918 { 36919 PrivTarget *n = (PrivTarget *) palloc(sizeof(PrivTarget)); 36920@@ -24023,22 +23159,16 @@ 36921 break; 36922 36923 case 736: 36924- 36925-/* Line 1455 of yacc.c */ 36926 #line 4695 "gram.y" 36927 { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} 36928 break; 36929 36930 case 737: 36931- 36932-/* Line 1455 of yacc.c */ 36933 #line 4696 "gram.y" 36934 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} 36935 break; 36936 36937 case 738: 36938- 36939-/* Line 1455 of yacc.c */ 36940 #line 4700 "gram.y" 36941 { 36942 PrivGrantee *n = makeNode(PrivGrantee); 36943@@ -24052,8 +23182,6 @@ 36944 break; 36945 36946 case 739: 36947- 36948-/* Line 1455 of yacc.c */ 36949 #line 4710 "gram.y" 36950 { 36951 PrivGrantee *n = makeNode(PrivGrantee); 36952@@ -24067,36 +23195,26 @@ 36953 break; 36954 36955 case 740: 36956- 36957-/* Line 1455 of yacc.c */ 36958 #line 4723 "gram.y" 36959 { (yyval.boolean) = TRUE; ;} 36960 break; 36961 36962 case 741: 36963- 36964-/* Line 1455 of yacc.c */ 36965 #line 4724 "gram.y" 36966 { (yyval.boolean) = FALSE; ;} 36967 break; 36968 36969 case 742: 36970- 36971-/* Line 1455 of yacc.c */ 36972 #line 4728 "gram.y" 36973 { (yyval.list) = list_make1((yyvsp[(1) - (1)].funwithargs)); ;} 36974 break; 36975 36976 case 743: 36977- 36978-/* Line 1455 of yacc.c */ 36979 #line 4730 "gram.y" 36980 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].funwithargs)); ;} 36981 break; 36982 36983 case 744: 36984- 36985-/* Line 1455 of yacc.c */ 36986 #line 4735 "gram.y" 36987 { 36988 FuncWithArgs *n = makeNode(FuncWithArgs); 36989@@ -24107,8 +23225,6 @@ 36990 break; 36991 36992 case 745: 36993- 36994-/* Line 1455 of yacc.c */ 36995 #line 4751 "gram.y" 36996 { 36997 GrantRoleStmt *n = makeNode(GrantRoleStmt); 36998@@ -24122,8 +23238,6 @@ 36999 break; 37000 37001 case 746: 37002- 37003-/* Line 1455 of yacc.c */ 37004 #line 4764 "gram.y" 37005 { 37006 GrantRoleStmt *n = makeNode(GrantRoleStmt); 37007@@ -24137,8 +23251,6 @@ 37008 break; 37009 37010 case 747: 37011- 37012-/* Line 1455 of yacc.c */ 37013 #line 4774 "gram.y" 37014 { 37015 GrantRoleStmt *n = makeNode(GrantRoleStmt); 37016@@ -24152,36 +23264,26 @@ 37017 break; 37018 37019 case 748: 37020- 37021-/* Line 1455 of yacc.c */ 37022 #line 4785 "gram.y" 37023 { (yyval.boolean) = TRUE; ;} 37024 break; 37025 37026 case 749: 37027- 37028-/* Line 1455 of yacc.c */ 37029 #line 4786 "gram.y" 37030 { (yyval.boolean) = FALSE; ;} 37031 break; 37032 37033 case 750: 37034- 37035-/* Line 1455 of yacc.c */ 37036 #line 4789 "gram.y" 37037 { (yyval.str) = (yyvsp[(3) - (3)].str); ;} 37038 break; 37039 37040 case 751: 37041- 37042-/* Line 1455 of yacc.c */ 37043 #line 4790 "gram.y" 37044 { (yyval.str) = NULL; ;} 37045 break; 37046 37047 case 752: 37048- 37049-/* Line 1455 of yacc.c */ 37050 #line 4801 "gram.y" 37051 { 37052 AlterDefaultPrivilegesStmt *n = makeNode(AlterDefaultPrivilegesStmt); 37053@@ -24192,22 +23294,16 @@ 37054 break; 37055 37056 case 753: 37057- 37058-/* Line 1455 of yacc.c */ 37059 #line 4810 "gram.y" 37060 { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} 37061 break; 37062 37063 case 754: 37064- 37065-/* Line 1455 of yacc.c */ 37066 #line 4811 "gram.y" 37067 { (yyval.list) = NIL; ;} 37068 break; 37069 37070 case 755: 37071- 37072-/* Line 1455 of yacc.c */ 37073 #line 4816 "gram.y" 37074 { 37075 (yyval.defelt) = makeDefElem("schemas", (Node *)(yyvsp[(3) - (3)].list)); 37076@@ -24215,8 +23311,6 @@ 37077 break; 37078 37079 case 756: 37080- 37081-/* Line 1455 of yacc.c */ 37082 #line 4820 "gram.y" 37083 { 37084 (yyval.defelt) = makeDefElem("roles", (Node *)(yyvsp[(3) - (3)].list)); 37085@@ -24224,8 +23318,6 @@ 37086 break; 37087 37088 case 757: 37089- 37090-/* Line 1455 of yacc.c */ 37091 #line 4824 "gram.y" 37092 { 37093 (yyval.defelt) = makeDefElem("roles", (Node *)(yyvsp[(3) - (3)].list)); 37094@@ -24233,8 +23325,6 @@ 37095 break; 37096 37097 case 758: 37098- 37099-/* Line 1455 of yacc.c */ 37100 #line 4836 "gram.y" 37101 { 37102 GrantStmt *n = makeNode(GrantStmt); 37103@@ -24250,8 +23340,6 @@ 37104 break; 37105 37106 case 759: 37107- 37108-/* Line 1455 of yacc.c */ 37109 #line 4849 "gram.y" 37110 { 37111 GrantStmt *n = makeNode(GrantStmt); 37112@@ -24268,8 +23356,6 @@ 37113 break; 37114 37115 case 760: 37116- 37117-/* Line 1455 of yacc.c */ 37118 #line 4863 "gram.y" 37119 { 37120 GrantStmt *n = makeNode(GrantStmt); 37121@@ -24286,29 +23372,21 @@ 37122 break; 37123 37124 case 761: 37125- 37126-/* Line 1455 of yacc.c */ 37127 #line 4878 "gram.y" 37128 { (yyval.ival) = ACL_OBJECT_RELATION; ;} 37129 break; 37130 37131 case 762: 37132- 37133-/* Line 1455 of yacc.c */ 37134 #line 4879 "gram.y" 37135 { (yyval.ival) = ACL_OBJECT_FUNCTION; ;} 37136 break; 37137 37138 case 763: 37139- 37140-/* Line 1455 of yacc.c */ 37141 #line 4880 "gram.y" 37142 { (yyval.ival) = ACL_OBJECT_SEQUENCE; ;} 37143 break; 37144 37145 case 764: 37146- 37147-/* Line 1455 of yacc.c */ 37148 #line 4895 "gram.y" 37149 { 37150 IndexStmt *n = makeNode(IndexStmt); 37151@@ -24326,78 +23404,56 @@ 37152 break; 37153 37154 case 765: 37155- 37156-/* Line 1455 of yacc.c */ 37157 #line 4911 "gram.y" 37158 { (yyval.boolean) = TRUE; ;} 37159 break; 37160 37161 case 766: 37162- 37163-/* Line 1455 of yacc.c */ 37164 #line 4912 "gram.y" 37165 { (yyval.boolean) = FALSE; ;} 37166 break; 37167 37168 case 767: 37169- 37170-/* Line 1455 of yacc.c */ 37171 #line 4916 "gram.y" 37172 { (yyval.boolean) = TRUE; ;} 37173 break; 37174 37175 case 768: 37176- 37177-/* Line 1455 of yacc.c */ 37178 #line 4917 "gram.y" 37179 { (yyval.boolean) = FALSE; ;} 37180 break; 37181 37182 case 769: 37183- 37184-/* Line 1455 of yacc.c */ 37185 #line 4921 "gram.y" 37186 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 37187 break; 37188 37189 case 770: 37190- 37191-/* Line 1455 of yacc.c */ 37192 #line 4922 "gram.y" 37193 { (yyval.str) = NULL; ;} 37194 break; 37195 37196 case 771: 37197- 37198-/* Line 1455 of yacc.c */ 37199 #line 4926 "gram.y" 37200 { (yyval.str) = (yyvsp[(2) - (2)].str); ;} 37201 break; 37202 37203 case 772: 37204- 37205-/* Line 1455 of yacc.c */ 37206 #line 4927 "gram.y" 37207 { (yyval.str) = DEFAULT_INDEX_TYPE; ;} 37208 break; 37209 37210 case 773: 37211- 37212-/* Line 1455 of yacc.c */ 37213 #line 4930 "gram.y" 37214 { (yyval.list) = list_make1((yyvsp[(1) - (1)].ielem)); ;} 37215 break; 37216 37217 case 774: 37218- 37219-/* Line 1455 of yacc.c */ 37220 #line 4931 "gram.y" 37221 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].ielem)); ;} 37222 break; 37223 37224 case 775: 37225- 37226-/* Line 1455 of yacc.c */ 37227 #line 4940 "gram.y" 37228 { 37229 (yyval.ielem) = makeNode(IndexElem); 37230@@ -24411,8 +23467,6 @@ 37231 break; 37232 37233 case 776: 37234- 37235-/* Line 1455 of yacc.c */ 37236 #line 4950 "gram.y" 37237 { 37238 (yyval.ielem) = makeNode(IndexElem); 37239@@ -24426,8 +23480,6 @@ 37240 break; 37241 37242 case 777: 37243- 37244-/* Line 1455 of yacc.c */ 37245 #line 4960 "gram.y" 37246 { 37247 (yyval.ielem) = makeNode(IndexElem); 37248@@ -24441,71 +23493,51 @@ 37249 break; 37250 37251 case 778: 37252- 37253-/* Line 1455 of yacc.c */ 37254 #line 4971 "gram.y" 37255 { (yyval.list) = (yyvsp[(1) - (1)].list); ;} 37256 break; 37257 37258 case 779: 37259- 37260-/* Line 1455 of yacc.c */ 37261 #line 4972 "gram.y" 37262 { (yyval.list) = (yyvsp[(2) - (2)].list); ;} 37263 break; 37264 37265 case 780: 37266- 37267-/* Line 1455 of yacc.c */ 37268 #line 4973 "gram.y" 37269 { (yyval.list) = NIL; ;} 37270 break; 37271 37272 case 781: 37273- 37274-/* Line 1455 of yacc.c */ 37275 #line 4976 "gram.y" 37276 { (yyval.ival) = SORTBY_ASC; ;} 37277 break; 37278 37279 case 782: 37280- 37281-/* Line 1455 of yacc.c */ 37282 #line 4977 "gram.y" 37283 { (yyval.ival) = SORTBY_DESC; ;} 37284 break; 37285 37286 case 783: 37287- 37288-/* Line 1455 of yacc.c */ 37289 #line 4978 "gram.y" 37290 { (yyval.ival) = SORTBY_DEFAULT; ;} 37291 break; 37292 37293 case 784: 37294- 37295-/* Line 1455 of yacc.c */ 37296 #line 4981 "gram.y" 37297 { (yyval.ival) = SORTBY_NULLS_FIRST; ;} 37298 break; 37299 37300 case 785: 37301- 37302-/* Line 1455 of yacc.c */ 37303 #line 4982 "gram.y" 37304 { (yyval.ival) = SORTBY_NULLS_LAST; ;} 37305 break; 37306 37307 case 786: 37308- 37309-/* Line 1455 of yacc.c */ 37310 #line 4983 "gram.y" 37311 { (yyval.ival) = SORTBY_NULLS_DEFAULT; ;} 37312 break; 37313 37314 case 787: 37315- 37316-/* Line 1455 of yacc.c */ 37317 #line 5001 "gram.y" 37318 { 37319 CreateFunctionStmt *n = makeNode(CreateFunctionStmt); 37320@@ -24520,8 +23552,6 @@ 37321 break; 37322 37323 case 788: 37324- 37325-/* Line 1455 of yacc.c */ 37326 #line 5013 "gram.y" 37327 { 37328 CreateFunctionStmt *n = makeNode(CreateFunctionStmt); 37329@@ -24537,8 +23567,6 @@ 37330 break; 37331 37332 case 789: 37333- 37334-/* Line 1455 of yacc.c */ 37335 #line 5026 "gram.y" 37336 { 37337 CreateFunctionStmt *n = makeNode(CreateFunctionStmt); 37338@@ -24553,78 +23581,56 @@ 37339 break; 37340 37341 case 790: 37342- 37343-/* Line 1455 of yacc.c */ 37344 #line 5039 "gram.y" 37345 { (yyval.boolean) = TRUE; ;} 37346 break; 37347 37348 case 791: 37349- 37350-/* Line 1455 of yacc.c */ 37351 #line 5040 "gram.y" 37352 { (yyval.boolean) = FALSE; ;} 37353 break; 37354 37355 case 792: 37356- 37357-/* Line 1455 of yacc.c */ 37358 #line 5043 "gram.y" 37359 { (yyval.list) = (yyvsp[(2) - (3)].list); ;} 37360 break; 37361 37362 case 793: 37363- 37364-/* Line 1455 of yacc.c */ 37365 #line 5044 "gram.y" 37366 { (yyval.list) = NIL; ;} 37367 break; 37368 37369 case 794: 37370- 37371-/* Line 1455 of yacc.c */ 37372 #line 5048 "gram.y" 37373 { (yyval.list) = list_make1((yyvsp[(1) - (1)].fun_param)); ;} 37374 break; 37375 37376 case 795: 37377- 37378-/* Line 1455 of yacc.c */ 37379 #line 5049 "gram.y" 37380 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].fun_param)); ;} 37381 break; 37382 37383 case 796: 37384- 37385-/* Line 1455 of yacc.c */ 37386 #line 5057 "gram.y" 37387 { (yyval.list) = (yyvsp[(2) - (3)].list); ;} 37388 break; 37389 37390 case 797: 37391- 37392-/* Line 1455 of yacc.c */ 37393 #line 5058 "gram.y" 37394 { (yyval.list) = NIL; ;} 37395 break; 37396 37397 case 798: 37398- 37399-/* Line 1455 of yacc.c */ 37400 #line 5062 "gram.y" 37401 { (yyval.list) = list_make1((yyvsp[(1) - (1)].fun_param)); ;} 37402 break; 37403 37404 case 799: 37405- 37406-/* Line 1455 of yacc.c */ 37407 #line 5064 "gram.y" 37408 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].fun_param)); ;} 37409 break; 37410 37411 case 800: 37412- 37413-/* Line 1455 of yacc.c */ 37414 #line 5079 "gram.y" 37415 { 37416 FunctionParameter *n = makeNode(FunctionParameter); 37417@@ -24637,8 +23643,6 @@ 37418 break; 37419 37420 case 801: 37421- 37422-/* Line 1455 of yacc.c */ 37423 #line 5088 "gram.y" 37424 { 37425 FunctionParameter *n = makeNode(FunctionParameter); 37426@@ -24651,8 +23655,6 @@ 37427 break; 37428 37429 case 802: 37430- 37431-/* Line 1455 of yacc.c */ 37432 #line 5097 "gram.y" 37433 { 37434 FunctionParameter *n = makeNode(FunctionParameter); 37435@@ -24665,8 +23667,6 @@ 37436 break; 37437 37438 case 803: 37439- 37440-/* Line 1455 of yacc.c */ 37441 #line 5106 "gram.y" 37442 { 37443 FunctionParameter *n = makeNode(FunctionParameter); 37444@@ -24679,8 +23679,6 @@ 37445 break; 37446 37447 case 804: 37448- 37449-/* Line 1455 of yacc.c */ 37450 #line 5115 "gram.y" 37451 { 37452 FunctionParameter *n = makeNode(FunctionParameter); 37453@@ -24693,43 +23691,31 @@ 37454 break; 37455 37456 case 805: 37457- 37458-/* Line 1455 of yacc.c */ 37459 #line 5126 "gram.y" 37460 { (yyval.fun_param_mode) = FUNC_PARAM_IN; ;} 37461 break; 37462 37463 case 806: 37464- 37465-/* Line 1455 of yacc.c */ 37466 #line 5127 "gram.y" 37467 { (yyval.fun_param_mode) = FUNC_PARAM_OUT; ;} 37468 break; 37469 37470 case 807: 37471- 37472-/* Line 1455 of yacc.c */ 37473 #line 5128 "gram.y" 37474 { (yyval.fun_param_mode) = FUNC_PARAM_INOUT; ;} 37475 break; 37476 37477 case 808: 37478- 37479-/* Line 1455 of yacc.c */ 37480 #line 5129 "gram.y" 37481 { (yyval.fun_param_mode) = FUNC_PARAM_INOUT; ;} 37482 break; 37483 37484 case 809: 37485- 37486-/* Line 1455 of yacc.c */ 37487 #line 5130 "gram.y" 37488 { (yyval.fun_param_mode) = FUNC_PARAM_VARIADIC; ;} 37489 break; 37490 37491 case 811: 37492- 37493-/* Line 1455 of yacc.c */ 37494 #line 5141 "gram.y" 37495 { 37496 /* We can catch over-specified results here if we want to, 37497@@ -24741,15 +23727,11 @@ 37498 break; 37499 37500 case 812: 37501- 37502-/* Line 1455 of yacc.c */ 37503 #line 5155 "gram.y" 37504 { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} 37505 break; 37506 37507 case 813: 37508- 37509-/* Line 1455 of yacc.c */ 37510 #line 5157 "gram.y" 37511 { 37512 (yyval.typnam) = makeTypeNameFromNameList(lcons(makeString((yyvsp[(1) - (4)].str)), (yyvsp[(2) - (4)].list))); 37513@@ -24759,8 +23741,6 @@ 37514 break; 37515 37516 case 814: 37517- 37518-/* Line 1455 of yacc.c */ 37519 #line 5163 "gram.y" 37520 { 37521 (yyval.typnam) = makeTypeNameFromNameList(lcons(makeString((yyvsp[(2) - (5)].str)), (yyvsp[(3) - (5)].list))); 37522@@ -24771,8 +23751,6 @@ 37523 break; 37524 37525 case 815: 37526- 37527-/* Line 1455 of yacc.c */ 37528 #line 5173 "gram.y" 37529 { 37530 (yyval.fun_param) = (yyvsp[(1) - (1)].fun_param); 37531@@ -24780,8 +23758,6 @@ 37532 break; 37533 37534 case 816: 37535- 37536-/* Line 1455 of yacc.c */ 37537 #line 5177 "gram.y" 37538 { 37539 (yyval.fun_param) = (yyvsp[(1) - (3)].fun_param); 37540@@ -24790,8 +23766,6 @@ 37541 break; 37542 37543 case 817: 37544- 37545-/* Line 1455 of yacc.c */ 37546 #line 5182 "gram.y" 37547 { 37548 (yyval.fun_param) = (yyvsp[(1) - (3)].fun_param); 37549@@ -24800,22 +23774,16 @@ 37550 break; 37551 37552 case 818: 37553- 37554-/* Line 1455 of yacc.c */ 37555 #line 5191 "gram.y" 37556 { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} 37557 break; 37558 37559 case 819: 37560- 37561-/* Line 1455 of yacc.c */ 37562 #line 5192 "gram.y" 37563 { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} 37564 break; 37565 37566 case 820: 37567- 37568-/* Line 1455 of yacc.c */ 37569 #line 5200 "gram.y" 37570 { 37571 (yyval.defelt) = makeDefElem("strict", (Node *)makeInteger(FALSE)); 37572@@ -24823,8 +23791,6 @@ 37573 break; 37574 37575 case 821: 37576- 37577-/* Line 1455 of yacc.c */ 37578 #line 5204 "gram.y" 37579 { 37580 (yyval.defelt) = makeDefElem("strict", (Node *)makeInteger(TRUE)); 37581@@ -24832,8 +23798,6 @@ 37582 break; 37583 37584 case 822: 37585- 37586-/* Line 1455 of yacc.c */ 37587 #line 5208 "gram.y" 37588 { 37589 (yyval.defelt) = makeDefElem("strict", (Node *)makeInteger(TRUE)); 37590@@ -24841,8 +23805,6 @@ 37591 break; 37592 37593 case 823: 37594- 37595-/* Line 1455 of yacc.c */ 37596 #line 5212 "gram.y" 37597 { 37598 (yyval.defelt) = makeDefElem("volatility", (Node *)makeString("immutable")); 37599@@ -24850,8 +23812,6 @@ 37600 break; 37601 37602 case 824: 37603- 37604-/* Line 1455 of yacc.c */ 37605 #line 5216 "gram.y" 37606 { 37607 (yyval.defelt) = makeDefElem("volatility", (Node *)makeString("stable")); 37608@@ -24859,8 +23819,6 @@ 37609 break; 37610 37611 case 825: 37612- 37613-/* Line 1455 of yacc.c */ 37614 #line 5220 "gram.y" 37615 { 37616 (yyval.defelt) = makeDefElem("volatility", (Node *)makeString("volatile")); 37617@@ -24868,8 +23826,6 @@ 37618 break; 37619 37620 case 826: 37621- 37622-/* Line 1455 of yacc.c */ 37623 #line 5224 "gram.y" 37624 { 37625 (yyval.defelt) = makeDefElem("security", (Node *)makeInteger(TRUE)); 37626@@ -24877,8 +23833,6 @@ 37627 break; 37628 37629 case 827: 37630- 37631-/* Line 1455 of yacc.c */ 37632 #line 5228 "gram.y" 37633 { 37634 (yyval.defelt) = makeDefElem("security", (Node *)makeInteger(FALSE)); 37635@@ -24886,8 +23840,6 @@ 37636 break; 37637 37638 case 828: 37639- 37640-/* Line 1455 of yacc.c */ 37641 #line 5232 "gram.y" 37642 { 37643 (yyval.defelt) = makeDefElem("security", (Node *)makeInteger(TRUE)); 37644@@ -24895,8 +23847,6 @@ 37645 break; 37646 37647 case 829: 37648- 37649-/* Line 1455 of yacc.c */ 37650 #line 5236 "gram.y" 37651 { 37652 (yyval.defelt) = makeDefElem("security", (Node *)makeInteger(FALSE)); 37653@@ -24904,8 +23854,6 @@ 37654 break; 37655 37656 case 830: 37657- 37658-/* Line 1455 of yacc.c */ 37659 #line 5240 "gram.y" 37660 { 37661 (yyval.defelt) = makeDefElem("cost", (Node *)(yyvsp[(2) - (2)].value)); 37662@@ -24913,8 +23861,6 @@ 37663 break; 37664 37665 case 831: 37666- 37667-/* Line 1455 of yacc.c */ 37668 #line 5244 "gram.y" 37669 { 37670 (yyval.defelt) = makeDefElem("rows", (Node *)(yyvsp[(2) - (2)].value)); 37671@@ -24922,8 +23868,6 @@ 37672 break; 37673 37674 case 832: 37675- 37676-/* Line 1455 of yacc.c */ 37677 #line 5248 "gram.y" 37678 { 37679 /* we abuse the normal content of a DefElem here */ 37680@@ -24932,8 +23876,6 @@ 37681 break; 37682 37683 case 833: 37684- 37685-/* Line 1455 of yacc.c */ 37686 #line 5256 "gram.y" 37687 { 37688 (yyval.defelt) = makeDefElem("as", (Node *)(yyvsp[(2) - (2)].list)); 37689@@ -24941,8 +23883,6 @@ 37690 break; 37691 37692 case 834: 37693- 37694-/* Line 1455 of yacc.c */ 37695 #line 5260 "gram.y" 37696 { 37697 (yyval.defelt) = makeDefElem("language", (Node *)makeString((yyvsp[(2) - (2)].str))); 37698@@ -24950,8 +23890,6 @@ 37699 break; 37700 37701 case 835: 37702- 37703-/* Line 1455 of yacc.c */ 37704 #line 5264 "gram.y" 37705 { 37706 (yyval.defelt) = makeDefElem("window", (Node *)makeInteger(TRUE)); 37707@@ -24959,8 +23897,6 @@ 37708 break; 37709 37710 case 836: 37711- 37712-/* Line 1455 of yacc.c */ 37713 #line 5268 "gram.y" 37714 { 37715 (yyval.defelt) = (yyvsp[(1) - (1)].defelt); 37716@@ -24968,15 +23904,11 @@ 37717 break; 37718 37719 case 837: 37720- 37721-/* Line 1455 of yacc.c */ 37722 #line 5273 "gram.y" 37723 { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} 37724 break; 37725 37726 case 838: 37727- 37728-/* Line 1455 of yacc.c */ 37729 #line 5275 "gram.y" 37730 { 37731 (yyval.list) = list_make2(makeString((yyvsp[(1) - (3)].str)), makeString((yyvsp[(3) - (3)].str))); 37732@@ -24984,22 +23916,16 @@ 37733 break; 37734 37735 case 839: 37736- 37737-/* Line 1455 of yacc.c */ 37738 #line 5281 "gram.y" 37739 { (yyval.list) = (yyvsp[(2) - (2)].list); ;} 37740 break; 37741 37742 case 840: 37743- 37744-/* Line 1455 of yacc.c */ 37745 #line 5282 "gram.y" 37746 { (yyval.list) = NIL; ;} 37747 break; 37748 37749 case 841: 37750- 37751-/* Line 1455 of yacc.c */ 37752 #line 5286 "gram.y" 37753 { 37754 FunctionParameter *n = makeNode(FunctionParameter); 37755@@ -25012,8 +23938,6 @@ 37756 break; 37757 37758 case 842: 37759- 37760-/* Line 1455 of yacc.c */ 37761 #line 5298 "gram.y" 37762 { 37763 (yyval.list) = list_make1((yyvsp[(1) - (1)].fun_param)); 37764@@ -25021,8 +23945,6 @@ 37765 break; 37766 37767 case 843: 37768- 37769-/* Line 1455 of yacc.c */ 37770 #line 5302 "gram.y" 37771 { 37772 (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].fun_param)); 37773@@ -25030,8 +23952,6 @@ 37774 break; 37775 37776 case 844: 37777- 37778-/* Line 1455 of yacc.c */ 37779 #line 5317 "gram.y" 37780 { 37781 AlterFunctionStmt *n = makeNode(AlterFunctionStmt); 37782@@ -25042,22 +23962,16 @@ 37783 break; 37784 37785 case 845: 37786- 37787-/* Line 1455 of yacc.c */ 37788 #line 5327 "gram.y" 37789 { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} 37790 break; 37791 37792 case 846: 37793- 37794-/* Line 1455 of yacc.c */ 37795 #line 5328 "gram.y" 37796 { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} 37797 break; 37798 37799 case 849: 37800- 37801-/* Line 1455 of yacc.c */ 37802 #line 5350 "gram.y" 37803 { 37804 RemoveFuncStmt *n = makeNode(RemoveFuncStmt); 37805@@ -25071,8 +23985,6 @@ 37806 break; 37807 37808 case 850: 37809- 37810-/* Line 1455 of yacc.c */ 37811 #line 5360 "gram.y" 37812 { 37813 RemoveFuncStmt *n = makeNode(RemoveFuncStmt); 37814@@ -25086,8 +23998,6 @@ 37815 break; 37816 37817 case 851: 37818- 37819-/* Line 1455 of yacc.c */ 37820 #line 5373 "gram.y" 37821 { 37822 RemoveFuncStmt *n = makeNode(RemoveFuncStmt); 37823@@ -25101,8 +24011,6 @@ 37824 break; 37825 37826 case 852: 37827- 37828-/* Line 1455 of yacc.c */ 37829 #line 5383 "gram.y" 37830 { 37831 RemoveFuncStmt *n = makeNode(RemoveFuncStmt); 37832@@ -25116,8 +24024,6 @@ 37833 break; 37834 37835 case 853: 37836- 37837-/* Line 1455 of yacc.c */ 37838 #line 5396 "gram.y" 37839 { 37840 RemoveFuncStmt *n = makeNode(RemoveFuncStmt); 37841@@ -25131,8 +24037,6 @@ 37842 break; 37843 37844 case 854: 37845- 37846-/* Line 1455 of yacc.c */ 37847 #line 5406 "gram.y" 37848 { 37849 RemoveFuncStmt *n = makeNode(RemoveFuncStmt); 37850@@ -25146,8 +24050,6 @@ 37851 break; 37852 37853 case 855: 37854- 37855-/* Line 1455 of yacc.c */ 37856 #line 5419 "gram.y" 37857 { 37858 ereport(ERROR, 37859@@ -25159,43 +24061,31 @@ 37860 break; 37861 37862 case 856: 37863- 37864-/* Line 1455 of yacc.c */ 37865 #line 5427 "gram.y" 37866 { (yyval.list) = list_make2((yyvsp[(2) - (5)].typnam), (yyvsp[(4) - (5)].typnam)); ;} 37867 break; 37868 37869 case 857: 37870- 37871-/* Line 1455 of yacc.c */ 37872 #line 5429 "gram.y" 37873 { (yyval.list) = list_make2(NULL, (yyvsp[(4) - (5)].typnam)); ;} 37874 break; 37875 37876 case 858: 37877- 37878-/* Line 1455 of yacc.c */ 37879 #line 5431 "gram.y" 37880 { (yyval.list) = list_make2((yyvsp[(2) - (5)].typnam), NULL); ;} 37881 break; 37882 37883 case 859: 37884- 37885-/* Line 1455 of yacc.c */ 37886 #line 5436 "gram.y" 37887 { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} 37888 break; 37889 37890 case 860: 37891- 37892-/* Line 1455 of yacc.c */ 37893 #line 5438 "gram.y" 37894 { (yyval.list) = lcons(makeString((yyvsp[(1) - (3)].str)), (yyvsp[(3) - (3)].list)); ;} 37895 break; 37896 37897 case 861: 37898- 37899-/* Line 1455 of yacc.c */ 37900 #line 5451 "gram.y" 37901 { 37902 DoStmt *n = makeNode(DoStmt); 37903@@ -25205,22 +24095,16 @@ 37904 break; 37905 37906 case 862: 37907- 37908-/* Line 1455 of yacc.c */ 37909 #line 5459 "gram.y" 37910 { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} 37911 break; 37912 37913 case 863: 37914- 37915-/* Line 1455 of yacc.c */ 37916 #line 5460 "gram.y" 37917 { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} 37918 break; 37919 37920 case 864: 37921- 37922-/* Line 1455 of yacc.c */ 37923 #line 5465 "gram.y" 37924 { 37925 (yyval.defelt) = makeDefElem("as", (Node *)makeString((yyvsp[(1) - (1)].str))); 37926@@ -25228,8 +24112,6 @@ 37927 break; 37928 37929 case 865: 37930- 37931-/* Line 1455 of yacc.c */ 37932 #line 5469 "gram.y" 37933 { 37934 (yyval.defelt) = makeDefElem("language", (Node *)makeString((yyvsp[(2) - (2)].str))); 37935@@ -25237,8 +24119,6 @@ 37936 break; 37937 37938 case 866: 37939- 37940-/* Line 1455 of yacc.c */ 37941 #line 5482 "gram.y" 37942 { 37943 CreateCastStmt *n = makeNode(CreateCastStmt); 37944@@ -25252,8 +24132,6 @@ 37945 break; 37946 37947 case 867: 37948- 37949-/* Line 1455 of yacc.c */ 37950 #line 5493 "gram.y" 37951 { 37952 CreateCastStmt *n = makeNode(CreateCastStmt); 37953@@ -25267,8 +24145,6 @@ 37954 break; 37955 37956 case 868: 37957- 37958-/* Line 1455 of yacc.c */ 37959 #line 5504 "gram.y" 37960 { 37961 CreateCastStmt *n = makeNode(CreateCastStmt); 37962@@ -25282,29 +24158,21 @@ 37963 break; 37964 37965 case 869: 37966- 37967-/* Line 1455 of yacc.c */ 37968 #line 5515 "gram.y" 37969 { (yyval.ival) = COERCION_IMPLICIT; ;} 37970 break; 37971 37972 case 870: 37973- 37974-/* Line 1455 of yacc.c */ 37975 #line 5516 "gram.y" 37976 { (yyval.ival) = COERCION_ASSIGNMENT; ;} 37977 break; 37978 37979 case 871: 37980- 37981-/* Line 1455 of yacc.c */ 37982 #line 5517 "gram.y" 37983 { (yyval.ival) = COERCION_EXPLICIT; ;} 37984 break; 37985 37986 case 872: 37987- 37988-/* Line 1455 of yacc.c */ 37989 #line 5522 "gram.y" 37990 { 37991 DropCastStmt *n = makeNode(DropCastStmt); 37992@@ -25317,22 +24185,16 @@ 37993 break; 37994 37995 case 873: 37996- 37997-/* Line 1455 of yacc.c */ 37998 #line 5532 "gram.y" 37999 { (yyval.boolean) = TRUE; ;} 38000 break; 38001 38002 case 874: 38003- 38004-/* Line 1455 of yacc.c */ 38005 #line 5533 "gram.y" 38006 { (yyval.boolean) = FALSE; ;} 38007 break; 38008 38009 case 875: 38010- 38011-/* Line 1455 of yacc.c */ 38012 #line 5548 "gram.y" 38013 { 38014 ReindexStmt *n = makeNode(ReindexStmt); 38015@@ -25344,8 +24206,6 @@ 38016 break; 38017 38018 case 876: 38019- 38020-/* Line 1455 of yacc.c */ 38021 #line 5556 "gram.y" 38022 { 38023 ReindexStmt *n = makeNode(ReindexStmt); 38024@@ -25359,8 +24219,6 @@ 38025 break; 38026 38027 case 877: 38028- 38029-/* Line 1455 of yacc.c */ 38030 #line 5566 "gram.y" 38031 { 38032 ReindexStmt *n = makeNode(ReindexStmt); 38033@@ -25374,36 +24232,26 @@ 38034 break; 38035 38036 case 878: 38037- 38038-/* Line 1455 of yacc.c */ 38039 #line 5578 "gram.y" 38040 { (yyval.objtype) = OBJECT_INDEX; ;} 38041 break; 38042 38043 case 879: 38044- 38045-/* Line 1455 of yacc.c */ 38046 #line 5579 "gram.y" 38047 { (yyval.objtype) = OBJECT_TABLE; ;} 38048 break; 38049 38050 case 880: 38051- 38052-/* Line 1455 of yacc.c */ 38053 #line 5582 "gram.y" 38054 { (yyval.boolean) = TRUE; ;} 38055 break; 38056 38057 case 881: 38058- 38059-/* Line 1455 of yacc.c */ 38060 #line 5583 "gram.y" 38061 { (yyval.boolean) = FALSE; ;} 38062 break; 38063 38064 case 882: 38065- 38066-/* Line 1455 of yacc.c */ 38067 #line 5594 "gram.y" 38068 { 38069 RenameStmt *n = makeNode(RenameStmt); 38070@@ -25416,8 +24264,6 @@ 38071 break; 38072 38073 case 883: 38074- 38075-/* Line 1455 of yacc.c */ 38076 #line 5603 "gram.y" 38077 { 38078 RenameStmt *n = makeNode(RenameStmt); 38079@@ -25429,8 +24275,6 @@ 38080 break; 38081 38082 case 884: 38083- 38084-/* Line 1455 of yacc.c */ 38085 #line 5611 "gram.y" 38086 { 38087 RenameStmt *n = makeNode(RenameStmt); 38088@@ -25442,8 +24286,6 @@ 38089 break; 38090 38091 case 885: 38092- 38093-/* Line 1455 of yacc.c */ 38094 #line 5619 "gram.y" 38095 { 38096 RenameStmt *n = makeNode(RenameStmt); 38097@@ -25456,8 +24298,6 @@ 38098 break; 38099 38100 case 886: 38101- 38102-/* Line 1455 of yacc.c */ 38103 #line 5628 "gram.y" 38104 { 38105 RenameStmt *n = makeNode(RenameStmt); 38106@@ -25469,8 +24309,6 @@ 38107 break; 38108 38109 case 887: 38110- 38111-/* Line 1455 of yacc.c */ 38112 #line 5636 "gram.y" 38113 { 38114 RenameStmt *n = makeNode(RenameStmt); 38115@@ -25482,8 +24320,6 @@ 38116 break; 38117 38118 case 888: 38119- 38120-/* Line 1455 of yacc.c */ 38121 #line 5644 "gram.y" 38122 { 38123 RenameStmt *n = makeNode(RenameStmt); 38124@@ -25496,8 +24332,6 @@ 38125 break; 38126 38127 case 889: 38128- 38129-/* Line 1455 of yacc.c */ 38130 #line 5653 "gram.y" 38131 { 38132 RenameStmt *n = makeNode(RenameStmt); 38133@@ -25510,8 +24344,6 @@ 38134 break; 38135 38136 case 890: 38137- 38138-/* Line 1455 of yacc.c */ 38139 #line 5662 "gram.y" 38140 { 38141 RenameStmt *n = makeNode(RenameStmt); 38142@@ -25523,8 +24355,6 @@ 38143 break; 38144 38145 case 891: 38146- 38147-/* Line 1455 of yacc.c */ 38148 #line 5670 "gram.y" 38149 { 38150 RenameStmt *n = makeNode(RenameStmt); 38151@@ -25537,8 +24367,6 @@ 38152 break; 38153 38154 case 892: 38155- 38156-/* Line 1455 of yacc.c */ 38157 #line 5679 "gram.y" 38158 { 38159 RenameStmt *n = makeNode(RenameStmt); 38160@@ -25551,8 +24379,6 @@ 38161 break; 38162 38163 case 893: 38164- 38165-/* Line 1455 of yacc.c */ 38166 #line 5688 "gram.y" 38167 { 38168 RenameStmt *n = makeNode(RenameStmt); 38169@@ -25565,8 +24391,6 @@ 38170 break; 38171 38172 case 894: 38173- 38174-/* Line 1455 of yacc.c */ 38175 #line 5697 "gram.y" 38176 { 38177 RenameStmt *n = makeNode(RenameStmt); 38178@@ -25579,8 +24403,6 @@ 38179 break; 38180 38181 case 895: 38182- 38183-/* Line 1455 of yacc.c */ 38184 #line 5706 "gram.y" 38185 { 38186 RenameStmt *n = makeNode(RenameStmt); 38187@@ -25593,8 +24415,6 @@ 38188 break; 38189 38190 case 896: 38191- 38192-/* Line 1455 of yacc.c */ 38193 #line 5715 "gram.y" 38194 { 38195 RenameStmt *n = makeNode(RenameStmt); 38196@@ -25607,8 +24427,6 @@ 38197 break; 38198 38199 case 897: 38200- 38201-/* Line 1455 of yacc.c */ 38202 #line 5724 "gram.y" 38203 { 38204 RenameStmt *n = makeNode(RenameStmt); 38205@@ -25620,8 +24438,6 @@ 38206 break; 38207 38208 case 898: 38209- 38210-/* Line 1455 of yacc.c */ 38211 #line 5732 "gram.y" 38212 { 38213 RenameStmt *n = makeNode(RenameStmt); 38214@@ -25633,8 +24449,6 @@ 38215 break; 38216 38217 case 899: 38218- 38219-/* Line 1455 of yacc.c */ 38220 #line 5740 "gram.y" 38221 { 38222 RenameStmt *n = makeNode(RenameStmt); 38223@@ -25646,8 +24460,6 @@ 38224 break; 38225 38226 case 900: 38227- 38228-/* Line 1455 of yacc.c */ 38229 #line 5748 "gram.y" 38230 { 38231 AlterTableSpaceOptionsStmt *n = 38232@@ -25660,8 +24472,6 @@ 38233 break; 38234 38235 case 901: 38236- 38237-/* Line 1455 of yacc.c */ 38238 #line 5757 "gram.y" 38239 { 38240 AlterTableSpaceOptionsStmt *n = 38241@@ -25674,8 +24484,6 @@ 38242 break; 38243 38244 case 902: 38245- 38246-/* Line 1455 of yacc.c */ 38247 #line 5766 "gram.y" 38248 { 38249 RenameStmt *n = makeNode(RenameStmt); 38250@@ -25687,8 +24495,6 @@ 38251 break; 38252 38253 case 903: 38254- 38255-/* Line 1455 of yacc.c */ 38256 #line 5774 "gram.y" 38257 { 38258 RenameStmt *n = makeNode(RenameStmt); 38259@@ -25700,8 +24506,6 @@ 38260 break; 38261 38262 case 904: 38263- 38264-/* Line 1455 of yacc.c */ 38265 #line 5782 "gram.y" 38266 { 38267 RenameStmt *n = makeNode(RenameStmt); 38268@@ -25713,8 +24517,6 @@ 38269 break; 38270 38271 case 905: 38272- 38273-/* Line 1455 of yacc.c */ 38274 #line 5790 "gram.y" 38275 { 38276 RenameStmt *n = makeNode(RenameStmt); 38277@@ -25726,8 +24528,6 @@ 38278 break; 38279 38280 case 906: 38281- 38282-/* Line 1455 of yacc.c */ 38283 #line 5798 "gram.y" 38284 { 38285 RenameStmt *n = makeNode(RenameStmt); 38286@@ -25739,36 +24539,26 @@ 38287 break; 38288 38289 case 907: 38290- 38291-/* Line 1455 of yacc.c */ 38292 #line 5807 "gram.y" 38293 { (yyval.ival) = COLUMN; ;} 38294 break; 38295 38296 case 908: 38297- 38298-/* Line 1455 of yacc.c */ 38299 #line 5808 "gram.y" 38300 { (yyval.ival) = 0; ;} 38301 break; 38302 38303 case 909: 38304- 38305-/* Line 1455 of yacc.c */ 38306 #line 5811 "gram.y" 38307 { (yyval.ival) = 1; ;} 38308 break; 38309 38310 case 910: 38311- 38312-/* Line 1455 of yacc.c */ 38313 #line 5812 "gram.y" 38314 { (yyval.ival) = 0; ;} 38315 break; 38316 38317 case 911: 38318- 38319-/* Line 1455 of yacc.c */ 38320 #line 5823 "gram.y" 38321 { 38322 AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt); 38323@@ -25781,8 +24571,6 @@ 38324 break; 38325 38326 case 912: 38327- 38328-/* Line 1455 of yacc.c */ 38329 #line 5832 "gram.y" 38330 { 38331 AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt); 38332@@ -25794,8 +24582,6 @@ 38333 break; 38334 38335 case 913: 38336- 38337-/* Line 1455 of yacc.c */ 38338 #line 5840 "gram.y" 38339 { 38340 AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt); 38341@@ -25808,8 +24594,6 @@ 38342 break; 38343 38344 case 914: 38345- 38346-/* Line 1455 of yacc.c */ 38347 #line 5849 "gram.y" 38348 { 38349 AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt); 38350@@ -25821,8 +24605,6 @@ 38351 break; 38352 38353 case 915: 38354- 38355-/* Line 1455 of yacc.c */ 38356 #line 5857 "gram.y" 38357 { 38358 AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt); 38359@@ -25834,8 +24616,6 @@ 38360 break; 38361 38362 case 916: 38363- 38364-/* Line 1455 of yacc.c */ 38365 #line 5865 "gram.y" 38366 { 38367 AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt); 38368@@ -25847,8 +24627,6 @@ 38369 break; 38370 38371 case 917: 38372- 38373-/* Line 1455 of yacc.c */ 38374 #line 5873 "gram.y" 38375 { 38376 AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt); 38377@@ -25860,8 +24638,6 @@ 38378 break; 38379 38380 case 918: 38381- 38382-/* Line 1455 of yacc.c */ 38383 #line 5889 "gram.y" 38384 { 38385 AlterOwnerStmt *n = makeNode(AlterOwnerStmt); 38386@@ -25874,8 +24650,6 @@ 38387 break; 38388 38389 case 919: 38390- 38391-/* Line 1455 of yacc.c */ 38392 #line 5898 "gram.y" 38393 { 38394 AlterOwnerStmt *n = makeNode(AlterOwnerStmt); 38395@@ -25887,8 +24661,6 @@ 38396 break; 38397 38398 case 920: 38399- 38400-/* Line 1455 of yacc.c */ 38401 #line 5906 "gram.y" 38402 { 38403 AlterOwnerStmt *n = makeNode(AlterOwnerStmt); 38404@@ -25900,8 +24672,6 @@ 38405 break; 38406 38407 case 921: 38408- 38409-/* Line 1455 of yacc.c */ 38410 #line 5914 "gram.y" 38411 { 38412 AlterOwnerStmt *n = makeNode(AlterOwnerStmt); 38413@@ -25913,8 +24683,6 @@ 38414 break; 38415 38416 case 922: 38417- 38418-/* Line 1455 of yacc.c */ 38419 #line 5922 "gram.y" 38420 { 38421 AlterOwnerStmt *n = makeNode(AlterOwnerStmt); 38422@@ -25927,8 +24695,6 @@ 38423 break; 38424 38425 case 923: 38426- 38427-/* Line 1455 of yacc.c */ 38428 #line 5931 "gram.y" 38429 { 38430 AlterOwnerStmt *n = makeNode(AlterOwnerStmt); 38431@@ -25940,8 +24706,6 @@ 38432 break; 38433 38434 case 924: 38435- 38436-/* Line 1455 of yacc.c */ 38437 #line 5939 "gram.y" 38438 { 38439 AlterOwnerStmt *n = makeNode(AlterOwnerStmt); 38440@@ -25953,8 +24717,6 @@ 38441 break; 38442 38443 case 925: 38444- 38445-/* Line 1455 of yacc.c */ 38446 #line 5947 "gram.y" 38447 { 38448 AlterOwnerStmt *n = makeNode(AlterOwnerStmt); 38449@@ -25967,8 +24729,6 @@ 38450 break; 38451 38452 case 926: 38453- 38454-/* Line 1455 of yacc.c */ 38455 #line 5956 "gram.y" 38456 { 38457 AlterOwnerStmt *n = makeNode(AlterOwnerStmt); 38458@@ -25981,8 +24741,6 @@ 38459 break; 38460 38461 case 927: 38462- 38463-/* Line 1455 of yacc.c */ 38464 #line 5965 "gram.y" 38465 { 38466 AlterOwnerStmt *n = makeNode(AlterOwnerStmt); 38467@@ -25995,8 +24753,6 @@ 38468 break; 38469 38470 case 928: 38471- 38472-/* Line 1455 of yacc.c */ 38473 #line 5974 "gram.y" 38474 { 38475 AlterOwnerStmt *n = makeNode(AlterOwnerStmt); 38476@@ -26008,8 +24764,6 @@ 38477 break; 38478 38479 case 929: 38480- 38481-/* Line 1455 of yacc.c */ 38482 #line 5982 "gram.y" 38483 { 38484 AlterOwnerStmt *n = makeNode(AlterOwnerStmt); 38485@@ -26021,8 +24775,6 @@ 38486 break; 38487 38488 case 930: 38489- 38490-/* Line 1455 of yacc.c */ 38491 #line 5990 "gram.y" 38492 { 38493 AlterOwnerStmt *n = makeNode(AlterOwnerStmt); 38494@@ -26034,8 +24786,6 @@ 38495 break; 38496 38497 case 931: 38498- 38499-/* Line 1455 of yacc.c */ 38500 #line 5998 "gram.y" 38501 { 38502 AlterOwnerStmt *n = makeNode(AlterOwnerStmt); 38503@@ -26047,8 +24797,6 @@ 38504 break; 38505 38506 case 932: 38507- 38508-/* Line 1455 of yacc.c */ 38509 #line 6006 "gram.y" 38510 { 38511 AlterOwnerStmt *n = makeNode(AlterOwnerStmt); 38512@@ -26060,8 +24808,6 @@ 38513 break; 38514 38515 case 933: 38516- 38517-/* Line 1455 of yacc.c */ 38518 #line 6014 "gram.y" 38519 { 38520 AlterOwnerStmt *n = makeNode(AlterOwnerStmt); 38521@@ -26073,8 +24819,6 @@ 38522 break; 38523 38524 case 934: 38525- 38526-/* Line 1455 of yacc.c */ 38527 #line 6022 "gram.y" 38528 { 38529 AlterOwnerStmt *n = makeNode(AlterOwnerStmt); 38530@@ -26086,8 +24830,6 @@ 38531 break; 38532 38533 case 935: 38534- 38535-/* Line 1455 of yacc.c */ 38536 #line 6041 "gram.y" 38537 { 38538 RuleStmt *n = makeNode(RuleStmt); 38539@@ -26103,29 +24845,21 @@ 38540 break; 38541 38542 case 936: 38543- 38544-/* Line 1455 of yacc.c */ 38545 #line 6055 "gram.y" 38546 { (yyval.list) = NIL; ;} 38547 break; 38548 38549 case 937: 38550- 38551-/* Line 1455 of yacc.c */ 38552 #line 6056 "gram.y" 38553 { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} 38554 break; 38555 38556 case 938: 38557- 38558-/* Line 1455 of yacc.c */ 38559 #line 6057 "gram.y" 38560 { (yyval.list) = (yyvsp[(2) - (3)].list); ;} 38561 break; 38562 38563 case 939: 38564- 38565-/* Line 1455 of yacc.c */ 38566 #line 6063 "gram.y" 38567 { if ((yyvsp[(3) - (3)].node) != NULL) 38568 (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 38569@@ -26135,8 +24869,6 @@ 38570 break; 38571 38572 case 940: 38573- 38574-/* Line 1455 of yacc.c */ 38575 #line 6069 "gram.y" 38576 { if ((yyvsp[(1) - (1)].node) != NULL) 38577 (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); 38578@@ -26146,71 +24878,51 @@ 38579 break; 38580 38581 case 946: 38582- 38583-/* Line 1455 of yacc.c */ 38584 #line 6085 "gram.y" 38585 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 38586 break; 38587 38588 case 947: 38589- 38590-/* Line 1455 of yacc.c */ 38591 #line 6086 "gram.y" 38592 { (yyval.node) = NULL; ;} 38593 break; 38594 38595 case 948: 38596- 38597-/* Line 1455 of yacc.c */ 38598 #line 6089 "gram.y" 38599 { (yyval.ival) = CMD_SELECT; ;} 38600 break; 38601 38602 case 949: 38603- 38604-/* Line 1455 of yacc.c */ 38605 #line 6090 "gram.y" 38606 { (yyval.ival) = CMD_UPDATE; ;} 38607 break; 38608 38609 case 950: 38610- 38611-/* Line 1455 of yacc.c */ 38612 #line 6091 "gram.y" 38613 { (yyval.ival) = CMD_DELETE; ;} 38614 break; 38615 38616 case 951: 38617- 38618-/* Line 1455 of yacc.c */ 38619 #line 6092 "gram.y" 38620 { (yyval.ival) = CMD_INSERT; ;} 38621 break; 38622 38623 case 952: 38624- 38625-/* Line 1455 of yacc.c */ 38626 #line 6096 "gram.y" 38627 { (yyval.boolean) = TRUE; ;} 38628 break; 38629 38630 case 953: 38631- 38632-/* Line 1455 of yacc.c */ 38633 #line 6097 "gram.y" 38634 { (yyval.boolean) = FALSE; ;} 38635 break; 38636 38637 case 954: 38638- 38639-/* Line 1455 of yacc.c */ 38640 #line 6098 "gram.y" 38641 { (yyval.boolean) = FALSE; ;} 38642 break; 38643 38644 case 955: 38645- 38646-/* Line 1455 of yacc.c */ 38647 #line 6104 "gram.y" 38648 { 38649 DropPropertyStmt *n = makeNode(DropPropertyStmt); 38650@@ -26224,8 +24936,6 @@ 38651 break; 38652 38653 case 956: 38654- 38655-/* Line 1455 of yacc.c */ 38656 #line 6114 "gram.y" 38657 { 38658 DropPropertyStmt *n = makeNode(DropPropertyStmt); 38659@@ -26239,8 +24949,6 @@ 38660 break; 38661 38662 case 957: 38663- 38664-/* Line 1455 of yacc.c */ 38665 #line 6135 "gram.y" 38666 { 38667 NotifyStmt *n = makeNode(NotifyStmt); 38668@@ -26251,22 +24959,16 @@ 38669 break; 38670 38671 case 958: 38672- 38673-/* Line 1455 of yacc.c */ 38674 #line 6144 "gram.y" 38675 { (yyval.str) = (yyvsp[(2) - (2)].str); ;} 38676 break; 38677 38678 case 959: 38679- 38680-/* Line 1455 of yacc.c */ 38681 #line 6145 "gram.y" 38682 { (yyval.str) = NULL; ;} 38683 break; 38684 38685 case 960: 38686- 38687-/* Line 1455 of yacc.c */ 38688 #line 6149 "gram.y" 38689 { 38690 ListenStmt *n = makeNode(ListenStmt); 38691@@ -26276,8 +24978,6 @@ 38692 break; 38693 38694 case 961: 38695- 38696-/* Line 1455 of yacc.c */ 38697 #line 6158 "gram.y" 38698 { 38699 UnlistenStmt *n = makeNode(UnlistenStmt); 38700@@ -26287,8 +24987,6 @@ 38701 break; 38702 38703 case 962: 38704- 38705-/* Line 1455 of yacc.c */ 38706 #line 6164 "gram.y" 38707 { 38708 UnlistenStmt *n = makeNode(UnlistenStmt); 38709@@ -26298,8 +24996,6 @@ 38710 break; 38711 38712 case 963: 38713- 38714-/* Line 1455 of yacc.c */ 38715 #line 6183 "gram.y" 38716 { 38717 TransactionStmt *n = makeNode(TransactionStmt); 38718@@ -26310,8 +25006,6 @@ 38719 break; 38720 38721 case 964: 38722- 38723-/* Line 1455 of yacc.c */ 38724 #line 6190 "gram.y" 38725 { 38726 TransactionStmt *n = makeNode(TransactionStmt); 38727@@ -26322,8 +25016,6 @@ 38728 break; 38729 38730 case 965: 38731- 38732-/* Line 1455 of yacc.c */ 38733 #line 6197 "gram.y" 38734 { 38735 TransactionStmt *n = makeNode(TransactionStmt); 38736@@ -26334,8 +25026,6 @@ 38737 break; 38738 38739 case 966: 38740- 38741-/* Line 1455 of yacc.c */ 38742 #line 6204 "gram.y" 38743 { 38744 TransactionStmt *n = makeNode(TransactionStmt); 38745@@ -26346,8 +25036,6 @@ 38746 break; 38747 38748 case 967: 38749- 38750-/* Line 1455 of yacc.c */ 38751 #line 6211 "gram.y" 38752 { 38753 TransactionStmt *n = makeNode(TransactionStmt); 38754@@ -26358,8 +25046,6 @@ 38755 break; 38756 38757 case 968: 38758- 38759-/* Line 1455 of yacc.c */ 38760 #line 6218 "gram.y" 38761 { 38762 TransactionStmt *n = makeNode(TransactionStmt); 38763@@ -26370,8 +25056,6 @@ 38764 break; 38765 38766 case 969: 38767- 38768-/* Line 1455 of yacc.c */ 38769 #line 6225 "gram.y" 38770 { 38771 TransactionStmt *n = makeNode(TransactionStmt); 38772@@ -26383,8 +25067,6 @@ 38773 break; 38774 38775 case 970: 38776- 38777-/* Line 1455 of yacc.c */ 38778 #line 6233 "gram.y" 38779 { 38780 TransactionStmt *n = makeNode(TransactionStmt); 38781@@ -26396,8 +25078,6 @@ 38782 break; 38783 38784 case 971: 38785- 38786-/* Line 1455 of yacc.c */ 38787 #line 6241 "gram.y" 38788 { 38789 TransactionStmt *n = makeNode(TransactionStmt); 38790@@ -26409,8 +25089,6 @@ 38791 break; 38792 38793 case 972: 38794- 38795-/* Line 1455 of yacc.c */ 38796 #line 6249 "gram.y" 38797 { 38798 TransactionStmt *n = makeNode(TransactionStmt); 38799@@ -26422,8 +25100,6 @@ 38800 break; 38801 38802 case 973: 38803- 38804-/* Line 1455 of yacc.c */ 38805 #line 6257 "gram.y" 38806 { 38807 TransactionStmt *n = makeNode(TransactionStmt); 38808@@ -26435,8 +25111,6 @@ 38809 break; 38810 38811 case 974: 38812- 38813-/* Line 1455 of yacc.c */ 38814 #line 6265 "gram.y" 38815 { 38816 TransactionStmt *n = makeNode(TransactionStmt); 38817@@ -26447,8 +25121,6 @@ 38818 break; 38819 38820 case 975: 38821- 38822-/* Line 1455 of yacc.c */ 38823 #line 6272 "gram.y" 38824 { 38825 TransactionStmt *n = makeNode(TransactionStmt); 38826@@ -26459,8 +25131,6 @@ 38827 break; 38828 38829 case 976: 38830- 38831-/* Line 1455 of yacc.c */ 38832 #line 6279 "gram.y" 38833 { 38834 TransactionStmt *n = makeNode(TransactionStmt); 38835@@ -26471,81 +25141,59 @@ 38836 break; 38837 38838 case 977: 38839- 38840-/* Line 1455 of yacc.c */ 38841 #line 6287 "gram.y" 38842 {;} 38843 break; 38844 38845 case 978: 38846- 38847-/* Line 1455 of yacc.c */ 38848 #line 6288 "gram.y" 38849 {;} 38850 break; 38851 38852 case 979: 38853- 38854-/* Line 1455 of yacc.c */ 38855 #line 6289 "gram.y" 38856 {;} 38857 break; 38858 38859 case 980: 38860- 38861-/* Line 1455 of yacc.c */ 38862 #line 6294 "gram.y" 38863 { (yyval.defelt) = makeDefElem("transaction_isolation", 38864 makeStringConst((yyvsp[(3) - (3)].str), (yylsp[(3) - (3)]))); ;} 38865 break; 38866 38867 case 981: 38868- 38869-/* Line 1455 of yacc.c */ 38870 #line 6297 "gram.y" 38871 { (yyval.defelt) = makeDefElem("transaction_read_only", 38872 makeIntConst(TRUE, (yylsp[(1) - (2)]))); ;} 38873 break; 38874 38875 case 982: 38876- 38877-/* Line 1455 of yacc.c */ 38878 #line 6300 "gram.y" 38879 { (yyval.defelt) = makeDefElem("transaction_read_only", 38880 makeIntConst(FALSE, (yylsp[(1) - (2)]))); ;} 38881 break; 38882 38883 case 983: 38884- 38885-/* Line 1455 of yacc.c */ 38886 #line 6307 "gram.y" 38887 { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} 38888 break; 38889 38890 case 984: 38891- 38892-/* Line 1455 of yacc.c */ 38893 #line 6309 "gram.y" 38894 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); ;} 38895 break; 38896 38897 case 985: 38898- 38899-/* Line 1455 of yacc.c */ 38900 #line 6311 "gram.y" 38901 { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} 38902 break; 38903 38904 case 987: 38905- 38906-/* Line 1455 of yacc.c */ 38907 #line 6317 "gram.y" 38908 { (yyval.list) = NIL; ;} 38909 break; 38910 38911 case 988: 38912- 38913-/* Line 1455 of yacc.c */ 38914 #line 6331 "gram.y" 38915 { 38916 ViewStmt *n = makeNode(ViewStmt); 38917@@ -26559,8 +25207,6 @@ 38918 break; 38919 38920 case 989: 38921- 38922-/* Line 1455 of yacc.c */ 38923 #line 6342 "gram.y" 38924 { 38925 ViewStmt *n = makeNode(ViewStmt); 38926@@ -26574,8 +25220,6 @@ 38927 break; 38928 38929 case 990: 38930- 38931-/* Line 1455 of yacc.c */ 38932 #line 6355 "gram.y" 38933 { 38934 ereport(ERROR, 38935@@ -26585,8 +25229,6 @@ 38936 break; 38937 38938 case 991: 38939- 38940-/* Line 1455 of yacc.c */ 38941 #line 6361 "gram.y" 38942 { 38943 ereport(ERROR, 38944@@ -26596,8 +25238,6 @@ 38945 break; 38946 38947 case 992: 38948- 38949-/* Line 1455 of yacc.c */ 38950 #line 6367 "gram.y" 38951 { 38952 ereport(ERROR, 38953@@ -26607,15 +25247,11 @@ 38954 break; 38955 38956 case 993: 38957- 38958-/* Line 1455 of yacc.c */ 38959 #line 6372 "gram.y" 38960 { (yyval.list) = NIL; ;} 38961 break; 38962 38963 case 994: 38964- 38965-/* Line 1455 of yacc.c */ 38966 #line 6383 "gram.y" 38967 { 38968 LoadStmt *n = makeNode(LoadStmt); 38969@@ -26625,8 +25261,6 @@ 38970 break; 38971 38972 case 995: 38973- 38974-/* Line 1455 of yacc.c */ 38975 #line 6399 "gram.y" 38976 { 38977 CreatedbStmt *n = makeNode(CreatedbStmt); 38978@@ -26637,22 +25271,16 @@ 38979 break; 38980 38981 case 996: 38982- 38983-/* Line 1455 of yacc.c */ 38984 #line 6408 "gram.y" 38985 { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} 38986 break; 38987 38988 case 997: 38989- 38990-/* Line 1455 of yacc.c */ 38991 #line 6409 "gram.y" 38992 { (yyval.list) = NIL; ;} 38993 break; 38994 38995 case 998: 38996- 38997-/* Line 1455 of yacc.c */ 38998 #line 6414 "gram.y" 38999 { 39000 (yyval.defelt) = makeDefElem("tablespace", (Node *)makeString((yyvsp[(3) - (3)].str))); 39001@@ -26660,8 +25288,6 @@ 39002 break; 39003 39004 case 999: 39005- 39006-/* Line 1455 of yacc.c */ 39007 #line 6418 "gram.y" 39008 { 39009 (yyval.defelt) = makeDefElem("tablespace", NULL); 39010@@ -26669,8 +25295,6 @@ 39011 break; 39012 39013 case 1000: 39014- 39015-/* Line 1455 of yacc.c */ 39016 #line 6422 "gram.y" 39017 { 39018 (yyval.defelt) = makeDefElem("location", (Node *)makeString((yyvsp[(3) - (3)].str))); 39019@@ -26678,8 +25302,6 @@ 39020 break; 39021 39022 case 1001: 39023- 39024-/* Line 1455 of yacc.c */ 39025 #line 6426 "gram.y" 39026 { 39027 (yyval.defelt) = makeDefElem("location", NULL); 39028@@ -26687,8 +25309,6 @@ 39029 break; 39030 39031 case 1002: 39032- 39033-/* Line 1455 of yacc.c */ 39034 #line 6430 "gram.y" 39035 { 39036 (yyval.defelt) = makeDefElem("template", (Node *)makeString((yyvsp[(3) - (3)].str))); 39037@@ -26696,8 +25316,6 @@ 39038 break; 39039 39040 case 1003: 39041- 39042-/* Line 1455 of yacc.c */ 39043 #line 6434 "gram.y" 39044 { 39045 (yyval.defelt) = makeDefElem("template", NULL); 39046@@ -26705,8 +25323,6 @@ 39047 break; 39048 39049 case 1004: 39050- 39051-/* Line 1455 of yacc.c */ 39052 #line 6438 "gram.y" 39053 { 39054 (yyval.defelt) = makeDefElem("encoding", (Node *)makeString((yyvsp[(3) - (3)].str))); 39055@@ -26714,8 +25330,6 @@ 39056 break; 39057 39058 case 1005: 39059- 39060-/* Line 1455 of yacc.c */ 39061 #line 6442 "gram.y" 39062 { 39063 (yyval.defelt) = makeDefElem("encoding", (Node *)makeInteger((yyvsp[(3) - (3)].ival))); 39064@@ -26723,8 +25337,6 @@ 39065 break; 39066 39067 case 1006: 39068- 39069-/* Line 1455 of yacc.c */ 39070 #line 6446 "gram.y" 39071 { 39072 (yyval.defelt) = makeDefElem("encoding", NULL); 39073@@ -26732,8 +25344,6 @@ 39074 break; 39075 39076 case 1007: 39077- 39078-/* Line 1455 of yacc.c */ 39079 #line 6450 "gram.y" 39080 { 39081 (yyval.defelt) = makeDefElem("lc_collate", (Node *)makeString((yyvsp[(3) - (3)].str))); 39082@@ -26741,8 +25351,6 @@ 39083 break; 39084 39085 case 1008: 39086- 39087-/* Line 1455 of yacc.c */ 39088 #line 6454 "gram.y" 39089 { 39090 (yyval.defelt) = makeDefElem("lc_collate", NULL); 39091@@ -26750,8 +25358,6 @@ 39092 break; 39093 39094 case 1009: 39095- 39096-/* Line 1455 of yacc.c */ 39097 #line 6458 "gram.y" 39098 { 39099 (yyval.defelt) = makeDefElem("lc_ctype", (Node *)makeString((yyvsp[(3) - (3)].str))); 39100@@ -26759,8 +25365,6 @@ 39101 break; 39102 39103 case 1010: 39104- 39105-/* Line 1455 of yacc.c */ 39106 #line 6462 "gram.y" 39107 { 39108 (yyval.defelt) = makeDefElem("lc_ctype", NULL); 39109@@ -26768,8 +25372,6 @@ 39110 break; 39111 39112 case 1011: 39113- 39114-/* Line 1455 of yacc.c */ 39115 #line 6466 "gram.y" 39116 { 39117 (yyval.defelt) = makeDefElem("connectionlimit", (Node *)makeInteger((yyvsp[(4) - (4)].ival))); 39118@@ -26777,8 +25379,6 @@ 39119 break; 39120 39121 case 1012: 39122- 39123-/* Line 1455 of yacc.c */ 39124 #line 6470 "gram.y" 39125 { 39126 (yyval.defelt) = makeDefElem("owner", (Node *)makeString((yyvsp[(3) - (3)].str))); 39127@@ -26786,8 +25386,6 @@ 39128 break; 39129 39130 case 1013: 39131- 39132-/* Line 1455 of yacc.c */ 39133 #line 6474 "gram.y" 39134 { 39135 (yyval.defelt) = makeDefElem("owner", NULL); 39136@@ -26795,22 +25393,16 @@ 39137 break; 39138 39139 case 1014: 39140- 39141-/* Line 1455 of yacc.c */ 39142 #line 6483 "gram.y" 39143 {;} 39144 break; 39145 39146 case 1015: 39147- 39148-/* Line 1455 of yacc.c */ 39149 #line 6484 "gram.y" 39150 {;} 39151 break; 39152 39153 case 1016: 39154- 39155-/* Line 1455 of yacc.c */ 39156 #line 6496 "gram.y" 39157 { 39158 AlterDatabaseStmt *n = makeNode(AlterDatabaseStmt); 39159@@ -26821,8 +25413,6 @@ 39160 break; 39161 39162 case 1017: 39163- 39164-/* Line 1455 of yacc.c */ 39165 #line 6503 "gram.y" 39166 { 39167 AlterDatabaseStmt *n = makeNode(AlterDatabaseStmt); 39168@@ -26834,8 +25424,6 @@ 39169 break; 39170 39171 case 1018: 39172- 39173-/* Line 1455 of yacc.c */ 39174 #line 6514 "gram.y" 39175 { 39176 AlterDatabaseSetStmt *n = makeNode(AlterDatabaseSetStmt); 39177@@ -26846,22 +25434,16 @@ 39178 break; 39179 39180 case 1019: 39181- 39182-/* Line 1455 of yacc.c */ 39183 #line 6524 "gram.y" 39184 { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} 39185 break; 39186 39187 case 1020: 39188- 39189-/* Line 1455 of yacc.c */ 39190 #line 6525 "gram.y" 39191 { (yyval.list) = NIL; ;} 39192 break; 39193 39194 case 1021: 39195- 39196-/* Line 1455 of yacc.c */ 39197 #line 6530 "gram.y" 39198 { 39199 (yyval.defelt) = makeDefElem("connectionlimit", (Node *)makeInteger((yyvsp[(4) - (4)].ival))); 39200@@ -26869,8 +25451,6 @@ 39201 break; 39202 39203 case 1022: 39204- 39205-/* Line 1455 of yacc.c */ 39206 #line 6544 "gram.y" 39207 { 39208 DropdbStmt *n = makeNode(DropdbStmt); 39209@@ -26881,8 +25461,6 @@ 39210 break; 39211 39212 case 1023: 39213- 39214-/* Line 1455 of yacc.c */ 39215 #line 6551 "gram.y" 39216 { 39217 DropdbStmt *n = makeNode(DropdbStmt); 39218@@ -26893,8 +25471,6 @@ 39219 break; 39220 39221 case 1024: 39222- 39223-/* Line 1455 of yacc.c */ 39224 #line 6568 "gram.y" 39225 { 39226 CreateDomainStmt *n = makeNode(CreateDomainStmt); 39227@@ -26906,8 +25482,6 @@ 39228 break; 39229 39230 case 1025: 39231- 39232-/* Line 1455 of yacc.c */ 39233 #line 6580 "gram.y" 39234 { 39235 AlterDomainStmt *n = makeNode(AlterDomainStmt); 39236@@ -26919,8 +25493,6 @@ 39237 break; 39238 39239 case 1026: 39240- 39241-/* Line 1455 of yacc.c */ 39242 #line 6589 "gram.y" 39243 { 39244 AlterDomainStmt *n = makeNode(AlterDomainStmt); 39245@@ -26931,8 +25503,6 @@ 39246 break; 39247 39248 case 1027: 39249- 39250-/* Line 1455 of yacc.c */ 39251 #line 6597 "gram.y" 39252 { 39253 AlterDomainStmt *n = makeNode(AlterDomainStmt); 39254@@ -26943,8 +25513,6 @@ 39255 break; 39256 39257 case 1028: 39258- 39259-/* Line 1455 of yacc.c */ 39260 #line 6605 "gram.y" 39261 { 39262 AlterDomainStmt *n = makeNode(AlterDomainStmt); 39263@@ -26956,8 +25524,6 @@ 39264 break; 39265 39266 case 1029: 39267- 39268-/* Line 1455 of yacc.c */ 39269 #line 6614 "gram.y" 39270 { 39271 AlterDomainStmt *n = makeNode(AlterDomainStmt); 39272@@ -26970,22 +25536,16 @@ 39273 break; 39274 39275 case 1030: 39276- 39277-/* Line 1455 of yacc.c */ 39278 #line 6624 "gram.y" 39279 {;} 39280 break; 39281 39282 case 1031: 39283- 39284-/* Line 1455 of yacc.c */ 39285 #line 6625 "gram.y" 39286 {;} 39287 break; 39288 39289 case 1032: 39290- 39291-/* Line 1455 of yacc.c */ 39292 #line 6637 "gram.y" 39293 { 39294 AlterTSDictionaryStmt *n = makeNode(AlterTSDictionaryStmt); 39295@@ -26996,8 +25556,6 @@ 39296 break; 39297 39298 case 1033: 39299- 39300-/* Line 1455 of yacc.c */ 39301 #line 6647 "gram.y" 39302 { 39303 AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt); 39304@@ -27011,8 +25569,6 @@ 39305 break; 39306 39307 case 1034: 39308- 39309-/* Line 1455 of yacc.c */ 39310 #line 6657 "gram.y" 39311 { 39312 AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt); 39313@@ -27026,8 +25582,6 @@ 39314 break; 39315 39316 case 1035: 39317- 39318-/* Line 1455 of yacc.c */ 39319 #line 6667 "gram.y" 39320 { 39321 AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt); 39322@@ -27041,8 +25595,6 @@ 39323 break; 39324 39325 case 1036: 39326- 39327-/* Line 1455 of yacc.c */ 39328 #line 6677 "gram.y" 39329 { 39330 AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt); 39331@@ -27056,8 +25608,6 @@ 39332 break; 39333 39334 case 1037: 39335- 39336-/* Line 1455 of yacc.c */ 39337 #line 6687 "gram.y" 39338 { 39339 AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt); 39340@@ -27069,8 +25619,6 @@ 39341 break; 39342 39343 case 1038: 39344- 39345-/* Line 1455 of yacc.c */ 39346 #line 6695 "gram.y" 39347 { 39348 AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt); 39349@@ -27082,8 +25630,6 @@ 39350 break; 39351 39352 case 1039: 39353- 39354-/* Line 1455 of yacc.c */ 39355 #line 6717 "gram.y" 39356 { 39357 CreateConversionStmt *n = makeNode(CreateConversionStmt); 39358@@ -27097,8 +25643,6 @@ 39359 break; 39360 39361 case 1040: 39362- 39363-/* Line 1455 of yacc.c */ 39364 #line 6739 "gram.y" 39365 { 39366 ClusterStmt *n = makeNode(ClusterStmt); 39367@@ -27110,8 +25654,6 @@ 39368 break; 39369 39370 case 1041: 39371- 39372-/* Line 1455 of yacc.c */ 39373 #line 6747 "gram.y" 39374 { 39375 ClusterStmt *n = makeNode(ClusterStmt); 39376@@ -27123,8 +25665,6 @@ 39377 break; 39378 39379 case 1042: 39380- 39381-/* Line 1455 of yacc.c */ 39382 #line 6756 "gram.y" 39383 { 39384 ClusterStmt *n = makeNode(ClusterStmt); 39385@@ -27136,22 +25676,16 @@ 39386 break; 39387 39388 case 1043: 39389- 39390-/* Line 1455 of yacc.c */ 39391 #line 6766 "gram.y" 39392 { (yyval.str) = (yyvsp[(2) - (2)].str); ;} 39393 break; 39394 39395 case 1044: 39396- 39397-/* Line 1455 of yacc.c */ 39398 #line 6767 "gram.y" 39399 { (yyval.str) = NULL; ;} 39400 break; 39401 39402 case 1045: 39403- 39404-/* Line 1455 of yacc.c */ 39405 #line 6780 "gram.y" 39406 { 39407 VacuumStmt *n = makeNode(VacuumStmt); 39408@@ -27169,8 +25703,6 @@ 39409 break; 39410 39411 case 1046: 39412- 39413-/* Line 1455 of yacc.c */ 39414 #line 6794 "gram.y" 39415 { 39416 VacuumStmt *n = makeNode(VacuumStmt); 39417@@ -27188,8 +25720,6 @@ 39418 break; 39419 39420 case 1047: 39421- 39422-/* Line 1455 of yacc.c */ 39423 #line 6808 "gram.y" 39424 { 39425 VacuumStmt *n = (VacuumStmt *) (yyvsp[(5) - (5)].node); 39426@@ -27205,8 +25735,6 @@ 39427 break; 39428 39429 case 1048: 39430- 39431-/* Line 1455 of yacc.c */ 39432 #line 6820 "gram.y" 39433 { 39434 VacuumStmt *n = makeNode(VacuumStmt); 39435@@ -27222,8 +25750,6 @@ 39436 break; 39437 39438 case 1049: 39439- 39440-/* Line 1455 of yacc.c */ 39441 #line 6832 "gram.y" 39442 { 39443 VacuumStmt *n = makeNode(VacuumStmt); 39444@@ -27241,50 +25767,36 @@ 39445 break; 39446 39447 case 1050: 39448- 39449-/* Line 1455 of yacc.c */ 39450 #line 6848 "gram.y" 39451 { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;} 39452 break; 39453 39454 case 1051: 39455- 39456-/* Line 1455 of yacc.c */ 39457 #line 6849 "gram.y" 39458 { (yyval.ival) = (yyvsp[(1) - (3)].ival) | (yyvsp[(3) - (3)].ival); ;} 39459 break; 39460 39461 case 1052: 39462- 39463-/* Line 1455 of yacc.c */ 39464 #line 6853 "gram.y" 39465 { (yyval.ival) = VACOPT_ANALYZE; ;} 39466 break; 39467 39468 case 1053: 39469- 39470-/* Line 1455 of yacc.c */ 39471 #line 6854 "gram.y" 39472 { (yyval.ival) = VACOPT_VERBOSE; ;} 39473 break; 39474 39475 case 1054: 39476- 39477-/* Line 1455 of yacc.c */ 39478 #line 6855 "gram.y" 39479 { (yyval.ival) = VACOPT_FREEZE; ;} 39480 break; 39481 39482 case 1055: 39483- 39484-/* Line 1455 of yacc.c */ 39485 #line 6856 "gram.y" 39486 { (yyval.ival) = VACOPT_FULL; ;} 39487 break; 39488 39489 case 1056: 39490- 39491-/* Line 1455 of yacc.c */ 39492 #line 6861 "gram.y" 39493 { 39494 VacuumStmt *n = makeNode(VacuumStmt); 39495@@ -27300,8 +25812,6 @@ 39496 break; 39497 39498 case 1057: 39499- 39500-/* Line 1455 of yacc.c */ 39501 #line 6873 "gram.y" 39502 { 39503 VacuumStmt *n = makeNode(VacuumStmt); 39504@@ -27317,78 +25827,56 @@ 39505 break; 39506 39507 case 1058: 39508- 39509-/* Line 1455 of yacc.c */ 39510 #line 6887 "gram.y" 39511 {;} 39512 break; 39513 39514 case 1059: 39515- 39516-/* Line 1455 of yacc.c */ 39517 #line 6888 "gram.y" 39518 {;} 39519 break; 39520 39521 case 1060: 39522- 39523-/* Line 1455 of yacc.c */ 39524 #line 6892 "gram.y" 39525 { (yyval.boolean) = TRUE; ;} 39526 break; 39527 39528 case 1061: 39529- 39530-/* Line 1455 of yacc.c */ 39531 #line 6893 "gram.y" 39532 { (yyval.boolean) = FALSE; ;} 39533 break; 39534 39535 case 1062: 39536- 39537-/* Line 1455 of yacc.c */ 39538 #line 6896 "gram.y" 39539 { (yyval.boolean) = TRUE; ;} 39540 break; 39541 39542 case 1063: 39543- 39544-/* Line 1455 of yacc.c */ 39545 #line 6897 "gram.y" 39546 { (yyval.boolean) = FALSE; ;} 39547 break; 39548 39549 case 1064: 39550- 39551-/* Line 1455 of yacc.c */ 39552 #line 6900 "gram.y" 39553 { (yyval.boolean) = TRUE; ;} 39554 break; 39555 39556 case 1065: 39557- 39558-/* Line 1455 of yacc.c */ 39559 #line 6901 "gram.y" 39560 { (yyval.boolean) = FALSE; ;} 39561 break; 39562 39563 case 1066: 39564- 39565-/* Line 1455 of yacc.c */ 39566 #line 6905 "gram.y" 39567 { (yyval.list) = (yyvsp[(2) - (3)].list); ;} 39568 break; 39569 39570 case 1067: 39571- 39572-/* Line 1455 of yacc.c */ 39573 #line 6906 "gram.y" 39574 { (yyval.list) = NIL; ;} 39575 break; 39576 39577 case 1068: 39578- 39579-/* Line 1455 of yacc.c */ 39580 #line 6920 "gram.y" 39581 { 39582 ExplainStmt *n = makeNode(ExplainStmt); 39583@@ -27399,8 +25887,6 @@ 39584 break; 39585 39586 case 1069: 39587- 39588-/* Line 1455 of yacc.c */ 39589 #line 6927 "gram.y" 39590 { 39591 ExplainStmt *n = makeNode(ExplainStmt); 39592@@ -27414,8 +25900,6 @@ 39593 break; 39594 39595 case 1070: 39596- 39597-/* Line 1455 of yacc.c */ 39598 #line 6937 "gram.y" 39599 { 39600 ExplainStmt *n = makeNode(ExplainStmt); 39601@@ -27426,8 +25910,6 @@ 39602 break; 39603 39604 case 1071: 39605- 39606-/* Line 1455 of yacc.c */ 39607 #line 6944 "gram.y" 39608 { 39609 ExplainStmt *n = makeNode(ExplainStmt); 39610@@ -27438,8 +25920,6 @@ 39611 break; 39612 39613 case 1079: 39614- 39615-/* Line 1455 of yacc.c */ 39616 #line 6964 "gram.y" 39617 { 39618 (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); 39619@@ -27447,8 +25927,6 @@ 39620 break; 39621 39622 case 1080: 39623- 39624-/* Line 1455 of yacc.c */ 39625 #line 6968 "gram.y" 39626 { 39627 (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); 39628@@ -27456,8 +25934,6 @@ 39629 break; 39630 39631 case 1081: 39632- 39633-/* Line 1455 of yacc.c */ 39634 #line 6975 "gram.y" 39635 { 39636 (yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node)); 39637@@ -27465,50 +25941,36 @@ 39638 break; 39639 39640 case 1082: 39641- 39642-/* Line 1455 of yacc.c */ 39643 #line 6981 "gram.y" 39644 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 39645 break; 39646 39647 case 1083: 39648- 39649-/* Line 1455 of yacc.c */ 39650 #line 6982 "gram.y" 39651 { (yyval.str) = "analyze"; ;} 39652 break; 39653 39654 case 1084: 39655- 39656-/* Line 1455 of yacc.c */ 39657 #line 6983 "gram.y" 39658 { (yyval.str) = "verbose"; ;} 39659 break; 39660 39661 case 1085: 39662- 39663-/* Line 1455 of yacc.c */ 39664 #line 6987 "gram.y" 39665 { (yyval.node) = (Node *) makeString((yyvsp[(1) - (1)].str)); ;} 39666 break; 39667 39668 case 1086: 39669- 39670-/* Line 1455 of yacc.c */ 39671 #line 6988 "gram.y" 39672 { (yyval.node) = (Node *) (yyvsp[(1) - (1)].value); ;} 39673 break; 39674 39675 case 1087: 39676- 39677-/* Line 1455 of yacc.c */ 39678 #line 6989 "gram.y" 39679 { (yyval.node) = NULL; ;} 39680 break; 39681 39682 case 1088: 39683- 39684-/* Line 1455 of yacc.c */ 39685 #line 7000 "gram.y" 39686 { 39687 PrepareStmt *n = makeNode(PrepareStmt); 39688@@ -27520,22 +25982,16 @@ 39689 break; 39690 39691 case 1089: 39692- 39693-/* Line 1455 of yacc.c */ 39694 #line 7009 "gram.y" 39695 { (yyval.list) = (yyvsp[(2) - (3)].list); ;} 39696 break; 39697 39698 case 1090: 39699- 39700-/* Line 1455 of yacc.c */ 39701 #line 7010 "gram.y" 39702 { (yyval.list) = NIL; ;} 39703 break; 39704 39705 case 1095: 39706- 39707-/* Line 1455 of yacc.c */ 39708 #line 7028 "gram.y" 39709 { 39710 ExecuteStmt *n = makeNode(ExecuteStmt); 39711@@ -27547,8 +26003,6 @@ 39712 break; 39713 39714 case 1096: 39715- 39716-/* Line 1455 of yacc.c */ 39717 #line 7037 "gram.y" 39718 { 39719 ExecuteStmt *n = makeNode(ExecuteStmt); 39720@@ -27566,22 +26020,16 @@ 39721 break; 39722 39723 case 1097: 39724- 39725-/* Line 1455 of yacc.c */ 39726 #line 7052 "gram.y" 39727 { (yyval.list) = (yyvsp[(2) - (3)].list); ;} 39728 break; 39729 39730 case 1098: 39731- 39732-/* Line 1455 of yacc.c */ 39733 #line 7053 "gram.y" 39734 { (yyval.list) = NIL; ;} 39735 break; 39736 39737 case 1099: 39738- 39739-/* Line 1455 of yacc.c */ 39740 #line 7064 "gram.y" 39741 { 39742 DeallocateStmt *n = makeNode(DeallocateStmt); 39743@@ -27591,8 +26039,6 @@ 39744 break; 39745 39746 case 1100: 39747- 39748-/* Line 1455 of yacc.c */ 39749 #line 7070 "gram.y" 39750 { 39751 DeallocateStmt *n = makeNode(DeallocateStmt); 39752@@ -27602,8 +26048,6 @@ 39753 break; 39754 39755 case 1101: 39756- 39757-/* Line 1455 of yacc.c */ 39758 #line 7076 "gram.y" 39759 { 39760 DeallocateStmt *n = makeNode(DeallocateStmt); 39761@@ -27613,8 +26057,6 @@ 39762 break; 39763 39764 case 1102: 39765- 39766-/* Line 1455 of yacc.c */ 39767 #line 7082 "gram.y" 39768 { 39769 DeallocateStmt *n = makeNode(DeallocateStmt); 39770@@ -27624,8 +26066,6 @@ 39771 break; 39772 39773 case 1103: 39774- 39775-/* Line 1455 of yacc.c */ 39776 #line 7098 "gram.y" 39777 { 39778 (yyvsp[(4) - (5)].istmt)->relation = (yyvsp[(3) - (5)].range); 39779@@ -27635,8 +26075,6 @@ 39780 break; 39781 39782 case 1104: 39783- 39784-/* Line 1455 of yacc.c */ 39785 #line 7107 "gram.y" 39786 { 39787 (yyval.istmt) = makeNode(InsertStmt); 39788@@ -27646,8 +26084,6 @@ 39789 break; 39790 39791 case 1105: 39792- 39793-/* Line 1455 of yacc.c */ 39794 #line 7113 "gram.y" 39795 { 39796 (yyval.istmt) = makeNode(InsertStmt); 39797@@ -27657,8 +26093,6 @@ 39798 break; 39799 39800 case 1106: 39801- 39802-/* Line 1455 of yacc.c */ 39803 #line 7119 "gram.y" 39804 { 39805 (yyval.istmt) = makeNode(InsertStmt); 39806@@ -27668,22 +26102,16 @@ 39807 break; 39808 39809 case 1107: 39810- 39811-/* Line 1455 of yacc.c */ 39812 #line 7128 "gram.y" 39813 { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;} 39814 break; 39815 39816 case 1108: 39817- 39818-/* Line 1455 of yacc.c */ 39819 #line 7130 "gram.y" 39820 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].target)); ;} 39821 break; 39822 39823 case 1109: 39824- 39825-/* Line 1455 of yacc.c */ 39826 #line 7135 "gram.y" 39827 { 39828 (yyval.target) = makeNode(ResTarget); 39829@@ -27695,22 +26123,16 @@ 39830 break; 39831 39832 case 1110: 39833- 39834-/* Line 1455 of yacc.c */ 39835 #line 7145 "gram.y" 39836 { (yyval.list) = (yyvsp[(2) - (2)].list); ;} 39837 break; 39838 39839 case 1111: 39840- 39841-/* Line 1455 of yacc.c */ 39842 #line 7146 "gram.y" 39843 { (yyval.list) = NIL; ;} 39844 break; 39845 39846 case 1112: 39847- 39848-/* Line 1455 of yacc.c */ 39849 #line 7159 "gram.y" 39850 { 39851 DeleteStmt *n = makeNode(DeleteStmt); 39852@@ -27723,22 +26145,16 @@ 39853 break; 39854 39855 case 1113: 39856- 39857-/* Line 1455 of yacc.c */ 39858 #line 7170 "gram.y" 39859 { (yyval.list) = (yyvsp[(2) - (2)].list); ;} 39860 break; 39861 39862 case 1114: 39863- 39864-/* Line 1455 of yacc.c */ 39865 #line 7171 "gram.y" 39866 { (yyval.list) = NIL; ;} 39867 break; 39868 39869 case 1115: 39870- 39871-/* Line 1455 of yacc.c */ 39872 #line 7183 "gram.y" 39873 { 39874 LockStmt *n = makeNode(LockStmt); 39875@@ -27751,92 +26167,66 @@ 39876 break; 39877 39878 case 1116: 39879- 39880-/* Line 1455 of yacc.c */ 39881 #line 7193 "gram.y" 39882 { (yyval.ival) = (yyvsp[(2) - (3)].ival); ;} 39883 break; 39884 39885 case 1117: 39886- 39887-/* Line 1455 of yacc.c */ 39888 #line 7194 "gram.y" 39889 { (yyval.ival) = AccessExclusiveLock; ;} 39890 break; 39891 39892 case 1118: 39893- 39894-/* Line 1455 of yacc.c */ 39895 #line 7197 "gram.y" 39896 { (yyval.ival) = AccessShareLock; ;} 39897 break; 39898 39899 case 1119: 39900- 39901-/* Line 1455 of yacc.c */ 39902 #line 7198 "gram.y" 39903 { (yyval.ival) = RowShareLock; ;} 39904 break; 39905 39906 case 1120: 39907- 39908-/* Line 1455 of yacc.c */ 39909 #line 7199 "gram.y" 39910 { (yyval.ival) = RowExclusiveLock; ;} 39911 break; 39912 39913 case 1121: 39914- 39915-/* Line 1455 of yacc.c */ 39916 #line 7200 "gram.y" 39917 { (yyval.ival) = ShareUpdateExclusiveLock; ;} 39918 break; 39919 39920 case 1122: 39921- 39922-/* Line 1455 of yacc.c */ 39923 #line 7201 "gram.y" 39924 { (yyval.ival) = ShareLock; ;} 39925 break; 39926 39927 case 1123: 39928- 39929-/* Line 1455 of yacc.c */ 39930 #line 7202 "gram.y" 39931 { (yyval.ival) = ShareRowExclusiveLock; ;} 39932 break; 39933 39934 case 1124: 39935- 39936-/* Line 1455 of yacc.c */ 39937 #line 7203 "gram.y" 39938 { (yyval.ival) = ExclusiveLock; ;} 39939 break; 39940 39941 case 1125: 39942- 39943-/* Line 1455 of yacc.c */ 39944 #line 7204 "gram.y" 39945 { (yyval.ival) = AccessExclusiveLock; ;} 39946 break; 39947 39948 case 1126: 39949- 39950-/* Line 1455 of yacc.c */ 39951 #line 7207 "gram.y" 39952 { (yyval.boolean) = TRUE; ;} 39953 break; 39954 39955 case 1127: 39956- 39957-/* Line 1455 of yacc.c */ 39958 #line 7208 "gram.y" 39959 { (yyval.boolean) = FALSE; ;} 39960 break; 39961 39962 case 1128: 39963- 39964-/* Line 1455 of yacc.c */ 39965 #line 7224 "gram.y" 39966 { 39967 UpdateStmt *n = makeNode(UpdateStmt); 39968@@ -27850,36 +26240,26 @@ 39969 break; 39970 39971 case 1129: 39972- 39973-/* Line 1455 of yacc.c */ 39974 #line 7236 "gram.y" 39975 { (yyval.list) = (yyvsp[(1) - (1)].list); ;} 39976 break; 39977 39978 case 1130: 39979- 39980-/* Line 1455 of yacc.c */ 39981 #line 7237 "gram.y" 39982 { (yyval.list) = list_concat((yyvsp[(1) - (3)].list),(yyvsp[(3) - (3)].list)); ;} 39983 break; 39984 39985 case 1131: 39986- 39987-/* Line 1455 of yacc.c */ 39988 #line 7241 "gram.y" 39989 { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;} 39990 break; 39991 39992 case 1132: 39993- 39994-/* Line 1455 of yacc.c */ 39995 #line 7242 "gram.y" 39996 { (yyval.list) = (yyvsp[(1) - (1)].list); ;} 39997 break; 39998 39999 case 1133: 40000- 40001-/* Line 1455 of yacc.c */ 40002 #line 7247 "gram.y" 40003 { 40004 (yyval.target) = (yyvsp[(1) - (3)].target); 40005@@ -27888,8 +26268,6 @@ 40006 break; 40007 40008 case 1134: 40009- 40010-/* Line 1455 of yacc.c */ 40011 #line 7255 "gram.y" 40012 { 40013 ListCell *col_cell; 40014@@ -27918,8 +26296,6 @@ 40015 break; 40016 40017 case 1135: 40018- 40019-/* Line 1455 of yacc.c */ 40020 #line 7283 "gram.y" 40021 { 40022 (yyval.target) = makeNode(ResTarget); 40023@@ -27931,22 +26307,16 @@ 40024 break; 40025 40026 case 1136: 40027- 40028-/* Line 1455 of yacc.c */ 40029 #line 7293 "gram.y" 40030 { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;} 40031 break; 40032 40033 case 1137: 40034- 40035-/* Line 1455 of yacc.c */ 40036 #line 7294 "gram.y" 40037 { (yyval.list) = lappend((yyvsp[(1) - (3)].list),(yyvsp[(3) - (3)].target)); ;} 40038 break; 40039 40040 case 1138: 40041- 40042-/* Line 1455 of yacc.c */ 40043 #line 7305 "gram.y" 40044 { 40045 DeclareCursorStmt *n = makeNode(DeclareCursorStmt); 40046@@ -27959,92 +26329,66 @@ 40047 break; 40048 40049 case 1139: 40050- 40051-/* Line 1455 of yacc.c */ 40052 #line 7315 "gram.y" 40053 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 40054 break; 40055 40056 case 1140: 40057- 40058-/* Line 1455 of yacc.c */ 40059 #line 7318 "gram.y" 40060 { (yyval.ival) = 0; ;} 40061 break; 40062 40063 case 1141: 40064- 40065-/* Line 1455 of yacc.c */ 40066 #line 7319 "gram.y" 40067 { (yyval.ival) = (yyvsp[(1) - (3)].ival) | CURSOR_OPT_NO_SCROLL; ;} 40068 break; 40069 40070 case 1142: 40071- 40072-/* Line 1455 of yacc.c */ 40073 #line 7320 "gram.y" 40074 { (yyval.ival) = (yyvsp[(1) - (2)].ival) | CURSOR_OPT_SCROLL; ;} 40075 break; 40076 40077 case 1143: 40078- 40079-/* Line 1455 of yacc.c */ 40080 #line 7321 "gram.y" 40081 { (yyval.ival) = (yyvsp[(1) - (2)].ival) | CURSOR_OPT_BINARY; ;} 40082 break; 40083 40084 case 1144: 40085- 40086-/* Line 1455 of yacc.c */ 40087 #line 7322 "gram.y" 40088 { (yyval.ival) = (yyvsp[(1) - (2)].ival) | CURSOR_OPT_INSENSITIVE; ;} 40089 break; 40090 40091 case 1145: 40092- 40093-/* Line 1455 of yacc.c */ 40094 #line 7325 "gram.y" 40095 { (yyval.ival) = 0; ;} 40096 break; 40097 40098 case 1146: 40099- 40100-/* Line 1455 of yacc.c */ 40101 #line 7326 "gram.y" 40102 { (yyval.ival) = CURSOR_OPT_HOLD; ;} 40103 break; 40104 40105 case 1147: 40106- 40107-/* Line 1455 of yacc.c */ 40108 #line 7327 "gram.y" 40109 { (yyval.ival) = 0; ;} 40110 break; 40111 40112 case 1150: 40113- 40114-/* Line 1455 of yacc.c */ 40115 #line 7380 "gram.y" 40116 { (yyval.node) = (yyvsp[(2) - (3)].node); ;} 40117 break; 40118 40119 case 1151: 40120- 40121-/* Line 1455 of yacc.c */ 40122 #line 7381 "gram.y" 40123 { (yyval.node) = (yyvsp[(2) - (3)].node); ;} 40124 break; 40125 40126 case 1152: 40127- 40128-/* Line 1455 of yacc.c */ 40129 #line 7395 "gram.y" 40130 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 40131 break; 40132 40133 case 1153: 40134- 40135-/* Line 1455 of yacc.c */ 40136 #line 7397 "gram.y" 40137 { 40138 insertSelectOptions((SelectStmt *) (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].list), NIL, 40139@@ -28055,8 +26399,6 @@ 40140 break; 40141 40142 case 1154: 40143- 40144-/* Line 1455 of yacc.c */ 40145 #line 7404 "gram.y" 40146 { 40147 insertSelectOptions((SelectStmt *) (yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].list), (yyvsp[(3) - (4)].list), 40148@@ -28068,8 +26410,6 @@ 40149 break; 40150 40151 case 1155: 40152- 40153-/* Line 1455 of yacc.c */ 40154 #line 7412 "gram.y" 40155 { 40156 insertSelectOptions((SelectStmt *) (yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].list), (yyvsp[(4) - (4)].list), 40157@@ -28081,8 +26421,6 @@ 40158 break; 40159 40160 case 1156: 40161- 40162-/* Line 1455 of yacc.c */ 40163 #line 7420 "gram.y" 40164 { 40165 insertSelectOptions((SelectStmt *) (yyvsp[(2) - (2)].node), NULL, NIL, 40166@@ -28094,8 +26432,6 @@ 40167 break; 40168 40169 case 1157: 40170- 40171-/* Line 1455 of yacc.c */ 40172 #line 7428 "gram.y" 40173 { 40174 insertSelectOptions((SelectStmt *) (yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].list), NIL, 40175@@ -28107,8 +26443,6 @@ 40176 break; 40177 40178 case 1158: 40179- 40180-/* Line 1455 of yacc.c */ 40181 #line 7436 "gram.y" 40182 { 40183 insertSelectOptions((SelectStmt *) (yyvsp[(2) - (5)].node), (yyvsp[(3) - (5)].list), (yyvsp[(4) - (5)].list), 40184@@ -28120,8 +26454,6 @@ 40185 break; 40186 40187 case 1159: 40188- 40189-/* Line 1455 of yacc.c */ 40190 #line 7444 "gram.y" 40191 { 40192 insertSelectOptions((SelectStmt *) (yyvsp[(2) - (5)].node), (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list), 40193@@ -28133,22 +26465,16 @@ 40194 break; 40195 40196 case 1160: 40197- 40198-/* Line 1455 of yacc.c */ 40199 #line 7454 "gram.y" 40200 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 40201 break; 40202 40203 case 1161: 40204- 40205-/* Line 1455 of yacc.c */ 40206 #line 7455 "gram.y" 40207 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 40208 break; 40209 40210 case 1162: 40211- 40212-/* Line 1455 of yacc.c */ 40213 #line 7485 "gram.y" 40214 { 40215 SelectStmt *n = makeNode(SelectStmt); 40216@@ -28165,15 +26491,11 @@ 40217 break; 40218 40219 case 1163: 40220- 40221-/* Line 1455 of yacc.c */ 40222 #line 7497 "gram.y" 40223 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 40224 break; 40225 40226 case 1164: 40227- 40228-/* Line 1455 of yacc.c */ 40229 #line 7499 "gram.y" 40230 { 40231 /* same as SELECT * FROM relation_expr */ 40232@@ -28196,8 +26518,6 @@ 40233 break; 40234 40235 case 1165: 40236- 40237-/* Line 1455 of yacc.c */ 40238 #line 7518 "gram.y" 40239 { 40240 (yyval.node) = makeSetOp(SETOP_UNION, (yyvsp[(3) - (4)].boolean), (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node)); 40241@@ -28205,8 +26525,6 @@ 40242 break; 40243 40244 case 1166: 40245- 40246-/* Line 1455 of yacc.c */ 40247 #line 7522 "gram.y" 40248 { 40249 (yyval.node) = makeSetOp(SETOP_INTERSECT, (yyvsp[(3) - (4)].boolean), (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node)); 40250@@ -28214,8 +26532,6 @@ 40251 break; 40252 40253 case 1167: 40254- 40255-/* Line 1455 of yacc.c */ 40256 #line 7526 "gram.y" 40257 { 40258 (yyval.node) = makeSetOp(SETOP_EXCEPT, (yyvsp[(3) - (4)].boolean), (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node)); 40259@@ -28223,8 +26539,6 @@ 40260 break; 40261 40262 case 1168: 40263- 40264-/* Line 1455 of yacc.c */ 40265 #line 7541 "gram.y" 40266 { 40267 (yyval.with) = makeNode(WithClause); 40268@@ -28235,8 +26549,6 @@ 40269 break; 40270 40271 case 1169: 40272- 40273-/* Line 1455 of yacc.c */ 40274 #line 7548 "gram.y" 40275 { 40276 (yyval.with) = makeNode(WithClause); 40277@@ -28247,22 +26559,16 @@ 40278 break; 40279 40280 case 1170: 40281- 40282-/* Line 1455 of yacc.c */ 40283 #line 7557 "gram.y" 40284 { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} 40285 break; 40286 40287 case 1171: 40288- 40289-/* Line 1455 of yacc.c */ 40290 #line 7558 "gram.y" 40291 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} 40292 break; 40293 40294 case 1172: 40295- 40296-/* Line 1455 of yacc.c */ 40297 #line 7562 "gram.y" 40298 { 40299 CommonTableExpr *n = makeNode(CommonTableExpr); 40300@@ -28275,8 +26581,6 @@ 40301 break; 40302 40303 case 1173: 40304- 40305-/* Line 1455 of yacc.c */ 40306 #line 7574 "gram.y" 40307 { 40308 (yyval.into) = makeNode(IntoClause); 40309@@ -28289,15 +26593,11 @@ 40310 break; 40311 40312 case 1174: 40313- 40314-/* Line 1455 of yacc.c */ 40315 #line 7583 "gram.y" 40316 { (yyval.into) = NULL; ;} 40317 break; 40318 40319 case 1175: 40320- 40321-/* Line 1455 of yacc.c */ 40322 #line 7592 "gram.y" 40323 { 40324 (yyval.range) = (yyvsp[(3) - (3)].range); 40325@@ -28306,8 +26606,6 @@ 40326 break; 40327 40328 case 1176: 40329- 40330-/* Line 1455 of yacc.c */ 40331 #line 7597 "gram.y" 40332 { 40333 (yyval.range) = (yyvsp[(3) - (3)].range); 40334@@ -28316,8 +26614,6 @@ 40335 break; 40336 40337 case 1177: 40338- 40339-/* Line 1455 of yacc.c */ 40340 #line 7602 "gram.y" 40341 { 40342 (yyval.range) = (yyvsp[(4) - (4)].range); 40343@@ -28326,8 +26622,6 @@ 40344 break; 40345 40346 case 1178: 40347- 40348-/* Line 1455 of yacc.c */ 40349 #line 7607 "gram.y" 40350 { 40351 (yyval.range) = (yyvsp[(4) - (4)].range); 40352@@ -28336,8 +26630,6 @@ 40353 break; 40354 40355 case 1179: 40356- 40357-/* Line 1455 of yacc.c */ 40358 #line 7612 "gram.y" 40359 { 40360 (yyval.range) = (yyvsp[(4) - (4)].range); 40361@@ -28346,8 +26638,6 @@ 40362 break; 40363 40364 case 1180: 40365- 40366-/* Line 1455 of yacc.c */ 40367 #line 7617 "gram.y" 40368 { 40369 (yyval.range) = (yyvsp[(4) - (4)].range); 40370@@ -28356,8 +26646,6 @@ 40371 break; 40372 40373 case 1181: 40374- 40375-/* Line 1455 of yacc.c */ 40376 #line 7622 "gram.y" 40377 { 40378 (yyval.range) = (yyvsp[(2) - (2)].range); 40379@@ -28366,8 +26654,6 @@ 40380 break; 40381 40382 case 1182: 40383- 40384-/* Line 1455 of yacc.c */ 40385 #line 7627 "gram.y" 40386 { 40387 (yyval.range) = (yyvsp[(1) - (1)].range); 40388@@ -28376,106 +26662,76 @@ 40389 break; 40390 40391 case 1183: 40392- 40393-/* Line 1455 of yacc.c */ 40394 #line 7633 "gram.y" 40395 {;} 40396 break; 40397 40398 case 1184: 40399- 40400-/* Line 1455 of yacc.c */ 40401 #line 7634 "gram.y" 40402 {;} 40403 break; 40404 40405 case 1185: 40406- 40407-/* Line 1455 of yacc.c */ 40408 #line 7637 "gram.y" 40409 { (yyval.boolean) = TRUE; ;} 40410 break; 40411 40412 case 1186: 40413- 40414-/* Line 1455 of yacc.c */ 40415 #line 7638 "gram.y" 40416 { (yyval.boolean) = FALSE; ;} 40417 break; 40418 40419 case 1187: 40420- 40421-/* Line 1455 of yacc.c */ 40422 #line 7639 "gram.y" 40423 { (yyval.boolean) = FALSE; ;} 40424 break; 40425 40426 case 1188: 40427- 40428-/* Line 1455 of yacc.c */ 40429 #line 7646 "gram.y" 40430 { (yyval.list) = list_make1(NIL); ;} 40431 break; 40432 40433 case 1189: 40434- 40435-/* Line 1455 of yacc.c */ 40436 #line 7647 "gram.y" 40437 { (yyval.list) = (yyvsp[(4) - (5)].list); ;} 40438 break; 40439 40440 case 1190: 40441- 40442-/* Line 1455 of yacc.c */ 40443 #line 7648 "gram.y" 40444 { (yyval.list) = NIL; ;} 40445 break; 40446 40447 case 1191: 40448- 40449-/* Line 1455 of yacc.c */ 40450 #line 7649 "gram.y" 40451 { (yyval.list) = NIL; ;} 40452 break; 40453 40454 case 1192: 40455- 40456-/* Line 1455 of yacc.c */ 40457 #line 7653 "gram.y" 40458 { (yyval.list) = (yyvsp[(1) - (1)].list);;} 40459 break; 40460 40461 case 1193: 40462- 40463-/* Line 1455 of yacc.c */ 40464 #line 7654 "gram.y" 40465 { (yyval.list) = NIL; ;} 40466 break; 40467 40468 case 1194: 40469- 40470-/* Line 1455 of yacc.c */ 40471 #line 7658 "gram.y" 40472 { (yyval.list) = (yyvsp[(3) - (3)].list); ;} 40473 break; 40474 40475 case 1195: 40476- 40477-/* Line 1455 of yacc.c */ 40478 #line 7662 "gram.y" 40479 { (yyval.list) = list_make1((yyvsp[(1) - (1)].sortby)); ;} 40480 break; 40481 40482 case 1196: 40483- 40484-/* Line 1455 of yacc.c */ 40485 #line 7663 "gram.y" 40486 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].sortby)); ;} 40487 break; 40488 40489 case 1197: 40490- 40491-/* Line 1455 of yacc.c */ 40492 #line 7667 "gram.y" 40493 { 40494 (yyval.sortby) = makeNode(SortBy); 40495@@ -28488,8 +26744,6 @@ 40496 break; 40497 40498 case 1198: 40499- 40500-/* Line 1455 of yacc.c */ 40501 #line 7676 "gram.y" 40502 { 40503 (yyval.sortby) = makeNode(SortBy); 40504@@ -28502,57 +26756,41 @@ 40505 break; 40506 40507 case 1199: 40508- 40509-/* Line 1455 of yacc.c */ 40510 #line 7688 "gram.y" 40511 { (yyval.list) = list_make2((yyvsp[(2) - (2)].node), (yyvsp[(1) - (2)].node)); ;} 40512 break; 40513 40514 case 1200: 40515- 40516-/* Line 1455 of yacc.c */ 40517 #line 7689 "gram.y" 40518 { (yyval.list) = list_make2((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); ;} 40519 break; 40520 40521 case 1201: 40522- 40523-/* Line 1455 of yacc.c */ 40524 #line 7690 "gram.y" 40525 { (yyval.list) = list_make2(NULL, (yyvsp[(1) - (1)].node)); ;} 40526 break; 40527 40528 case 1202: 40529- 40530-/* Line 1455 of yacc.c */ 40531 #line 7691 "gram.y" 40532 { (yyval.list) = list_make2((yyvsp[(1) - (1)].node), NULL); ;} 40533 break; 40534 40535 case 1203: 40536- 40537-/* Line 1455 of yacc.c */ 40538 #line 7695 "gram.y" 40539 { (yyval.list) = (yyvsp[(1) - (1)].list); ;} 40540 break; 40541 40542 case 1204: 40543- 40544-/* Line 1455 of yacc.c */ 40545 #line 7696 "gram.y" 40546 { (yyval.list) = list_make2(NULL,NULL); ;} 40547 break; 40548 40549 case 1205: 40550- 40551-/* Line 1455 of yacc.c */ 40552 #line 7701 "gram.y" 40553 { (yyval.node) = (yyvsp[(2) - (2)].node); ;} 40554 break; 40555 40556 case 1206: 40557- 40558-/* Line 1455 of yacc.c */ 40559 #line 7703 "gram.y" 40560 { 40561 /* Disabled because it was too confusing, bjm 2002-02-18 */ 40562@@ -28565,36 +26803,26 @@ 40563 break; 40564 40565 case 1207: 40566- 40567-/* Line 1455 of yacc.c */ 40568 #line 7713 "gram.y" 40569 { (yyval.node) = (yyvsp[(3) - (5)].node); ;} 40570 break; 40571 40572 case 1208: 40573- 40574-/* Line 1455 of yacc.c */ 40575 #line 7718 "gram.y" 40576 { (yyval.node) = (yyvsp[(2) - (2)].node); ;} 40577 break; 40578 40579 case 1209: 40580- 40581-/* Line 1455 of yacc.c */ 40582 #line 7721 "gram.y" 40583 { (yyval.node) = (yyvsp[(2) - (3)].node); ;} 40584 break; 40585 40586 case 1210: 40587- 40588-/* Line 1455 of yacc.c */ 40589 #line 7725 "gram.y" 40590 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 40591 break; 40592 40593 case 1211: 40594- 40595-/* Line 1455 of yacc.c */ 40596 #line 7727 "gram.y" 40597 { 40598 /* LIMIT ALL is represented as a NULL constant */ 40599@@ -28603,141 +26831,101 @@ 40600 break; 40601 40602 case 1212: 40603- 40604-/* Line 1455 of yacc.c */ 40605 #line 7734 "gram.y" 40606 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 40607 break; 40608 40609 case 1213: 40610- 40611-/* Line 1455 of yacc.c */ 40612 #line 7744 "gram.y" 40613 { (yyval.node) = makeIntConst((yyvsp[(1) - (1)].ival), (yylsp[(1) - (1)])); ;} 40614 break; 40615 40616 case 1214: 40617- 40618-/* Line 1455 of yacc.c */ 40619 #line 7745 "gram.y" 40620 { (yyval.node) = (yyvsp[(2) - (3)].node); ;} 40621 break; 40622 40623 case 1215: 40624- 40625-/* Line 1455 of yacc.c */ 40626 #line 7746 "gram.y" 40627 { (yyval.node) = makeIntConst(1, -1); ;} 40628 break; 40629 40630 case 1216: 40631- 40632-/* Line 1455 of yacc.c */ 40633 #line 7754 "gram.y" 40634 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 40635 break; 40636 40637 case 1217: 40638- 40639-/* Line 1455 of yacc.c */ 40640 #line 7758 "gram.y" 40641 { (yyval.ival) = 0; ;} 40642 break; 40643 40644 case 1218: 40645- 40646-/* Line 1455 of yacc.c */ 40647 #line 7759 "gram.y" 40648 { (yyval.ival) = 0; ;} 40649 break; 40650 40651 case 1219: 40652- 40653-/* Line 1455 of yacc.c */ 40654 #line 7762 "gram.y" 40655 { (yyval.ival) = 0; ;} 40656 break; 40657 40658 case 1220: 40659- 40660-/* Line 1455 of yacc.c */ 40661 #line 7763 "gram.y" 40662 { (yyval.ival) = 0; ;} 40663 break; 40664 40665 case 1221: 40666- 40667-/* Line 1455 of yacc.c */ 40668 #line 7768 "gram.y" 40669 { (yyval.list) = (yyvsp[(3) - (3)].list); ;} 40670 break; 40671 40672 case 1222: 40673- 40674-/* Line 1455 of yacc.c */ 40675 #line 7769 "gram.y" 40676 { (yyval.list) = NIL; ;} 40677 break; 40678 40679 case 1223: 40680- 40681-/* Line 1455 of yacc.c */ 40682 #line 7773 "gram.y" 40683 { (yyval.node) = (yyvsp[(2) - (2)].node); ;} 40684 break; 40685 40686 case 1224: 40687- 40688-/* Line 1455 of yacc.c */ 40689 #line 7774 "gram.y" 40690 { (yyval.node) = NULL; ;} 40691 break; 40692 40693 case 1225: 40694- 40695-/* Line 1455 of yacc.c */ 40696 #line 7778 "gram.y" 40697 { (yyval.list) = (yyvsp[(1) - (1)].list); ;} 40698 break; 40699 40700 case 1226: 40701- 40702-/* Line 1455 of yacc.c */ 40703 #line 7779 "gram.y" 40704 { (yyval.list) = NIL; ;} 40705 break; 40706 40707 case 1227: 40708- 40709-/* Line 1455 of yacc.c */ 40710 #line 7783 "gram.y" 40711 { (yyval.list) = (yyvsp[(1) - (1)].list); ;} 40712 break; 40713 40714 case 1228: 40715- 40716-/* Line 1455 of yacc.c */ 40717 #line 7784 "gram.y" 40718 { (yyval.list) = NIL; ;} 40719 break; 40720 40721 case 1229: 40722- 40723-/* Line 1455 of yacc.c */ 40724 #line 7788 "gram.y" 40725 { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} 40726 break; 40727 40728 case 1230: 40729- 40730-/* Line 1455 of yacc.c */ 40731 #line 7789 "gram.y" 40732 { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} 40733 break; 40734 40735 case 1231: 40736- 40737-/* Line 1455 of yacc.c */ 40738 #line 7794 "gram.y" 40739 { 40740 LockingClause *n = makeNode(LockingClause); 40741@@ -28749,8 +26937,6 @@ 40742 break; 40743 40744 case 1232: 40745- 40746-/* Line 1455 of yacc.c */ 40747 #line 7802 "gram.y" 40748 { 40749 LockingClause *n = makeNode(LockingClause); 40750@@ -28762,22 +26948,16 @@ 40751 break; 40752 40753 case 1233: 40754- 40755-/* Line 1455 of yacc.c */ 40756 #line 7812 "gram.y" 40757 { (yyval.list) = (yyvsp[(2) - (2)].list); ;} 40758 break; 40759 40760 case 1234: 40761- 40762-/* Line 1455 of yacc.c */ 40763 #line 7813 "gram.y" 40764 { (yyval.list) = NIL; ;} 40765 break; 40766 40767 case 1235: 40768- 40769-/* Line 1455 of yacc.c */ 40770 #line 7819 "gram.y" 40771 { 40772 SelectStmt *n = makeNode(SelectStmt); 40773@@ -28787,8 +26967,6 @@ 40774 break; 40775 40776 case 1236: 40777- 40778-/* Line 1455 of yacc.c */ 40779 #line 7825 "gram.y" 40780 { 40781 SelectStmt *n = (SelectStmt *) (yyvsp[(1) - (3)].node); 40782@@ -28798,36 +26976,26 @@ 40783 break; 40784 40785 case 1237: 40786- 40787-/* Line 1455 of yacc.c */ 40788 #line 7842 "gram.y" 40789 { (yyval.list) = (yyvsp[(2) - (2)].list); ;} 40790 break; 40791 40792 case 1238: 40793- 40794-/* Line 1455 of yacc.c */ 40795 #line 7843 "gram.y" 40796 { (yyval.list) = NIL; ;} 40797 break; 40798 40799 case 1239: 40800- 40801-/* Line 1455 of yacc.c */ 40802 #line 7847 "gram.y" 40803 { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} 40804 break; 40805 40806 case 1240: 40807- 40808-/* Line 1455 of yacc.c */ 40809 #line 7848 "gram.y" 40810 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} 40811 break; 40812 40813 case 1241: 40814- 40815-/* Line 1455 of yacc.c */ 40816 #line 7859 "gram.y" 40817 { 40818 (yyval.node) = (Node *) (yyvsp[(1) - (1)].range); 40819@@ -28835,8 +27003,6 @@ 40820 break; 40821 40822 case 1242: 40823- 40824-/* Line 1455 of yacc.c */ 40825 #line 7863 "gram.y" 40826 { 40827 (yyvsp[(1) - (2)].range)->alias = (yyvsp[(2) - (2)].alias); 40828@@ -28845,8 +27011,6 @@ 40829 break; 40830 40831 case 1243: 40832- 40833-/* Line 1455 of yacc.c */ 40834 #line 7868 "gram.y" 40835 { 40836 RangeFunction *n = makeNode(RangeFunction); 40837@@ -28857,8 +27021,6 @@ 40838 break; 40839 40840 case 1244: 40841- 40842-/* Line 1455 of yacc.c */ 40843 #line 7875 "gram.y" 40844 { 40845 RangeFunction *n = makeNode(RangeFunction); 40846@@ -28870,8 +27032,6 @@ 40847 break; 40848 40849 case 1245: 40850- 40851-/* Line 1455 of yacc.c */ 40852 #line 7883 "gram.y" 40853 { 40854 RangeFunction *n = makeNode(RangeFunction); 40855@@ -28882,8 +27042,6 @@ 40856 break; 40857 40858 case 1246: 40859- 40860-/* Line 1455 of yacc.c */ 40861 #line 7890 "gram.y" 40862 { 40863 RangeFunction *n = makeNode(RangeFunction); 40864@@ -28897,8 +27055,6 @@ 40865 break; 40866 40867 case 1247: 40868- 40869-/* Line 1455 of yacc.c */ 40870 #line 7900 "gram.y" 40871 { 40872 RangeFunction *n = makeNode(RangeFunction); 40873@@ -28912,8 +27068,6 @@ 40874 break; 40875 40876 case 1248: 40877- 40878-/* Line 1455 of yacc.c */ 40879 #line 7910 "gram.y" 40880 { 40881 /* 40882@@ -28945,8 +27099,6 @@ 40883 break; 40884 40885 case 1249: 40886- 40887-/* Line 1455 of yacc.c */ 40888 #line 7938 "gram.y" 40889 { 40890 RangeSubselect *n = makeNode(RangeSubselect); 40891@@ -28957,8 +27109,6 @@ 40892 break; 40893 40894 case 1250: 40895- 40896-/* Line 1455 of yacc.c */ 40897 #line 7945 "gram.y" 40898 { 40899 (yyval.node) = (Node *) (yyvsp[(1) - (1)].jexpr); 40900@@ -28966,8 +27116,6 @@ 40901 break; 40902 40903 case 1251: 40904- 40905-/* Line 1455 of yacc.c */ 40906 #line 7949 "gram.y" 40907 { 40908 (yyvsp[(2) - (4)].jexpr)->alias = (yyvsp[(4) - (4)].alias); 40909@@ -28976,8 +27124,6 @@ 40910 break; 40911 40912 case 1252: 40913- 40914-/* Line 1455 of yacc.c */ 40915 #line 7975 "gram.y" 40916 { 40917 (yyval.jexpr) = (yyvsp[(2) - (3)].jexpr); 40918@@ -28985,8 +27131,6 @@ 40919 break; 40920 40921 case 1253: 40922- 40923-/* Line 1455 of yacc.c */ 40924 #line 7979 "gram.y" 40925 { 40926 /* CROSS JOIN is same as unqualified inner join */ 40927@@ -29002,8 +27146,6 @@ 40928 break; 40929 40930 case 1254: 40931- 40932-/* Line 1455 of yacc.c */ 40933 #line 7991 "gram.y" 40934 { 40935 JoinExpr *n = makeNode(JoinExpr); 40936@@ -29020,8 +27162,6 @@ 40937 break; 40938 40939 case 1255: 40940- 40941-/* Line 1455 of yacc.c */ 40942 #line 8004 "gram.y" 40943 { 40944 /* letting join_type reduce to empty doesn't work */ 40945@@ -29039,8 +27179,6 @@ 40946 break; 40947 40948 case 1256: 40949- 40950-/* Line 1455 of yacc.c */ 40951 #line 8018 "gram.y" 40952 { 40953 JoinExpr *n = makeNode(JoinExpr); 40954@@ -29055,8 +27193,6 @@ 40955 break; 40956 40957 case 1257: 40958- 40959-/* Line 1455 of yacc.c */ 40960 #line 8029 "gram.y" 40961 { 40962 /* letting join_type reduce to empty doesn't work */ 40963@@ -29072,8 +27208,6 @@ 40964 break; 40965 40966 case 1258: 40967- 40968-/* Line 1455 of yacc.c */ 40969 #line 8044 "gram.y" 40970 { 40971 (yyval.alias) = makeNode(Alias); 40972@@ -29083,8 +27217,6 @@ 40973 break; 40974 40975 case 1259: 40976- 40977-/* Line 1455 of yacc.c */ 40978 #line 8050 "gram.y" 40979 { 40980 (yyval.alias) = makeNode(Alias); 40981@@ -29093,8 +27225,6 @@ 40982 break; 40983 40984 case 1260: 40985- 40986-/* Line 1455 of yacc.c */ 40987 #line 8055 "gram.y" 40988 { 40989 (yyval.alias) = makeNode(Alias); 40990@@ -29104,8 +27234,6 @@ 40991 break; 40992 40993 case 1261: 40994- 40995-/* Line 1455 of yacc.c */ 40996 #line 8061 "gram.y" 40997 { 40998 (yyval.alias) = makeNode(Alias); 40999@@ -29114,64 +27242,46 @@ 41000 break; 41001 41002 case 1262: 41003- 41004-/* Line 1455 of yacc.c */ 41005 #line 8067 "gram.y" 41006 { (yyval.jtype) = JOIN_FULL; ;} 41007 break; 41008 41009 case 1263: 41010- 41011-/* Line 1455 of yacc.c */ 41012 #line 8068 "gram.y" 41013 { (yyval.jtype) = JOIN_LEFT; ;} 41014 break; 41015 41016 case 1264: 41017- 41018-/* Line 1455 of yacc.c */ 41019 #line 8069 "gram.y" 41020 { (yyval.jtype) = JOIN_RIGHT; ;} 41021 break; 41022 41023 case 1265: 41024- 41025-/* Line 1455 of yacc.c */ 41026 #line 8070 "gram.y" 41027 { (yyval.jtype) = JOIN_INNER; ;} 41028 break; 41029 41030 case 1266: 41031- 41032-/* Line 1455 of yacc.c */ 41033 #line 8074 "gram.y" 41034 { (yyval.node) = NULL; ;} 41035 break; 41036 41037 case 1267: 41038- 41039-/* Line 1455 of yacc.c */ 41040 #line 8075 "gram.y" 41041 { (yyval.node) = NULL; ;} 41042 break; 41043 41044 case 1268: 41045- 41046-/* Line 1455 of yacc.c */ 41047 #line 8087 "gram.y" 41048 { (yyval.node) = (Node *) (yyvsp[(3) - (4)].list); ;} 41049 break; 41050 41051 case 1269: 41052- 41053-/* Line 1455 of yacc.c */ 41054 #line 8088 "gram.y" 41055 { (yyval.node) = (yyvsp[(2) - (2)].node); ;} 41056 break; 41057 41058 case 1270: 41059- 41060-/* Line 1455 of yacc.c */ 41061 #line 8094 "gram.y" 41062 { 41063 /* default inheritance */ 41064@@ -29182,8 +27292,6 @@ 41065 break; 41066 41067 case 1271: 41068- 41069-/* Line 1455 of yacc.c */ 41070 #line 8101 "gram.y" 41071 { 41072 /* inheritance query */ 41073@@ -29194,8 +27302,6 @@ 41074 break; 41075 41076 case 1272: 41077- 41078-/* Line 1455 of yacc.c */ 41079 #line 8108 "gram.y" 41080 { 41081 /* no inheritance */ 41082@@ -29206,8 +27312,6 @@ 41083 break; 41084 41085 case 1273: 41086- 41087-/* Line 1455 of yacc.c */ 41088 #line 8115 "gram.y" 41089 { 41090 /* no inheritance, SQL99-style syntax */ 41091@@ -29218,22 +27322,16 @@ 41092 break; 41093 41094 case 1274: 41095- 41096-/* Line 1455 of yacc.c */ 41097 #line 8125 "gram.y" 41098 { (yyval.list) = list_make1((yyvsp[(1) - (1)].range)); ;} 41099 break; 41100 41101 case 1275: 41102- 41103-/* Line 1455 of yacc.c */ 41104 #line 8126 "gram.y" 41105 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].range)); ;} 41106 break; 41107 41108 case 1276: 41109- 41110-/* Line 1455 of yacc.c */ 41111 #line 8140 "gram.y" 41112 { 41113 (yyval.range) = (yyvsp[(1) - (1)].range); 41114@@ -29241,8 +27339,6 @@ 41115 break; 41116 41117 case 1277: 41118- 41119-/* Line 1455 of yacc.c */ 41120 #line 8144 "gram.y" 41121 { 41122 Alias *alias = makeNode(Alias); 41123@@ -29253,8 +27349,6 @@ 41124 break; 41125 41126 case 1278: 41127- 41128-/* Line 1455 of yacc.c */ 41129 #line 8151 "gram.y" 41130 { 41131 Alias *alias = makeNode(Alias); 41132@@ -29265,36 +27359,26 @@ 41133 break; 41134 41135 case 1279: 41136- 41137-/* Line 1455 of yacc.c */ 41138 #line 8160 "gram.y" 41139 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 41140 break; 41141 41142 case 1280: 41143- 41144-/* Line 1455 of yacc.c */ 41145 #line 8165 "gram.y" 41146 { (yyval.node) = (yyvsp[(2) - (2)].node); ;} 41147 break; 41148 41149 case 1281: 41150- 41151-/* Line 1455 of yacc.c */ 41152 #line 8166 "gram.y" 41153 { (yyval.node) = NULL; ;} 41154 break; 41155 41156 case 1282: 41157- 41158-/* Line 1455 of yacc.c */ 41159 #line 8171 "gram.y" 41160 { (yyval.node) = (yyvsp[(2) - (2)].node); ;} 41161 break; 41162 41163 case 1283: 41164- 41165-/* Line 1455 of yacc.c */ 41166 #line 8173 "gram.y" 41167 { 41168 CurrentOfExpr *n = makeNode(CurrentOfExpr); 41169@@ -29306,15 +27390,11 @@ 41170 break; 41171 41172 case 1284: 41173- 41174-/* Line 1455 of yacc.c */ 41175 #line 8180 "gram.y" 41176 { (yyval.node) = NULL; ;} 41177 break; 41178 41179 case 1285: 41180- 41181-/* Line 1455 of yacc.c */ 41182 #line 8186 "gram.y" 41183 { 41184 (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); 41185@@ -29322,8 +27402,6 @@ 41186 break; 41187 41188 case 1286: 41189- 41190-/* Line 1455 of yacc.c */ 41191 #line 8190 "gram.y" 41192 { 41193 (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 41194@@ -29331,8 +27409,6 @@ 41195 break; 41196 41197 case 1287: 41198- 41199-/* Line 1455 of yacc.c */ 41200 #line 8196 "gram.y" 41201 { 41202 ColumnDef *n = makeNode(ColumnDef); 41203@@ -29345,8 +27421,6 @@ 41204 break; 41205 41206 case 1288: 41207- 41208-/* Line 1455 of yacc.c */ 41209 #line 8217 "gram.y" 41210 { 41211 (yyval.typnam) = (yyvsp[(1) - (2)].typnam); 41212@@ -29355,8 +27429,6 @@ 41213 break; 41214 41215 case 1289: 41216- 41217-/* Line 1455 of yacc.c */ 41218 #line 8222 "gram.y" 41219 { 41220 (yyval.typnam) = (yyvsp[(2) - (3)].typnam); 41221@@ -29366,8 +27438,6 @@ 41222 break; 41223 41224 case 1290: 41225- 41226-/* Line 1455 of yacc.c */ 41227 #line 8229 "gram.y" 41228 { 41229 (yyval.typnam) = (yyvsp[(1) - (5)].typnam); 41230@@ -29376,8 +27446,6 @@ 41231 break; 41232 41233 case 1291: 41234- 41235-/* Line 1455 of yacc.c */ 41236 #line 8234 "gram.y" 41237 { 41238 (yyval.typnam) = (yyvsp[(2) - (6)].typnam); 41239@@ -29387,8 +27455,6 @@ 41240 break; 41241 41242 case 1292: 41243- 41244-/* Line 1455 of yacc.c */ 41245 #line 8240 "gram.y" 41246 { 41247 (yyval.typnam) = (yyvsp[(1) - (2)].typnam); 41248@@ -29397,8 +27463,6 @@ 41249 break; 41250 41251 case 1293: 41252- 41253-/* Line 1455 of yacc.c */ 41254 #line 8245 "gram.y" 41255 { 41256 (yyval.typnam) = (yyvsp[(2) - (3)].typnam); 41257@@ -29408,64 +27472,46 @@ 41258 break; 41259 41260 case 1294: 41261- 41262-/* Line 1455 of yacc.c */ 41263 #line 8254 "gram.y" 41264 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeInteger(-1)); ;} 41265 break; 41266 41267 case 1295: 41268- 41269-/* Line 1455 of yacc.c */ 41270 #line 8256 "gram.y" 41271 { (yyval.list) = lappend((yyvsp[(1) - (4)].list), makeInteger((yyvsp[(3) - (4)].ival))); ;} 41272 break; 41273 41274 case 1296: 41275- 41276-/* Line 1455 of yacc.c */ 41277 #line 8258 "gram.y" 41278 { (yyval.list) = NIL; ;} 41279 break; 41280 41281 case 1297: 41282- 41283-/* Line 1455 of yacc.c */ 41284 #line 8262 "gram.y" 41285 { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} 41286 break; 41287 41288 case 1298: 41289- 41290-/* Line 1455 of yacc.c */ 41291 #line 8263 "gram.y" 41292 { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} 41293 break; 41294 41295 case 1299: 41296- 41297-/* Line 1455 of yacc.c */ 41298 #line 8264 "gram.y" 41299 { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} 41300 break; 41301 41302 case 1300: 41303- 41304-/* Line 1455 of yacc.c */ 41305 #line 8265 "gram.y" 41306 { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} 41307 break; 41308 41309 case 1301: 41310- 41311-/* Line 1455 of yacc.c */ 41312 #line 8266 "gram.y" 41313 { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} 41314 break; 41315 41316 case 1302: 41317- 41318-/* Line 1455 of yacc.c */ 41319 #line 8268 "gram.y" 41320 { 41321 (yyval.typnam) = (yyvsp[(1) - (2)].typnam); 41322@@ -29474,8 +27520,6 @@ 41323 break; 41324 41325 case 1303: 41326- 41327-/* Line 1455 of yacc.c */ 41328 #line 8273 "gram.y" 41329 { 41330 (yyval.typnam) = (yyvsp[(1) - (5)].typnam); 41331@@ -29495,36 +27539,26 @@ 41332 break; 41333 41334 case 1304: 41335- 41336-/* Line 1455 of yacc.c */ 41337 #line 8302 "gram.y" 41338 { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} 41339 break; 41340 41341 case 1305: 41342- 41343-/* Line 1455 of yacc.c */ 41344 #line 8303 "gram.y" 41345 { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} 41346 break; 41347 41348 case 1306: 41349- 41350-/* Line 1455 of yacc.c */ 41351 #line 8304 "gram.y" 41352 { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} 41353 break; 41354 41355 case 1307: 41356- 41357-/* Line 1455 of yacc.c */ 41358 #line 8305 "gram.y" 41359 { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} 41360 break; 41361 41362 case 1308: 41363- 41364-/* Line 1455 of yacc.c */ 41365 #line 8317 "gram.y" 41366 { 41367 (yyval.typnam) = makeTypeName((yyvsp[(1) - (2)].str)); 41368@@ -29534,8 +27568,6 @@ 41369 break; 41370 41371 case 1309: 41372- 41373-/* Line 1455 of yacc.c */ 41374 #line 8323 "gram.y" 41375 { 41376 (yyval.typnam) = makeTypeNameFromNameList(lcons(makeString((yyvsp[(1) - (3)].str)), (yyvsp[(2) - (3)].list))); 41377@@ -29545,22 +27577,16 @@ 41378 break; 41379 41380 case 1310: 41381- 41382-/* Line 1455 of yacc.c */ 41383 #line 8330 "gram.y" 41384 { (yyval.list) = (yyvsp[(2) - (3)].list); ;} 41385 break; 41386 41387 case 1311: 41388- 41389-/* Line 1455 of yacc.c */ 41390 #line 8331 "gram.y" 41391 { (yyval.list) = NIL; ;} 41392 break; 41393 41394 case 1312: 41395- 41396-/* Line 1455 of yacc.c */ 41397 #line 8338 "gram.y" 41398 { 41399 (yyval.typnam) = SystemTypeName("int4"); 41400@@ -29569,8 +27595,6 @@ 41401 break; 41402 41403 case 1313: 41404- 41405-/* Line 1455 of yacc.c */ 41406 #line 8343 "gram.y" 41407 { 41408 (yyval.typnam) = SystemTypeName("int4"); 41409@@ -29579,8 +27603,6 @@ 41410 break; 41411 41412 case 1314: 41413- 41414-/* Line 1455 of yacc.c */ 41415 #line 8348 "gram.y" 41416 { 41417 (yyval.typnam) = SystemTypeName("int2"); 41418@@ -29589,8 +27611,6 @@ 41419 break; 41420 41421 case 1315: 41422- 41423-/* Line 1455 of yacc.c */ 41424 #line 8353 "gram.y" 41425 { 41426 (yyval.typnam) = SystemTypeName("int8"); 41427@@ -29599,8 +27619,6 @@ 41428 break; 41429 41430 case 1316: 41431- 41432-/* Line 1455 of yacc.c */ 41433 #line 8358 "gram.y" 41434 { 41435 (yyval.typnam) = SystemTypeName("float4"); 41436@@ -29609,8 +27627,6 @@ 41437 break; 41438 41439 case 1317: 41440- 41441-/* Line 1455 of yacc.c */ 41442 #line 8363 "gram.y" 41443 { 41444 (yyval.typnam) = (yyvsp[(2) - (2)].typnam); 41445@@ -29619,8 +27635,6 @@ 41446 break; 41447 41448 case 1318: 41449- 41450-/* Line 1455 of yacc.c */ 41451 #line 8368 "gram.y" 41452 { 41453 (yyval.typnam) = SystemTypeName("float8"); 41454@@ -29629,8 +27643,6 @@ 41455 break; 41456 41457 case 1319: 41458- 41459-/* Line 1455 of yacc.c */ 41460 #line 8373 "gram.y" 41461 { 41462 (yyval.typnam) = SystemTypeName("numeric"); 41463@@ -29640,8 +27652,6 @@ 41464 break; 41465 41466 case 1320: 41467- 41468-/* Line 1455 of yacc.c */ 41469 #line 8379 "gram.y" 41470 { 41471 (yyval.typnam) = SystemTypeName("numeric"); 41472@@ -29651,8 +27661,6 @@ 41473 break; 41474 41475 case 1321: 41476- 41477-/* Line 1455 of yacc.c */ 41478 #line 8385 "gram.y" 41479 { 41480 (yyval.typnam) = SystemTypeName("numeric"); 41481@@ -29662,8 +27670,6 @@ 41482 break; 41483 41484 case 1322: 41485- 41486-/* Line 1455 of yacc.c */ 41487 #line 8391 "gram.y" 41488 { 41489 (yyval.typnam) = SystemTypeName("bool"); 41490@@ -29672,8 +27678,6 @@ 41491 break; 41492 41493 case 1323: 41494- 41495-/* Line 1455 of yacc.c */ 41496 #line 8398 "gram.y" 41497 { 41498 /* 41499@@ -29698,8 +27702,6 @@ 41500 break; 41501 41502 case 1324: 41503- 41504-/* Line 1455 of yacc.c */ 41505 #line 8419 "gram.y" 41506 { 41507 (yyval.typnam) = SystemTypeName("float8"); 41508@@ -29707,8 +27709,6 @@ 41509 break; 41510 41511 case 1325: 41512- 41513-/* Line 1455 of yacc.c */ 41514 #line 8429 "gram.y" 41515 { 41516 (yyval.typnam) = (yyvsp[(1) - (1)].typnam); 41517@@ -29716,8 +27716,6 @@ 41518 break; 41519 41520 case 1326: 41521- 41522-/* Line 1455 of yacc.c */ 41523 #line 8433 "gram.y" 41524 { 41525 (yyval.typnam) = (yyvsp[(1) - (1)].typnam); 41526@@ -29725,8 +27723,6 @@ 41527 break; 41528 41529 case 1327: 41530- 41531-/* Line 1455 of yacc.c */ 41532 #line 8441 "gram.y" 41533 { 41534 (yyval.typnam) = (yyvsp[(1) - (1)].typnam); 41535@@ -29734,8 +27730,6 @@ 41536 break; 41537 41538 case 1328: 41539- 41540-/* Line 1455 of yacc.c */ 41541 #line 8445 "gram.y" 41542 { 41543 (yyval.typnam) = (yyvsp[(1) - (1)].typnam); 41544@@ -29744,8 +27738,6 @@ 41545 break; 41546 41547 case 1329: 41548- 41549-/* Line 1455 of yacc.c */ 41550 #line 8453 "gram.y" 41551 { 41552 char *typname; 41553@@ -29758,8 +27750,6 @@ 41554 break; 41555 41556 case 1330: 41557- 41558-/* Line 1455 of yacc.c */ 41559 #line 8465 "gram.y" 41560 { 41561 /* bit defaults to bit(1), varbit to no limit */ 41562@@ -29777,8 +27767,6 @@ 41563 break; 41564 41565 case 1331: 41566- 41567-/* Line 1455 of yacc.c */ 41568 #line 8486 "gram.y" 41569 { 41570 (yyval.typnam) = (yyvsp[(1) - (1)].typnam); 41571@@ -29786,8 +27774,6 @@ 41572 break; 41573 41574 case 1332: 41575- 41576-/* Line 1455 of yacc.c */ 41577 #line 8490 "gram.y" 41578 { 41579 (yyval.typnam) = (yyvsp[(1) - (1)].typnam); 41580@@ -29795,8 +27781,6 @@ 41581 break; 41582 41583 case 1333: 41584- 41585-/* Line 1455 of yacc.c */ 41586 #line 8496 "gram.y" 41587 { 41588 (yyval.typnam) = (yyvsp[(1) - (1)].typnam); 41589@@ -29804,8 +27788,6 @@ 41590 break; 41591 41592 case 1334: 41593- 41594-/* Line 1455 of yacc.c */ 41595 #line 8500 "gram.y" 41596 { 41597 /* Length was not specified so allow to be unrestricted. 41598@@ -29820,8 +27802,6 @@ 41599 break; 41600 41601 case 1335: 41602- 41603-/* Line 1455 of yacc.c */ 41604 #line 8513 "gram.y" 41605 { 41606 if (((yyvsp[(5) - (5)].str) != NULL) && (strcmp((yyvsp[(5) - (5)].str), "sql_text") != 0)) 41607@@ -29842,8 +27822,6 @@ 41608 break; 41609 41610 case 1336: 41611- 41612-/* Line 1455 of yacc.c */ 41613 #line 8532 "gram.y" 41614 { 41615 if (((yyvsp[(2) - (2)].str) != NULL) && (strcmp((yyvsp[(2) - (2)].str), "sql_text") != 0)) 41616@@ -29868,78 +27846,56 @@ 41617 break; 41618 41619 case 1337: 41620- 41621-/* Line 1455 of yacc.c */ 41622 #line 8555 "gram.y" 41623 { (yyval.str) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;} 41624 break; 41625 41626 case 1338: 41627- 41628-/* Line 1455 of yacc.c */ 41629 #line 8557 "gram.y" 41630 { (yyval.str) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;} 41631 break; 41632 41633 case 1339: 41634- 41635-/* Line 1455 of yacc.c */ 41636 #line 8559 "gram.y" 41637 { (yyval.str) = "varchar"; ;} 41638 break; 41639 41640 case 1340: 41641- 41642-/* Line 1455 of yacc.c */ 41643 #line 8561 "gram.y" 41644 { (yyval.str) = (yyvsp[(3) - (3)].boolean) ? "varchar": "bpchar"; ;} 41645 break; 41646 41647 case 1341: 41648- 41649-/* Line 1455 of yacc.c */ 41650 #line 8563 "gram.y" 41651 { (yyval.str) = (yyvsp[(3) - (3)].boolean) ? "varchar": "bpchar"; ;} 41652 break; 41653 41654 case 1342: 41655- 41656-/* Line 1455 of yacc.c */ 41657 #line 8565 "gram.y" 41658 { (yyval.str) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;} 41659 break; 41660 41661 case 1343: 41662- 41663-/* Line 1455 of yacc.c */ 41664 #line 8569 "gram.y" 41665 { (yyval.boolean) = TRUE; ;} 41666 break; 41667 41668 case 1344: 41669- 41670-/* Line 1455 of yacc.c */ 41671 #line 8570 "gram.y" 41672 { (yyval.boolean) = FALSE; ;} 41673 break; 41674 41675 case 1345: 41676- 41677-/* Line 1455 of yacc.c */ 41678 #line 8574 "gram.y" 41679 { (yyval.str) = (yyvsp[(3) - (3)].str); ;} 41680 break; 41681 41682 case 1346: 41683- 41684-/* Line 1455 of yacc.c */ 41685 #line 8575 "gram.y" 41686 { (yyval.str) = NULL; ;} 41687 break; 41688 41689 case 1347: 41690- 41691-/* Line 1455 of yacc.c */ 41692 #line 8583 "gram.y" 41693 { 41694 if ((yyvsp[(5) - (5)].boolean)) 41695@@ -29952,8 +27908,6 @@ 41696 break; 41697 41698 case 1348: 41699- 41700-/* Line 1455 of yacc.c */ 41701 #line 8592 "gram.y" 41702 { 41703 if ((yyvsp[(2) - (2)].boolean)) 41704@@ -29965,8 +27919,6 @@ 41705 break; 41706 41707 case 1349: 41708- 41709-/* Line 1455 of yacc.c */ 41710 #line 8600 "gram.y" 41711 { 41712 if ((yyvsp[(5) - (5)].boolean)) 41713@@ -29979,8 +27931,6 @@ 41714 break; 41715 41716 case 1350: 41717- 41718-/* Line 1455 of yacc.c */ 41719 #line 8609 "gram.y" 41720 { 41721 if ((yyvsp[(2) - (2)].boolean)) 41722@@ -29992,8 +27942,6 @@ 41723 break; 41724 41725 case 1351: 41726- 41727-/* Line 1455 of yacc.c */ 41728 #line 8620 "gram.y" 41729 { 41730 (yyval.typnam) = SystemTypeName("interval"); 41731@@ -30002,71 +27950,51 @@ 41732 break; 41733 41734 case 1352: 41735- 41736-/* Line 1455 of yacc.c */ 41737 #line 8627 "gram.y" 41738 { (yyval.boolean) = TRUE; ;} 41739 break; 41740 41741 case 1353: 41742- 41743-/* Line 1455 of yacc.c */ 41744 #line 8628 "gram.y" 41745 { (yyval.boolean) = FALSE; ;} 41746 break; 41747 41748 case 1354: 41749- 41750-/* Line 1455 of yacc.c */ 41751 #line 8629 "gram.y" 41752 { (yyval.boolean) = FALSE; ;} 41753 break; 41754 41755 case 1355: 41756- 41757-/* Line 1455 of yacc.c */ 41758 #line 8634 "gram.y" 41759 { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(YEAR), (yylsp[(1) - (1)]))); ;} 41760 break; 41761 41762 case 1356: 41763- 41764-/* Line 1455 of yacc.c */ 41765 #line 8636 "gram.y" 41766 { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MONTH), (yylsp[(1) - (1)]))); ;} 41767 break; 41768 41769 case 1357: 41770- 41771-/* Line 1455 of yacc.c */ 41772 #line 8638 "gram.y" 41773 { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY), (yylsp[(1) - (1)]))); ;} 41774 break; 41775 41776 case 1358: 41777- 41778-/* Line 1455 of yacc.c */ 41779 #line 8640 "gram.y" 41780 { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR), (yylsp[(1) - (1)]))); ;} 41781 break; 41782 41783 case 1359: 41784- 41785-/* Line 1455 of yacc.c */ 41786 #line 8642 "gram.y" 41787 { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MINUTE), (yylsp[(1) - (1)]))); ;} 41788 break; 41789 41790 case 1360: 41791- 41792-/* Line 1455 of yacc.c */ 41793 #line 8644 "gram.y" 41794 { (yyval.list) = (yyvsp[(1) - (1)].list); ;} 41795 break; 41796 41797 case 1361: 41798- 41799-/* Line 1455 of yacc.c */ 41800 #line 8646 "gram.y" 41801 { 41802 (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(YEAR) | 41803@@ -30075,8 +28003,6 @@ 41804 break; 41805 41806 case 1362: 41807- 41808-/* Line 1455 of yacc.c */ 41809 #line 8651 "gram.y" 41810 { 41811 (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY) | 41812@@ -30085,8 +28011,6 @@ 41813 break; 41814 41815 case 1363: 41816- 41817-/* Line 1455 of yacc.c */ 41818 #line 8656 "gram.y" 41819 { 41820 (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY) | 41821@@ -30096,8 +28020,6 @@ 41822 break; 41823 41824 case 1364: 41825- 41826-/* Line 1455 of yacc.c */ 41827 #line 8662 "gram.y" 41828 { 41829 (yyval.list) = (yyvsp[(3) - (3)].list); 41830@@ -30109,8 +28031,6 @@ 41831 break; 41832 41833 case 1365: 41834- 41835-/* Line 1455 of yacc.c */ 41836 #line 8670 "gram.y" 41837 { 41838 (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR) | 41839@@ -30119,8 +28039,6 @@ 41840 break; 41841 41842 case 1366: 41843- 41844-/* Line 1455 of yacc.c */ 41845 #line 8675 "gram.y" 41846 { 41847 (yyval.list) = (yyvsp[(3) - (3)].list); 41848@@ -30131,8 +28049,6 @@ 41849 break; 41850 41851 case 1367: 41852- 41853-/* Line 1455 of yacc.c */ 41854 #line 8682 "gram.y" 41855 { 41856 (yyval.list) = (yyvsp[(3) - (3)].list); 41857@@ -30142,15 +28058,11 @@ 41858 break; 41859 41860 case 1368: 41861- 41862-/* Line 1455 of yacc.c */ 41863 #line 8688 "gram.y" 41864 { (yyval.list) = NIL; ;} 41865 break; 41866 41867 case 1369: 41868- 41869-/* Line 1455 of yacc.c */ 41870 #line 8693 "gram.y" 41871 { 41872 (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(SECOND), (yylsp[(1) - (1)]))); 41873@@ -30158,8 +28070,6 @@ 41874 break; 41875 41876 case 1370: 41877- 41878-/* Line 1455 of yacc.c */ 41879 #line 8697 "gram.y" 41880 { 41881 (yyval.list) = list_make2(makeIntConst(INTERVAL_MASK(SECOND), (yylsp[(1) - (4)])), 41882@@ -30168,22 +28078,16 @@ 41883 break; 41884 41885 case 1371: 41886- 41887-/* Line 1455 of yacc.c */ 41888 #line 8726 "gram.y" 41889 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 41890 break; 41891 41892 case 1372: 41893- 41894-/* Line 1455 of yacc.c */ 41895 #line 8728 "gram.y" 41896 { (yyval.node) = makeTypeCast((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].typnam), (yylsp[(2) - (3)])); ;} 41897 break; 41898 41899 case 1373: 41900- 41901-/* Line 1455 of yacc.c */ 41902 #line 8730 "gram.y" 41903 { 41904 FuncCall *n = makeNode(FuncCall); 41905@@ -30200,134 +28104,96 @@ 41906 break; 41907 41908 case 1374: 41909- 41910-/* Line 1455 of yacc.c */ 41911 #line 8752 "gram.y" 41912 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "+", NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} 41913 break; 41914 41915 case 1375: 41916- 41917-/* Line 1455 of yacc.c */ 41918 #line 8754 "gram.y" 41919 { (yyval.node) = doNegate((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} 41920 break; 41921 41922 case 1376: 41923- 41924-/* Line 1455 of yacc.c */ 41925 #line 8756 "gram.y" 41926 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "+", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 41927 break; 41928 41929 case 1377: 41930- 41931-/* Line 1455 of yacc.c */ 41932 #line 8758 "gram.y" 41933 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "-", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 41934 break; 41935 41936 case 1378: 41937- 41938-/* Line 1455 of yacc.c */ 41939 #line 8760 "gram.y" 41940 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "*", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 41941 break; 41942 41943 case 1379: 41944- 41945-/* Line 1455 of yacc.c */ 41946 #line 8762 "gram.y" 41947 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "/", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 41948 break; 41949 41950 case 1380: 41951- 41952-/* Line 1455 of yacc.c */ 41953 #line 8764 "gram.y" 41954 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "%", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 41955 break; 41956 41957 case 1381: 41958- 41959-/* Line 1455 of yacc.c */ 41960 #line 8766 "gram.y" 41961 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "^", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 41962 break; 41963 41964 case 1382: 41965- 41966-/* Line 1455 of yacc.c */ 41967 #line 8768 "gram.y" 41968 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "<", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 41969 break; 41970 41971 case 1383: 41972- 41973-/* Line 1455 of yacc.c */ 41974 #line 8770 "gram.y" 41975 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, ">", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 41976 break; 41977 41978 case 1384: 41979- 41980-/* Line 1455 of yacc.c */ 41981 #line 8772 "gram.y" 41982 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 41983 break; 41984 41985 case 1385: 41986- 41987-/* Line 1455 of yacc.c */ 41988 #line 8775 "gram.y" 41989 { (yyval.node) = (Node *) makeA_Expr(AEXPR_OP, (yyvsp[(2) - (3)].list), (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 41990 break; 41991 41992 case 1386: 41993- 41994-/* Line 1455 of yacc.c */ 41995 #line 8777 "gram.y" 41996 { (yyval.node) = (Node *) makeA_Expr(AEXPR_OP, (yyvsp[(1) - (2)].list), NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} 41997 break; 41998 41999 case 1387: 42000- 42001-/* Line 1455 of yacc.c */ 42002 #line 8779 "gram.y" 42003 { (yyval.node) = (Node *) makeA_Expr(AEXPR_OP, (yyvsp[(2) - (2)].list), (yyvsp[(1) - (2)].node), NULL, (yylsp[(2) - (2)])); ;} 42004 break; 42005 42006 case 1388: 42007- 42008-/* Line 1455 of yacc.c */ 42009 #line 8782 "gram.y" 42010 { (yyval.node) = (Node *) makeA_Expr(AEXPR_AND, NIL, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 42011 break; 42012 42013 case 1389: 42014- 42015-/* Line 1455 of yacc.c */ 42016 #line 8784 "gram.y" 42017 { (yyval.node) = (Node *) makeA_Expr(AEXPR_OR, NIL, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 42018 break; 42019 42020 case 1390: 42021- 42022-/* Line 1455 of yacc.c */ 42023 #line 8786 "gram.y" 42024 { (yyval.node) = (Node *) makeA_Expr(AEXPR_NOT, NIL, NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} 42025 break; 42026 42027 case 1391: 42028- 42029-/* Line 1455 of yacc.c */ 42030 #line 8789 "gram.y" 42031 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "~~", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 42032 break; 42033 42034 case 1392: 42035- 42036-/* Line 1455 of yacc.c */ 42037 #line 8791 "gram.y" 42038 { 42039 FuncCall *n = makeNode(FuncCall); 42040@@ -30344,15 +28210,11 @@ 42041 break; 42042 42043 case 1393: 42044- 42045-/* Line 1455 of yacc.c */ 42046 #line 8804 "gram.y" 42047 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~~", (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node), (yylsp[(2) - (4)])); ;} 42048 break; 42049 42050 case 1394: 42051- 42052-/* Line 1455 of yacc.c */ 42053 #line 8806 "gram.y" 42054 { 42055 FuncCall *n = makeNode(FuncCall); 42056@@ -30369,15 +28231,11 @@ 42057 break; 42058 42059 case 1395: 42060- 42061-/* Line 1455 of yacc.c */ 42062 #line 8819 "gram.y" 42063 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "~~*", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 42064 break; 42065 42066 case 1396: 42067- 42068-/* Line 1455 of yacc.c */ 42069 #line 8821 "gram.y" 42070 { 42071 FuncCall *n = makeNode(FuncCall); 42072@@ -30394,15 +28252,11 @@ 42073 break; 42074 42075 case 1397: 42076- 42077-/* Line 1455 of yacc.c */ 42078 #line 8834 "gram.y" 42079 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "!~~*", (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node), (yylsp[(2) - (4)])); ;} 42080 break; 42081 42082 case 1398: 42083- 42084-/* Line 1455 of yacc.c */ 42085 #line 8836 "gram.y" 42086 { 42087 FuncCall *n = makeNode(FuncCall); 42088@@ -30419,8 +28273,6 @@ 42089 break; 42090 42091 case 1399: 42092- 42093-/* Line 1455 of yacc.c */ 42094 #line 8850 "gram.y" 42095 { 42096 FuncCall *n = makeNode(FuncCall); 42097@@ -30437,8 +28289,6 @@ 42098 break; 42099 42100 case 1400: 42101- 42102-/* Line 1455 of yacc.c */ 42103 #line 8863 "gram.y" 42104 { 42105 FuncCall *n = makeNode(FuncCall); 42106@@ -30455,8 +28305,6 @@ 42107 break; 42108 42109 case 1401: 42110- 42111-/* Line 1455 of yacc.c */ 42112 #line 8876 "gram.y" 42113 { 42114 FuncCall *n = makeNode(FuncCall); 42115@@ -30473,8 +28321,6 @@ 42116 break; 42117 42118 case 1402: 42119- 42120-/* Line 1455 of yacc.c */ 42121 #line 8889 "gram.y" 42122 { 42123 FuncCall *n = makeNode(FuncCall); 42124@@ -30491,8 +28337,6 @@ 42125 break; 42126 42127 case 1403: 42128- 42129-/* Line 1455 of yacc.c */ 42130 #line 8912 "gram.y" 42131 { 42132 NullTest *n = makeNode(NullTest); 42133@@ -30503,8 +28347,6 @@ 42134 break; 42135 42136 case 1404: 42137- 42138-/* Line 1455 of yacc.c */ 42139 #line 8919 "gram.y" 42140 { 42141 NullTest *n = makeNode(NullTest); 42142@@ -30515,8 +28357,6 @@ 42143 break; 42144 42145 case 1405: 42146- 42147-/* Line 1455 of yacc.c */ 42148 #line 8926 "gram.y" 42149 { 42150 NullTest *n = makeNode(NullTest); 42151@@ -30527,8 +28367,6 @@ 42152 break; 42153 42154 case 1406: 42155- 42156-/* Line 1455 of yacc.c */ 42157 #line 8933 "gram.y" 42158 { 42159 NullTest *n = makeNode(NullTest); 42160@@ -30539,8 +28377,6 @@ 42161 break; 42162 42163 case 1407: 42164- 42165-/* Line 1455 of yacc.c */ 42166 #line 8940 "gram.y" 42167 { 42168 (yyval.node) = (Node *)makeOverlaps((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list), (yylsp[(2) - (3)]), yyscanner); 42169@@ -30548,8 +28384,6 @@ 42170 break; 42171 42172 case 1408: 42173- 42174-/* Line 1455 of yacc.c */ 42175 #line 8944 "gram.y" 42176 { 42177 BooleanTest *b = makeNode(BooleanTest); 42178@@ -30560,8 +28394,6 @@ 42179 break; 42180 42181 case 1409: 42182- 42183-/* Line 1455 of yacc.c */ 42184 #line 8951 "gram.y" 42185 { 42186 BooleanTest *b = makeNode(BooleanTest); 42187@@ -30572,8 +28404,6 @@ 42188 break; 42189 42190 case 1410: 42191- 42192-/* Line 1455 of yacc.c */ 42193 #line 8958 "gram.y" 42194 { 42195 BooleanTest *b = makeNode(BooleanTest); 42196@@ -30584,8 +28414,6 @@ 42197 break; 42198 42199 case 1411: 42200- 42201-/* Line 1455 of yacc.c */ 42202 #line 8965 "gram.y" 42203 { 42204 BooleanTest *b = makeNode(BooleanTest); 42205@@ -30596,8 +28424,6 @@ 42206 break; 42207 42208 case 1412: 42209- 42210-/* Line 1455 of yacc.c */ 42211 #line 8972 "gram.y" 42212 { 42213 BooleanTest *b = makeNode(BooleanTest); 42214@@ -30608,8 +28434,6 @@ 42215 break; 42216 42217 case 1413: 42218- 42219-/* Line 1455 of yacc.c */ 42220 #line 8979 "gram.y" 42221 { 42222 BooleanTest *b = makeNode(BooleanTest); 42223@@ -30620,8 +28444,6 @@ 42224 break; 42225 42226 case 1414: 42227- 42228-/* Line 1455 of yacc.c */ 42229 #line 8986 "gram.y" 42230 { 42231 (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_DISTINCT, "=", (yyvsp[(1) - (5)].node), (yyvsp[(5) - (5)].node), (yylsp[(2) - (5)])); 42232@@ -30629,8 +28451,6 @@ 42233 break; 42234 42235 case 1415: 42236- 42237-/* Line 1455 of yacc.c */ 42238 #line 8990 "gram.y" 42239 { 42240 (yyval.node) = (Node *) makeA_Expr(AEXPR_NOT, NIL, NULL, 42241@@ -30642,8 +28462,6 @@ 42242 break; 42243 42244 case 1416: 42245- 42246-/* Line 1455 of yacc.c */ 42247 #line 8998 "gram.y" 42248 { 42249 (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OF, "=", (yyvsp[(1) - (6)].node), (Node *) (yyvsp[(5) - (6)].list), (yylsp[(2) - (6)])); 42250@@ -30651,8 +28469,6 @@ 42251 break; 42252 42253 case 1417: 42254- 42255-/* Line 1455 of yacc.c */ 42256 #line 9002 "gram.y" 42257 { 42258 (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OF, "<>", (yyvsp[(1) - (7)].node), (Node *) (yyvsp[(6) - (7)].list), (yylsp[(2) - (7)])); 42259@@ -30660,8 +28476,6 @@ 42260 break; 42261 42262 case 1418: 42263- 42264-/* Line 1455 of yacc.c */ 42265 #line 9012 "gram.y" 42266 { 42267 (yyval.node) = (Node *) makeA_Expr(AEXPR_AND, NIL, 42268@@ -30672,8 +28486,6 @@ 42269 break; 42270 42271 case 1419: 42272- 42273-/* Line 1455 of yacc.c */ 42274 #line 9019 "gram.y" 42275 { 42276 (yyval.node) = (Node *) makeA_Expr(AEXPR_OR, NIL, 42277@@ -30684,8 +28496,6 @@ 42278 break; 42279 42280 case 1420: 42281- 42282-/* Line 1455 of yacc.c */ 42283 #line 9026 "gram.y" 42284 { 42285 (yyval.node) = (Node *) makeA_Expr(AEXPR_OR, NIL, 42286@@ -30702,8 +28512,6 @@ 42287 break; 42288 42289 case 1421: 42290- 42291-/* Line 1455 of yacc.c */ 42292 #line 9039 "gram.y" 42293 { 42294 (yyval.node) = (Node *) makeA_Expr(AEXPR_AND, NIL, 42295@@ -30720,8 +28528,6 @@ 42296 break; 42297 42298 case 1422: 42299- 42300-/* Line 1455 of yacc.c */ 42301 #line 9052 "gram.y" 42302 { 42303 /* in_expr returns a SubLink or a list of a_exprs */ 42304@@ -30744,8 +28550,6 @@ 42305 break; 42306 42307 case 1423: 42308- 42309-/* Line 1455 of yacc.c */ 42310 #line 9071 "gram.y" 42311 { 42312 /* in_expr returns a SubLink or a list of a_exprs */ 42313@@ -30770,8 +28574,6 @@ 42314 break; 42315 42316 case 1424: 42317- 42318-/* Line 1455 of yacc.c */ 42319 #line 9092 "gram.y" 42320 { 42321 SubLink *n = makeNode(SubLink); 42322@@ -30785,8 +28587,6 @@ 42323 break; 42324 42325 case 1425: 42326- 42327-/* Line 1455 of yacc.c */ 42328 #line 9102 "gram.y" 42329 { 42330 if ((yyvsp[(3) - (6)].ival) == ANY_SUBLINK) 42331@@ -30797,8 +28597,6 @@ 42332 break; 42333 42334 case 1426: 42335- 42336-/* Line 1455 of yacc.c */ 42337 #line 9109 "gram.y" 42338 { 42339 /* Not sure how to get rid of the parentheses 42340@@ -30818,8 +28616,6 @@ 42341 break; 42342 42343 case 1427: 42344- 42345-/* Line 1455 of yacc.c */ 42346 #line 9125 "gram.y" 42347 { 42348 (yyval.node) = makeXmlExpr(IS_DOCUMENT, NULL, NIL, 42349@@ -30828,8 +28624,6 @@ 42350 break; 42351 42352 case 1428: 42353- 42354-/* Line 1455 of yacc.c */ 42355 #line 9130 "gram.y" 42356 { 42357 (yyval.node) = (Node *) makeA_Expr(AEXPR_NOT, NIL, NULL, 42358@@ -30840,120 +28634,86 @@ 42359 break; 42360 42361 case 1429: 42362- 42363-/* Line 1455 of yacc.c */ 42364 #line 9148 "gram.y" 42365 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 42366 break; 42367 42368 case 1430: 42369- 42370-/* Line 1455 of yacc.c */ 42371 #line 9150 "gram.y" 42372 { (yyval.node) = makeTypeCast((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].typnam), (yylsp[(2) - (3)])); ;} 42373 break; 42374 42375 case 1431: 42376- 42377-/* Line 1455 of yacc.c */ 42378 #line 9152 "gram.y" 42379 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "+", NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} 42380 break; 42381 42382 case 1432: 42383- 42384-/* Line 1455 of yacc.c */ 42385 #line 9154 "gram.y" 42386 { (yyval.node) = doNegate((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} 42387 break; 42388 42389 case 1433: 42390- 42391-/* Line 1455 of yacc.c */ 42392 #line 9156 "gram.y" 42393 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "+", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 42394 break; 42395 42396 case 1434: 42397- 42398-/* Line 1455 of yacc.c */ 42399 #line 9158 "gram.y" 42400 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "-", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 42401 break; 42402 42403 case 1435: 42404- 42405-/* Line 1455 of yacc.c */ 42406 #line 9160 "gram.y" 42407 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "*", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 42408 break; 42409 42410 case 1436: 42411- 42412-/* Line 1455 of yacc.c */ 42413 #line 9162 "gram.y" 42414 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "/", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 42415 break; 42416 42417 case 1437: 42418- 42419-/* Line 1455 of yacc.c */ 42420 #line 9164 "gram.y" 42421 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "%", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 42422 break; 42423 42424 case 1438: 42425- 42426-/* Line 1455 of yacc.c */ 42427 #line 9166 "gram.y" 42428 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "^", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 42429 break; 42430 42431 case 1439: 42432- 42433-/* Line 1455 of yacc.c */ 42434 #line 9168 "gram.y" 42435 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "<", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 42436 break; 42437 42438 case 1440: 42439- 42440-/* Line 1455 of yacc.c */ 42441 #line 9170 "gram.y" 42442 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, ">", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 42443 break; 42444 42445 case 1441: 42446- 42447-/* Line 1455 of yacc.c */ 42448 #line 9172 "gram.y" 42449 { (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OP, "=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 42450 break; 42451 42452 case 1442: 42453- 42454-/* Line 1455 of yacc.c */ 42455 #line 9174 "gram.y" 42456 { (yyval.node) = (Node *) makeA_Expr(AEXPR_OP, (yyvsp[(2) - (3)].list), (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} 42457 break; 42458 42459 case 1443: 42460- 42461-/* Line 1455 of yacc.c */ 42462 #line 9176 "gram.y" 42463 { (yyval.node) = (Node *) makeA_Expr(AEXPR_OP, (yyvsp[(1) - (2)].list), NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} 42464 break; 42465 42466 case 1444: 42467- 42468-/* Line 1455 of yacc.c */ 42469 #line 9178 "gram.y" 42470 { (yyval.node) = (Node *) makeA_Expr(AEXPR_OP, (yyvsp[(2) - (2)].list), (yyvsp[(1) - (2)].node), NULL, (yylsp[(2) - (2)])); ;} 42471 break; 42472 42473 case 1445: 42474- 42475-/* Line 1455 of yacc.c */ 42476 #line 9180 "gram.y" 42477 { 42478 (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_DISTINCT, "=", (yyvsp[(1) - (5)].node), (yyvsp[(5) - (5)].node), (yylsp[(2) - (5)])); 42479@@ -30961,8 +28721,6 @@ 42480 break; 42481 42482 case 1446: 42483- 42484-/* Line 1455 of yacc.c */ 42485 #line 9184 "gram.y" 42486 { 42487 (yyval.node) = (Node *) makeA_Expr(AEXPR_NOT, NIL, 42488@@ -30971,8 +28729,6 @@ 42489 break; 42490 42491 case 1447: 42492- 42493-/* Line 1455 of yacc.c */ 42494 #line 9189 "gram.y" 42495 { 42496 (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OF, "=", (yyvsp[(1) - (6)].node), (Node *) (yyvsp[(5) - (6)].list), (yylsp[(2) - (6)])); 42497@@ -30980,8 +28736,6 @@ 42498 break; 42499 42500 case 1448: 42501- 42502-/* Line 1455 of yacc.c */ 42503 #line 9193 "gram.y" 42504 { 42505 (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_OF, "<>", (yyvsp[(1) - (7)].node), (Node *) (yyvsp[(6) - (7)].list), (yylsp[(2) - (7)])); 42506@@ -30989,8 +28743,6 @@ 42507 break; 42508 42509 case 1449: 42510- 42511-/* Line 1455 of yacc.c */ 42512 #line 9197 "gram.y" 42513 { 42514 (yyval.node) = makeXmlExpr(IS_DOCUMENT, NULL, NIL, 42515@@ -30999,8 +28751,6 @@ 42516 break; 42517 42518 case 1450: 42519- 42520-/* Line 1455 of yacc.c */ 42521 #line 9202 "gram.y" 42522 { 42523 (yyval.node) = (Node *) makeA_Expr(AEXPR_NOT, NIL, NULL, 42524@@ -31011,22 +28761,16 @@ 42525 break; 42526 42527 case 1451: 42528- 42529-/* Line 1455 of yacc.c */ 42530 #line 9218 "gram.y" 42531 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 42532 break; 42533 42534 case 1452: 42535- 42536-/* Line 1455 of yacc.c */ 42537 #line 9219 "gram.y" 42538 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 42539 break; 42540 42541 case 1453: 42542- 42543-/* Line 1455 of yacc.c */ 42544 #line 9221 "gram.y" 42545 { 42546 ParamRef *p = makeNode(ParamRef); 42547@@ -31045,8 +28789,6 @@ 42548 break; 42549 42550 case 1454: 42551- 42552-/* Line 1455 of yacc.c */ 42553 #line 9236 "gram.y" 42554 { 42555 if ((yyvsp[(4) - (4)].list)) 42556@@ -31062,22 +28804,16 @@ 42557 break; 42558 42559 case 1455: 42560- 42561-/* Line 1455 of yacc.c */ 42562 #line 9248 "gram.y" 42563 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 42564 break; 42565 42566 case 1456: 42567- 42568-/* Line 1455 of yacc.c */ 42569 #line 9250 "gram.y" 42570 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 42571 break; 42572 42573 case 1457: 42574- 42575-/* Line 1455 of yacc.c */ 42576 #line 9252 "gram.y" 42577 { 42578 SubLink *n = makeNode(SubLink); 42579@@ -31091,8 +28827,6 @@ 42580 break; 42581 42582 case 1458: 42583- 42584-/* Line 1455 of yacc.c */ 42585 #line 9262 "gram.y" 42586 { 42587 /* 42588@@ -31119,8 +28853,6 @@ 42589 break; 42590 42591 case 1459: 42592- 42593-/* Line 1455 of yacc.c */ 42594 #line 9285 "gram.y" 42595 { 42596 SubLink *n = makeNode(SubLink); 42597@@ -31134,8 +28866,6 @@ 42598 break; 42599 42600 case 1460: 42601- 42602-/* Line 1455 of yacc.c */ 42603 #line 9295 "gram.y" 42604 { 42605 SubLink *n = makeNode(SubLink); 42606@@ -31149,8 +28879,6 @@ 42607 break; 42608 42609 case 1461: 42610- 42611-/* Line 1455 of yacc.c */ 42612 #line 9305 "gram.y" 42613 { 42614 A_ArrayExpr *n = (A_ArrayExpr *) (yyvsp[(2) - (2)].node); 42615@@ -31162,8 +28890,6 @@ 42616 break; 42617 42618 case 1462: 42619- 42620-/* Line 1455 of yacc.c */ 42621 #line 9313 "gram.y" 42622 { 42623 RowExpr *r = makeNode(RowExpr); 42624@@ -31175,8 +28901,6 @@ 42625 break; 42626 42627 case 1463: 42628- 42629-/* Line 1455 of yacc.c */ 42630 #line 9331 "gram.y" 42631 { 42632 FuncCall *n = makeNode(FuncCall); 42633@@ -31193,8 +28917,6 @@ 42634 break; 42635 42636 case 1464: 42637- 42638-/* Line 1455 of yacc.c */ 42639 #line 9344 "gram.y" 42640 { 42641 FuncCall *n = makeNode(FuncCall); 42642@@ -31211,8 +28933,6 @@ 42643 break; 42644 42645 case 1465: 42646- 42647-/* Line 1455 of yacc.c */ 42648 #line 9357 "gram.y" 42649 { 42650 FuncCall *n = makeNode(FuncCall); 42651@@ -31229,8 +28949,6 @@ 42652 break; 42653 42654 case 1466: 42655- 42656-/* Line 1455 of yacc.c */ 42657 #line 9370 "gram.y" 42658 { 42659 FuncCall *n = makeNode(FuncCall); 42660@@ -31247,8 +28965,6 @@ 42661 break; 42662 42663 case 1467: 42664- 42665-/* Line 1455 of yacc.c */ 42666 #line 9383 "gram.y" 42667 { 42668 FuncCall *n = makeNode(FuncCall); 42669@@ -31265,8 +28981,6 @@ 42670 break; 42671 42672 case 1468: 42673- 42674-/* Line 1455 of yacc.c */ 42675 #line 9396 "gram.y" 42676 { 42677 FuncCall *n = makeNode(FuncCall); 42678@@ -31287,8 +29001,6 @@ 42679 break; 42680 42681 case 1469: 42682- 42683-/* Line 1455 of yacc.c */ 42684 #line 9413 "gram.y" 42685 { 42686 FuncCall *n = makeNode(FuncCall); 42687@@ -31305,8 +29017,6 @@ 42688 break; 42689 42690 case 1470: 42691- 42692-/* Line 1455 of yacc.c */ 42693 #line 9426 "gram.y" 42694 { 42695 /* 42696@@ -31333,8 +29043,6 @@ 42697 break; 42698 42699 case 1471: 42700- 42701-/* Line 1455 of yacc.c */ 42702 #line 9449 "gram.y" 42703 { 42704 /* 42705@@ -31359,8 +29067,6 @@ 42706 break; 42707 42708 case 1472: 42709- 42710-/* Line 1455 of yacc.c */ 42711 #line 9470 "gram.y" 42712 { 42713 /* 42714@@ -31374,8 +29080,6 @@ 42715 break; 42716 42717 case 1473: 42718- 42719-/* Line 1455 of yacc.c */ 42720 #line 9480 "gram.y" 42721 { 42722 /* 42723@@ -31392,8 +29096,6 @@ 42724 break; 42725 42726 case 1474: 42727- 42728-/* Line 1455 of yacc.c */ 42729 #line 9493 "gram.y" 42730 { 42731 /* 42732@@ -31414,8 +29116,6 @@ 42733 break; 42734 42735 case 1475: 42736- 42737-/* Line 1455 of yacc.c */ 42738 #line 9510 "gram.y" 42739 { 42740 /* 42741@@ -31432,8 +29132,6 @@ 42742 break; 42743 42744 case 1476: 42745- 42746-/* Line 1455 of yacc.c */ 42747 #line 9523 "gram.y" 42748 { 42749 /* 42750@@ -31447,8 +29145,6 @@ 42751 break; 42752 42753 case 1477: 42754- 42755-/* Line 1455 of yacc.c */ 42756 #line 9533 "gram.y" 42757 { 42758 /* 42759@@ -31465,8 +29161,6 @@ 42760 break; 42761 42762 case 1478: 42763- 42764-/* Line 1455 of yacc.c */ 42765 #line 9546 "gram.y" 42766 { 42767 /* 42768@@ -31480,8 +29174,6 @@ 42769 break; 42770 42771 case 1479: 42772- 42773-/* Line 1455 of yacc.c */ 42774 #line 9556 "gram.y" 42775 { 42776 /* 42777@@ -31498,8 +29190,6 @@ 42778 break; 42779 42780 case 1480: 42781- 42782-/* Line 1455 of yacc.c */ 42783 #line 9569 "gram.y" 42784 { 42785 FuncCall *n = makeNode(FuncCall); 42786@@ -31516,8 +29206,6 @@ 42787 break; 42788 42789 case 1481: 42790- 42791-/* Line 1455 of yacc.c */ 42792 #line 9582 "gram.y" 42793 { 42794 FuncCall *n = makeNode(FuncCall); 42795@@ -31534,8 +29222,6 @@ 42796 break; 42797 42798 case 1482: 42799- 42800-/* Line 1455 of yacc.c */ 42801 #line 9595 "gram.y" 42802 { 42803 FuncCall *n = makeNode(FuncCall); 42804@@ -31552,8 +29238,6 @@ 42805 break; 42806 42807 case 1483: 42808- 42809-/* Line 1455 of yacc.c */ 42810 #line 9608 "gram.y" 42811 { 42812 FuncCall *n = makeNode(FuncCall); 42813@@ -31570,8 +29254,6 @@ 42814 break; 42815 42816 case 1484: 42817- 42818-/* Line 1455 of yacc.c */ 42819 #line 9621 "gram.y" 42820 { 42821 FuncCall *n = makeNode(FuncCall); 42822@@ -31588,8 +29270,6 @@ 42823 break; 42824 42825 case 1485: 42826- 42827-/* Line 1455 of yacc.c */ 42828 #line 9634 "gram.y" 42829 { 42830 FuncCall *n = makeNode(FuncCall); 42831@@ -31606,15 +29286,11 @@ 42832 break; 42833 42834 case 1486: 42835- 42836-/* Line 1455 of yacc.c */ 42837 #line 9647 "gram.y" 42838 { (yyval.node) = makeTypeCast((yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].typnam), (yylsp[(1) - (6)])); ;} 42839 break; 42840 42841 case 1487: 42842- 42843-/* Line 1455 of yacc.c */ 42844 #line 9649 "gram.y" 42845 { 42846 FuncCall *n = makeNode(FuncCall); 42847@@ -31631,8 +29307,6 @@ 42848 break; 42849 42850 case 1488: 42851- 42852-/* Line 1455 of yacc.c */ 42853 #line 9662 "gram.y" 42854 { 42855 /* overlay(A PLACING B FROM C FOR D) is converted to 42856@@ -31654,8 +29328,6 @@ 42857 break; 42858 42859 case 1489: 42860- 42861-/* Line 1455 of yacc.c */ 42862 #line 9680 "gram.y" 42863 { 42864 /* position(A in B) is converted to position(B, A) */ 42865@@ -31673,8 +29345,6 @@ 42866 break; 42867 42868 case 1490: 42869- 42870-/* Line 1455 of yacc.c */ 42871 #line 9694 "gram.y" 42872 { 42873 /* substring(A from B for C) is converted to 42874@@ -31694,8 +29364,6 @@ 42875 break; 42876 42877 case 1491: 42878- 42879-/* Line 1455 of yacc.c */ 42880 #line 9710 "gram.y" 42881 { 42882 /* TREAT(expr AS target) converts expr of a particular type to target, 42883@@ -31721,8 +29389,6 @@ 42884 break; 42885 42886 case 1492: 42887- 42888-/* Line 1455 of yacc.c */ 42889 #line 9732 "gram.y" 42890 { 42891 /* various trim expressions are defined in SQL92 42892@@ -31742,8 +29408,6 @@ 42893 break; 42894 42895 case 1493: 42896- 42897-/* Line 1455 of yacc.c */ 42898 #line 9748 "gram.y" 42899 { 42900 FuncCall *n = makeNode(FuncCall); 42901@@ -31760,8 +29424,6 @@ 42902 break; 42903 42904 case 1494: 42905- 42906-/* Line 1455 of yacc.c */ 42907 #line 9761 "gram.y" 42908 { 42909 FuncCall *n = makeNode(FuncCall); 42910@@ -31778,8 +29440,6 @@ 42911 break; 42912 42913 case 1495: 42914- 42915-/* Line 1455 of yacc.c */ 42916 #line 9774 "gram.y" 42917 { 42918 FuncCall *n = makeNode(FuncCall); 42919@@ -31796,8 +29456,6 @@ 42920 break; 42921 42922 case 1496: 42923- 42924-/* Line 1455 of yacc.c */ 42925 #line 9787 "gram.y" 42926 { 42927 (yyval.node) = (Node *) makeSimpleA_Expr(AEXPR_NULLIF, "=", (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].node), (yylsp[(1) - (6)])); 42928@@ -31805,8 +29463,6 @@ 42929 break; 42930 42931 case 1497: 42932- 42933-/* Line 1455 of yacc.c */ 42934 #line 9791 "gram.y" 42935 { 42936 CoalesceExpr *c = makeNode(CoalesceExpr); 42937@@ -31817,8 +29473,6 @@ 42938 break; 42939 42940 case 1498: 42941- 42942-/* Line 1455 of yacc.c */ 42943 #line 9798 "gram.y" 42944 { 42945 MinMaxExpr *v = makeNode(MinMaxExpr); 42946@@ -31830,8 +29484,6 @@ 42947 break; 42948 42949 case 1499: 42950- 42951-/* Line 1455 of yacc.c */ 42952 #line 9806 "gram.y" 42953 { 42954 MinMaxExpr *v = makeNode(MinMaxExpr); 42955@@ -31843,8 +29495,6 @@ 42956 break; 42957 42958 case 1500: 42959- 42960-/* Line 1455 of yacc.c */ 42961 #line 9814 "gram.y" 42962 { 42963 (yyval.node) = makeXmlExpr(IS_XMLCONCAT, NULL, NIL, (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); 42964@@ -31852,8 +29502,6 @@ 42965 break; 42966 42967 case 1501: 42968- 42969-/* Line 1455 of yacc.c */ 42970 #line 9818 "gram.y" 42971 { 42972 (yyval.node) = makeXmlExpr(IS_XMLELEMENT, (yyvsp[(4) - (5)].str), NIL, NIL, (yylsp[(1) - (5)])); 42973@@ -31861,8 +29509,6 @@ 42974 break; 42975 42976 case 1502: 42977- 42978-/* Line 1455 of yacc.c */ 42979 #line 9822 "gram.y" 42980 { 42981 (yyval.node) = makeXmlExpr(IS_XMLELEMENT, (yyvsp[(4) - (7)].str), (yyvsp[(6) - (7)].list), NIL, (yylsp[(1) - (7)])); 42982@@ -31870,8 +29516,6 @@ 42983 break; 42984 42985 case 1503: 42986- 42987-/* Line 1455 of yacc.c */ 42988 #line 9826 "gram.y" 42989 { 42990 (yyval.node) = makeXmlExpr(IS_XMLELEMENT, (yyvsp[(4) - (7)].str), NIL, (yyvsp[(6) - (7)].list), (yylsp[(1) - (7)])); 42991@@ -31879,8 +29523,6 @@ 42992 break; 42993 42994 case 1504: 42995- 42996-/* Line 1455 of yacc.c */ 42997 #line 9830 "gram.y" 42998 { 42999 (yyval.node) = makeXmlExpr(IS_XMLELEMENT, (yyvsp[(4) - (9)].str), (yyvsp[(6) - (9)].list), (yyvsp[(8) - (9)].list), (yylsp[(1) - (9)])); 43000@@ -31888,8 +29530,6 @@ 43001 break; 43002 43003 case 1505: 43004- 43005-/* Line 1455 of yacc.c */ 43006 #line 9834 "gram.y" 43007 { 43008 (yyval.node) = makeXmlExpr(IS_XMLFOREST, NULL, (yyvsp[(3) - (4)].list), NIL, (yylsp[(1) - (4)])); 43009@@ -31897,8 +29537,6 @@ 43010 break; 43011 43012 case 1506: 43013- 43014-/* Line 1455 of yacc.c */ 43015 #line 9838 "gram.y" 43016 { 43017 XmlExpr *x = (XmlExpr *) 43018@@ -31911,8 +29549,6 @@ 43019 break; 43020 43021 case 1507: 43022- 43023-/* Line 1455 of yacc.c */ 43024 #line 9847 "gram.y" 43025 { 43026 (yyval.node) = makeXmlExpr(IS_XMLPI, (yyvsp[(4) - (5)].str), NULL, NIL, (yylsp[(1) - (5)])); 43027@@ -31920,8 +29556,6 @@ 43028 break; 43029 43030 case 1508: 43031- 43032-/* Line 1455 of yacc.c */ 43033 #line 9851 "gram.y" 43034 { 43035 (yyval.node) = makeXmlExpr(IS_XMLPI, (yyvsp[(4) - (7)].str), NULL, list_make1((yyvsp[(6) - (7)].node)), (yylsp[(1) - (7)])); 43036@@ -31929,8 +29563,6 @@ 43037 break; 43038 43039 case 1509: 43040- 43041-/* Line 1455 of yacc.c */ 43042 #line 9855 "gram.y" 43043 { 43044 (yyval.node) = makeXmlExpr(IS_XMLROOT, NULL, NIL, 43045@@ -31939,8 +29571,6 @@ 43046 break; 43047 43048 case 1510: 43049- 43050-/* Line 1455 of yacc.c */ 43051 #line 9860 "gram.y" 43052 { 43053 XmlSerialize *n = makeNode(XmlSerialize); 43054@@ -31953,71 +29583,51 @@ 43055 break; 43056 43057 case 1511: 43058- 43059-/* Line 1455 of yacc.c */ 43060 #line 9874 "gram.y" 43061 { (yyval.node) = (yyvsp[(2) - (2)].node); ;} 43062 break; 43063 43064 case 1512: 43065- 43066-/* Line 1455 of yacc.c */ 43067 #line 9876 "gram.y" 43068 { (yyval.node) = makeNullAConst(-1); ;} 43069 break; 43070 43071 case 1513: 43072- 43073-/* Line 1455 of yacc.c */ 43074 #line 9880 "gram.y" 43075 { (yyval.node) = makeIntConst(XML_STANDALONE_YES, -1); ;} 43076 break; 43077 43078 case 1514: 43079- 43080-/* Line 1455 of yacc.c */ 43081 #line 9882 "gram.y" 43082 { (yyval.node) = makeIntConst(XML_STANDALONE_NO, -1); ;} 43083 break; 43084 43085 case 1515: 43086- 43087-/* Line 1455 of yacc.c */ 43088 #line 9884 "gram.y" 43089 { (yyval.node) = makeIntConst(XML_STANDALONE_NO_VALUE, -1); ;} 43090 break; 43091 43092 case 1516: 43093- 43094-/* Line 1455 of yacc.c */ 43095 #line 9886 "gram.y" 43096 { (yyval.node) = makeIntConst(XML_STANDALONE_OMITTED, -1); ;} 43097 break; 43098 43099 case 1517: 43100- 43101-/* Line 1455 of yacc.c */ 43102 #line 9889 "gram.y" 43103 { (yyval.list) = (yyvsp[(3) - (4)].list); ;} 43104 break; 43105 43106 case 1518: 43107- 43108-/* Line 1455 of yacc.c */ 43109 #line 9892 "gram.y" 43110 { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;} 43111 break; 43112 43113 case 1519: 43114- 43115-/* Line 1455 of yacc.c */ 43116 #line 9893 "gram.y" 43117 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].target)); ;} 43118 break; 43119 43120 case 1520: 43121- 43122-/* Line 1455 of yacc.c */ 43123 #line 9897 "gram.y" 43124 { 43125 (yyval.target) = makeNode(ResTarget); 43126@@ -32029,8 +29639,6 @@ 43127 break; 43128 43129 case 1521: 43130- 43131-/* Line 1455 of yacc.c */ 43132 #line 9905 "gram.y" 43133 { 43134 (yyval.target) = makeNode(ResTarget); 43135@@ -32042,71 +29650,51 @@ 43136 break; 43137 43138 case 1522: 43139- 43140-/* Line 1455 of yacc.c */ 43141 #line 9914 "gram.y" 43142 { (yyval.ival) = XMLOPTION_DOCUMENT; ;} 43143 break; 43144 43145 case 1523: 43146- 43147-/* Line 1455 of yacc.c */ 43148 #line 9915 "gram.y" 43149 { (yyval.ival) = XMLOPTION_CONTENT; ;} 43150 break; 43151 43152 case 1524: 43153- 43154-/* Line 1455 of yacc.c */ 43155 #line 9918 "gram.y" 43156 { (yyval.boolean) = TRUE; ;} 43157 break; 43158 43159 case 1525: 43160- 43161-/* Line 1455 of yacc.c */ 43162 #line 9919 "gram.y" 43163 { (yyval.boolean) = FALSE; ;} 43164 break; 43165 43166 case 1526: 43167- 43168-/* Line 1455 of yacc.c */ 43169 #line 9920 "gram.y" 43170 { (yyval.boolean) = FALSE; ;} 43171 break; 43172 43173 case 1527: 43174- 43175-/* Line 1455 of yacc.c */ 43176 #line 9927 "gram.y" 43177 { (yyval.list) = (yyvsp[(2) - (2)].list); ;} 43178 break; 43179 43180 case 1528: 43181- 43182-/* Line 1455 of yacc.c */ 43183 #line 9928 "gram.y" 43184 { (yyval.list) = NIL; ;} 43185 break; 43186 43187 case 1529: 43188- 43189-/* Line 1455 of yacc.c */ 43190 #line 9932 "gram.y" 43191 { (yyval.list) = list_make1((yyvsp[(1) - (1)].windef)); ;} 43192 break; 43193 43194 case 1530: 43195- 43196-/* Line 1455 of yacc.c */ 43197 #line 9934 "gram.y" 43198 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].windef)); ;} 43199 break; 43200 43201 case 1531: 43202- 43203-/* Line 1455 of yacc.c */ 43204 #line 9939 "gram.y" 43205 { 43206 WindowDef *n = (yyvsp[(3) - (3)].windef); 43207@@ -32116,15 +29704,11 @@ 43208 break; 43209 43210 case 1532: 43211- 43212-/* Line 1455 of yacc.c */ 43213 #line 9947 "gram.y" 43214 { (yyval.windef) = (yyvsp[(2) - (2)].windef); ;} 43215 break; 43216 43217 case 1533: 43218- 43219-/* Line 1455 of yacc.c */ 43220 #line 9949 "gram.y" 43221 { 43222 WindowDef *n = makeNode(WindowDef); 43223@@ -32141,15 +29725,11 @@ 43224 break; 43225 43226 case 1534: 43227- 43228-/* Line 1455 of yacc.c */ 43229 #line 9962 "gram.y" 43230 { (yyval.windef) = NULL; ;} 43231 break; 43232 43233 case 1535: 43234- 43235-/* Line 1455 of yacc.c */ 43236 #line 9967 "gram.y" 43237 { 43238 WindowDef *n = makeNode(WindowDef); 43239@@ -32167,36 +29747,26 @@ 43240 break; 43241 43242 case 1536: 43243- 43244-/* Line 1455 of yacc.c */ 43245 #line 9992 "gram.y" 43246 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 43247 break; 43248 43249 case 1537: 43250- 43251-/* Line 1455 of yacc.c */ 43252 #line 9993 "gram.y" 43253 { (yyval.str) = NULL; ;} 43254 break; 43255 43256 case 1538: 43257- 43258-/* Line 1455 of yacc.c */ 43259 #line 9996 "gram.y" 43260 { (yyval.list) = (yyvsp[(3) - (3)].list); ;} 43261 break; 43262 43263 case 1539: 43264- 43265-/* Line 1455 of yacc.c */ 43266 #line 9997 "gram.y" 43267 { (yyval.list) = NIL; ;} 43268 break; 43269 43270 case 1540: 43271- 43272-/* Line 1455 of yacc.c */ 43273 #line 10009 "gram.y" 43274 { 43275 WindowDef *n = (yyvsp[(2) - (2)].windef); 43276@@ -32218,8 +29788,6 @@ 43277 break; 43278 43279 case 1541: 43280- 43281-/* Line 1455 of yacc.c */ 43282 #line 10027 "gram.y" 43283 { 43284 WindowDef *n = (yyvsp[(2) - (2)].windef); 43285@@ -32229,8 +29797,6 @@ 43286 break; 43287 43288 case 1542: 43289- 43290-/* Line 1455 of yacc.c */ 43291 #line 10033 "gram.y" 43292 { 43293 WindowDef *n = makeNode(WindowDef); 43294@@ -32242,8 +29808,6 @@ 43295 break; 43296 43297 case 1543: 43298- 43299-/* Line 1455 of yacc.c */ 43300 #line 10043 "gram.y" 43301 { 43302 WindowDef *n = (yyvsp[(1) - (1)].windef); 43303@@ -32264,8 +29828,6 @@ 43304 break; 43305 43306 case 1544: 43307- 43308-/* Line 1455 of yacc.c */ 43309 #line 10060 "gram.y" 43310 { 43311 WindowDef *n1 = (yyvsp[(2) - (4)].windef); 43312@@ -32306,8 +29868,6 @@ 43313 break; 43314 43315 case 1545: 43316- 43317-/* Line 1455 of yacc.c */ 43318 #line 10105 "gram.y" 43319 { 43320 WindowDef *n = makeNode(WindowDef); 43321@@ -32319,8 +29879,6 @@ 43322 break; 43323 43324 case 1546: 43325- 43326-/* Line 1455 of yacc.c */ 43327 #line 10113 "gram.y" 43328 { 43329 WindowDef *n = makeNode(WindowDef); 43330@@ -32332,8 +29890,6 @@ 43331 break; 43332 43333 case 1547: 43334- 43335-/* Line 1455 of yacc.c */ 43336 #line 10121 "gram.y" 43337 { 43338 WindowDef *n = makeNode(WindowDef); 43339@@ -32345,8 +29901,6 @@ 43340 break; 43341 43342 case 1548: 43343- 43344-/* Line 1455 of yacc.c */ 43345 #line 10129 "gram.y" 43346 { 43347 WindowDef *n = makeNode(WindowDef); 43348@@ -32358,8 +29912,6 @@ 43349 break; 43350 43351 case 1549: 43352- 43353-/* Line 1455 of yacc.c */ 43354 #line 10137 "gram.y" 43355 { 43356 WindowDef *n = makeNode(WindowDef); 43357@@ -32371,197 +29923,141 @@ 43358 break; 43359 43360 case 1550: 43361- 43362-/* Line 1455 of yacc.c */ 43363 #line 10157 "gram.y" 43364 { (yyval.list) = (yyvsp[(3) - (4)].list); ;} 43365 break; 43366 43367 case 1551: 43368- 43369-/* Line 1455 of yacc.c */ 43370 #line 10158 "gram.y" 43371 { (yyval.list) = NIL; ;} 43372 break; 43373 43374 case 1552: 43375- 43376-/* Line 1455 of yacc.c */ 43377 #line 10159 "gram.y" 43378 { (yyval.list) = lappend((yyvsp[(2) - (5)].list), (yyvsp[(4) - (5)].node)); ;} 43379 break; 43380 43381 case 1553: 43382- 43383-/* Line 1455 of yacc.c */ 43384 #line 10162 "gram.y" 43385 { (yyval.ival) = ANY_SUBLINK; ;} 43386 break; 43387 43388 case 1554: 43389- 43390-/* Line 1455 of yacc.c */ 43391 #line 10163 "gram.y" 43392 { (yyval.ival) = ANY_SUBLINK; ;} 43393 break; 43394 43395 case 1555: 43396- 43397-/* Line 1455 of yacc.c */ 43398 #line 10164 "gram.y" 43399 { (yyval.ival) = ALL_SUBLINK; ;} 43400 break; 43401 43402 case 1556: 43403- 43404-/* Line 1455 of yacc.c */ 43405 #line 10167 "gram.y" 43406 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 43407 break; 43408 43409 case 1557: 43410- 43411-/* Line 1455 of yacc.c */ 43412 #line 10168 "gram.y" 43413 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 43414 break; 43415 43416 case 1558: 43417- 43418-/* Line 1455 of yacc.c */ 43419 #line 10171 "gram.y" 43420 { (yyval.str) = "+"; ;} 43421 break; 43422 43423 case 1559: 43424- 43425-/* Line 1455 of yacc.c */ 43426 #line 10172 "gram.y" 43427 { (yyval.str) = "-"; ;} 43428 break; 43429 43430 case 1560: 43431- 43432-/* Line 1455 of yacc.c */ 43433 #line 10173 "gram.y" 43434 { (yyval.str) = "*"; ;} 43435 break; 43436 43437 case 1561: 43438- 43439-/* Line 1455 of yacc.c */ 43440 #line 10174 "gram.y" 43441 { (yyval.str) = "/"; ;} 43442 break; 43443 43444 case 1562: 43445- 43446-/* Line 1455 of yacc.c */ 43447 #line 10175 "gram.y" 43448 { (yyval.str) = "%"; ;} 43449 break; 43450 43451 case 1563: 43452- 43453-/* Line 1455 of yacc.c */ 43454 #line 10176 "gram.y" 43455 { (yyval.str) = "^"; ;} 43456 break; 43457 43458 case 1564: 43459- 43460-/* Line 1455 of yacc.c */ 43461 #line 10177 "gram.y" 43462 { (yyval.str) = "<"; ;} 43463 break; 43464 43465 case 1565: 43466- 43467-/* Line 1455 of yacc.c */ 43468 #line 10178 "gram.y" 43469 { (yyval.str) = ">"; ;} 43470 break; 43471 43472 case 1566: 43473- 43474-/* Line 1455 of yacc.c */ 43475 #line 10179 "gram.y" 43476 { (yyval.str) = "="; ;} 43477 break; 43478 43479 case 1567: 43480- 43481-/* Line 1455 of yacc.c */ 43482 #line 10183 "gram.y" 43483 { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} 43484 break; 43485 43486 case 1568: 43487- 43488-/* Line 1455 of yacc.c */ 43489 #line 10185 "gram.y" 43490 { (yyval.list) = (yyvsp[(3) - (4)].list); ;} 43491 break; 43492 43493 case 1569: 43494- 43495-/* Line 1455 of yacc.c */ 43496 #line 10190 "gram.y" 43497 { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} 43498 break; 43499 43500 case 1570: 43501- 43502-/* Line 1455 of yacc.c */ 43503 #line 10192 "gram.y" 43504 { (yyval.list) = (yyvsp[(3) - (4)].list); ;} 43505 break; 43506 43507 case 1571: 43508- 43509-/* Line 1455 of yacc.c */ 43510 #line 10197 "gram.y" 43511 { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} 43512 break; 43513 43514 case 1572: 43515- 43516-/* Line 1455 of yacc.c */ 43517 #line 10199 "gram.y" 43518 { (yyval.list) = (yyvsp[(3) - (4)].list); ;} 43519 break; 43520 43521 case 1573: 43522- 43523-/* Line 1455 of yacc.c */ 43524 #line 10201 "gram.y" 43525 { (yyval.list) = list_make1(makeString("~~")); ;} 43526 break; 43527 43528 case 1574: 43529- 43530-/* Line 1455 of yacc.c */ 43531 #line 10203 "gram.y" 43532 { (yyval.list) = list_make1(makeString("!~~")); ;} 43533 break; 43534 43535 case 1575: 43536- 43537-/* Line 1455 of yacc.c */ 43538 #line 10205 "gram.y" 43539 { (yyval.list) = list_make1(makeString("~~*")); ;} 43540 break; 43541 43542 case 1576: 43543- 43544-/* Line 1455 of yacc.c */ 43545 #line 10207 "gram.y" 43546 { (yyval.list) = list_make1(makeString("!~~*")); ;} 43547 break; 43548 43549 case 1577: 43550- 43551-/* Line 1455 of yacc.c */ 43552 #line 10219 "gram.y" 43553 { 43554 (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); 43555@@ -32569,8 +30065,6 @@ 43556 break; 43557 43558 case 1578: 43559- 43560-/* Line 1455 of yacc.c */ 43561 #line 10223 "gram.y" 43562 { 43563 (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 43564@@ -32578,8 +30072,6 @@ 43565 break; 43566 43567 case 1579: 43568- 43569-/* Line 1455 of yacc.c */ 43570 #line 10230 "gram.y" 43571 { 43572 (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); 43573@@ -32587,8 +30079,6 @@ 43574 break; 43575 43576 case 1580: 43577- 43578-/* Line 1455 of yacc.c */ 43579 #line 10234 "gram.y" 43580 { 43581 (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); 43582@@ -32596,8 +30086,6 @@ 43583 break; 43584 43585 case 1581: 43586- 43587-/* Line 1455 of yacc.c */ 43588 #line 10240 "gram.y" 43589 { 43590 (yyval.node) = (yyvsp[(1) - (1)].node); 43591@@ -32605,8 +30093,6 @@ 43592 break; 43593 43594 case 1582: 43595- 43596-/* Line 1455 of yacc.c */ 43597 #line 10244 "gram.y" 43598 { 43599 NamedArgExpr *na = makeNode(NamedArgExpr); 43600@@ -32619,22 +30105,16 @@ 43601 break; 43602 43603 case 1583: 43604- 43605-/* Line 1455 of yacc.c */ 43606 #line 10254 "gram.y" 43607 { (yyval.list) = list_make1((yyvsp[(1) - (1)].typnam)); ;} 43608 break; 43609 43610 case 1584: 43611- 43612-/* Line 1455 of yacc.c */ 43613 #line 10255 "gram.y" 43614 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].typnam)); ;} 43615 break; 43616 43617 case 1585: 43618- 43619-/* Line 1455 of yacc.c */ 43620 #line 10259 "gram.y" 43621 { 43622 (yyval.node) = makeAArrayExpr((yyvsp[(2) - (3)].list), (yylsp[(1) - (3)])); 43623@@ -32642,8 +30122,6 @@ 43624 break; 43625 43626 case 1586: 43627- 43628-/* Line 1455 of yacc.c */ 43629 #line 10263 "gram.y" 43630 { 43631 (yyval.node) = makeAArrayExpr((yyvsp[(2) - (3)].list), (yylsp[(1) - (3)])); 43632@@ -32651,8 +30129,6 @@ 43633 break; 43634 43635 case 1587: 43636- 43637-/* Line 1455 of yacc.c */ 43638 #line 10267 "gram.y" 43639 { 43640 (yyval.node) = makeAArrayExpr(NIL, (yylsp[(1) - (2)])); 43641@@ -32660,22 +30136,16 @@ 43642 break; 43643 43644 case 1588: 43645- 43646-/* Line 1455 of yacc.c */ 43647 #line 10272 "gram.y" 43648 { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} 43649 break; 43650 43651 case 1589: 43652- 43653-/* Line 1455 of yacc.c */ 43654 #line 10273 "gram.y" 43655 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} 43656 break; 43657 43658 case 1590: 43659- 43660-/* Line 1455 of yacc.c */ 43661 #line 10279 "gram.y" 43662 { 43663 (yyval.list) = list_make2(makeStringConst((yyvsp[(1) - (3)].str), (yylsp[(1) - (3)])), (yyvsp[(3) - (3)].node)); 43664@@ -32683,71 +30153,51 @@ 43665 break; 43666 43667 case 1591: 43668- 43669-/* Line 1455 of yacc.c */ 43670 #line 10282 "gram.y" 43671 { (yyval.list) = NIL; ;} 43672 break; 43673 43674 case 1592: 43675- 43676-/* Line 1455 of yacc.c */ 43677 #line 10289 "gram.y" 43678 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 43679 break; 43680 43681 case 1593: 43682- 43683-/* Line 1455 of yacc.c */ 43684 #line 10290 "gram.y" 43685 { (yyval.str) = "year"; ;} 43686 break; 43687 43688 case 1594: 43689- 43690-/* Line 1455 of yacc.c */ 43691 #line 10291 "gram.y" 43692 { (yyval.str) = "month"; ;} 43693 break; 43694 43695 case 1595: 43696- 43697-/* Line 1455 of yacc.c */ 43698 #line 10292 "gram.y" 43699 { (yyval.str) = "day"; ;} 43700 break; 43701 43702 case 1596: 43703- 43704-/* Line 1455 of yacc.c */ 43705 #line 10293 "gram.y" 43706 { (yyval.str) = "hour"; ;} 43707 break; 43708 43709 case 1597: 43710- 43711-/* Line 1455 of yacc.c */ 43712 #line 10294 "gram.y" 43713 { (yyval.str) = "minute"; ;} 43714 break; 43715 43716 case 1598: 43717- 43718-/* Line 1455 of yacc.c */ 43719 #line 10295 "gram.y" 43720 { (yyval.str) = "second"; ;} 43721 break; 43722 43723 case 1599: 43724- 43725-/* Line 1455 of yacc.c */ 43726 #line 10296 "gram.y" 43727 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 43728 break; 43729 43730 case 1600: 43731- 43732-/* Line 1455 of yacc.c */ 43733 #line 10307 "gram.y" 43734 { 43735 (yyval.list) = list_make4((yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].node), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node)); 43736@@ -32755,8 +30205,6 @@ 43737 break; 43738 43739 case 1601: 43740- 43741-/* Line 1455 of yacc.c */ 43742 #line 10311 "gram.y" 43743 { 43744 (yyval.list) = list_make3((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].node)); 43745@@ -32764,29 +30212,21 @@ 43746 break; 43747 43748 case 1602: 43749- 43750-/* Line 1455 of yacc.c */ 43751 #line 10318 "gram.y" 43752 { (yyval.node) = (yyvsp[(2) - (2)].node); ;} 43753 break; 43754 43755 case 1603: 43756- 43757-/* Line 1455 of yacc.c */ 43758 #line 10324 "gram.y" 43759 { (yyval.list) = list_make2((yyvsp[(3) - (3)].node), (yyvsp[(1) - (3)].node)); ;} 43760 break; 43761 43762 case 1604: 43763- 43764-/* Line 1455 of yacc.c */ 43765 #line 10325 "gram.y" 43766 { (yyval.list) = NIL; ;} 43767 break; 43768 43769 case 1605: 43770- 43771-/* Line 1455 of yacc.c */ 43772 #line 10342 "gram.y" 43773 { 43774 (yyval.list) = list_make3((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].node)); 43775@@ -32794,8 +30234,6 @@ 43776 break; 43777 43778 case 1606: 43779- 43780-/* Line 1455 of yacc.c */ 43781 #line 10346 "gram.y" 43782 { 43783 /* not legal per SQL99, but might as well allow it */ 43784@@ -32804,8 +30242,6 @@ 43785 break; 43786 43787 case 1607: 43788- 43789-/* Line 1455 of yacc.c */ 43790 #line 10351 "gram.y" 43791 { 43792 (yyval.list) = list_make2((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); 43793@@ -32813,8 +30249,6 @@ 43794 break; 43795 43796 case 1608: 43797- 43798-/* Line 1455 of yacc.c */ 43799 #line 10355 "gram.y" 43800 { 43801 /* 43802@@ -32833,8 +30267,6 @@ 43803 break; 43804 43805 case 1609: 43806- 43807-/* Line 1455 of yacc.c */ 43808 #line 10370 "gram.y" 43809 { 43810 (yyval.list) = (yyvsp[(1) - (1)].list); 43811@@ -32842,50 +30274,36 @@ 43812 break; 43813 43814 case 1610: 43815- 43816-/* Line 1455 of yacc.c */ 43817 #line 10374 "gram.y" 43818 { (yyval.list) = NIL; ;} 43819 break; 43820 43821 case 1611: 43822- 43823-/* Line 1455 of yacc.c */ 43824 #line 10378 "gram.y" 43825 { (yyval.node) = (yyvsp[(2) - (2)].node); ;} 43826 break; 43827 43828 case 1612: 43829- 43830-/* Line 1455 of yacc.c */ 43831 #line 10381 "gram.y" 43832 { (yyval.node) = (yyvsp[(2) - (2)].node); ;} 43833 break; 43834 43835 case 1613: 43836- 43837-/* Line 1455 of yacc.c */ 43838 #line 10384 "gram.y" 43839 { (yyval.list) = lappend((yyvsp[(3) - (3)].list), (yyvsp[(1) - (3)].node)); ;} 43840 break; 43841 43842 case 1614: 43843- 43844-/* Line 1455 of yacc.c */ 43845 #line 10385 "gram.y" 43846 { (yyval.list) = (yyvsp[(2) - (2)].list); ;} 43847 break; 43848 43849 case 1615: 43850- 43851-/* Line 1455 of yacc.c */ 43852 #line 10386 "gram.y" 43853 { (yyval.list) = (yyvsp[(1) - (1)].list); ;} 43854 break; 43855 43856 case 1616: 43857- 43858-/* Line 1455 of yacc.c */ 43859 #line 10390 "gram.y" 43860 { 43861 SubLink *n = makeNode(SubLink); 43862@@ -32896,15 +30314,11 @@ 43863 break; 43864 43865 case 1617: 43866- 43867-/* Line 1455 of yacc.c */ 43868 #line 10396 "gram.y" 43869 { (yyval.node) = (Node *)(yyvsp[(2) - (3)].list); ;} 43870 break; 43871 43872 case 1618: 43873- 43874-/* Line 1455 of yacc.c */ 43875 #line 10407 "gram.y" 43876 { 43877 CaseExpr *c = makeNode(CaseExpr); 43878@@ -32918,22 +30332,16 @@ 43879 break; 43880 43881 case 1619: 43882- 43883-/* Line 1455 of yacc.c */ 43884 #line 10420 "gram.y" 43885 { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} 43886 break; 43887 43888 case 1620: 43889- 43890-/* Line 1455 of yacc.c */ 43891 #line 10421 "gram.y" 43892 { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} 43893 break; 43894 43895 case 1621: 43896- 43897-/* Line 1455 of yacc.c */ 43898 #line 10426 "gram.y" 43899 { 43900 CaseWhen *w = makeNode(CaseWhen); 43901@@ -32945,36 +30353,26 @@ 43902 break; 43903 43904 case 1622: 43905- 43906-/* Line 1455 of yacc.c */ 43907 #line 10436 "gram.y" 43908 { (yyval.node) = (yyvsp[(2) - (2)].node); ;} 43909 break; 43910 43911 case 1623: 43912- 43913-/* Line 1455 of yacc.c */ 43914 #line 10437 "gram.y" 43915 { (yyval.node) = NULL; ;} 43916 break; 43917 43918 case 1624: 43919- 43920-/* Line 1455 of yacc.c */ 43921 #line 10440 "gram.y" 43922 { (yyval.node) = (yyvsp[(1) - (1)].node); ;} 43923 break; 43924 43925 case 1625: 43926- 43927-/* Line 1455 of yacc.c */ 43928 #line 10441 "gram.y" 43929 { (yyval.node) = NULL; ;} 43930 break; 43931 43932 case 1626: 43933- 43934-/* Line 1455 of yacc.c */ 43935 #line 10445 "gram.y" 43936 { 43937 (yyval.node) = makeColumnRef((yyvsp[(1) - (1)].str), NIL, (yylsp[(1) - (1)]), yyscanner); 43938@@ -32982,8 +30380,6 @@ 43939 break; 43940 43941 case 1627: 43942- 43943-/* Line 1455 of yacc.c */ 43944 #line 10449 "gram.y" 43945 { 43946 (yyval.node) = makeColumnRef((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].list), (yylsp[(1) - (2)]), yyscanner); 43947@@ -32991,8 +30387,6 @@ 43948 break; 43949 43950 case 1628: 43951- 43952-/* Line 1455 of yacc.c */ 43953 #line 10456 "gram.y" 43954 { 43955 (yyval.node) = (Node *) makeString((yyvsp[(2) - (2)].str)); 43956@@ -33000,8 +30394,6 @@ 43957 break; 43958 43959 case 1629: 43960- 43961-/* Line 1455 of yacc.c */ 43962 #line 10460 "gram.y" 43963 { 43964 (yyval.node) = (Node *) makeNode(A_Star); 43965@@ -33009,8 +30401,6 @@ 43966 break; 43967 43968 case 1630: 43969- 43970-/* Line 1455 of yacc.c */ 43971 #line 10464 "gram.y" 43972 { 43973 A_Indices *ai = makeNode(A_Indices); 43974@@ -33021,8 +30411,6 @@ 43975 break; 43976 43977 case 1631: 43978- 43979-/* Line 1455 of yacc.c */ 43980 #line 10471 "gram.y" 43981 { 43982 A_Indices *ai = makeNode(A_Indices); 43983@@ -33033,43 +30421,31 @@ 43984 break; 43985 43986 case 1632: 43987- 43988-/* Line 1455 of yacc.c */ 43989 #line 10480 "gram.y" 43990 { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} 43991 break; 43992 43993 case 1633: 43994- 43995-/* Line 1455 of yacc.c */ 43996 #line 10481 "gram.y" 43997 { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} 43998 break; 43999 44000 case 1634: 44001- 44002-/* Line 1455 of yacc.c */ 44003 #line 10485 "gram.y" 44004 { (yyval.list) = NIL; ;} 44005 break; 44006 44007 case 1635: 44008- 44009-/* Line 1455 of yacc.c */ 44010 #line 10486 "gram.y" 44011 { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} 44012 break; 44013 44014 case 1638: 44015- 44016-/* Line 1455 of yacc.c */ 44017 #line 10501 "gram.y" 44018 { (yyval.node) = (Node *) (yyvsp[(1) - (1)].node); ;} 44019 break; 44020 44021 case 1639: 44022- 44023-/* Line 1455 of yacc.c */ 44024 #line 10503 "gram.y" 44025 { 44026 SetToDefault *n = makeNode(SetToDefault); 44027@@ -33079,43 +30455,31 @@ 44028 break; 44029 44030 case 1640: 44031- 44032-/* Line 1455 of yacc.c */ 44033 #line 10511 "gram.y" 44034 { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} 44035 break; 44036 44037 case 1641: 44038- 44039-/* Line 1455 of yacc.c */ 44040 #line 10512 "gram.y" 44041 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} 44042 break; 44043 44044 case 1642: 44045- 44046-/* Line 1455 of yacc.c */ 44047 #line 10520 "gram.y" 44048 { (yyval.list) = (yyvsp[(2) - (3)].list); ;} 44049 break; 44050 44051 case 1643: 44052- 44053-/* Line 1455 of yacc.c */ 44054 #line 10531 "gram.y" 44055 { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;} 44056 break; 44057 44058 case 1644: 44059- 44060-/* Line 1455 of yacc.c */ 44061 #line 10532 "gram.y" 44062 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].target)); ;} 44063 break; 44064 44065 case 1645: 44066- 44067-/* Line 1455 of yacc.c */ 44068 #line 10536 "gram.y" 44069 { 44070 (yyval.target) = makeNode(ResTarget); 44071@@ -33127,8 +30491,6 @@ 44072 break; 44073 44074 case 1646: 44075- 44076-/* Line 1455 of yacc.c */ 44077 #line 10552 "gram.y" 44078 { 44079 (yyval.target) = makeNode(ResTarget); 44080@@ -33140,8 +30502,6 @@ 44081 break; 44082 44083 case 1647: 44084- 44085-/* Line 1455 of yacc.c */ 44086 #line 10560 "gram.y" 44087 { 44088 (yyval.target) = makeNode(ResTarget); 44089@@ -33153,8 +30513,6 @@ 44090 break; 44091 44092 case 1648: 44093- 44094-/* Line 1455 of yacc.c */ 44095 #line 10568 "gram.y" 44096 { 44097 ColumnRef *n = makeNode(ColumnRef); 44098@@ -33170,22 +30528,16 @@ 44099 break; 44100 44101 case 1649: 44102- 44103-/* Line 1455 of yacc.c */ 44104 #line 10589 "gram.y" 44105 { (yyval.list) = list_make1((yyvsp[(1) - (1)].range)); ;} 44106 break; 44107 44108 case 1650: 44109- 44110-/* Line 1455 of yacc.c */ 44111 #line 10590 "gram.y" 44112 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].range)); ;} 44113 break; 44114 44115 case 1651: 44116- 44117-/* Line 1455 of yacc.c */ 44118 #line 10602 "gram.y" 44119 { 44120 (yyval.range) = makeNode(RangeVar); 44121@@ -33197,8 +30549,6 @@ 44122 break; 44123 44124 case 1652: 44125- 44126-/* Line 1455 of yacc.c */ 44127 #line 10610 "gram.y" 44128 { 44129 check_qualified_name((yyvsp[(2) - (2)].list), yyscanner); 44130@@ -33228,71 +30578,51 @@ 44131 break; 44132 44133 case 1653: 44134- 44135-/* Line 1455 of yacc.c */ 44136 #line 10638 "gram.y" 44137 { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} 44138 break; 44139 44140 case 1654: 44141- 44142-/* Line 1455 of yacc.c */ 44143 #line 10640 "gram.y" 44144 { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;} 44145 break; 44146 44147 case 1655: 44148- 44149-/* Line 1455 of yacc.c */ 44150 #line 10644 "gram.y" 44151 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 44152 break; 44153 44154 case 1656: 44155- 44156-/* Line 1455 of yacc.c */ 44157 #line 10647 "gram.y" 44158 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 44159 break; 44160 44161 case 1657: 44162- 44163-/* Line 1455 of yacc.c */ 44164 #line 10650 "gram.y" 44165 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 44166 break; 44167 44168 case 1658: 44169- 44170-/* Line 1455 of yacc.c */ 44171 #line 10652 "gram.y" 44172 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 44173 break; 44174 44175 case 1659: 44176- 44177-/* Line 1455 of yacc.c */ 44178 #line 10654 "gram.y" 44179 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 44180 break; 44181 44182 case 1660: 44183- 44184-/* Line 1455 of yacc.c */ 44185 #line 10656 "gram.y" 44186 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 44187 break; 44188 44189 case 1661: 44190- 44191-/* Line 1455 of yacc.c */ 44192 #line 10667 "gram.y" 44193 { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} 44194 break; 44195 44196 case 1662: 44197- 44198-/* Line 1455 of yacc.c */ 44199 #line 10669 "gram.y" 44200 { 44201 (yyval.list) = check_func_name(lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)), 44202@@ -33301,8 +30631,6 @@ 44203 break; 44204 44205 case 1663: 44206- 44207-/* Line 1455 of yacc.c */ 44208 #line 10680 "gram.y" 44209 { 44210 (yyval.node) = makeIntConst((yyvsp[(1) - (1)].ival), (yylsp[(1) - (1)])); 44211@@ -33310,8 +30638,6 @@ 44212 break; 44213 44214 case 1664: 44215- 44216-/* Line 1455 of yacc.c */ 44217 #line 10684 "gram.y" 44218 { 44219 (yyval.node) = makeFloatConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); 44220@@ -33319,8 +30645,6 @@ 44221 break; 44222 44223 case 1665: 44224- 44225-/* Line 1455 of yacc.c */ 44226 #line 10688 "gram.y" 44227 { 44228 (yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); 44229@@ -33328,8 +30652,6 @@ 44230 break; 44231 44232 case 1666: 44233- 44234-/* Line 1455 of yacc.c */ 44235 #line 10692 "gram.y" 44236 { 44237 (yyval.node) = makeBitStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); 44238@@ -33337,8 +30659,6 @@ 44239 break; 44240 44241 case 1667: 44242- 44243-/* Line 1455 of yacc.c */ 44244 #line 10696 "gram.y" 44245 { 44246 /* This is a bit constant per SQL99: 44247@@ -33351,8 +30671,6 @@ 44248 break; 44249 44250 case 1668: 44251- 44252-/* Line 1455 of yacc.c */ 44253 #line 10705 "gram.y" 44254 { 44255 /* generic type 'literal' syntax */ 44256@@ -33363,8 +30681,6 @@ 44257 break; 44258 44259 case 1669: 44260- 44261-/* Line 1455 of yacc.c */ 44262 #line 10712 "gram.y" 44263 { 44264 /* generic syntax with a type modifier */ 44265@@ -33393,8 +30709,6 @@ 44266 break; 44267 44268 case 1670: 44269- 44270-/* Line 1455 of yacc.c */ 44271 #line 10737 "gram.y" 44272 { 44273 (yyval.node) = makeStringConstCast((yyvsp[(2) - (2)].str), (yylsp[(2) - (2)]), (yyvsp[(1) - (2)].typnam)); 44274@@ -33402,8 +30716,6 @@ 44275 break; 44276 44277 case 1671: 44278- 44279-/* Line 1455 of yacc.c */ 44280 #line 10741 "gram.y" 44281 { 44282 TypeName *t = (yyvsp[(1) - (3)].typnam); 44283@@ -33413,8 +30725,6 @@ 44284 break; 44285 44286 case 1672: 44287- 44288-/* Line 1455 of yacc.c */ 44289 #line 10747 "gram.y" 44290 { 44291 TypeName *t = (yyvsp[(1) - (6)].typnam); 44292@@ -33435,8 +30745,6 @@ 44293 break; 44294 44295 case 1673: 44296- 44297-/* Line 1455 of yacc.c */ 44298 #line 10764 "gram.y" 44299 { 44300 (yyval.node) = makeBoolAConst(TRUE, (yylsp[(1) - (1)])); 44301@@ -33444,8 +30752,6 @@ 44302 break; 44303 44304 case 1674: 44305- 44306-/* Line 1455 of yacc.c */ 44307 #line 10768 "gram.y" 44308 { 44309 (yyval.node) = makeBoolAConst(FALSE, (yylsp[(1) - (1)])); 44310@@ -33453,8 +30759,6 @@ 44311 break; 44312 44313 case 1675: 44314- 44315-/* Line 1455 of yacc.c */ 44316 #line 10772 "gram.y" 44317 { 44318 (yyval.node) = makeNullAConst((yylsp[(1) - (1)])); 44319@@ -33462,128 +30766,93 @@ 44320 break; 44321 44322 case 1676: 44323- 44324-/* Line 1455 of yacc.c */ 44325 #line 10777 "gram.y" 44326 { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;} 44327 break; 44328 44329 case 1677: 44330- 44331-/* Line 1455 of yacc.c */ 44332 #line 10778 "gram.y" 44333 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 44334 break; 44335 44336 case 1678: 44337- 44338-/* Line 1455 of yacc.c */ 44339 #line 10779 "gram.y" 44340 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 44341 break; 44342 44343 case 1679: 44344- 44345-/* Line 1455 of yacc.c */ 44346 #line 10781 "gram.y" 44347 { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;} 44348 break; 44349 44350 case 1680: 44351- 44352-/* Line 1455 of yacc.c */ 44353 #line 10782 "gram.y" 44354 { (yyval.ival) = + (yyvsp[(2) - (2)].ival); ;} 44355 break; 44356 44357 case 1681: 44358- 44359-/* Line 1455 of yacc.c */ 44360 #line 10783 "gram.y" 44361 { (yyval.ival) = - (yyvsp[(2) - (2)].ival); ;} 44362 break; 44363 44364 case 1682: 44365- 44366-/* Line 1455 of yacc.c */ 44367 #line 10799 "gram.y" 44368 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 44369 break; 44370 44371 case 1683: 44372- 44373-/* Line 1455 of yacc.c */ 44374 #line 10800 "gram.y" 44375 { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} 44376 break; 44377 44378 case 1684: 44379- 44380-/* Line 1455 of yacc.c */ 44381 #line 10801 "gram.y" 44382 { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} 44383 break; 44384 44385 case 1685: 44386- 44387-/* Line 1455 of yacc.c */ 44388 #line 10806 "gram.y" 44389 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 44390 break; 44391 44392 case 1686: 44393- 44394-/* Line 1455 of yacc.c */ 44395 #line 10807 "gram.y" 44396 { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} 44397 break; 44398 44399 case 1687: 44400- 44401-/* Line 1455 of yacc.c */ 44402 #line 10808 "gram.y" 44403 { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} 44404 break; 44405 44406 case 1688: 44407- 44408-/* Line 1455 of yacc.c */ 44409 #line 10814 "gram.y" 44410 { (yyval.str) = (yyvsp[(1) - (1)].str); ;} 44411 break; 44412 44413 case 1689: 44414- 44415-/* Line 1455 of yacc.c */ 44416 #line 10815 "gram.y" 44417 { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} 44418 break; 44419 44420 case 1690: 44421- 44422-/* Line 1455 of yacc.c */ 44423 #line 10816 "gram.y" 44424 { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} 44425 break; 44426 44427 case 1691: 44428- 44429-/* Line 1455 of yacc.c */ 44430 #line 10817 "gram.y" 44431 { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} 44432 break; 44433 44434 case 1692: 44435- 44436-/* Line 1455 of yacc.c */ 44437 #line 10818 "gram.y" 44438 { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} 44439 break; 44440 44441 44442- 44443-/* Line 1455 of yacc.c */ 44444-#line 33587 "gram.c" 44445+/* Line 1267 of yacc.c. */ 44446+#line 30856 "gram" 44447 default: break; 44448 } 44449 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 44450@@ -33659,7 +30928,7 @@ 44451 44452 if (yyerrstatus == 3) 44453 { 44454- /* If just tried and failed to reuse lookahead token after an 44455+ /* If just tried and failed to reuse look-ahead token after an 44456 error, discard it. */ 44457 44458 if (yychar <= YYEOF) 44459@@ -33676,7 +30945,7 @@ 44460 } 44461 } 44462 44463- /* Else will try to reuse lookahead token after shifting the error 44464+ /* Else will try to reuse look-ahead token after shifting the error 44465 token. */ 44466 goto yyerrlab1; 44467 44468@@ -33734,11 +31003,14 @@ 44469 YY_STACK_PRINT (yyss, yyssp); 44470 } 44471 44472+ if (yyn == YYFINAL) 44473+ YYACCEPT; 44474+ 44475 *++yyvsp = yylval; 44476 44477 yyerror_range[1] = yylloc; 44478 /* Using YYLLOC is tempting, but would change the location of 44479- the lookahead. YYLOC is available though. */ 44480+ the look-ahead. YYLOC is available though. */ 44481 YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2); 44482 *++yylsp = yyloc; 44483 44484@@ -33763,7 +31035,7 @@ 44485 yyresult = 1; 44486 goto yyreturn; 44487 44488-#if !defined(yyoverflow) || YYERROR_VERBOSE 44489+#ifndef yyoverflow 44490 /*-------------------------------------------------. 44491 | yyexhaustedlab -- memory exhaustion comes here. | 44492 `-------------------------------------------------*/ 44493@@ -33774,7 +31046,7 @@ 44494 #endif 44495 44496 yyreturn: 44497- if (yychar != YYEMPTY) 44498+ if (yychar != YYEOF && yychar != YYEMPTY) 44499 yydestruct ("Cleanup: discarding lookahead", 44500 yytoken, &yylval, &yylloc, yyscanner); 44501 /* Do not reclaim the symbols of the rule which action triggered 44502@@ -33800,8 +31072,6 @@ 44503 } 44504 44505 44506- 44507-/* Line 1675 of yacc.c */ 44508 #line 11270 "gram.y" 44509 44510 44511--- postgresql-9.0.12/src/backend/parser/gram.h 2013-02-04 13:44:21.000000000 -0800 44512+++ postgresql/src/backend/parser/gram.h 2013-03-19 20:10:04.000000000 -0700 44513@@ -1,23 +1,24 @@ 44514- 44515-/* A Bison parser, made by GNU Bison 2.4.1. */ 44516+/* A Bison parser, made by GNU Bison 2.3. */ 44517 44518 /* Skeleton interface for Bison's Yacc-like parsers in C 44519- 44520- Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 44521+ 44522+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 44523 Free Software Foundation, Inc. 44524- 44525- This program is free software: you can redistribute it and/or modify 44526+ 44527+ This program is free software; you can redistribute it and/or modify 44528 it under the terms of the GNU General Public License as published by 44529- the Free Software Foundation, either version 3 of the License, or 44530- (at your option) any later version. 44531- 44532+ the Free Software Foundation; either version 2, or (at your option) 44533+ any later version. 44534+ 44535 This program is distributed in the hope that it will be useful, 44536 but WITHOUT ANY WARRANTY; without even the implied warranty of 44537 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 44538 GNU General Public License for more details. 44539- 44540+ 44541 You should have received a copy of the GNU General Public License 44542- along with this program. If not, see <http://www.gnu.org/licenses/>. */ 44543+ along with this program; if not, write to the Free Software 44544+ Foundation, Inc., 51 Franklin Street, Fifth Floor, 44545+ Boston, MA 02110-1301, USA. */ 44546 44547 /* As a special exception, you may create a larger work that contains 44548 part or all of the Bison parser skeleton and distribute that work 44549@@ -28,11 +29,10 @@ 44550 special exception, which will cause the skeleton and the resulting 44551 Bison output files to be licensed under the GNU General Public 44552 License without this special exception. 44553- 44554+ 44555 This special exception was added by the Free Software Foundation in 44556 version 2.2 of Bison. */ 44557 44558- 44559 /* Tokens. */ 44560 #ifndef YYTOKENTYPE 44561 # define YYTOKENTYPE 44562@@ -452,16 +452,426 @@ 44563 UMINUS = 668 44564 }; 44565 #endif 44566+/* Tokens. */ 44567+#define IDENT 258 44568+#define FCONST 259 44569+#define SCONST 260 44570+#define BCONST 261 44571+#define XCONST 262 44572+#define Op 263 44573+#define ICONST 264 44574+#define PARAM 265 44575+#define TYPECAST 266 44576+#define DOT_DOT 267 44577+#define COLON_EQUALS 268 44578+#define ABORT_P 269 44579+#define ABSOLUTE_P 270 44580+#define ACCESS 271 44581+#define ACTION 272 44582+#define ADD_P 273 44583+#define ADMIN 274 44584+#define AFTER 275 44585+#define AGGREGATE 276 44586+#define ALL 277 44587+#define ALSO 278 44588+#define ALTER 279 44589+#define ALWAYS 280 44590+#define ANALYSE 281 44591+#define ANALYZE 282 44592+#define AND 283 44593+#define ANY 284 44594+#define ARRAY 285 44595+#define AS 286 44596+#define ASC 287 44597+#define ASSERTION 288 44598+#define ASSIGNMENT 289 44599+#define ASYMMETRIC 290 44600+#define AT 291 44601+#define AUTHORIZATION 292 44602+#define BACKWARD 293 44603+#define BEFORE 294 44604+#define BEGIN_P 295 44605+#define BETWEEN 296 44606+#define BIGINT 297 44607+#define BINARY 298 44608+#define BIT 299 44609+#define BOOLEAN_P 300 44610+#define BOTH 301 44611+#define BY 302 44612+#define CACHE 303 44613+#define CALLED 304 44614+#define CASCADE 305 44615+#define CASCADED 306 44616+#define CASE 307 44617+#define CAST 308 44618+#define CATALOG_P 309 44619+#define CHAIN 310 44620+#define CHAR_P 311 44621+#define CHARACTER 312 44622+#define CHARACTERISTICS 313 44623+#define CHECK 314 44624+#define CHECKPOINT 315 44625+#define CLASS 316 44626+#define CLOSE 317 44627+#define CLUSTER 318 44628+#define COALESCE 319 44629+#define COLLATE 320 44630+#define COLUMN 321 44631+#define COMMENT 322 44632+#define COMMENTS 323 44633+#define COMMIT 324 44634+#define COMMITTED 325 44635+#define CONCURRENTLY 326 44636+#define CONFIGURATION 327 44637+#define CONNECTION 328 44638+#define CONSTRAINT 329 44639+#define CONSTRAINTS 330 44640+#define CONTENT_P 331 44641+#define CONTINUE_P 332 44642+#define CONVERSION_P 333 44643+#define COPY 334 44644+#define COST 335 44645+#define CREATE 336 44646+#define CREATEDB 337 44647+#define CREATEROLE 338 44648+#define CREATEUSER 339 44649+#define CROSS 340 44650+#define CSV 341 44651+#define CURRENT_P 342 44652+#define CURRENT_CATALOG 343 44653+#define CURRENT_DATE 344 44654+#define CURRENT_ROLE 345 44655+#define CURRENT_SCHEMA 346 44656+#define CURRENT_TIME 347 44657+#define CURRENT_TIMESTAMP 348 44658+#define CURRENT_USER 349 44659+#define CURSOR 350 44660+#define CYCLE 351 44661+#define DATA_P 352 44662+#define DATABASE 353 44663+#define DAY_P 354 44664+#define DEALLOCATE 355 44665+#define DEC 356 44666+#define DECIMAL_P 357 44667+#define DECLARE 358 44668+#define DEFAULT 359 44669+#define DEFAULTS 360 44670+#define DEFERRABLE 361 44671+#define DEFERRED 362 44672+#define DEFINER 363 44673+#define DELETE_P 364 44674+#define DELIMITER 365 44675+#define DELIMITERS 366 44676+#define DESC 367 44677+#define DICTIONARY 368 44678+#define DISABLE_P 369 44679+#define DISCARD 370 44680+#define DISTINCT 371 44681+#define DO 372 44682+#define DOCUMENT_P 373 44683+#define DOMAIN_P 374 44684+#define DOUBLE_P 375 44685+#define DROP 376 44686+#define EACH 377 44687+#define ELSE 378 44688+#define ENABLE_P 379 44689+#define ENCODING 380 44690+#define ENCRYPTED 381 44691+#define END_P 382 44692+#define ENUM_P 383 44693+#define ESCAPE 384 44694+#define EXCEPT 385 44695+#define EXCLUDE 386 44696+#define EXCLUDING 387 44697+#define EXCLUSIVE 388 44698+#define EXECUTE 389 44699+#define EXISTS 390 44700+#define EXPLAIN 391 44701+#define EXTERNAL 392 44702+#define EXTRACT 393 44703+#define FALSE_P 394 44704+#define FAMILY 395 44705+#define FETCH 396 44706+#define FIRST_P 397 44707+#define FLOAT_P 398 44708+#define FOLLOWING 399 44709+#define FOR 400 44710+#define FORCE 401 44711+#define FOREIGN 402 44712+#define FORWARD 403 44713+#define FREEZE 404 44714+#define FROM 405 44715+#define FULL 406 44716+#define FUNCTION 407 44717+#define FUNCTIONS 408 44718+#define GLOBAL 409 44719+#define GRANT 410 44720+#define GRANTED 411 44721+#define GREATEST 412 44722+#define GROUP_P 413 44723+#define HANDLER 414 44724+#define HAVING 415 44725+#define HEADER_P 416 44726+#define HOLD 417 44727+#define HOUR_P 418 44728+#define IDENTITY_P 419 44729+#define IF_P 420 44730+#define ILIKE 421 44731+#define IMMEDIATE 422 44732+#define IMMUTABLE 423 44733+#define IMPLICIT_P 424 44734+#define IN_P 425 44735+#define INCLUDING 426 44736+#define INCREMENT 427 44737+#define INDEX 428 44738+#define INDEXES 429 44739+#define INHERIT 430 44740+#define INHERITS 431 44741+#define INITIALLY 432 44742+#define INLINE_P 433 44743+#define INNER_P 434 44744+#define INOUT 435 44745+#define INPUT_P 436 44746+#define INSENSITIVE 437 44747+#define INSERT 438 44748+#define INSTEAD 439 44749+#define INT_P 440 44750+#define INTEGER 441 44751+#define INTERSECT 442 44752+#define INTERVAL 443 44753+#define INTO 444 44754+#define INVOKER 445 44755+#define IS 446 44756+#define ISNULL 447 44757+#define ISOLATION 448 44758+#define JOIN 449 44759+#define KEY 450 44760+#define LANGUAGE 451 44761+#define LARGE_P 452 44762+#define LAST_P 453 44763+#define LC_COLLATE_P 454 44764+#define LC_CTYPE_P 455 44765+#define LEADING 456 44766+#define LEAST 457 44767+#define LEFT 458 44768+#define LEVEL 459 44769+#define LIKE 460 44770+#define LIMIT 461 44771+#define LISTEN 462 44772+#define LOAD 463 44773+#define LOCAL 464 44774+#define LOCALTIME 465 44775+#define LOCALTIMESTAMP 466 44776+#define LOCATION 467 44777+#define LOCK_P 468 44778+#define LOGIN_P 469 44779+#define MAPPING 470 44780+#define MATCH 471 44781+#define MAXVALUE 472 44782+#define MINUTE_P 473 44783+#define MINVALUE 474 44784+#define MODE 475 44785+#define MONTH_P 476 44786+#define MOVE 477 44787+#define NAME_P 478 44788+#define NAMES 479 44789+#define NATIONAL 480 44790+#define NATURAL 481 44791+#define NCHAR 482 44792+#define NEXT 483 44793+#define NO 484 44794+#define NOCREATEDB 485 44795+#define NOCREATEROLE 486 44796+#define NOCREATEUSER 487 44797+#define NOINHERIT 488 44798+#define NOLOGIN_P 489 44799+#define NONE 490 44800+#define NOSUPERUSER 491 44801+#define NOT 492 44802+#define NOTHING 493 44803+#define NOTIFY 494 44804+#define NOTNULL 495 44805+#define NOWAIT 496 44806+#define NULL_P 497 44807+#define NULLIF 498 44808+#define NULLS_P 499 44809+#define NUMERIC 500 44810+#define OBJECT_P 501 44811+#define OF 502 44812+#define OFF 503 44813+#define OFFSET 504 44814+#define OIDS 505 44815+#define ON 506 44816+#define ONLY 507 44817+#define OPERATOR 508 44818+#define OPTION 509 44819+#define OPTIONS 510 44820+#define OR 511 44821+#define ORDER 512 44822+#define OUT_P 513 44823+#define OUTER_P 514 44824+#define OVER 515 44825+#define OVERLAPS 516 44826+#define OVERLAY 517 44827+#define OWNED 518 44828+#define OWNER 519 44829+#define PARSER 520 44830+#define PARTIAL 521 44831+#define PARTITION 522 44832+#define PASSWORD 523 44833+#define PLACING 524 44834+#define PLANS 525 44835+#define POSITION 526 44836+#define PRECEDING 527 44837+#define PRECISION 528 44838+#define PRESERVE 529 44839+#define PREPARE 530 44840+#define PREPARED 531 44841+#define PRIMARY 532 44842+#define PRIOR 533 44843+#define PRIVILEGES 534 44844+#define PROCEDURAL 535 44845+#define PROCEDURE 536 44846+#define QUOTE 537 44847+#define RANGE 538 44848+#define READ 539 44849+#define REAL 540 44850+#define REASSIGN 541 44851+#define RECHECK 542 44852+#define RECURSIVE 543 44853+#define REFERENCES 544 44854+#define REINDEX 545 44855+#define RELATIVE_P 546 44856+#define RELEASE 547 44857+#define RENAME 548 44858+#define REPEATABLE 549 44859+#define REPLACE 550 44860+#define REPLICA 551 44861+#define RESET 552 44862+#define RESTART 553 44863+#define RESTRICT 554 44864+#define RETURNING 555 44865+#define RETURNS 556 44866+#define REVOKE 557 44867+#define RIGHT 558 44868+#define ROLE 559 44869+#define ROLLBACK 560 44870+#define ROW 561 44871+#define ROWS 562 44872+#define RULE 563 44873+#define SAVEPOINT 564 44874+#define SCHEMA 565 44875+#define SCROLL 566 44876+#define SEARCH 567 44877+#define SECOND_P 568 44878+#define SECURITY 569 44879+#define SELECT 570 44880+#define SEQUENCE 571 44881+#define SEQUENCES 572 44882+#define SERIALIZABLE 573 44883+#define SERVER 574 44884+#define SESSION 575 44885+#define SESSION_USER 576 44886+#define SET 577 44887+#define SETOF 578 44888+#define SHARE 579 44889+#define SHOW 580 44890+#define SIMILAR 581 44891+#define SIMPLE 582 44892+#define SMALLINT 583 44893+#define SOME 584 44894+#define STABLE 585 44895+#define STANDALONE_P 586 44896+#define START 587 44897+#define STATEMENT 588 44898+#define STATISTICS 589 44899+#define STDIN 590 44900+#define STDOUT 591 44901+#define STORAGE 592 44902+#define STRICT_P 593 44903+#define STRIP_P 594 44904+#define SUBSTRING 595 44905+#define SUPERUSER_P 596 44906+#define SYMMETRIC 597 44907+#define SYSID 598 44908+#define SYSTEM_P 599 44909+#define TABLE 600 44910+#define TABLES 601 44911+#define TABLESPACE 602 44912+#define TEMP 603 44913+#define TEMPLATE 604 44914+#define TEMPORARY 605 44915+#define TEXT_P 606 44916+#define THEN 607 44917+#define TIME 608 44918+#define TIMESTAMP 609 44919+#define TO 610 44920+#define TRAILING 611 44921+#define TRANSACTION 612 44922+#define TREAT 613 44923+#define TRIGGER 614 44924+#define TRIM 615 44925+#define TRUE_P 616 44926+#define TRUNCATE 617 44927+#define TRUSTED 618 44928+#define TYPE_P 619 44929+#define UNBOUNDED 620 44930+#define UNCOMMITTED 621 44931+#define UNENCRYPTED 622 44932+#define UNION 623 44933+#define UNIQUE 624 44934+#define UNKNOWN 625 44935+#define UNLISTEN 626 44936+#define UNTIL 627 44937+#define UPDATE 628 44938+#define USER 629 44939+#define USING 630 44940+#define VACUUM 631 44941+#define VALID 632 44942+#define VALIDATOR 633 44943+#define VALUE_P 634 44944+#define VALUES 635 44945+#define VARCHAR 636 44946+#define VARIADIC 637 44947+#define VARYING 638 44948+#define VERBOSE 639 44949+#define VERSION_P 640 44950+#define VIEW 641 44951+#define VOLATILE 642 44952+#define WHEN 643 44953+#define WHERE 644 44954+#define WHITESPACE_P 645 44955+#define WINDOW 646 44956+#define WITH 647 44957+#define WITHOUT 648 44958+#define WORK 649 44959+#define WRAPPER 650 44960+#define WRITE 651 44961+#define XML_P 652 44962+#define XMLATTRIBUTES 653 44963+#define XMLCONCAT 654 44964+#define XMLELEMENT 655 44965+#define XMLFOREST 656 44966+#define XMLPARSE 657 44967+#define XMLPI 658 44968+#define XMLROOT 659 44969+#define XMLSERIALIZE 660 44970+#define YEAR_P 661 44971+#define YES_P 662 44972+#define ZONE 663 44973+#define NULLS_FIRST 664 44974+#define NULLS_LAST 665 44975+#define WITH_TIME 666 44976+#define POSTFIXOP 667 44977+#define UMINUS 668 44978+ 44979 44980 44981 44982 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 44983 typedef union YYSTYPE 44984-{ 44985- 44986-/* Line 1676 of yacc.c */ 44987 #line 146 "gram.y" 44988- 44989+{ 44990 core_YYSTYPE core_yystype; 44991 /* these fields must match core_YYSTYPE: */ 44992 int ival; 44993@@ -496,15 +906,13 @@ 44994 AccessPriv *accesspriv; 44995 InsertStmt *istmt; 44996 VariableSetStmt *vsetstmt; 44997- 44998- 44999- 45000-/* Line 1676 of yacc.c */ 45001-#line 504 "gram.h" 45002-} YYSTYPE; 45003-# define YYSTYPE_IS_TRIVIAL 1 45004+} 45005+/* Line 1529 of yacc.c. */ 45006+#line 912 "gram.h" 45007+ YYSTYPE; 45008 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 45009 # define YYSTYPE_IS_DECLARED 1 45010+# define YYSTYPE_IS_TRIVIAL 1 45011 #endif 45012 45013 45014@@ -523,4 +931,3 @@ 45015 #endif 45016 45017 45018- 45019