~ubuntu-branches/ubuntu/saucy/postgresql-8.4/saucy

« back to all changes in this revision

Viewing changes to src/interfaces/ecpg/preproc/preproc.c

  • Committer: Package Import Robot
  • Author(s): Martin Pitt
  • Date: 2011-12-02 14:46:33 UTC
  • mfrom: (13.1.8 sid)
  • Revision ID: package-import@ubuntu.com-20111202144633-azdcoyqh7sduwr15
Tags: 8.4.10-1
* New upstream bug fix release:
  - Fix bugs in information_schema.referential_constraints view.
    This view was being insufficiently careful about matching the
    foreign-key constraint to the depended-on primary or unique key
    constraint. That could result in failure to show a foreign key
    constraint at all, or showing it multiple times, or claiming that
    it depends on a different constraint than the one it really does.
    Since the view definition is installed by initdb, merely upgrading
    will not fix the problem. If you need to fix this in an existing
    installation, you can (as a superuser) drop the information_schema
    schema then re-create it by sourcing
    "SHAREDIR/information_schema.sql". (Run pg_config --sharedir if
    you're uncertain where "SHAREDIR" is.) This must be repeated in
    each database to be fixed.
  - Fix incorrect replay of WAL records for GIN index updates.
    This could result in transiently failing to find index entries
    after a crash, or on a hot-standby server. The problem would be
    repaired by the next "VACUUM" of the index, however.
  - Fix TOAST-related data corruption during CREATE TABLE dest AS
    SELECT - FROM src or INSERT INTO dest SELECT * FROM src.
    If a table has been modified by "ALTER TABLE ADD COLUMN", attempts
    to copy its data verbatim to another table could produce corrupt
    results in certain corner cases. The problem can only manifest in
    this precise form in 8.4 and later, but we patched earlier versions
    as well in case there are other code paths that could trigger the
    same bug.
  - Fix race condition during toast table access from stale syscache
    entries.
  - Track dependencies of functions on items used in parameter default
    expressions. Previously, a referenced object could be dropped without
    having dropped or modified the function, leading to misbehavior when the
    function was used. Note that merely installing this update will not fix
    the missing dependency entries; to do that, you'd need to "CREATE OR
    REPLACE" each such function afterwards. If you have functions whose
    defaults depend on non-built-in objects, doing so is recommended.
  - Allow inlining of set-returning SQL functions with multiple OUT
    parameters.
  - Make DatumGetInetP() unpack inet datums that have a 1-byte header,
    and add a new macro, DatumGetInetPP(), that does not.
  - Improve locale support in money type's input and output.
    Aside from not supporting all standard lc_monetary formatting
    options, the input and output functions were inconsistent, meaning
    there were locales in which dumped money values could not be
    re-read.
  - Don't let transform_null_equals affect CASE foo WHEN NULL ...
    constructs. transform_null_equals is only supposed to affect foo = NULL
    expressions written directly by the user, not equality checks
    generated internally by this form of CASE.
  - Change foreign-key trigger creation order to better support
    self-referential foreign keys. For a cascading foreign key that
    references its own table, a row update will fire both the ON UPDATE
    trigger and the CHECK trigger as one event. The ON UPDATE trigger must
    execute first, else the CHECK will check a non-final state of the row
    and possibly throw an inappropriate error. However, the firing order of
    these triggers is determined by their names, which generally sort in
    creation order since the triggers have auto-generated names following
    the convention "RI_ConstraintTrigger_NNNN". A proper fix would require
    modifying that convention, which we will do in 9.2, but it seems risky
    to change it in existing releases. So this patch just changes the
    creation order of the triggers. Users encountering this type of error
    should drop and re-create the foreign key constraint to get its triggers
    into the right order.
  - Avoid floating-point underflow while tracking buffer allocation
    rate.
  - Preserve blank lines within commands in psql's command history.
    The former behavior could cause problems if an empty line was
    removed from within a string literal, for example.
  - Fix pg_dump to dump user-defined casts between auto-generated
    types, such as table rowtypes.
  - Use the preferred version of xsubpp to build PL/Perl, not
    necessarily the operating system's main copy.
  - Fix incorrect coding in "contrib/dict_int" and "contrib/dict_xsyn".
  - Honor query cancel interrupts promptly in pgstatindex().
  - Ensure VPATH builds properly install all server header files.
  - Shorten file names reported in verbose error messages.
    Regular builds have always reported just the name of the C file
    containing the error message call, but VPATH builds formerly
    reported an absolute path name.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* A Bison parser, made by GNU Bison 1.875.  */
2
 
 
3
 
/* Skeleton parser for Yacc-like parsing with Bison,
4
 
   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
5
 
 
6
 
   This program is free software; you can redistribute it and/or modify
 
1
 
 
2
/* A Bison parser, made by GNU Bison 2.4.1.  */
 
3
 
 
4
/* Skeleton implementation for Bison's Yacc-like parsers in C
 
5
   
 
6
      Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
 
7
   Free Software Foundation, Inc.
 
8
   
 
9
   This program is free software: you can redistribute it and/or modify
7
10
   it under the terms of the GNU General Public License as published by
8
 
   the Free Software Foundation; either version 2, or (at your option)
9
 
   any later version.
10
 
 
 
11
   the Free Software Foundation, either version 3 of the License, or
 
12
   (at your option) any later version.
 
13
   
11
14
   This program is distributed in the hope that it will be useful,
12
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
17
   GNU General Public License for more details.
15
 
 
 
18
   
16
19
   You should have received a copy of the GNU General Public License
17
 
   along with this program; if not, write to the Free Software
18
 
   Foundation, Inc., 59 Temple Place - Suite 330,
19
 
   Boston, MA 02111-1307, USA.  */
20
 
 
21
 
/* As a special exception, when this file is copied by Bison into a
22
 
   Bison output file, you may use that output file without restriction.
23
 
   This special exception was added by the Free Software Foundation
24
 
   in version 1.24 of Bison.  */
25
 
 
26
 
/* Written by Richard Stallman by simplifying the original so called
27
 
   ``semantic'' parser.  */
 
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
21
 
 
22
/* As a special exception, you may create a larger work that contains
 
23
   part or all of the Bison parser skeleton and distribute that work
 
24
   under terms of your choice, so long as that work isn't itself a
 
25
   parser generator using the skeleton or a modified version thereof
 
26
   as a parser skeleton.  Alternatively, if you modify or redistribute
 
27
   the parser skeleton itself, you may (at your option) remove this
 
28
   special exception, which will cause the skeleton and the resulting
 
29
   Bison output files to be licensed under the GNU General Public
 
30
   License without this special exception.
 
31
   
 
32
   This special exception was added by the Free Software Foundation in
 
33
   version 2.2 of Bison.  */
 
34
 
 
35
/* C LALR(1) parser skeleton written by Richard Stallman, by
 
36
   simplifying the original so-called "semantic" parser.  */
28
37
 
29
38
/* All symbols defined below should begin with yy or YY, to avoid
30
39
   infringing on user name space.  This should be done even for local
36
45
/* Identify Bison output.  */
37
46
#define YYBISON 1
38
47
 
 
48
/* Bison version.  */
 
49
#define YYBISON_VERSION "2.4.1"
 
50
 
39
51
/* Skeleton name.  */
40
52
#define YYSKELETON_NAME "yacc.c"
41
53
 
42
54
/* Pure parsers.  */
43
55
#define YYPURE 0
44
56
 
 
57
/* Push parsers.  */
 
58
#define YYPUSH 0
 
59
 
 
60
/* Pull parsers.  */
 
61
#define YYPULL 1
 
62
 
45
63
/* Using locations.  */
46
64
#define YYLSP_NEEDED 1
47
65
 
48
 
/* If NAME_PREFIX is specified substitute the variables and functions
49
 
   names.  */
50
 
#define yyparse base_yyparse
51
 
#define yylex   base_yylex
52
 
#define yyerror base_yyerror
53
 
#define yylval  base_yylval
54
 
#define yychar  base_yychar
55
 
#define yydebug base_yydebug
56
 
#define yynerrs base_yynerrs
57
 
#define yylloc base_yylloc
 
66
/* Substitute the variable and function names.  */
 
67
#define yyparse         base_yyparse
 
68
#define yylex           base_yylex
 
69
#define yyerror         base_yyerror
 
70
#define yylval          base_yylval
 
71
#define yychar          base_yychar
 
72
#define yydebug         base_yydebug
 
73
#define yynerrs         base_yynerrs
 
74
#define yylloc          base_yylloc
 
75
 
 
76
/* Copy the first part of user declarations.  */
 
77
 
 
78
/* Line 189 of yacc.c  */
 
79
#line 5 "preproc.y"
 
80
 
 
81
#include "postgres_fe.h"
 
82
 
 
83
#include "extern.h"
 
84
#include <unistd.h>
 
85
 
 
86
/* Location tracking support --- simpler than bison's default */
 
87
#define YYLLOC_DEFAULT(Current, Rhs, N) \
 
88
        do { \
 
89
                if (N) \
 
90
                        (Current) = (Rhs)[1]; \
 
91
                else \
 
92
                        (Current) = (Rhs)[0]; \
 
93
        } while (0)
 
94
 
 
95
/*
 
96
 * The %name-prefix option below will make bison call base_yylex, but we
 
97
 * really want it to call filtered_base_yylex (see parser.c).
 
98
 */
 
99
#define base_yylex filtered_base_yylex
 
100
 
 
101
/*
 
102
 * This is only here so the string gets into the POT.  Bison uses it
 
103
 * internally.
 
104
 */
 
105
#define bison_gettext_dummy gettext_noop("syntax error")
 
106
 
 
107
/*
 
108
 * Variables containing simple states.
 
109
 */
 
110
int struct_level = 0;
 
111
int braces_open; /* brace level counter */
 
112
int ecpg_informix_var = 0;
 
113
char    *connection = NULL;
 
114
char    *input_filename = NULL;
 
115
 
 
116
static int      QueryIsRule = 0, FoundInto = 0;
 
117
static int      initializer = 0;
 
118
static int      pacounter = 1;
 
119
static char     pacounter_buffer[sizeof(int) * CHAR_BIT * 10 / 3]; /* a rough guess at the size we need */
 
120
static struct this_type actual_type[STRUCT_DEPTH];
 
121
static char *actual_startline[STRUCT_DEPTH];
 
122
 
 
123
/* temporarily store struct members while creating the data structure */
 
124
struct ECPGstruct_member *struct_member_list[STRUCT_DEPTH] = { NULL };
 
125
 
 
126
/* also store struct type so we can do a sizeof() later */
 
127
static char *ECPGstruct_sizeof = NULL;
 
128
 
 
129
/* for forward declarations we have to store some data as well */
 
130
static char *forward_name = NULL;
 
131
 
 
132
struct ECPGtype ecpg_no_indicator = {ECPGt_NO_INDICATOR, NULL, NULL, {NULL}, 0};
 
133
struct variable no_indicator = {"no_indicator", &ecpg_no_indicator, 0, NULL};
 
134
 
 
135
struct ECPGtype ecpg_query = {ECPGt_char_variable, NULL, NULL, {NULL}, 0};
 
136
 
 
137
/*
 
138
 * Handle parsing errors and warnings
 
139
 */
 
140
void
 
141
mmerror(int error_code, enum errortype type, const char *error, ...)
 
142
{
 
143
        va_list ap;
 
144
 
 
145
        /* internationalize the error message string */
 
146
        error = _(error);
 
147
 
 
148
        fprintf(stderr, "%s:%d: ", input_filename, yylineno);
 
149
 
 
150
        switch(type)
 
151
        {
 
152
                case ET_WARNING:
 
153
                        fprintf(stderr, _("WARNING: "));
 
154
                        break;
 
155
                case ET_ERROR:
 
156
                case ET_FATAL:
 
157
                        fprintf(stderr, _("ERROR: "));
 
158
                        break;
 
159
        }
 
160
 
 
161
        va_start(ap, error);
 
162
        vfprintf(stderr, error, ap);
 
163
        va_end(ap);
 
164
 
 
165
        fprintf(stderr, "\n");
 
166
 
 
167
        switch(type)
 
168
        {
 
169
                case ET_WARNING:
 
170
                        break;
 
171
                case ET_ERROR:
 
172
                        ret_value = error_code;
 
173
                        break;
 
174
                case ET_FATAL:
 
175
                        if (yyin)
 
176
                                fclose(yyin);
 
177
                        if (yyout)
 
178
                                fclose(yyout);
 
179
                        
 
180
                        if (strcmp(output_filename, "-") != 0 && unlink(output_filename) != 0)
 
181
                                fprintf(stderr, _("could not remove output file \"%s\"\n"), output_filename);
 
182
                        exit(error_code);
 
183
        }
 
184
}
 
185
 
 
186
/*
 
187
 * string concatenation
 
188
 */
 
189
 
 
190
static char *
 
191
cat2_str(char *str1, char *str2)
 
192
{
 
193
        char * res_str  = (char *)mm_alloc(strlen(str1) + strlen(str2) + 2);
 
194
 
 
195
        strcpy(res_str, str1);
 
196
        if (strlen(str1) != 0 && strlen(str2) != 0)
 
197
                strcat(res_str, " ");
 
198
        strcat(res_str, str2);
 
199
        free(str1);
 
200
        free(str2);
 
201
        return(res_str);
 
202
}
 
203
 
 
204
static char *
 
205
cat_str(int count, ...)
 
206
{
 
207
        va_list         args;
 
208
        int                     i;
 
209
        char            *res_str;
 
210
 
 
211
        va_start(args, count);
 
212
 
 
213
        res_str = va_arg(args, char *);
 
214
 
 
215
        /* now add all other strings */
 
216
        for (i = 1; i < count; i++)
 
217
                res_str = cat2_str(res_str, va_arg(args, char *));
 
218
 
 
219
        va_end(args);
 
220
 
 
221
        return(res_str);
 
222
}
 
223
 
 
224
char *
 
225
make_str(const char *str)
 
226
{
 
227
        char * res_str = (char *)mm_alloc(strlen(str) + 1);
 
228
 
 
229
        strcpy(res_str, str);
 
230
        return res_str;
 
231
}
 
232
 
 
233
static char *
 
234
make2_str(char *str1, char *str2)
 
235
{
 
236
        char * res_str  = (char *)mm_alloc(strlen(str1) + strlen(str2) + 1);
 
237
 
 
238
        strcpy(res_str, str1);
 
239
        strcat(res_str, str2);
 
240
        free(str1);
 
241
        free(str2);
 
242
        return(res_str);
 
243
}
 
244
 
 
245
static char *
 
246
make3_str(char *str1, char *str2, char *str3)
 
247
{
 
248
        char * res_str  = (char *)mm_alloc(strlen(str1) + strlen(str2) +strlen(str3) + 1);
 
249
 
 
250
        strcpy(res_str, str1);
 
251
        strcat(res_str, str2);
 
252
        strcat(res_str, str3);
 
253
        free(str1);
 
254
        free(str2);
 
255
        free(str3);
 
256
        return(res_str);
 
257
}
 
258
 
 
259
/* and the rest */
 
260
static char *
 
261
make_name(void)
 
262
{
 
263
        return mm_strdup(yytext);
 
264
}
 
265
 
 
266
static char *
 
267
create_questionmarks(char *name, bool array)
 
268
{
 
269
        struct variable *p = find_variable(name);
 
270
        int count;
 
271
        char *result = EMPTY;
 
272
 
 
273
        /* In case we have a struct, we have to print as many "?" as there are attributes in the struct
 
274
         * An array is only allowed together with an element argument
 
275
         * This is essantially only used for inserts, but using a struct as input parameter is an error anywhere else
 
276
         * so we don't have to worry here. */
 
277
 
 
278
        if (p->type->type == ECPGt_struct || (array && p->type->type == ECPGt_array && p->type->u.element->type == ECPGt_struct))
 
279
        {
 
280
                struct ECPGstruct_member *m;
 
281
 
 
282
                if (p->type->type == ECPGt_struct)
 
283
                        m = p->type->u.members;
 
284
                else
 
285
                        m = p->type->u.element->u.members;
 
286
 
 
287
                for (count = 0; m != NULL; m=m->next, count++);
 
288
        }
 
289
        else
 
290
                count = 1;
 
291
 
 
292
        for (; count > 0; count --)
 
293
        {
 
294
                sprintf(pacounter_buffer, "$%d", pacounter++);
 
295
                result = cat_str(3, result, mm_strdup(pacounter_buffer), make_str(" , "));
 
296
        }
 
297
 
 
298
        /* removed the trailing " ," */
 
299
 
 
300
        result[strlen(result)-3] = '\0';
 
301
        return(result);
 
302
}
 
303
 
 
304
static char *
 
305
adjust_informix(struct arguments *list)
 
306
{
 
307
        /* Informix accepts DECLARE with variables that are out of scope when OPEN is called.
 
308
         * for instance you can declare variables in a function, and then subsequently use them
 
309
         * {
 
310
         *      declare_vars();
 
311
         *      exec sql ... which uses vars declared in the above function
 
312
         *
 
313
         * This breaks standard and leads to some very dangerous programming.
 
314
         * Since they do, we have to work around and accept their syntax as well.
 
315
         * But we will do so ONLY in Informix mode.
 
316
         * We have to change the variables to our own struct and just store the pointer instead of the variable
 
317
         */
 
318
 
 
319
         struct arguments *ptr;
 
320
         char *result = make_str("");
 
321
 
 
322
         for (ptr = list; ptr != NULL; ptr = ptr->next)
 
323
         {
 
324
                char temp[20]; /* this should be sufficient unless you have 8 byte integers */
 
325
                char *original_var;
 
326
 
 
327
                /* change variable name to "ECPG_informix_get_var(<counter>)" */
 
328
                original_var = ptr->variable->name;
 
329
                sprintf(temp, "%d))", ecpg_informix_var);
 
330
 
 
331
                if ((ptr->variable->type->type != ECPGt_varchar && ptr->variable->type->type != ECPGt_char && ptr->variable->type->type != ECPGt_unsigned_char) && atoi(ptr->variable->type->size) > 1)
 
332
                {
 
333
                        ptr->variable = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->variable->type->u.element->type)), make_str(" *)(ECPG_informix_get_var("), mm_strdup(temp)), ECPGmake_array_type(ECPGmake_simple_type(ptr->variable->type->u.element->type, make_str("1"), ptr->variable->type->u.element->lineno), ptr->variable->type->size), 0);
 
334
                        sprintf(temp, "%d, (", ecpg_informix_var++);
 
335
                }
 
336
                else if ((ptr->variable->type->type == ECPGt_varchar || ptr->variable->type->type == ECPGt_char || ptr->variable->type->type == ECPGt_unsigned_char) && atoi(ptr->variable->type->size) > 1)
 
337
                {
 
338
                        ptr->variable = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->variable->type->type)), make_str(" *)(ECPG_informix_get_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->variable->type->type, ptr->variable->type->size, ptr->variable->type->lineno), 0);
 
339
                        sprintf(temp, "%d, (", ecpg_informix_var++);
 
340
                }
 
341
                else
 
342
                {
 
343
                        ptr->variable = new_variable(cat_str(4, make_str("*("), mm_strdup(ecpg_type_name(ptr->variable->type->type)), make_str(" *)(ECPG_informix_get_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->variable->type->type, ptr->variable->type->size, ptr->variable->type->lineno), 0);
 
344
                        sprintf(temp, "%d, &(", ecpg_informix_var++);
 
345
                }
 
346
 
 
347
                /* create call to "ECPG_informix_set_var(<counter>, <pointer>. <linen number>)" */
 
348
                result = cat_str(5, result, make_str("ECPG_informix_set_var("), mm_strdup(temp), mm_strdup(original_var), make_str("), __LINE__);\n"));
 
349
 
 
350
                /* now the indicator if there is one */
 
351
                if (ptr->indicator->type->type != ECPGt_NO_INDICATOR)
 
352
                {
 
353
                        /* change variable name to "ECPG_informix_get_var(<counter>)" */
 
354
                        original_var = ptr->indicator->name;
 
355
                        sprintf(temp, "%d))", ecpg_informix_var);
 
356
 
 
357
                        /* create call to "ECPG_informix_set_var(<counter>, <pointer>. <linen number>)" */
 
358
                        if (atoi(ptr->indicator->type->size) > 1)
 
359
                        {
 
360
                                ptr->indicator = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->indicator->type->type)), make_str(" *)(ECPG_informix_get_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->indicator->type->type, ptr->indicator->type->size, ptr->variable->type->lineno), 0);
 
361
                                sprintf(temp, "%d, (", ecpg_informix_var++);
 
362
                        }
 
363
                        else
 
364
                        {
 
365
                                ptr->indicator = new_variable(cat_str(4, make_str("*("), mm_strdup(ecpg_type_name(ptr->indicator->type->type)), make_str(" *)(ECPG_informix_get_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->indicator->type->type, ptr->indicator->type->size, ptr->variable->type->lineno), 0);
 
366
                                sprintf(temp, "%d, &(", ecpg_informix_var++);
 
367
                        }
 
368
                        result = cat_str(5, result, make_str("ECPG_informix_set_var("), mm_strdup(temp), mm_strdup(original_var), make_str("), __LINE__);\n"));
 
369
                }
 
370
         }
 
371
 
 
372
         return result;
 
373
}
 
374
 
 
375
static struct cursor *
 
376
add_additional_variables(char *name, bool insert)
 
377
{
 
378
        struct cursor *ptr;
 
379
        struct arguments *p;
 
380
 
 
381
        for (ptr = cur; ptr != NULL; ptr=ptr->next)
 
382
        {
 
383
                if (strcmp(ptr->name, name) == 0)
 
384
                        break;
 
385
        }
 
386
 
 
387
        if (ptr == NULL)
 
388
        {
 
389
                mmerror(PARSE_ERROR, ET_ERROR, "cursor \"%s\" does not exist", name);
 
390
                return NULL;
 
391
        }
 
392
 
 
393
        if (insert)
 
394
        {
 
395
                /* add all those input variables that were given earlier
 
396
                 * note that we have to append here but have to keep the existing order */
 
397
                for (p = ptr->argsinsert; p; p = p->next)
 
398
                        add_variable_to_tail(&argsinsert, p->variable, p->indicator);
 
399
        }
 
400
 
 
401
        /* add all those output variables that were given earlier */
 
402
        for (p = ptr->argsresult; p; p = p->next)
 
403
                add_variable_to_tail(&argsresult, p->variable, p->indicator);
 
404
 
 
405
        return ptr;
 
406
}
 
407
 
 
408
static void
 
409
add_typedef(char *name, char * dimension, char * length, enum ECPGttype type_enum, char *type_dimension, char *type_index, int initializer, int array)
 
410
{
 
411
        /* add entry to list */
 
412
        struct typedefs *ptr, *this;
 
413
 
 
414
        if ((type_enum == ECPGt_struct ||
 
415
             type_enum == ECPGt_union) &&
 
416
            initializer == 1)
 
417
                mmerror(PARSE_ERROR, ET_ERROR, "initializer not allowed in type definition");
 
418
        else
 
419
        {
 
420
                for (ptr = types; ptr != NULL; ptr = ptr->next)
 
421
                {
 
422
                        if (strcmp(name, ptr->name) == 0)
 
423
                                /* re-definition is a bug */
 
424
                                mmerror(PARSE_ERROR, ET_ERROR, "type \"%s\" is already defined", name);
 
425
                }
 
426
                adjust_array(type_enum, &dimension, &length, type_dimension, type_index, array, true);
 
427
 
 
428
                this = (struct typedefs *) mm_alloc(sizeof(struct typedefs));
 
429
 
 
430
                /* initial definition */
 
431
                this->next = types;
 
432
                this->name = name;
 
433
                this->brace_level = braces_open;
 
434
                this->type = (struct this_type *) mm_alloc(sizeof(struct this_type));
 
435
                this->type->type_enum = type_enum;
 
436
                this->type->type_str = mm_strdup(name);
 
437
                this->type->type_dimension = dimension; /* dimension of array */
 
438
                this->type->type_index = length;        /* length of string */
 
439
                this->type->type_sizeof = ECPGstruct_sizeof;
 
440
                this->struct_member_list = (type_enum == ECPGt_struct || type_enum == ECPGt_union) ?
 
441
                ECPGstruct_member_dup(struct_member_list[struct_level]) : NULL;
 
442
 
 
443
                if (type_enum != ECPGt_varchar &&
 
444
                        type_enum != ECPGt_char &&
 
445
                        type_enum != ECPGt_unsigned_char &&
 
446
                        atoi(this->type->type_index) >= 0)
 
447
                        mmerror(PARSE_ERROR, ET_ERROR, "multidimensional arrays for simple data types are not supported");
 
448
 
 
449
                types = this;
 
450
        }
 
451
}
 
452
 
 
453
 
 
454
/* Line 189 of yacc.c  */
 
455
#line 456 "preproc.c"
 
456
 
 
457
/* Enabling traces.  */
 
458
#ifndef YYDEBUG
 
459
# define YYDEBUG 0
 
460
#endif
 
461
 
 
462
/* Enabling verbose error messages.  */
 
463
#ifdef YYERROR_VERBOSE
 
464
# undef YYERROR_VERBOSE
 
465
# define YYERROR_VERBOSE 1
 
466
#else
 
467
# define YYERROR_VERBOSE 0
 
468
#endif
 
469
 
 
470
/* Enabling the token table.  */
 
471
#ifndef YYTOKEN_TABLE
 
472
# define YYTOKEN_TABLE 0
 
473
#endif
 
474
 
58
475
 
59
476
/* Tokens.  */
60
477
#ifndef YYTOKENTYPE
547
964
     UMINUS = 740
548
965
   };
549
966
#endif
550
 
#define SQL_ALLOCATE 258
551
 
#define SQL_AUTOCOMMIT 259
552
 
#define SQL_BOOL 260
553
 
#define SQL_BREAK 261
554
 
#define SQL_CALL 262
555
 
#define SQL_CARDINALITY 263
556
 
#define SQL_CONNECT 264
557
 
#define SQL_COUNT 265
558
 
#define SQL_DATETIME_INTERVAL_CODE 266
559
 
#define SQL_DATETIME_INTERVAL_PRECISION 267
560
 
#define SQL_DESCRIBE 268
561
 
#define SQL_DESCRIPTOR 269
562
 
#define SQL_DISCONNECT 270
563
 
#define SQL_FOUND 271
564
 
#define SQL_FREE 272
565
 
#define SQL_GET 273
566
 
#define SQL_GO 274
567
 
#define SQL_GOTO 275
568
 
#define SQL_IDENTIFIED 276
569
 
#define SQL_INDICATOR 277
570
 
#define SQL_KEY_MEMBER 278
571
 
#define SQL_LENGTH 279
572
 
#define SQL_LONG 280
573
 
#define SQL_NULLABLE 281
574
 
#define SQL_OCTET_LENGTH 282
575
 
#define SQL_OPEN 283
576
 
#define SQL_OUTPUT 284
577
 
#define SQL_REFERENCE 285
578
 
#define SQL_RETURNED_LENGTH 286
579
 
#define SQL_RETURNED_OCTET_LENGTH 287
580
 
#define SQL_SCALE 288
581
 
#define SQL_SECTION 289
582
 
#define SQL_SHORT 290
583
 
#define SQL_SIGNED 291
584
 
#define SQL_SQL 292
585
 
#define SQL_SQLERROR 293
586
 
#define SQL_SQLPRINT 294
587
 
#define SQL_SQLWARNING 295
588
 
#define SQL_START 296
589
 
#define SQL_STOP 297
590
 
#define SQL_STRUCT 298
591
 
#define SQL_UNSIGNED 299
592
 
#define SQL_VAR 300
593
 
#define SQL_WHENEVER 301
594
 
#define S_ADD 302
595
 
#define S_AND 303
596
 
#define S_ANYTHING 304
597
 
#define S_AUTO 305
598
 
#define S_CONST 306
599
 
#define S_DEC 307
600
 
#define S_DIV 308
601
 
#define S_DOTPOINT 309
602
 
#define S_EQUAL 310
603
 
#define S_EXTERN 311
604
 
#define S_INC 312
605
 
#define S_LSHIFT 313
606
 
#define S_MEMPOINT 314
607
 
#define S_MEMBER 315
608
 
#define S_MOD 316
609
 
#define S_MUL 317
610
 
#define S_NEQUAL 318
611
 
#define S_OR 319
612
 
#define S_REGISTER 320
613
 
#define S_RSHIFT 321
614
 
#define S_STATIC 322
615
 
#define S_SUB 323
616
 
#define S_VOLATILE 324
617
 
#define S_TYPEDEF 325
618
 
#define TYPECAST 326
619
 
#define CSTRING 327
620
 
#define CVARIABLE 328
621
 
#define CPP_LINE 329
622
 
#define IP 330
623
 
#define DOLCONST 331
624
 
#define ECONST 332
625
 
#define NCONST 333
626
 
#define UCONST 334
627
 
#define UIDENT 335
628
 
#define ABORT_P 336
629
 
#define ABSOLUTE_P 337
630
 
#define ACCESS 338
631
 
#define ACTION 339
632
 
#define ADD_P 340
633
 
#define ADMIN 341
634
 
#define AFTER 342
635
 
#define AGGREGATE 343
636
 
#define ALL 344
637
 
#define ALSO 345
638
 
#define ALTER 346
639
 
#define ALWAYS 347
640
 
#define ANALYSE 348
641
 
#define ANALYZE 349
642
 
#define AND 350
643
 
#define ANY 351
644
 
#define ARRAY 352
645
 
#define AS 353
646
 
#define ASC 354
647
 
#define ASSERTION 355
648
 
#define ASSIGNMENT 356
649
 
#define ASYMMETRIC 357
650
 
#define AT 358
651
 
#define AUTHORIZATION 359
652
 
#define BACKWARD 360
653
 
#define BEFORE 361
654
 
#define BEGIN_P 362
655
 
#define BETWEEN 363
656
 
#define BIGINT 364
657
 
#define BINARY 365
658
 
#define BIT 366
659
 
#define BOOLEAN_P 367
660
 
#define BOTH 368
661
 
#define BY 369
662
 
#define CACHE 370
663
 
#define CALLED 371
664
 
#define CASCADE 372
665
 
#define CASCADED 373
666
 
#define CASE 374
667
 
#define CAST 375
668
 
#define CATALOG_P 376
669
 
#define CHAIN 377
670
 
#define CHAR_P 378
671
 
#define CHARACTER 379
672
 
#define CHARACTERISTICS 380
673
 
#define CHECK 381
674
 
#define CHECKPOINT 382
675
 
#define CLASS 383
676
 
#define CLOSE 384
677
 
#define CLUSTER 385
678
 
#define COALESCE 386
679
 
#define COLLATE 387
680
 
#define COLUMN 388
681
 
#define COMMENT 389
682
 
#define COMMIT 390
683
 
#define COMMITTED 391
684
 
#define CONCURRENTLY 392
685
 
#define CONFIGURATION 393
686
 
#define CONNECTION 394
687
 
#define CONSTRAINT 395
688
 
#define CONSTRAINTS 396
689
 
#define CONTENT_P 397
690
 
#define CONTINUE_P 398
691
 
#define CONVERSION_P 399
692
 
#define COPY 400
693
 
#define COST 401
694
 
#define CREATE 402
695
 
#define CREATEDB 403
696
 
#define CREATEROLE 404
697
 
#define CREATEUSER 405
698
 
#define CROSS 406
699
 
#define CSV 407
700
 
#define CURRENT_P 408
701
 
#define CURRENT_CATALOG 409
702
 
#define CURRENT_DATE 410
703
 
#define CURRENT_ROLE 411
704
 
#define CURRENT_SCHEMA 412
705
 
#define CURRENT_TIME 413
706
 
#define CURRENT_TIMESTAMP 414
707
 
#define CURRENT_USER 415
708
 
#define CURSOR 416
709
 
#define CYCLE 417
710
 
#define DATA_P 418
711
 
#define DATABASE 419
712
 
#define DAY_P 420
713
 
#define DEALLOCATE 421
714
 
#define DEC 422
715
 
#define DECIMAL_P 423
716
 
#define DECLARE 424
717
 
#define DEFAULT 425
718
 
#define DEFAULTS 426
719
 
#define DEFERRABLE 427
720
 
#define DEFERRED 428
721
 
#define DEFINER 429
722
 
#define DELETE_P 430
723
 
#define DELIMITER 431
724
 
#define DELIMITERS 432
725
 
#define DESC 433
726
 
#define DICTIONARY 434
727
 
#define DISABLE_P 435
728
 
#define DISCARD 436
729
 
#define DISTINCT 437
730
 
#define DO 438
731
 
#define DOCUMENT_P 439
732
 
#define DOMAIN_P 440
733
 
#define DOUBLE_P 441
734
 
#define DROP 442
735
 
#define EACH 443
736
 
#define ELSE 444
737
 
#define ENABLE_P 445
738
 
#define ENCODING 446
739
 
#define ENCRYPTED 447
740
 
#define END_P 448
741
 
#define ENUM_P 449
742
 
#define ESCAPE 450
743
 
#define EXCEPT 451
744
 
#define EXCLUDING 452
745
 
#define EXCLUSIVE 453
746
 
#define EXECUTE 454
747
 
#define EXISTS 455
748
 
#define EXPLAIN 456
749
 
#define EXTERNAL 457
750
 
#define EXTRACT 458
751
 
#define FALSE_P 459
752
 
#define FAMILY 460
753
 
#define FETCH 461
754
 
#define FIRST_P 462
755
 
#define FLOAT_P 463
756
 
#define FOLLOWING 464
757
 
#define FOR 465
758
 
#define FORCE 466
759
 
#define FOREIGN 467
760
 
#define FORWARD 468
761
 
#define FREEZE 469
762
 
#define FROM 470
763
 
#define FULL 471
764
 
#define FUNCTION 472
765
 
#define GLOBAL 473
766
 
#define GRANT 474
767
 
#define GRANTED 475
768
 
#define GREATEST 476
769
 
#define GROUP_P 477
770
 
#define HANDLER 478
771
 
#define HAVING 479
772
 
#define HEADER_P 480
773
 
#define HOLD 481
774
 
#define HOUR_P 482
775
 
#define IDENTITY_P 483
776
 
#define IF_P 484
777
 
#define ILIKE 485
778
 
#define IMMEDIATE 486
779
 
#define IMMUTABLE 487
780
 
#define IMPLICIT_P 488
781
 
#define IN_P 489
782
 
#define INCLUDING 490
783
 
#define INCREMENT 491
784
 
#define INDEX 492
785
 
#define INDEXES 493
786
 
#define INHERIT 494
787
 
#define INHERITS 495
788
 
#define INITIALLY 496
789
 
#define INNER_P 497
790
 
#define INOUT 498
791
 
#define INPUT_P 499
792
 
#define INSENSITIVE 500
793
 
#define INSERT 501
794
 
#define INSTEAD 502
795
 
#define INT_P 503
796
 
#define INTEGER 504
797
 
#define INTERSECT 505
798
 
#define INTERVAL 506
799
 
#define INTO 507
800
 
#define INVOKER 508
801
 
#define IS 509
802
 
#define ISNULL 510
803
 
#define ISOLATION 511
804
 
#define JOIN 512
805
 
#define KEY 513
806
 
#define LANCOMPILER 514
807
 
#define LANGUAGE 515
808
 
#define LARGE_P 516
809
 
#define LAST_P 517
810
 
#define LC_COLLATE_P 518
811
 
#define LC_CTYPE_P 519
812
 
#define LEADING 520
813
 
#define LEAST 521
814
 
#define LEFT 522
815
 
#define LEVEL 523
816
 
#define LIKE 524
817
 
#define LIMIT 525
818
 
#define LISTEN 526
819
 
#define LOAD 527
820
 
#define LOCAL 528
821
 
#define LOCALTIME 529
822
 
#define LOCALTIMESTAMP 530
823
 
#define LOCATION 531
824
 
#define LOCK_P 532
825
 
#define LOGIN_P 533
826
 
#define MAPPING 534
827
 
#define MATCH 535
828
 
#define MAXVALUE 536
829
 
#define MINUTE_P 537
830
 
#define MINVALUE 538
831
 
#define MODE 539
832
 
#define MONTH_P 540
833
 
#define MOVE 541
834
 
#define NAME_P 542
835
 
#define NAMES 543
836
 
#define NATIONAL 544
837
 
#define NATURAL 545
838
 
#define NCHAR 546
839
 
#define NEW 547
840
 
#define NEXT 548
841
 
#define NO 549
842
 
#define NOCREATEDB 550
843
 
#define NOCREATEROLE 551
844
 
#define NOCREATEUSER 552
845
 
#define NOINHERIT 553
846
 
#define NOLOGIN_P 554
847
 
#define NONE 555
848
 
#define NOSUPERUSER 556
849
 
#define NOT 557
850
 
#define NOTHING 558
851
 
#define NOTIFY 559
852
 
#define NOTNULL 560
853
 
#define NOWAIT 561
854
 
#define NULL_P 562
855
 
#define NULLIF 563
856
 
#define NULLS_P 564
857
 
#define NUMERIC 565
858
 
#define OBJECT_P 566
859
 
#define OF 567
860
 
#define OFF 568
861
 
#define OFFSET 569
862
 
#define OIDS 570
863
 
#define OLD 571
864
 
#define ON 572
865
 
#define ONLY 573
866
 
#define OPERATOR 574
867
 
#define OPTION 575
868
 
#define OPTIONS 576
869
 
#define OR 577
870
 
#define ORDER 578
871
 
#define OUT_P 579
872
 
#define OUTER_P 580
873
 
#define OVER 581
874
 
#define OVERLAPS 582
875
 
#define OVERLAY 583
876
 
#define OWNED 584
877
 
#define OWNER 585
878
 
#define PARSER 586
879
 
#define PARTIAL 587
880
 
#define PARTITION 588
881
 
#define PASSWORD 589
882
 
#define PLACING 590
883
 
#define PLANS 591
884
 
#define POSITION 592
885
 
#define PRECEDING 593
886
 
#define PRECISION 594
887
 
#define PRESERVE 595
888
 
#define PREPARE 596
889
 
#define PREPARED 597
890
 
#define PRIMARY 598
891
 
#define PRIOR 599
892
 
#define PRIVILEGES 600
893
 
#define PROCEDURAL 601
894
 
#define PROCEDURE 602
895
 
#define QUOTE 603
896
 
#define RANGE 604
897
 
#define READ 605
898
 
#define REAL 606
899
 
#define REASSIGN 607
900
 
#define RECHECK 608
901
 
#define RECURSIVE 609
902
 
#define REFERENCES 610
903
 
#define REINDEX 611
904
 
#define RELATIVE_P 612
905
 
#define RELEASE 613
906
 
#define RENAME 614
907
 
#define REPEATABLE 615
908
 
#define REPLACE 616
909
 
#define REPLICA 617
910
 
#define RESET 618
911
 
#define RESTART 619
912
 
#define RESTRICT 620
913
 
#define RETURNING 621
914
 
#define RETURNS 622
915
 
#define REVOKE 623
916
 
#define RIGHT 624
917
 
#define ROLE 625
918
 
#define ROLLBACK 626
919
 
#define ROW 627
920
 
#define ROWS 628
921
 
#define RULE 629
922
 
#define SAVEPOINT 630
923
 
#define SCHEMA 631
924
 
#define SCROLL 632
925
 
#define SEARCH 633
926
 
#define SECOND_P 634
927
 
#define SECURITY 635
928
 
#define SELECT 636
929
 
#define SEQUENCE 637
930
 
#define SERIALIZABLE 638
931
 
#define SERVER 639
932
 
#define SESSION 640
933
 
#define SESSION_USER 641
934
 
#define SET 642
935
 
#define SETOF 643
936
 
#define SHARE 644
937
 
#define SHOW 645
938
 
#define SIMILAR 646
939
 
#define SIMPLE 647
940
 
#define SMALLINT 648
941
 
#define SOME 649
942
 
#define STABLE 650
943
 
#define STANDALONE_P 651
944
 
#define START 652
945
 
#define STATEMENT 653
946
 
#define STATISTICS 654
947
 
#define STDIN 655
948
 
#define STDOUT 656
949
 
#define STORAGE 657
950
 
#define STRICT_P 658
951
 
#define STRIP_P 659
952
 
#define SUBSTRING 660
953
 
#define SUPERUSER_P 661
954
 
#define SYMMETRIC 662
955
 
#define SYSID 663
956
 
#define SYSTEM_P 664
957
 
#define TABLE 665
958
 
#define TABLESPACE 666
959
 
#define TEMP 667
960
 
#define TEMPLATE 668
961
 
#define TEMPORARY 669
962
 
#define TEXT_P 670
963
 
#define THEN 671
964
 
#define TIME 672
965
 
#define TIMESTAMP 673
966
 
#define TO 674
967
 
#define TRAILING 675
968
 
#define TRANSACTION 676
969
 
#define TREAT 677
970
 
#define TRIGGER 678
971
 
#define TRIM 679
972
 
#define TRUE_P 680
973
 
#define TRUNCATE 681
974
 
#define TRUSTED 682
975
 
#define TYPE_P 683
976
 
#define UNBOUNDED 684
977
 
#define UNCOMMITTED 685
978
 
#define UNENCRYPTED 686
979
 
#define UNION 687
980
 
#define UNIQUE 688
981
 
#define UNKNOWN 689
982
 
#define UNLISTEN 690
983
 
#define UNTIL 691
984
 
#define UPDATE 692
985
 
#define USER 693
986
 
#define USING 694
987
 
#define VACUUM 695
988
 
#define VALID 696
989
 
#define VALIDATOR 697
990
 
#define VALUE_P 698
991
 
#define VALUES 699
992
 
#define VARCHAR 700
993
 
#define VARIADIC 701
994
 
#define VARYING 702
995
 
#define VERBOSE 703
996
 
#define VERSION_P 704
997
 
#define VIEW 705
998
 
#define VOLATILE 706
999
 
#define WHEN 707
1000
 
#define WHERE 708
1001
 
#define WHITESPACE_P 709
1002
 
#define WINDOW 710
1003
 
#define WITH 711
1004
 
#define WITHOUT 712
1005
 
#define WORK 713
1006
 
#define WRAPPER 714
1007
 
#define WRITE 715
1008
 
#define XML_P 716
1009
 
#define XMLATTRIBUTES 717
1010
 
#define XMLCONCAT 718
1011
 
#define XMLELEMENT 719
1012
 
#define XMLFOREST 720
1013
 
#define XMLPARSE 721
1014
 
#define XMLPI 722
1015
 
#define XMLROOT 723
1016
 
#define XMLSERIALIZE 724
1017
 
#define YEAR_P 725
1018
 
#define YES_P 726
1019
 
#define ZONE 727
1020
 
#define NULLS_FIRST 728
1021
 
#define NULLS_LAST 729
1022
 
#define WITH_TIME 730
1023
 
#define IDENT 731
1024
 
#define FCONST 732
1025
 
#define SCONST 733
1026
 
#define BCONST 734
1027
 
#define XCONST 735
1028
 
#define Op 736
1029
 
#define ICONST 737
1030
 
#define PARAM 738
1031
 
#define POSTFIXOP 739
1032
 
#define UMINUS 740
1033
 
 
1034
 
 
1035
 
 
1036
 
 
1037
 
/* Copy the first part of user declarations.  */
1038
 
#line 5 "preproc.y"
1039
 
 
1040
 
#include "postgres_fe.h"
1041
 
 
1042
 
#include "extern.h"
1043
 
#include <unistd.h>
1044
 
 
1045
 
/* Location tracking support --- simpler than bison's default */
1046
 
#define YYLLOC_DEFAULT(Current, Rhs, N) \
1047
 
        do { \
1048
 
                if (N) \
1049
 
                        (Current) = (Rhs)[1]; \
1050
 
                else \
1051
 
                        (Current) = (Rhs)[0]; \
1052
 
        } while (0)
1053
 
 
1054
 
/*
1055
 
 * The %name-prefix option below will make bison call base_yylex, but we
1056
 
 * really want it to call filtered_base_yylex (see parser.c).
1057
 
 */
1058
 
#define base_yylex filtered_base_yylex
1059
 
 
1060
 
/*
1061
 
 * This is only here so the string gets into the POT.  Bison uses it
1062
 
 * internally.
1063
 
 */
1064
 
#define bison_gettext_dummy gettext_noop("syntax error")
1065
 
 
1066
 
/*
1067
 
 * Variables containing simple states.
1068
 
 */
1069
 
int struct_level = 0;
1070
 
int braces_open; /* brace level counter */
1071
 
int ecpg_informix_var = 0;
1072
 
char    *connection = NULL;
1073
 
char    *input_filename = NULL;
1074
 
 
1075
 
static int      QueryIsRule = 0, FoundInto = 0;
1076
 
static int      initializer = 0;
1077
 
static int      pacounter = 1;
1078
 
static char     pacounter_buffer[sizeof(int) * CHAR_BIT * 10 / 3]; /* a rough guess at the size we need */
1079
 
static struct this_type actual_type[STRUCT_DEPTH];
1080
 
static char *actual_startline[STRUCT_DEPTH];
1081
 
 
1082
 
/* temporarily store struct members while creating the data structure */
1083
 
struct ECPGstruct_member *struct_member_list[STRUCT_DEPTH] = { NULL };
1084
 
 
1085
 
/* also store struct type so we can do a sizeof() later */
1086
 
static char *ECPGstruct_sizeof = NULL;
1087
 
 
1088
 
/* for forward declarations we have to store some data as well */
1089
 
static char *forward_name = NULL;
1090
 
 
1091
 
struct ECPGtype ecpg_no_indicator = {ECPGt_NO_INDICATOR, NULL, NULL, {NULL}, 0};
1092
 
struct variable no_indicator = {"no_indicator", &ecpg_no_indicator, 0, NULL};
1093
 
 
1094
 
struct ECPGtype ecpg_query = {ECPGt_char_variable, NULL, NULL, {NULL}, 0};
1095
 
 
1096
 
/*
1097
 
 * Handle parsing errors and warnings
1098
 
 */
1099
 
void
1100
 
mmerror(int error_code, enum errortype type, const char *error, ...)
1101
 
{
1102
 
        va_list ap;
1103
 
 
1104
 
        /* internationalize the error message string */
1105
 
        error = _(error);
1106
 
 
1107
 
        fprintf(stderr, "%s:%d: ", input_filename, yylineno);
1108
 
 
1109
 
        switch(type)
1110
 
        {
1111
 
                case ET_WARNING:
1112
 
                        fprintf(stderr, _("WARNING: "));
1113
 
                        break;
1114
 
                case ET_ERROR:
1115
 
                case ET_FATAL:
1116
 
                        fprintf(stderr, _("ERROR: "));
1117
 
                        break;
1118
 
        }
1119
 
 
1120
 
        va_start(ap, error);
1121
 
        vfprintf(stderr, error, ap);
1122
 
        va_end(ap);
1123
 
 
1124
 
        fprintf(stderr, "\n");
1125
 
 
1126
 
        switch(type)
1127
 
        {
1128
 
                case ET_WARNING:
1129
 
                        break;
1130
 
                case ET_ERROR:
1131
 
                        ret_value = error_code;
1132
 
                        break;
1133
 
                case ET_FATAL:
1134
 
                        if (yyin)
1135
 
                                fclose(yyin);
1136
 
                        if (yyout)
1137
 
                                fclose(yyout);
1138
 
                        
1139
 
                        if (strcmp(output_filename, "-") != 0 && unlink(output_filename) != 0)
1140
 
                                fprintf(stderr, _("could not remove output file \"%s\"\n"), output_filename);
1141
 
                        exit(error_code);
1142
 
        }
1143
 
}
1144
 
 
1145
 
/*
1146
 
 * string concatenation
1147
 
 */
1148
 
 
1149
 
static char *
1150
 
cat2_str(char *str1, char *str2)
1151
 
{
1152
 
        char * res_str  = (char *)mm_alloc(strlen(str1) + strlen(str2) + 2);
1153
 
 
1154
 
        strcpy(res_str, str1);
1155
 
        if (strlen(str1) != 0 && strlen(str2) != 0)
1156
 
                strcat(res_str, " ");
1157
 
        strcat(res_str, str2);
1158
 
        free(str1);
1159
 
        free(str2);
1160
 
        return(res_str);
1161
 
}
1162
 
 
1163
 
static char *
1164
 
cat_str(int count, ...)
1165
 
{
1166
 
        va_list         args;
1167
 
        int                     i;
1168
 
        char            *res_str;
1169
 
 
1170
 
        va_start(args, count);
1171
 
 
1172
 
        res_str = va_arg(args, char *);
1173
 
 
1174
 
        /* now add all other strings */
1175
 
        for (i = 1; i < count; i++)
1176
 
                res_str = cat2_str(res_str, va_arg(args, char *));
1177
 
 
1178
 
        va_end(args);
1179
 
 
1180
 
        return(res_str);
1181
 
}
1182
 
 
1183
 
char *
1184
 
make_str(const char *str)
1185
 
{
1186
 
        char * res_str = (char *)mm_alloc(strlen(str) + 1);
1187
 
 
1188
 
        strcpy(res_str, str);
1189
 
        return res_str;
1190
 
}
1191
 
 
1192
 
static char *
1193
 
make2_str(char *str1, char *str2)
1194
 
{
1195
 
        char * res_str  = (char *)mm_alloc(strlen(str1) + strlen(str2) + 1);
1196
 
 
1197
 
        strcpy(res_str, str1);
1198
 
        strcat(res_str, str2);
1199
 
        free(str1);
1200
 
        free(str2);
1201
 
        return(res_str);
1202
 
}
1203
 
 
1204
 
static char *
1205
 
make3_str(char *str1, char *str2, char *str3)
1206
 
{
1207
 
        char * res_str  = (char *)mm_alloc(strlen(str1) + strlen(str2) +strlen(str3) + 1);
1208
 
 
1209
 
        strcpy(res_str, str1);
1210
 
        strcat(res_str, str2);
1211
 
        strcat(res_str, str3);
1212
 
        free(str1);
1213
 
        free(str2);
1214
 
        free(str3);
1215
 
        return(res_str);
1216
 
}
1217
 
 
1218
 
/* and the rest */
1219
 
static char *
1220
 
make_name(void)
1221
 
{
1222
 
        return mm_strdup(yytext);
1223
 
}
1224
 
 
1225
 
static char *
1226
 
create_questionmarks(char *name, bool array)
1227
 
{
1228
 
        struct variable *p = find_variable(name);
1229
 
        int count;
1230
 
        char *result = EMPTY;
1231
 
 
1232
 
        /* In case we have a struct, we have to print as many "?" as there are attributes in the struct
1233
 
         * An array is only allowed together with an element argument
1234
 
         * This is essantially only used for inserts, but using a struct as input parameter is an error anywhere else
1235
 
         * so we don't have to worry here. */
1236
 
 
1237
 
        if (p->type->type == ECPGt_struct || (array && p->type->type == ECPGt_array && p->type->u.element->type == ECPGt_struct))
1238
 
        {
1239
 
                struct ECPGstruct_member *m;
1240
 
 
1241
 
                if (p->type->type == ECPGt_struct)
1242
 
                        m = p->type->u.members;
1243
 
                else
1244
 
                        m = p->type->u.element->u.members;
1245
 
 
1246
 
                for (count = 0; m != NULL; m=m->next, count++);
1247
 
        }
1248
 
        else
1249
 
                count = 1;
1250
 
 
1251
 
        for (; count > 0; count --)
1252
 
        {
1253
 
                sprintf(pacounter_buffer, "$%d", pacounter++);
1254
 
                result = cat_str(3, result, mm_strdup(pacounter_buffer), make_str(" , "));
1255
 
        }
1256
 
 
1257
 
        /* removed the trailing " ," */
1258
 
 
1259
 
        result[strlen(result)-3] = '\0';
1260
 
        return(result);
1261
 
}
1262
 
 
1263
 
static char *
1264
 
adjust_informix(struct arguments *list)
1265
 
{
1266
 
        /* Informix accepts DECLARE with variables that are out of scope when OPEN is called.
1267
 
         * for instance you can declare variables in a function, and then subsequently use them
1268
 
         * {
1269
 
         *      declare_vars();
1270
 
         *      exec sql ... which uses vars declared in the above function
1271
 
         *
1272
 
         * This breaks standard and leads to some very dangerous programming.
1273
 
         * Since they do, we have to work around and accept their syntax as well.
1274
 
         * But we will do so ONLY in Informix mode.
1275
 
         * We have to change the variables to our own struct and just store the pointer instead of the variable
1276
 
         */
1277
 
 
1278
 
         struct arguments *ptr;
1279
 
         char *result = make_str("");
1280
 
 
1281
 
         for (ptr = list; ptr != NULL; ptr = ptr->next)
1282
 
         {
1283
 
                char temp[20]; /* this should be sufficient unless you have 8 byte integers */
1284
 
                char *original_var;
1285
 
 
1286
 
                /* change variable name to "ECPG_informix_get_var(<counter>)" */
1287
 
                original_var = ptr->variable->name;
1288
 
                sprintf(temp, "%d))", ecpg_informix_var);
1289
 
 
1290
 
                if ((ptr->variable->type->type != ECPGt_varchar && ptr->variable->type->type != ECPGt_char && ptr->variable->type->type != ECPGt_unsigned_char) && atoi(ptr->variable->type->size) > 1)
1291
 
                {
1292
 
                        ptr->variable = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->variable->type->u.element->type)), make_str(" *)(ECPG_informix_get_var("), mm_strdup(temp)), ECPGmake_array_type(ECPGmake_simple_type(ptr->variable->type->u.element->type, make_str("1"), ptr->variable->type->u.element->lineno), ptr->variable->type->size), 0);
1293
 
                        sprintf(temp, "%d, (", ecpg_informix_var++);
1294
 
                }
1295
 
                else if ((ptr->variable->type->type == ECPGt_varchar || ptr->variable->type->type == ECPGt_char || ptr->variable->type->type == ECPGt_unsigned_char) && atoi(ptr->variable->type->size) > 1)
1296
 
                {
1297
 
                        ptr->variable = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->variable->type->type)), make_str(" *)(ECPG_informix_get_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->variable->type->type, ptr->variable->type->size, ptr->variable->type->lineno), 0);
1298
 
                        sprintf(temp, "%d, (", ecpg_informix_var++);
1299
 
                }
1300
 
                else
1301
 
                {
1302
 
                        ptr->variable = new_variable(cat_str(4, make_str("*("), mm_strdup(ecpg_type_name(ptr->variable->type->type)), make_str(" *)(ECPG_informix_get_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->variable->type->type, ptr->variable->type->size, ptr->variable->type->lineno), 0);
1303
 
                        sprintf(temp, "%d, &(", ecpg_informix_var++);
1304
 
                }
1305
 
 
1306
 
                /* create call to "ECPG_informix_set_var(<counter>, <pointer>. <linen number>)" */
1307
 
                result = cat_str(5, result, make_str("ECPG_informix_set_var("), mm_strdup(temp), mm_strdup(original_var), make_str("), __LINE__);\n"));
1308
 
 
1309
 
                /* now the indicator if there is one */
1310
 
                if (ptr->indicator->type->type != ECPGt_NO_INDICATOR)
1311
 
                {
1312
 
                        /* change variable name to "ECPG_informix_get_var(<counter>)" */
1313
 
                        original_var = ptr->indicator->name;
1314
 
                        sprintf(temp, "%d))", ecpg_informix_var);
1315
 
 
1316
 
                        /* create call to "ECPG_informix_set_var(<counter>, <pointer>. <linen number>)" */
1317
 
                        if (atoi(ptr->indicator->type->size) > 1)
1318
 
                        {
1319
 
                                ptr->indicator = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->indicator->type->type)), make_str(" *)(ECPG_informix_get_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->indicator->type->type, ptr->indicator->type->size, ptr->variable->type->lineno), 0);
1320
 
                                sprintf(temp, "%d, (", ecpg_informix_var++);
1321
 
                        }
1322
 
                        else
1323
 
                        {
1324
 
                                ptr->indicator = new_variable(cat_str(4, make_str("*("), mm_strdup(ecpg_type_name(ptr->indicator->type->type)), make_str(" *)(ECPG_informix_get_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->indicator->type->type, ptr->indicator->type->size, ptr->variable->type->lineno), 0);
1325
 
                                sprintf(temp, "%d, &(", ecpg_informix_var++);
1326
 
                        }
1327
 
                        result = cat_str(5, result, make_str("ECPG_informix_set_var("), mm_strdup(temp), mm_strdup(original_var), make_str("), __LINE__);\n"));
1328
 
                }
1329
 
         }
1330
 
 
1331
 
         return result;
1332
 
}
1333
 
 
1334
 
static struct cursor *
1335
 
add_additional_variables(char *name, bool insert)
1336
 
{
1337
 
        struct cursor *ptr;
1338
 
        struct arguments *p;
1339
 
 
1340
 
        for (ptr = cur; ptr != NULL; ptr=ptr->next)
1341
 
        {
1342
 
                if (strcmp(ptr->name, name) == 0)
1343
 
                        break;
1344
 
        }
1345
 
 
1346
 
        if (ptr == NULL)
1347
 
        {
1348
 
                mmerror(PARSE_ERROR, ET_ERROR, "cursor \"%s\" does not exist", name);
1349
 
                return NULL;
1350
 
        }
1351
 
 
1352
 
        if (insert)
1353
 
        {
1354
 
                /* add all those input variables that were given earlier
1355
 
                 * note that we have to append here but have to keep the existing order */
1356
 
                for (p = ptr->argsinsert; p; p = p->next)
1357
 
                        add_variable_to_tail(&argsinsert, p->variable, p->indicator);
1358
 
        }
1359
 
 
1360
 
        /* add all those output variables that were given earlier */
1361
 
        for (p = ptr->argsresult; p; p = p->next)
1362
 
                add_variable_to_tail(&argsresult, p->variable, p->indicator);
1363
 
 
1364
 
        return ptr;
1365
 
}
1366
 
 
1367
 
static void
1368
 
add_typedef(char *name, char * dimension, char * length, enum ECPGttype type_enum, char *type_dimension, char *type_index, int initializer, int array)
1369
 
{
1370
 
        /* add entry to list */
1371
 
        struct typedefs *ptr, *this;
1372
 
 
1373
 
        if ((type_enum == ECPGt_struct ||
1374
 
             type_enum == ECPGt_union) &&
1375
 
            initializer == 1)
1376
 
                mmerror(PARSE_ERROR, ET_ERROR, "initializer not allowed in type definition");
1377
 
        else
1378
 
        {
1379
 
                for (ptr = types; ptr != NULL; ptr = ptr->next)
1380
 
                {
1381
 
                        if (strcmp(name, ptr->name) == 0)
1382
 
                                /* re-definition is a bug */
1383
 
                                mmerror(PARSE_ERROR, ET_ERROR, "type \"%s\" is already defined", name);
1384
 
                }
1385
 
                adjust_array(type_enum, &dimension, &length, type_dimension, type_index, array, true);
1386
 
 
1387
 
                this = (struct typedefs *) mm_alloc(sizeof(struct typedefs));
1388
 
 
1389
 
                /* initial definition */
1390
 
                this->next = types;
1391
 
                this->name = name;
1392
 
                this->brace_level = braces_open;
1393
 
                this->type = (struct this_type *) mm_alloc(sizeof(struct this_type));
1394
 
                this->type->type_enum = type_enum;
1395
 
                this->type->type_str = mm_strdup(name);
1396
 
                this->type->type_dimension = dimension; /* dimension of array */
1397
 
                this->type->type_index = length;        /* length of string */
1398
 
                this->type->type_sizeof = ECPGstruct_sizeof;
1399
 
                this->struct_member_list = (type_enum == ECPGt_struct || type_enum == ECPGt_union) ?
1400
 
                ECPGstruct_member_dup(struct_member_list[struct_level]) : NULL;
1401
 
 
1402
 
                if (type_enum != ECPGt_varchar &&
1403
 
                        type_enum != ECPGt_char &&
1404
 
                        type_enum != ECPGt_unsigned_char &&
1405
 
                        atoi(this->type->type_index) >= 0)
1406
 
                        mmerror(PARSE_ERROR, ET_ERROR, "multidimensional arrays for simple data types are not supported");
1407
 
 
1408
 
                types = this;
1409
 
        }
1410
 
}
1411
 
 
1412
 
 
1413
 
/* Enabling traces.  */
1414
 
#ifndef YYDEBUG
1415
 
# define YYDEBUG 0
1416
 
#endif
1417
 
 
1418
 
/* Enabling verbose error messages.  */
1419
 
#ifdef YYERROR_VERBOSE
1420
 
# undef YYERROR_VERBOSE
1421
 
# define YYERROR_VERBOSE 1
1422
 
#else
1423
 
# define YYERROR_VERBOSE 0
1424
 
#endif
1425
 
 
1426
 
#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
 
967
 
 
968
 
 
969
 
 
970
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 
971
typedef union YYSTYPE
 
972
{
 
973
 
 
974
/* Line 214 of yacc.c  */
1427
975
#line 383 "preproc.y"
1428
 
typedef union YYSTYPE {
 
976
 
1429
977
        double  dval;
1430
978
        char    *str;
1431
979
        int     ival;
1438
986
        struct  fetch_desc      descriptor;
1439
987
        struct  su_symbol       struct_union;
1440
988
        struct  prep            prep;
 
989
 
 
990
 
 
991
 
 
992
/* Line 214 of yacc.c  */
 
993
#line 994 "preproc.c"
1441
994
} YYSTYPE;
1442
 
/* Line 186 of yacc.c.  */
1443
 
#line 1443 "preproc.c"
 
995
# define YYSTYPE_IS_TRIVIAL 1
1444
996
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
1445
997
# define YYSTYPE_IS_DECLARED 1
1446
 
# define YYSTYPE_IS_TRIVIAL 1
1447
998
#endif
1448
999
 
1449
 
#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
 
1000
#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
1450
1001
typedef struct YYLTYPE
1451
1002
{
1452
1003
  int first_line;
1463
1014
/* Copy the second part of user declarations.  */
1464
1015
 
1465
1016
 
1466
 
/* Line 214 of yacc.c.  */
1467
 
#line 1467 "preproc.c"
1468
 
 
1469
 
#if ! defined (yyoverflow) || YYERROR_VERBOSE
 
1017
/* Line 264 of yacc.c  */
 
1018
#line 1019 "preproc.c"
 
1019
 
 
1020
#ifdef short
 
1021
# undef short
 
1022
#endif
 
1023
 
 
1024
#ifdef YYTYPE_UINT8
 
1025
typedef YYTYPE_UINT8 yytype_uint8;
 
1026
#else
 
1027
typedef unsigned char yytype_uint8;
 
1028
#endif
 
1029
 
 
1030
#ifdef YYTYPE_INT8
 
1031
typedef YYTYPE_INT8 yytype_int8;
 
1032
#elif (defined __STDC__ || defined __C99__FUNC__ \
 
1033
     || defined __cplusplus || defined _MSC_VER)
 
1034
typedef signed char yytype_int8;
 
1035
#else
 
1036
typedef short int yytype_int8;
 
1037
#endif
 
1038
 
 
1039
#ifdef YYTYPE_UINT16
 
1040
typedef YYTYPE_UINT16 yytype_uint16;
 
1041
#else
 
1042
typedef unsigned short int yytype_uint16;
 
1043
#endif
 
1044
 
 
1045
#ifdef YYTYPE_INT16
 
1046
typedef YYTYPE_INT16 yytype_int16;
 
1047
#else
 
1048
typedef short int yytype_int16;
 
1049
#endif
 
1050
 
 
1051
#ifndef YYSIZE_T
 
1052
# ifdef __SIZE_TYPE__
 
1053
#  define YYSIZE_T __SIZE_TYPE__
 
1054
# elif defined size_t
 
1055
#  define YYSIZE_T size_t
 
1056
# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
 
1057
     || defined __cplusplus || defined _MSC_VER)
 
1058
#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 
1059
#  define YYSIZE_T size_t
 
1060
# else
 
1061
#  define YYSIZE_T unsigned int
 
1062
# endif
 
1063
#endif
 
1064
 
 
1065
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 
1066
 
 
1067
#ifndef YY_
 
1068
# if YYENABLE_NLS
 
1069
#  if ENABLE_NLS
 
1070
#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 
1071
#   define YY_(msgid) dgettext ("bison-runtime", msgid)
 
1072
#  endif
 
1073
# endif
 
1074
# ifndef YY_
 
1075
#  define YY_(msgid) msgid
 
1076
# endif
 
1077
#endif
 
1078
 
 
1079
/* Suppress unused-variable warnings by "using" E.  */
 
1080
#if ! defined lint || defined __GNUC__
 
1081
# define YYUSE(e) ((void) (e))
 
1082
#else
 
1083
# define YYUSE(e) /* empty */
 
1084
#endif
 
1085
 
 
1086
/* Identity function, used to suppress warnings about constant conditions.  */
 
1087
#ifndef lint
 
1088
# define YYID(n) (n)
 
1089
#else
 
1090
#if (defined __STDC__ || defined __C99__FUNC__ \
 
1091
     || defined __cplusplus || defined _MSC_VER)
 
1092
static int
 
1093
YYID (int yyi)
 
1094
#else
 
1095
static int
 
1096
YYID (yyi)
 
1097
    int yyi;
 
1098
#endif
 
1099
{
 
1100
  return yyi;
 
1101
}
 
1102
#endif
 
1103
 
 
1104
#if ! defined yyoverflow || YYERROR_VERBOSE
1470
1105
 
1471
1106
/* The parser invokes alloca or malloc; define the necessary symbols.  */
1472
1107
 
1473
 
# if YYSTACK_USE_ALLOCA
1474
 
#  define YYSTACK_ALLOC alloca
1475
 
# else
1476
 
#  ifndef YYSTACK_USE_ALLOCA
1477
 
#   if defined (alloca) || defined (_ALLOCA_H)
 
1108
# ifdef YYSTACK_USE_ALLOCA
 
1109
#  if YYSTACK_USE_ALLOCA
 
1110
#   ifdef __GNUC__
 
1111
#    define YYSTACK_ALLOC __builtin_alloca
 
1112
#   elif defined __BUILTIN_VA_ARG_INCR
 
1113
#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
 
1114
#   elif defined _AIX
 
1115
#    define YYSTACK_ALLOC __alloca
 
1116
#   elif defined _MSC_VER
 
1117
#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
 
1118
#    define alloca _alloca
 
1119
#   else
1478
1120
#    define YYSTACK_ALLOC alloca
1479
 
#   else
1480
 
#    ifdef __GNUC__
1481
 
#     define YYSTACK_ALLOC __builtin_alloca
 
1121
#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 
1122
     || defined __cplusplus || defined _MSC_VER)
 
1123
#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 
1124
#     ifndef _STDLIB_H
 
1125
#      define _STDLIB_H 1
 
1126
#     endif
1482
1127
#    endif
1483
1128
#   endif
1484
1129
#  endif
1485
1130
# endif
1486
1131
 
1487
1132
# ifdef YYSTACK_ALLOC
1488
 
   /* Pacify GCC's `empty if-body' warning. */
1489
 
#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
 
1133
   /* Pacify GCC's `empty if-body' warning.  */
 
1134
#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
 
1135
#  ifndef YYSTACK_ALLOC_MAXIMUM
 
1136
    /* The OS might guarantee only one guard page at the bottom of the stack,
 
1137
       and a page size can be as small as 4096 bytes.  So we cannot safely
 
1138
       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
 
1139
       to allow for a few compiler-allocated temporary stack slots.  */
 
1140
#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
 
1141
#  endif
1490
1142
# else
1491
 
#  if defined (__STDC__) || defined (__cplusplus)
 
1143
#  define YYSTACK_ALLOC YYMALLOC
 
1144
#  define YYSTACK_FREE YYFREE
 
1145
#  ifndef YYSTACK_ALLOC_MAXIMUM
 
1146
#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 
1147
#  endif
 
1148
#  if (defined __cplusplus && ! defined _STDLIB_H \
 
1149
       && ! ((defined YYMALLOC || defined malloc) \
 
1150
             && (defined YYFREE || defined free)))
1492
1151
#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1493
 
#   define YYSIZE_T size_t
1494
 
#  endif
1495
 
#  define YYSTACK_ALLOC malloc
1496
 
#  define YYSTACK_FREE free
 
1152
#   ifndef _STDLIB_H
 
1153
#    define _STDLIB_H 1
 
1154
#   endif
 
1155
#  endif
 
1156
#  ifndef YYMALLOC
 
1157
#   define YYMALLOC malloc
 
1158
#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 
1159
     || defined __cplusplus || defined _MSC_VER)
 
1160
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 
1161
#   endif
 
1162
#  endif
 
1163
#  ifndef YYFREE
 
1164
#   define YYFREE free
 
1165
#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 
1166
     || defined __cplusplus || defined _MSC_VER)
 
1167
void free (void *); /* INFRINGES ON USER NAME SPACE */
 
1168
#   endif
 
1169
#  endif
1497
1170
# endif
1498
 
#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
1499
 
 
1500
 
 
1501
 
#if (! defined (yyoverflow) \
1502
 
     && (! defined (__cplusplus) \
1503
 
         || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 
1171
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 
1172
 
 
1173
 
 
1174
#if (! defined yyoverflow \
 
1175
     && (! defined __cplusplus \
 
1176
         || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
 
1177
             && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1504
1178
 
1505
1179
/* A type that is properly aligned for any stack member.  */
1506
1180
union yyalloc
1507
1181
{
1508
 
  short yyss;
1509
 
  YYSTYPE yyvs;
1510
 
    YYLTYPE yyls;
 
1182
  yytype_int16 yyss_alloc;
 
1183
  YYSTYPE yyvs_alloc;
 
1184
  YYLTYPE yyls_alloc;
1511
1185
};
1512
1186
 
1513
1187
/* The size of the maximum gap between one aligned stack and the next.  */
1516
1190
/* The size of an array large to enough to hold all stacks, each with
1517
1191
   N elements.  */
1518
1192
# define YYSTACK_BYTES(N) \
1519
 
     ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))      \
 
1193
     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
1520
1194
      + 2 * YYSTACK_GAP_MAXIMUM)
1521
1195
 
1522
1196
/* Copy COUNT objects from FROM to TO.  The source and destination do
1523
1197
   not overlap.  */
1524
1198
# ifndef YYCOPY
1525
 
#  if 1 < __GNUC__
 
1199
#  if defined __GNUC__ && 1 < __GNUC__
1526
1200
#   define YYCOPY(To, From, Count) \
1527
1201
      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1528
1202
#  else
1529
1203
#   define YYCOPY(To, From, Count)              \
1530
1204
      do                                        \
1531
1205
        {                                       \
1532
 
          register YYSIZE_T yyi;                \
 
1206
          YYSIZE_T yyi;                         \
1533
1207
          for (yyi = 0; yyi < (Count); yyi++)   \
1534
1208
            (To)[yyi] = (From)[yyi];            \
1535
1209
        }                                       \
1536
 
      while (0)
 
1210
      while (YYID (0))
1537
1211
#  endif
1538
1212
# endif
1539
1213
 
1542
1216
   elements in the stack, and YYPTR gives the new location of the
1543
1217
   stack.  Advance YYPTR to a properly aligned location for the next
1544
1218
   stack.  */
1545
 
# define YYSTACK_RELOCATE(Stack)                                        \
 
1219
# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
1546
1220
    do                                                                  \
1547
1221
      {                                                                 \
1548
1222
        YYSIZE_T yynewbytes;                                            \
1549
 
        YYCOPY (&yyptr->Stack, Stack, yysize);                          \
1550
 
        Stack = &yyptr->Stack;                                          \
 
1223
        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
 
1224
        Stack = &yyptr->Stack_alloc;                                    \
1551
1225
        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1552
1226
        yyptr += yynewbytes / sizeof (*yyptr);                          \
1553
1227
      }                                                                 \
1554
 
    while (0)
1555
 
 
1556
 
#endif
1557
 
 
1558
 
#if defined (__STDC__) || defined (__cplusplus)
1559
 
   typedef signed char yysigned_char;
1560
 
#else
1561
 
   typedef short yysigned_char;
1562
 
#endif
1563
 
 
1564
 
/* YYFINAL -- State number of the termination state. */
 
1228
    while (YYID (0))
 
1229
 
 
1230
#endif
 
1231
 
 
1232
/* YYFINAL -- State number of the termination state.  */
1565
1233
#define YYFINAL  3
1566
1234
/* YYLAST -- Last index in YYTABLE.  */
1567
1235
#define YYLAST   85041
1568
1236
 
1569
 
/* YYNTOKENS -- Number of terminals. */
 
1237
/* YYNTOKENS -- Number of terminals.  */
1570
1238
#define YYNTOKENS  505
1571
 
/* YYNNTS -- Number of nonterminals. */
 
1239
/* YYNNTS -- Number of nonterminals.  */
1572
1240
#define YYNNTS  616
1573
 
/* YYNRULES -- Number of rules. */
 
1241
/* YYNRULES -- Number of rules.  */
1574
1242
#define YYNRULES  2451
1575
 
/* YYNRULES -- Number of states. */
 
1243
/* YYNRULES -- Number of states.  */
1576
1244
#define YYNSTATES  4251
1577
1245
 
1578
1246
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
1579
1247
#define YYUNDEFTOK  2
1580
1248
#define YYMAXUTOK   740
1581
1249
 
1582
 
#define YYTRANSLATE(YYX)                                                \
 
1250
#define YYTRANSLATE(YYX)                                                \
1583
1251
  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1584
1252
 
1585
1253
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
1586
 
static const unsigned short yytranslate[] =
 
1254
static const yytype_uint16 yytranslate[] =
1587
1255
{
1588
1256
       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1589
1257
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1665
1333
#if YYDEBUG
1666
1334
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1667
1335
   YYRHS.  */
1668
 
static const unsigned short yyprhs[] =
 
1336
static const yytype_uint16 yyprhs[] =
1669
1337
{
1670
1338
       0,     0,     3,     5,     7,     9,    11,    13,    15,    17,
1671
1339
      19,    21,    23,    25,    27,    29,    31,    33,    35,    37,
1915
1583
    7771,  7774
1916
1584
};
1917
1585
 
1918
 
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
1919
 
static const short yyrhs[] =
 
1586
/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 
1587
static const yytype_int16 yyrhs[] =
1920
1588
{
1921
1589
     506,     0,    -1,   973,    -1,   774,    -1,   775,    -1,   780,
1922
1590
      -1,   618,    -1,   632,    -1,   732,    -1,   520,    -1,   750,
2699
2367
};
2700
2368
 
2701
2369
/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
2702
 
static const unsigned short yyrline[] =
 
2370
static const yytype_uint16 yyrline[] =
2703
2371
{
2704
2372
       0,  1188,  1188,  1191,  1193,  1195,  1197,  1199,  1201,  1203,
2705
2373
    1205,  1207,  1209,  1211,  1213,  1215,  1217,  1219,  1221,  1223,
2950
2618
};
2951
2619
#endif
2952
2620
 
2953
 
#if YYDEBUG || YYERROR_VERBOSE
2954
 
/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
2955
 
   First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 
2621
#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 
2622
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 
2623
   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
2956
2624
static const char *const yytname[] =
2957
2625
{
2958
 
  "$end", "error", "$undefined", "SQL_ALLOCATE", "SQL_AUTOCOMMIT", 
2959
 
  "SQL_BOOL", "SQL_BREAK", "SQL_CALL", "SQL_CARDINALITY", "SQL_CONNECT", 
2960
 
  "SQL_COUNT", "SQL_DATETIME_INTERVAL_CODE", 
2961
 
  "SQL_DATETIME_INTERVAL_PRECISION", "SQL_DESCRIBE", "SQL_DESCRIPTOR", 
2962
 
  "SQL_DISCONNECT", "SQL_FOUND", "SQL_FREE", "SQL_GET", "SQL_GO", 
2963
 
  "SQL_GOTO", "SQL_IDENTIFIED", "SQL_INDICATOR", "SQL_KEY_MEMBER", 
2964
 
  "SQL_LENGTH", "SQL_LONG", "SQL_NULLABLE", "SQL_OCTET_LENGTH", 
2965
 
  "SQL_OPEN", "SQL_OUTPUT", "SQL_REFERENCE", "SQL_RETURNED_LENGTH", 
2966
 
  "SQL_RETURNED_OCTET_LENGTH", "SQL_SCALE", "SQL_SECTION", "SQL_SHORT", 
2967
 
  "SQL_SIGNED", "SQL_SQL", "SQL_SQLERROR", "SQL_SQLPRINT", 
2968
 
  "SQL_SQLWARNING", "SQL_START", "SQL_STOP", "SQL_STRUCT", "SQL_UNSIGNED", 
2969
 
  "SQL_VAR", "SQL_WHENEVER", "S_ADD", "S_AND", "S_ANYTHING", "S_AUTO", 
2970
 
  "S_CONST", "S_DEC", "S_DIV", "S_DOTPOINT", "S_EQUAL", "S_EXTERN", 
2971
 
  "S_INC", "S_LSHIFT", "S_MEMPOINT", "S_MEMBER", "S_MOD", "S_MUL", 
2972
 
  "S_NEQUAL", "S_OR", "S_REGISTER", "S_RSHIFT", "S_STATIC", "S_SUB", 
2973
 
  "S_VOLATILE", "S_TYPEDEF", "TYPECAST", "CSTRING", "CVARIABLE", 
2974
 
  "CPP_LINE", "IP", "DOLCONST", "ECONST", "NCONST", "UCONST", "UIDENT", 
2975
 
  "ABORT_P", "ABSOLUTE_P", "ACCESS", "ACTION", "ADD_P", "ADMIN", "AFTER", 
2976
 
  "AGGREGATE", "ALL", "ALSO", "ALTER", "ALWAYS", "ANALYSE", "ANALYZE", 
2977
 
  "AND", "ANY", "ARRAY", "AS", "ASC", "ASSERTION", "ASSIGNMENT", 
2978
 
  "ASYMMETRIC", "AT", "AUTHORIZATION", "BACKWARD", "BEFORE", "BEGIN_P", 
2979
 
  "BETWEEN", "BIGINT", "BINARY", "BIT", "BOOLEAN_P", "BOTH", "BY", 
2980
 
  "CACHE", "CALLED", "CASCADE", "CASCADED", "CASE", "CAST", "CATALOG_P", 
2981
 
  "CHAIN", "CHAR_P", "CHARACTER", "CHARACTERISTICS", "CHECK", 
2982
 
  "CHECKPOINT", "CLASS", "CLOSE", "CLUSTER", "COALESCE", "COLLATE", 
2983
 
  "COLUMN", "COMMENT", "COMMIT", "COMMITTED", "CONCURRENTLY", 
2984
 
  "CONFIGURATION", "CONNECTION", "CONSTRAINT", "CONSTRAINTS", "CONTENT_P", 
2985
 
  "CONTINUE_P", "CONVERSION_P", "COPY", "COST", "CREATE", "CREATEDB", 
2986
 
  "CREATEROLE", "CREATEUSER", "CROSS", "CSV", "CURRENT_P", 
2987
 
  "CURRENT_CATALOG", "CURRENT_DATE", "CURRENT_ROLE", "CURRENT_SCHEMA", 
2988
 
  "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", "CURSOR", "CYCLE", 
2989
 
  "DATA_P", "DATABASE", "DAY_P", "DEALLOCATE", "DEC", "DECIMAL_P", 
2990
 
  "DECLARE", "DEFAULT", "DEFAULTS", "DEFERRABLE", "DEFERRED", "DEFINER", 
2991
 
  "DELETE_P", "DELIMITER", "DELIMITERS", "DESC", "DICTIONARY", 
2992
 
  "DISABLE_P", "DISCARD", "DISTINCT", "DO", "DOCUMENT_P", "DOMAIN_P", 
2993
 
  "DOUBLE_P", "DROP", "EACH", "ELSE", "ENABLE_P", "ENCODING", "ENCRYPTED", 
2994
 
  "END_P", "ENUM_P", "ESCAPE", "EXCEPT", "EXCLUDING", "EXCLUSIVE", 
2995
 
  "EXECUTE", "EXISTS", "EXPLAIN", "EXTERNAL", "EXTRACT", "FALSE_P", 
2996
 
  "FAMILY", "FETCH", "FIRST_P", "FLOAT_P", "FOLLOWING", "FOR", "FORCE", 
2997
 
  "FOREIGN", "FORWARD", "FREEZE", "FROM", "FULL", "FUNCTION", "GLOBAL", 
2998
 
  "GRANT", "GRANTED", "GREATEST", "GROUP_P", "HANDLER", "HAVING", 
2999
 
  "HEADER_P", "HOLD", "HOUR_P", "IDENTITY_P", "IF_P", "ILIKE", 
3000
 
  "IMMEDIATE", "IMMUTABLE", "IMPLICIT_P", "IN_P", "INCLUDING", 
3001
 
  "INCREMENT", "INDEX", "INDEXES", "INHERIT", "INHERITS", "INITIALLY", 
3002
 
  "INNER_P", "INOUT", "INPUT_P", "INSENSITIVE", "INSERT", "INSTEAD", 
3003
 
  "INT_P", "INTEGER", "INTERSECT", "INTERVAL", "INTO", "INVOKER", "IS", 
3004
 
  "ISNULL", "ISOLATION", "JOIN", "KEY", "LANCOMPILER", "LANGUAGE", 
3005
 
  "LARGE_P", "LAST_P", "LC_COLLATE_P", "LC_CTYPE_P", "LEADING", "LEAST", 
3006
 
  "LEFT", "LEVEL", "LIKE", "LIMIT", "LISTEN", "LOAD", "LOCAL", 
3007
 
  "LOCALTIME", "LOCALTIMESTAMP", "LOCATION", "LOCK_P", "LOGIN_P", 
3008
 
  "MAPPING", "MATCH", "MAXVALUE", "MINUTE_P", "MINVALUE", "MODE", 
3009
 
  "MONTH_P", "MOVE", "NAME_P", "NAMES", "NATIONAL", "NATURAL", "NCHAR", 
3010
 
  "NEW", "NEXT", "NO", "NOCREATEDB", "NOCREATEROLE", "NOCREATEUSER", 
3011
 
  "NOINHERIT", "NOLOGIN_P", "NONE", "NOSUPERUSER", "NOT", "NOTHING", 
3012
 
  "NOTIFY", "NOTNULL", "NOWAIT", "NULL_P", "NULLIF", "NULLS_P", "NUMERIC", 
3013
 
  "OBJECT_P", "OF", "OFF", "OFFSET", "OIDS", "OLD", "ON", "ONLY", 
3014
 
  "OPERATOR", "OPTION", "OPTIONS", "OR", "ORDER", "OUT_P", "OUTER_P", 
3015
 
  "OVER", "OVERLAPS", "OVERLAY", "OWNED", "OWNER", "PARSER", "PARTIAL", 
3016
 
  "PARTITION", "PASSWORD", "PLACING", "PLANS", "POSITION", "PRECEDING", 
3017
 
  "PRECISION", "PRESERVE", "PREPARE", "PREPARED", "PRIMARY", "PRIOR", 
3018
 
  "PRIVILEGES", "PROCEDURAL", "PROCEDURE", "QUOTE", "RANGE", "READ", 
3019
 
  "REAL", "REASSIGN", "RECHECK", "RECURSIVE", "REFERENCES", "REINDEX", 
3020
 
  "RELATIVE_P", "RELEASE", "RENAME", "REPEATABLE", "REPLACE", "REPLICA", 
3021
 
  "RESET", "RESTART", "RESTRICT", "RETURNING", "RETURNS", "REVOKE", 
3022
 
  "RIGHT", "ROLE", "ROLLBACK", "ROW", "ROWS", "RULE", "SAVEPOINT", 
3023
 
  "SCHEMA", "SCROLL", "SEARCH", "SECOND_P", "SECURITY", "SELECT", 
3024
 
  "SEQUENCE", "SERIALIZABLE", "SERVER", "SESSION", "SESSION_USER", "SET", 
3025
 
  "SETOF", "SHARE", "SHOW", "SIMILAR", "SIMPLE", "SMALLINT", "SOME", 
3026
 
  "STABLE", "STANDALONE_P", "START", "STATEMENT", "STATISTICS", "STDIN", 
3027
 
  "STDOUT", "STORAGE", "STRICT_P", "STRIP_P", "SUBSTRING", "SUPERUSER_P", 
3028
 
  "SYMMETRIC", "SYSID", "SYSTEM_P", "TABLE", "TABLESPACE", "TEMP", 
3029
 
  "TEMPLATE", "TEMPORARY", "TEXT_P", "THEN", "TIME", "TIMESTAMP", "TO", 
3030
 
  "TRAILING", "TRANSACTION", "TREAT", "TRIGGER", "TRIM", "TRUE_P", 
3031
 
  "TRUNCATE", "TRUSTED", "TYPE_P", "UNBOUNDED", "UNCOMMITTED", 
3032
 
  "UNENCRYPTED", "UNION", "UNIQUE", "UNKNOWN", "UNLISTEN", "UNTIL", 
3033
 
  "UPDATE", "USER", "USING", "VACUUM", "VALID", "VALIDATOR", "VALUE_P", 
3034
 
  "VALUES", "VARCHAR", "VARIADIC", "VARYING", "VERBOSE", "VERSION_P", 
3035
 
  "VIEW", "VOLATILE", "WHEN", "WHERE", "WHITESPACE_P", "WINDOW", "WITH", 
3036
 
  "WITHOUT", "WORK", "WRAPPER", "WRITE", "XML_P", "XMLATTRIBUTES", 
3037
 
  "XMLCONCAT", "XMLELEMENT", "XMLFOREST", "XMLPARSE", "XMLPI", "XMLROOT", 
3038
 
  "XMLSERIALIZE", "YEAR_P", "YES_P", "ZONE", "NULLS_FIRST", "NULLS_LAST", 
3039
 
  "WITH_TIME", "IDENT", "FCONST", "SCONST", "BCONST", "XCONST", "Op", 
3040
 
  "ICONST", "PARAM", "'='", "'<'", "'>'", "POSTFIXOP", "'+'", "'-'", 
3041
 
  "'*'", "'/'", "'%'", "'^'", "UMINUS", "'['", "']'", "'('", "')'", "'.'", 
3042
 
  "','", "';'", "':'", "'{'", "'}'", "$accept", "prog", "stmt", 
3043
 
  "CreateRoleStmt", "opt_with", "OptRoleList", "OptRoleElem", 
3044
 
  "CreateUserStmt", "AlterRoleStmt", "AlterRoleSetStmt", "AlterUserStmt", 
3045
 
  "AlterUserSetStmt", "DropRoleStmt", "DropUserStmt", "CreateGroupStmt", 
3046
 
  "AlterGroupStmt", "add_drop", "DropGroupStmt", "CreateSchemaStmt", 
3047
 
  "OptSchemaName", "OptSchemaEltList", "schema_stmt", "VariableSetStmt", 
3048
 
  "set_rest", "var_name", "var_list", "var_value", "iso_level", 
3049
 
  "opt_boolean", "zone_value", "opt_encoding", "ColId_or_Sconst", 
3050
 
  "VariableResetStmt", "SetResetClause", "VariableShowStmt", 
3051
 
  "ConstraintsSetStmt", "constraints_set_list", "constraints_set_mode", 
3052
 
  "CheckPointStmt", "DiscardStmt", "AlterTableStmt", "alter_table_cmds", 
3053
 
  "alter_table_cmd", "alter_column_default", "opt_drop_behavior", 
3054
 
  "alter_using", "reloptions", "opt_reloptions", "reloption_list", 
3055
 
  "reloption_elem", "ClosePortalStmt", "CopyStmt", "copy_from", 
3056
 
  "copy_file_name", "copy_opt_list", "copy_opt_item", "opt_binary", 
3057
 
  "opt_oids", "copy_delimiter", "opt_using", "CreateStmt", "OptTemp", 
3058
 
  "OptTableElementList", "TableElementList", "TableElement", "columnDef", 
3059
 
  "ColQualList", "ColConstraint", "ColConstraintElem", "ConstraintAttr", 
3060
 
  "TableLikeClause", "TableLikeOptionList", "TableLikeOption", 
3061
 
  "TableConstraint", "ConstraintElem", "opt_column_list", "columnList", 
3062
 
  "columnElem", "key_match", "key_actions", "key_update", "key_delete", 
3063
 
  "key_action", "OptInherit", "OptWith", "OnCommitOption", 
3064
 
  "OptTableSpace", "OptConsTableSpace", "create_as_target", "OptCreateAs", 
3065
 
  "CreateAsList", "CreateAsElement", "opt_with_data", "CreateSeqStmt", 
3066
 
  "AlterSeqStmt", "OptSeqOptList", "SeqOptList", "SeqOptElem", "opt_by", 
3067
 
  "NumericOnly", "CreatePLangStmt", "opt_trusted", "handler_name", 
3068
 
  "validator_clause", "opt_validator", "opt_lancompiler", "DropPLangStmt", 
3069
 
  "opt_procedural", "CreateTableSpaceStmt", "OptTableSpaceOwner", 
3070
 
  "DropTableSpaceStmt", "CreateFdwStmt", "DropFdwStmt", "AlterFdwStmt", 
3071
 
  "create_generic_options", "generic_option_list", 
3072
 
  "alter_generic_options", "alter_generic_option_list", 
3073
 
  "alter_generic_option_elem", "generic_option_elem", 
3074
 
  "generic_option_name", "generic_option_arg", "CreateForeignServerStmt", 
3075
 
  "opt_type", "foreign_server_version", "opt_foreign_server_version", 
3076
 
  "DropForeignServerStmt", "AlterForeignServerStmt", 
3077
 
  "CreateUserMappingStmt", "auth_ident", "DropUserMappingStmt", 
3078
 
  "AlterUserMappingStmt", "CreateTrigStmt", "TriggerActionTime", 
3079
 
  "TriggerEvents", "TriggerOneEvent", "TriggerForSpec", "TriggerForOpt", 
3080
 
  "TriggerForType", "TriggerFuncArgs", "TriggerFuncArg", 
3081
 
  "OptConstrFromTable", "ConstraintAttributeSpec", 
3082
 
  "ConstraintDeferrabilitySpec", "ConstraintTimeSpec", "DropTrigStmt", 
3083
 
  "CreateAssertStmt", "DropAssertStmt", "DefineStmt", "definition", 
3084
 
  "def_list", "def_elem", "def_arg", "aggr_args", "old_aggr_definition", 
3085
 
  "old_aggr_list", "old_aggr_elem", "enum_val_list", "CreateOpClassStmt", 
3086
 
  "opclass_item_list", "opclass_item", "opt_default", "opt_opfamily", 
3087
 
  "opt_recheck", "CreateOpFamilyStmt", "AlterOpFamilyStmt", 
3088
 
  "opclass_drop_list", "opclass_drop", "DropOpClassStmt", 
3089
 
  "DropOpFamilyStmt", "DropOwnedStmt", "ReassignOwnedStmt", "DropStmt", 
3090
 
  "drop_type", "any_name_list", "any_name", "attrs", "TruncateStmt", 
3091
 
  "opt_restart_seqs", "CommentStmt", "comment_type", "comment_text", 
3092
 
  "FetchStmt", "fetch_direction", "from_in", "GrantStmt", "RevokeStmt", 
3093
 
  "privileges", "privilege_list", "privilege", "privilege_target", 
3094
 
  "grantee_list", "grantee", "opt_grant_grant_option", 
3095
 
  "function_with_argtypes_list", "function_with_argtypes", 
3096
 
  "GrantRoleStmt", "RevokeRoleStmt", "opt_grant_admin_option", 
3097
 
  "opt_granted_by", "IndexStmt", "index_opt_unique", 
3098
 
  "access_method_clause", "index_params", "index_elem", "opt_class", 
3099
 
  "opt_asc_desc", "opt_nulls_order", "CreateFunctionStmt", 
3100
 
  "opt_or_replace", "func_args", "func_args_list", 
3101
 
  "func_args_with_defaults", "func_args_with_defaults_list", "func_arg", 
3102
 
  "arg_class", "param_name", "func_return", "func_type", 
3103
 
  "func_arg_with_default", "createfunc_opt_list", "common_func_opt_item", 
3104
 
  "createfunc_opt_item", "func_as", "opt_definition", "table_func_column", 
3105
 
  "table_func_column_list", "AlterFunctionStmt", "alterfunc_opt_list", 
3106
 
  "opt_restrict", "RemoveFuncStmt", "RemoveAggrStmt", "RemoveOperStmt", 
3107
 
  "oper_argtypes", "any_operator", "CreateCastStmt", "cast_context", 
3108
 
  "DropCastStmt", "opt_if_exists", "ReindexStmt", "reindex_type", 
3109
 
  "opt_force", "RenameStmt", "opt_column", "opt_set_data", 
3110
 
  "AlterObjectSchemaStmt", "AlterOwnerStmt", "RuleActionList", 
3111
 
  "RuleActionMulti", "RuleActionStmt", "RuleActionStmtOrEmpty", "event", 
3112
 
  "opt_instead", "DropRuleStmt", "NotifyStmt", "ListenStmt", 
3113
 
  "UnlistenStmt", "TransactionStmt", "opt_transaction", 
3114
 
  "transaction_mode_item", "transaction_mode_list", 
3115
 
  "transaction_mode_list_or_empty", "ViewStmt", "opt_check_option", 
3116
 
  "LoadStmt", "CreatedbStmt", "createdb_opt_list", "createdb_opt_item", 
3117
 
  "opt_equal", "AlterDatabaseStmt", "AlterDatabaseSetStmt", 
3118
 
  "alterdb_opt_list", "alterdb_opt_item", "DropdbStmt", 
3119
 
  "CreateDomainStmt", "AlterDomainStmt", "opt_as", 
3120
 
  "AlterTSDictionaryStmt", "AlterTSConfigurationStmt", 
3121
 
  "CreateConversionStmt", "ClusterStmt", "cluster_index_specification", 
3122
 
  "VacuumStmt", "AnalyzeStmt", "analyze_keyword", "opt_verbose", 
3123
 
  "opt_full", "opt_freeze", "opt_name_list", "ExplainStmt", 
3124
 
  "ExplainableStmt", "opt_analyze", "PrepareStmt", "prep_type_clause", 
3125
 
  "PreparableStmt", "ExecuteStmt", "execute_param_clause", "InsertStmt", 
3126
 
  "insert_rest", "insert_column_list", "insert_column_item", 
3127
 
  "returning_clause", "DeleteStmt", "using_clause", "LockStmt", 
3128
 
  "opt_lock", "lock_type", "opt_nowait", "UpdateStmt", "set_clause_list", 
3129
 
  "set_clause", "single_set_clause", "multiple_set_clause", "set_target", 
3130
 
  "set_target_list", "DeclareCursorStmt", "cursor_options", "opt_hold", 
3131
 
  "SelectStmt", "select_with_parens", "select_no_parens", "select_clause", 
3132
 
  "simple_select", "with_clause", "cte_list", "common_table_expr", 
3133
 
  "into_clause", "OptTempTableName", "opt_table", "opt_all", 
3134
 
  "opt_distinct", "opt_sort_clause", "sort_clause", "sortby_list", 
3135
 
  "sortby", "select_limit", "opt_select_limit", "select_limit_value", 
3136
 
  "opt_select_fetch_first_value", "select_offset_value", 
3137
 
  "select_offset_value2", "row_or_rows", "first_or_next", "group_clause", 
3138
 
  "having_clause", "for_locking_clause", "opt_for_locking_clause", 
3139
 
  "for_locking_items", "for_locking_item", "locked_rels_list", 
3140
 
  "values_clause", "from_clause", "from_list", "table_ref", 
3141
 
  "joined_table", "alias_clause", "join_type", "join_outer", "join_qual", 
3142
 
  "relation_expr", "relation_expr_list", "relation_expr_opt_alias", 
3143
 
  "func_table", "where_clause", "where_or_current_clause", 
3144
 
  "TableFuncElementList", "TableFuncElement", "Typename", 
3145
 
  "opt_array_bounds", "SimpleTypename", "ConstTypename", "GenericType", 
3146
 
  "opt_type_modifiers", "Numeric", "opt_float", "Bit", "ConstBit", 
3147
 
  "BitWithLength", "BitWithoutLength", "Character", "ConstCharacter", 
3148
 
  "CharacterWithLength", "CharacterWithoutLength", "character", 
3149
 
  "opt_varying", "opt_charset", "ConstDatetime", "ConstInterval", 
3150
 
  "opt_timezone", "opt_interval", "interval_second", "a_expr", "b_expr", 
3151
 
  "c_expr", "func_expr", "xml_root_version", "opt_xml_root_standalone", 
3152
 
  "xml_attributes", "xml_attribute_list", "xml_attribute_el", 
3153
 
  "document_or_content", "xml_whitespace_option", "window_clause", 
3154
 
  "window_definition_list", "window_definition", "over_clause", 
3155
 
  "window_specification", "opt_existing_window_name", 
3156
 
  "opt_partition_clause", "opt_frame_clause", "frame_extent", 
3157
 
  "frame_bound", "row", "sub_type", "all_Op", "MathOp", "qual_Op", 
3158
 
  "qual_all_Op", "subquery_Op", "expr_list", "type_list", "array_expr", 
3159
 
  "array_expr_list", "extract_list", "extract_arg", "overlay_list", 
3160
 
  "overlay_placing", "position_list", "substr_list", "substr_from", 
3161
 
  "substr_for", "trim_list", "in_expr", "case_expr", "when_clause_list", 
3162
 
  "when_clause", "case_default", "case_arg", "columnref", 
3163
 
  "indirection_el", "indirection", "opt_indirection", "opt_asymmetric", 
3164
 
  "ctext_expr", "ctext_expr_list", "ctext_row", "target_list", 
3165
 
  "target_el", "relation_name", "qualified_name_list", "qualified_name", 
3166
 
  "name_list", "name", "database_name", "access_method", "attr_name", 
3167
 
  "index_name", "file_name", "func_name", "AexprConst", "Iconst", 
3168
 
  "RoleId", "SignedIconst", "unreserved_keyword", "col_name_keyword", 
3169
 
  "type_func_name_keyword", "reserved_keyword", "SpecialRuleRelation", 
3170
 
  "statements", "statement", "CreateAsStmt", "@1", "RuleStmt", "@2", "at", 
3171
 
  "ECPGConnect", "connection_target", "opt_database_name", "db_prefix", 
3172
 
  "server", "opt_server", "server_name", "opt_port", 
3173
 
  "opt_connection_name", "opt_user", "ora_user", "user_name", 
3174
 
  "char_variable", "opt_options", "connect_options", "opt_opt_value", 
3175
 
  "prepared_name", "ECPGCursorStmt", "ECPGExecuteImmediateStmt", 
3176
 
  "ECPGVarDeclaration", "single_vt_declaration", "precision", "opt_scale", 
3177
 
  "ecpg_interval", "ECPGDeclaration", "@3", "sql_startdeclare", 
3178
 
  "sql_enddeclare", "var_type_declarations", "vt_declarations", 
3179
 
  "variable_declarations", "type_declaration", "@4", "var_declaration", 
3180
 
  "@5", "@6", "opt_bit_field", "storage_declaration", "storage_clause", 
3181
 
  "storage_modifier", "var_type", "enum_type", "enum_definition", 
3182
 
  "struct_union_type_with_symbol", "@7", "struct_union_type", "@8", 
3183
 
  "s_struct_union_symbol", "s_struct_union", "simple_type", 
3184
 
  "unsigned_type", "signed_type", "opt_signed", "variable_list", 
3185
 
  "variable", "opt_initializer", "opt_pointer", "ECPGDeclare", 
3186
 
  "ECPGDisconnect", "dis_name", "connection_object", "execstring", 
3187
 
  "ECPGFree", "ECPGOpen", "opt_ecpg_using", "ecpg_using", 
3188
 
  "using_descriptor", "into_descriptor", "opt_sql", "using_list", 
3189
 
  "UsingValue", "UsingConst", "ECPGDescribe", "opt_output", 
3190
 
  "ECPGAllocateDescr", "ECPGDeallocateDescr", "ECPGGetDescriptorHeader", 
3191
 
  "ECPGGetDescHeaderItems", "ECPGGetDescHeaderItem", 
3192
 
  "ECPGSetDescriptorHeader", "ECPGSetDescHeaderItems", 
3193
 
  "ECPGSetDescHeaderItem", "IntConstVar", "desc_header_item", 
3194
 
  "ECPGGetDescriptor", "ECPGGetDescItems", "ECPGGetDescItem", 
3195
 
  "ECPGSetDescriptor", "ECPGSetDescItems", "ECPGSetDescItem", 
3196
 
  "AllConstVar", "descriptor_item", "ECPGSetAutocommit", "on_off", 
3197
 
  "ECPGSetConnection", "ECPGTypedef", "@9", "opt_reference", "ECPGVar", 
3198
 
  "@10", "ECPGWhenever", "action", "ECPGKeywords", "ECPGKeywords_vanames", 
3199
 
  "ECPGKeywords_rest", "ECPGTypeName", "symbol", "ECPGColId", "ColId", 
3200
 
  "type_function_name", "ColLabel", "ECPGColLabel", "ECPGColLabelCommon", 
3201
 
  "ECPGCKeywords", "all_unreserved_keyword", "ECPGunreserved_interval", 
3202
 
  "into_list", "ecpgstart", "c_args", "coutputvariable", "civarind", 
3203
 
  "civar", "indicator", "cvariable", "ecpg_param", "ecpg_bconst", 
3204
 
  "ecpg_fconst", "ecpg_sconst", "ecpg_xconst", "ecpg_ident", 
3205
 
  "quoted_ident_stringvar", "c_stuff_item", "c_stuff", "c_list", "c_term", 
3206
 
  "c_thing", "c_anything", "DeallocateStmt", "Iresult", "execute_rest", 
 
2626
  "$end", "error", "$undefined", "SQL_ALLOCATE", "SQL_AUTOCOMMIT",
 
2627
  "SQL_BOOL", "SQL_BREAK", "SQL_CALL", "SQL_CARDINALITY", "SQL_CONNECT",
 
2628
  "SQL_COUNT", "SQL_DATETIME_INTERVAL_CODE",
 
2629
  "SQL_DATETIME_INTERVAL_PRECISION", "SQL_DESCRIBE", "SQL_DESCRIPTOR",
 
2630
  "SQL_DISCONNECT", "SQL_FOUND", "SQL_FREE", "SQL_GET", "SQL_GO",
 
2631
  "SQL_GOTO", "SQL_IDENTIFIED", "SQL_INDICATOR", "SQL_KEY_MEMBER",
 
2632
  "SQL_LENGTH", "SQL_LONG", "SQL_NULLABLE", "SQL_OCTET_LENGTH", "SQL_OPEN",
 
2633
  "SQL_OUTPUT", "SQL_REFERENCE", "SQL_RETURNED_LENGTH",
 
2634
  "SQL_RETURNED_OCTET_LENGTH", "SQL_SCALE", "SQL_SECTION", "SQL_SHORT",
 
2635
  "SQL_SIGNED", "SQL_SQL", "SQL_SQLERROR", "SQL_SQLPRINT",
 
2636
  "SQL_SQLWARNING", "SQL_START", "SQL_STOP", "SQL_STRUCT", "SQL_UNSIGNED",
 
2637
  "SQL_VAR", "SQL_WHENEVER", "S_ADD", "S_AND", "S_ANYTHING", "S_AUTO",
 
2638
  "S_CONST", "S_DEC", "S_DIV", "S_DOTPOINT", "S_EQUAL", "S_EXTERN",
 
2639
  "S_INC", "S_LSHIFT", "S_MEMPOINT", "S_MEMBER", "S_MOD", "S_MUL",
 
2640
  "S_NEQUAL", "S_OR", "S_REGISTER", "S_RSHIFT", "S_STATIC", "S_SUB",
 
2641
  "S_VOLATILE", "S_TYPEDEF", "TYPECAST", "CSTRING", "CVARIABLE",
 
2642
  "CPP_LINE", "IP", "DOLCONST", "ECONST", "NCONST", "UCONST", "UIDENT",
 
2643
  "ABORT_P", "ABSOLUTE_P", "ACCESS", "ACTION", "ADD_P", "ADMIN", "AFTER",
 
2644
  "AGGREGATE", "ALL", "ALSO", "ALTER", "ALWAYS", "ANALYSE", "ANALYZE",
 
2645
  "AND", "ANY", "ARRAY", "AS", "ASC", "ASSERTION", "ASSIGNMENT",
 
2646
  "ASYMMETRIC", "AT", "AUTHORIZATION", "BACKWARD", "BEFORE", "BEGIN_P",
 
2647
  "BETWEEN", "BIGINT", "BINARY", "BIT", "BOOLEAN_P", "BOTH", "BY", "CACHE",
 
2648
  "CALLED", "CASCADE", "CASCADED", "CASE", "CAST", "CATALOG_P", "CHAIN",
 
2649
  "CHAR_P", "CHARACTER", "CHARACTERISTICS", "CHECK", "CHECKPOINT", "CLASS",
 
2650
  "CLOSE", "CLUSTER", "COALESCE", "COLLATE", "COLUMN", "COMMENT", "COMMIT",
 
2651
  "COMMITTED", "CONCURRENTLY", "CONFIGURATION", "CONNECTION", "CONSTRAINT",
 
2652
  "CONSTRAINTS", "CONTENT_P", "CONTINUE_P", "CONVERSION_P", "COPY", "COST",
 
2653
  "CREATE", "CREATEDB", "CREATEROLE", "CREATEUSER", "CROSS", "CSV",
 
2654
  "CURRENT_P", "CURRENT_CATALOG", "CURRENT_DATE", "CURRENT_ROLE",
 
2655
  "CURRENT_SCHEMA", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER",
 
2656
  "CURSOR", "CYCLE", "DATA_P", "DATABASE", "DAY_P", "DEALLOCATE", "DEC",
 
2657
  "DECIMAL_P", "DECLARE", "DEFAULT", "DEFAULTS", "DEFERRABLE", "DEFERRED",
 
2658
  "DEFINER", "DELETE_P", "DELIMITER", "DELIMITERS", "DESC", "DICTIONARY",
 
2659
  "DISABLE_P", "DISCARD", "DISTINCT", "DO", "DOCUMENT_P", "DOMAIN_P",
 
2660
  "DOUBLE_P", "DROP", "EACH", "ELSE", "ENABLE_P", "ENCODING", "ENCRYPTED",
 
2661
  "END_P", "ENUM_P", "ESCAPE", "EXCEPT", "EXCLUDING", "EXCLUSIVE",
 
2662
  "EXECUTE", "EXISTS", "EXPLAIN", "EXTERNAL", "EXTRACT", "FALSE_P",
 
2663
  "FAMILY", "FETCH", "FIRST_P", "FLOAT_P", "FOLLOWING", "FOR", "FORCE",
 
2664
  "FOREIGN", "FORWARD", "FREEZE", "FROM", "FULL", "FUNCTION", "GLOBAL",
 
2665
  "GRANT", "GRANTED", "GREATEST", "GROUP_P", "HANDLER", "HAVING",
 
2666
  "HEADER_P", "HOLD", "HOUR_P", "IDENTITY_P", "IF_P", "ILIKE", "IMMEDIATE",
 
2667
  "IMMUTABLE", "IMPLICIT_P", "IN_P", "INCLUDING", "INCREMENT", "INDEX",
 
2668
  "INDEXES", "INHERIT", "INHERITS", "INITIALLY", "INNER_P", "INOUT",
 
2669
  "INPUT_P", "INSENSITIVE", "INSERT", "INSTEAD", "INT_P", "INTEGER",
 
2670
  "INTERSECT", "INTERVAL", "INTO", "INVOKER", "IS", "ISNULL", "ISOLATION",
 
2671
  "JOIN", "KEY", "LANCOMPILER", "LANGUAGE", "LARGE_P", "LAST_P",
 
2672
  "LC_COLLATE_P", "LC_CTYPE_P", "LEADING", "LEAST", "LEFT", "LEVEL",
 
2673
  "LIKE", "LIMIT", "LISTEN", "LOAD", "LOCAL", "LOCALTIME",
 
2674
  "LOCALTIMESTAMP", "LOCATION", "LOCK_P", "LOGIN_P", "MAPPING", "MATCH",
 
2675
  "MAXVALUE", "MINUTE_P", "MINVALUE", "MODE", "MONTH_P", "MOVE", "NAME_P",
 
2676
  "NAMES", "NATIONAL", "NATURAL", "NCHAR", "NEW", "NEXT", "NO",
 
2677
  "NOCREATEDB", "NOCREATEROLE", "NOCREATEUSER", "NOINHERIT", "NOLOGIN_P",
 
2678
  "NONE", "NOSUPERUSER", "NOT", "NOTHING", "NOTIFY", "NOTNULL", "NOWAIT",
 
2679
  "NULL_P", "NULLIF", "NULLS_P", "NUMERIC", "OBJECT_P", "OF", "OFF",
 
2680
  "OFFSET", "OIDS", "OLD", "ON", "ONLY", "OPERATOR", "OPTION", "OPTIONS",
 
2681
  "OR", "ORDER", "OUT_P", "OUTER_P", "OVER", "OVERLAPS", "OVERLAY",
 
2682
  "OWNED", "OWNER", "PARSER", "PARTIAL", "PARTITION", "PASSWORD",
 
2683
  "PLACING", "PLANS", "POSITION", "PRECEDING", "PRECISION", "PRESERVE",
 
2684
  "PREPARE", "PREPARED", "PRIMARY", "PRIOR", "PRIVILEGES", "PROCEDURAL",
 
2685
  "PROCEDURE", "QUOTE", "RANGE", "READ", "REAL", "REASSIGN", "RECHECK",
 
2686
  "RECURSIVE", "REFERENCES", "REINDEX", "RELATIVE_P", "RELEASE", "RENAME",
 
2687
  "REPEATABLE", "REPLACE", "REPLICA", "RESET", "RESTART", "RESTRICT",
 
2688
  "RETURNING", "RETURNS", "REVOKE", "RIGHT", "ROLE", "ROLLBACK", "ROW",
 
2689
  "ROWS", "RULE", "SAVEPOINT", "SCHEMA", "SCROLL", "SEARCH", "SECOND_P",
 
2690
  "SECURITY", "SELECT", "SEQUENCE", "SERIALIZABLE", "SERVER", "SESSION",
 
2691
  "SESSION_USER", "SET", "SETOF", "SHARE", "SHOW", "SIMILAR", "SIMPLE",
 
2692
  "SMALLINT", "SOME", "STABLE", "STANDALONE_P", "START", "STATEMENT",
 
2693
  "STATISTICS", "STDIN", "STDOUT", "STORAGE", "STRICT_P", "STRIP_P",
 
2694
  "SUBSTRING", "SUPERUSER_P", "SYMMETRIC", "SYSID", "SYSTEM_P", "TABLE",
 
2695
  "TABLESPACE", "TEMP", "TEMPLATE", "TEMPORARY", "TEXT_P", "THEN", "TIME",
 
2696
  "TIMESTAMP", "TO", "TRAILING", "TRANSACTION", "TREAT", "TRIGGER", "TRIM",
 
2697
  "TRUE_P", "TRUNCATE", "TRUSTED", "TYPE_P", "UNBOUNDED", "UNCOMMITTED",
 
2698
  "UNENCRYPTED", "UNION", "UNIQUE", "UNKNOWN", "UNLISTEN", "UNTIL",
 
2699
  "UPDATE", "USER", "USING", "VACUUM", "VALID", "VALIDATOR", "VALUE_P",
 
2700
  "VALUES", "VARCHAR", "VARIADIC", "VARYING", "VERBOSE", "VERSION_P",
 
2701
  "VIEW", "VOLATILE", "WHEN", "WHERE", "WHITESPACE_P", "WINDOW", "WITH",
 
2702
  "WITHOUT", "WORK", "WRAPPER", "WRITE", "XML_P", "XMLATTRIBUTES",
 
2703
  "XMLCONCAT", "XMLELEMENT", "XMLFOREST", "XMLPARSE", "XMLPI", "XMLROOT",
 
2704
  "XMLSERIALIZE", "YEAR_P", "YES_P", "ZONE", "NULLS_FIRST", "NULLS_LAST",
 
2705
  "WITH_TIME", "IDENT", "FCONST", "SCONST", "BCONST", "XCONST", "Op",
 
2706
  "ICONST", "PARAM", "'='", "'<'", "'>'", "POSTFIXOP", "'+'", "'-'", "'*'",
 
2707
  "'/'", "'%'", "'^'", "UMINUS", "'['", "']'", "'('", "')'", "'.'", "','",
 
2708
  "';'", "':'", "'{'", "'}'", "$accept", "prog", "stmt", "CreateRoleStmt",
 
2709
  "opt_with", "OptRoleList", "OptRoleElem", "CreateUserStmt",
 
2710
  "AlterRoleStmt", "AlterRoleSetStmt", "AlterUserStmt", "AlterUserSetStmt",
 
2711
  "DropRoleStmt", "DropUserStmt", "CreateGroupStmt", "AlterGroupStmt",
 
2712
  "add_drop", "DropGroupStmt", "CreateSchemaStmt", "OptSchemaName",
 
2713
  "OptSchemaEltList", "schema_stmt", "VariableSetStmt", "set_rest",
 
2714
  "var_name", "var_list", "var_value", "iso_level", "opt_boolean",
 
2715
  "zone_value", "opt_encoding", "ColId_or_Sconst", "VariableResetStmt",
 
2716
  "SetResetClause", "VariableShowStmt", "ConstraintsSetStmt",
 
2717
  "constraints_set_list", "constraints_set_mode", "CheckPointStmt",
 
2718
  "DiscardStmt", "AlterTableStmt", "alter_table_cmds", "alter_table_cmd",
 
2719
  "alter_column_default", "opt_drop_behavior", "alter_using", "reloptions",
 
2720
  "opt_reloptions", "reloption_list", "reloption_elem", "ClosePortalStmt",
 
2721
  "CopyStmt", "copy_from", "copy_file_name", "copy_opt_list",
 
2722
  "copy_opt_item", "opt_binary", "opt_oids", "copy_delimiter", "opt_using",
 
2723
  "CreateStmt", "OptTemp", "OptTableElementList", "TableElementList",
 
2724
  "TableElement", "columnDef", "ColQualList", "ColConstraint",
 
2725
  "ColConstraintElem", "ConstraintAttr", "TableLikeClause",
 
2726
  "TableLikeOptionList", "TableLikeOption", "TableConstraint",
 
2727
  "ConstraintElem", "opt_column_list", "columnList", "columnElem",
 
2728
  "key_match", "key_actions", "key_update", "key_delete", "key_action",
 
2729
  "OptInherit", "OptWith", "OnCommitOption", "OptTableSpace",
 
2730
  "OptConsTableSpace", "create_as_target", "OptCreateAs", "CreateAsList",
 
2731
  "CreateAsElement", "opt_with_data", "CreateSeqStmt", "AlterSeqStmt",
 
2732
  "OptSeqOptList", "SeqOptList", "SeqOptElem", "opt_by", "NumericOnly",
 
2733
  "CreatePLangStmt", "opt_trusted", "handler_name", "validator_clause",
 
2734
  "opt_validator", "opt_lancompiler", "DropPLangStmt", "opt_procedural",
 
2735
  "CreateTableSpaceStmt", "OptTableSpaceOwner", "DropTableSpaceStmt",
 
2736
  "CreateFdwStmt", "DropFdwStmt", "AlterFdwStmt", "create_generic_options",
 
2737
  "generic_option_list", "alter_generic_options",
 
2738
  "alter_generic_option_list", "alter_generic_option_elem",
 
2739
  "generic_option_elem", "generic_option_name", "generic_option_arg",
 
2740
  "CreateForeignServerStmt", "opt_type", "foreign_server_version",
 
2741
  "opt_foreign_server_version", "DropForeignServerStmt",
 
2742
  "AlterForeignServerStmt", "CreateUserMappingStmt", "auth_ident",
 
2743
  "DropUserMappingStmt", "AlterUserMappingStmt", "CreateTrigStmt",
 
2744
  "TriggerActionTime", "TriggerEvents", "TriggerOneEvent",
 
2745
  "TriggerForSpec", "TriggerForOpt", "TriggerForType", "TriggerFuncArgs",
 
2746
  "TriggerFuncArg", "OptConstrFromTable", "ConstraintAttributeSpec",
 
2747
  "ConstraintDeferrabilitySpec", "ConstraintTimeSpec", "DropTrigStmt",
 
2748
  "CreateAssertStmt", "DropAssertStmt", "DefineStmt", "definition",
 
2749
  "def_list", "def_elem", "def_arg", "aggr_args", "old_aggr_definition",
 
2750
  "old_aggr_list", "old_aggr_elem", "enum_val_list", "CreateOpClassStmt",
 
2751
  "opclass_item_list", "opclass_item", "opt_default", "opt_opfamily",
 
2752
  "opt_recheck", "CreateOpFamilyStmt", "AlterOpFamilyStmt",
 
2753
  "opclass_drop_list", "opclass_drop", "DropOpClassStmt",
 
2754
  "DropOpFamilyStmt", "DropOwnedStmt", "ReassignOwnedStmt", "DropStmt",
 
2755
  "drop_type", "any_name_list", "any_name", "attrs", "TruncateStmt",
 
2756
  "opt_restart_seqs", "CommentStmt", "comment_type", "comment_text",
 
2757
  "FetchStmt", "fetch_direction", "from_in", "GrantStmt", "RevokeStmt",
 
2758
  "privileges", "privilege_list", "privilege", "privilege_target",
 
2759
  "grantee_list", "grantee", "opt_grant_grant_option",
 
2760
  "function_with_argtypes_list", "function_with_argtypes", "GrantRoleStmt",
 
2761
  "RevokeRoleStmt", "opt_grant_admin_option", "opt_granted_by",
 
2762
  "IndexStmt", "index_opt_unique", "access_method_clause", "index_params",
 
2763
  "index_elem", "opt_class", "opt_asc_desc", "opt_nulls_order",
 
2764
  "CreateFunctionStmt", "opt_or_replace", "func_args", "func_args_list",
 
2765
  "func_args_with_defaults", "func_args_with_defaults_list", "func_arg",
 
2766
  "arg_class", "param_name", "func_return", "func_type",
 
2767
  "func_arg_with_default", "createfunc_opt_list", "common_func_opt_item",
 
2768
  "createfunc_opt_item", "func_as", "opt_definition", "table_func_column",
 
2769
  "table_func_column_list", "AlterFunctionStmt", "alterfunc_opt_list",
 
2770
  "opt_restrict", "RemoveFuncStmt", "RemoveAggrStmt", "RemoveOperStmt",
 
2771
  "oper_argtypes", "any_operator", "CreateCastStmt", "cast_context",
 
2772
  "DropCastStmt", "opt_if_exists", "ReindexStmt", "reindex_type",
 
2773
  "opt_force", "RenameStmt", "opt_column", "opt_set_data",
 
2774
  "AlterObjectSchemaStmt", "AlterOwnerStmt", "RuleActionList",
 
2775
  "RuleActionMulti", "RuleActionStmt", "RuleActionStmtOrEmpty", "event",
 
2776
  "opt_instead", "DropRuleStmt", "NotifyStmt", "ListenStmt",
 
2777
  "UnlistenStmt", "TransactionStmt", "opt_transaction",
 
2778
  "transaction_mode_item", "transaction_mode_list",
 
2779
  "transaction_mode_list_or_empty", "ViewStmt", "opt_check_option",
 
2780
  "LoadStmt", "CreatedbStmt", "createdb_opt_list", "createdb_opt_item",
 
2781
  "opt_equal", "AlterDatabaseStmt", "AlterDatabaseSetStmt",
 
2782
  "alterdb_opt_list", "alterdb_opt_item", "DropdbStmt", "CreateDomainStmt",
 
2783
  "AlterDomainStmt", "opt_as", "AlterTSDictionaryStmt",
 
2784
  "AlterTSConfigurationStmt", "CreateConversionStmt", "ClusterStmt",
 
2785
  "cluster_index_specification", "VacuumStmt", "AnalyzeStmt",
 
2786
  "analyze_keyword", "opt_verbose", "opt_full", "opt_freeze",
 
2787
  "opt_name_list", "ExplainStmt", "ExplainableStmt", "opt_analyze",
 
2788
  "PrepareStmt", "prep_type_clause", "PreparableStmt", "ExecuteStmt",
 
2789
  "execute_param_clause", "InsertStmt", "insert_rest",
 
2790
  "insert_column_list", "insert_column_item", "returning_clause",
 
2791
  "DeleteStmt", "using_clause", "LockStmt", "opt_lock", "lock_type",
 
2792
  "opt_nowait", "UpdateStmt", "set_clause_list", "set_clause",
 
2793
  "single_set_clause", "multiple_set_clause", "set_target",
 
2794
  "set_target_list", "DeclareCursorStmt", "cursor_options", "opt_hold",
 
2795
  "SelectStmt", "select_with_parens", "select_no_parens", "select_clause",
 
2796
  "simple_select", "with_clause", "cte_list", "common_table_expr",
 
2797
  "into_clause", "OptTempTableName", "opt_table", "opt_all",
 
2798
  "opt_distinct", "opt_sort_clause", "sort_clause", "sortby_list",
 
2799
  "sortby", "select_limit", "opt_select_limit", "select_limit_value",
 
2800
  "opt_select_fetch_first_value", "select_offset_value",
 
2801
  "select_offset_value2", "row_or_rows", "first_or_next", "group_clause",
 
2802
  "having_clause", "for_locking_clause", "opt_for_locking_clause",
 
2803
  "for_locking_items", "for_locking_item", "locked_rels_list",
 
2804
  "values_clause", "from_clause", "from_list", "table_ref", "joined_table",
 
2805
  "alias_clause", "join_type", "join_outer", "join_qual", "relation_expr",
 
2806
  "relation_expr_list", "relation_expr_opt_alias", "func_table",
 
2807
  "where_clause", "where_or_current_clause", "TableFuncElementList",
 
2808
  "TableFuncElement", "Typename", "opt_array_bounds", "SimpleTypename",
 
2809
  "ConstTypename", "GenericType", "opt_type_modifiers", "Numeric",
 
2810
  "opt_float", "Bit", "ConstBit", "BitWithLength", "BitWithoutLength",
 
2811
  "Character", "ConstCharacter", "CharacterWithLength",
 
2812
  "CharacterWithoutLength", "character", "opt_varying", "opt_charset",
 
2813
  "ConstDatetime", "ConstInterval", "opt_timezone", "opt_interval",
 
2814
  "interval_second", "a_expr", "b_expr", "c_expr", "func_expr",
 
2815
  "xml_root_version", "opt_xml_root_standalone", "xml_attributes",
 
2816
  "xml_attribute_list", "xml_attribute_el", "document_or_content",
 
2817
  "xml_whitespace_option", "window_clause", "window_definition_list",
 
2818
  "window_definition", "over_clause", "window_specification",
 
2819
  "opt_existing_window_name", "opt_partition_clause", "opt_frame_clause",
 
2820
  "frame_extent", "frame_bound", "row", "sub_type", "all_Op", "MathOp",
 
2821
  "qual_Op", "qual_all_Op", "subquery_Op", "expr_list", "type_list",
 
2822
  "array_expr", "array_expr_list", "extract_list", "extract_arg",
 
2823
  "overlay_list", "overlay_placing", "position_list", "substr_list",
 
2824
  "substr_from", "substr_for", "trim_list", "in_expr", "case_expr",
 
2825
  "when_clause_list", "when_clause", "case_default", "case_arg",
 
2826
  "columnref", "indirection_el", "indirection", "opt_indirection",
 
2827
  "opt_asymmetric", "ctext_expr", "ctext_expr_list", "ctext_row",
 
2828
  "target_list", "target_el", "relation_name", "qualified_name_list",
 
2829
  "qualified_name", "name_list", "name", "database_name", "access_method",
 
2830
  "attr_name", "index_name", "file_name", "func_name", "AexprConst",
 
2831
  "Iconst", "RoleId", "SignedIconst", "unreserved_keyword",
 
2832
  "col_name_keyword", "type_func_name_keyword", "reserved_keyword",
 
2833
  "SpecialRuleRelation", "statements", "statement", "CreateAsStmt", "$@1",
 
2834
  "RuleStmt", "$@2", "at", "ECPGConnect", "connection_target",
 
2835
  "opt_database_name", "db_prefix", "server", "opt_server", "server_name",
 
2836
  "opt_port", "opt_connection_name", "opt_user", "ora_user", "user_name",
 
2837
  "char_variable", "opt_options", "connect_options", "opt_opt_value",
 
2838
  "prepared_name", "ECPGCursorStmt", "ECPGExecuteImmediateStmt",
 
2839
  "ECPGVarDeclaration", "single_vt_declaration", "precision", "opt_scale",
 
2840
  "ecpg_interval", "ECPGDeclaration", "$@3", "sql_startdeclare",
 
2841
  "sql_enddeclare", "var_type_declarations", "vt_declarations",
 
2842
  "variable_declarations", "type_declaration", "$@4", "var_declaration",
 
2843
  "$@5", "$@6", "opt_bit_field", "storage_declaration", "storage_clause",
 
2844
  "storage_modifier", "var_type", "enum_type", "enum_definition",
 
2845
  "struct_union_type_with_symbol", "$@7", "struct_union_type", "$@8",
 
2846
  "s_struct_union_symbol", "s_struct_union", "simple_type",
 
2847
  "unsigned_type", "signed_type", "opt_signed", "variable_list",
 
2848
  "variable", "opt_initializer", "opt_pointer", "ECPGDeclare",
 
2849
  "ECPGDisconnect", "dis_name", "connection_object", "execstring",
 
2850
  "ECPGFree", "ECPGOpen", "opt_ecpg_using", "ecpg_using",
 
2851
  "using_descriptor", "into_descriptor", "opt_sql", "using_list",
 
2852
  "UsingValue", "UsingConst", "ECPGDescribe", "opt_output",
 
2853
  "ECPGAllocateDescr", "ECPGDeallocateDescr", "ECPGGetDescriptorHeader",
 
2854
  "ECPGGetDescHeaderItems", "ECPGGetDescHeaderItem",
 
2855
  "ECPGSetDescriptorHeader", "ECPGSetDescHeaderItems",
 
2856
  "ECPGSetDescHeaderItem", "IntConstVar", "desc_header_item",
 
2857
  "ECPGGetDescriptor", "ECPGGetDescItems", "ECPGGetDescItem",
 
2858
  "ECPGSetDescriptor", "ECPGSetDescItems", "ECPGSetDescItem",
 
2859
  "AllConstVar", "descriptor_item", "ECPGSetAutocommit", "on_off",
 
2860
  "ECPGSetConnection", "ECPGTypedef", "$@9", "opt_reference", "ECPGVar",
 
2861
  "$@10", "ECPGWhenever", "action", "ECPGKeywords", "ECPGKeywords_vanames",
 
2862
  "ECPGKeywords_rest", "ECPGTypeName", "symbol", "ECPGColId", "ColId",
 
2863
  "type_function_name", "ColLabel", "ECPGColLabel", "ECPGColLabelCommon",
 
2864
  "ECPGCKeywords", "all_unreserved_keyword", "ECPGunreserved_interval",
 
2865
  "into_list", "ecpgstart", "c_args", "coutputvariable", "civarind",
 
2866
  "civar", "indicator", "cvariable", "ecpg_param", "ecpg_bconst",
 
2867
  "ecpg_fconst", "ecpg_sconst", "ecpg_xconst", "ecpg_ident",
 
2868
  "quoted_ident_stringvar", "c_stuff_item", "c_stuff", "c_list", "c_term",
 
2869
  "c_thing", "c_anything", "DeallocateStmt", "Iresult", "execute_rest",
3207
2870
  "ecpg_into", 0
3208
2871
};
3209
2872
#endif
3211
2874
# ifdef YYPRINT
3212
2875
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
3213
2876
   token YYLEX-NUM.  */
3214
 
static const unsigned short yytoknum[] =
 
2877
static const yytype_uint16 yytoknum[] =
3215
2878
{
3216
2879
       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
3217
2880
     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
3268
2931
# endif
3269
2932
 
3270
2933
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
3271
 
static const unsigned short yyr1[] =
 
2934
static const yytype_uint16 yyr1[] =
3272
2935
{
3273
2936
       0,   505,   506,   507,   507,   507,   507,   507,   507,   507,
3274
2937
     507,   507,   507,   507,   507,   507,   507,   507,   507,   507,
3519
3182
};
3520
3183
 
3521
3184
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
3522
 
static const unsigned char yyr2[] =
 
3185
static const yytype_uint8 yyr2[] =
3523
3186
{
3524
3187
       0,     2,     1,     1,     1,     1,     1,     1,     1,     1,
3525
3188
       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
3772
3435
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
3773
3436
   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
3774
3437
   means the default is an error.  */
3775
 
static const unsigned short yydefact[] =
 
3438
static const yytype_uint16 yydefact[] =
3776
3439
{
3777
3440
    1980,     0,     2,     1,  2410,  2414,  2418,  2419,  2337,  2420,
3778
3441
    2421,  2386,  2387,  2388,  2389,  2390,  2391,  2392,  2393,  2394,
4202
3865
     505
4203
3866
};
4204
3867
 
4205
 
/* YYDEFGOTO[NTERM-NUM]. */
4206
 
static const short yydefgoto[] =
 
3868
/* YYDEFGOTO[NTERM-NUM].  */
 
3869
static const yytype_int16 yydefgoto[] =
4207
3870
{
4208
3871
      -1,     1,   245,   246,  1588,  2252,  2821,   247,   248,   249,
4209
3872
     250,   251,   252,   253,   254,   255,  1618,   256,   257,  1215,
4703
4366
};
4704
4367
 
4705
4368
/* YYPGOTO[NTERM-NUM].  */
4706
 
static const short yypgoto[] =
 
4369
static const yytype_int16 yypgoto[] =
4707
4370
{
4708
4371
   -3712, -3712,  3210, -3712, -1112, -1376, -3712, -3712, -3712, -3712,
4709
4372
   -3712, -3712, -3712, -3712, -3712, -3712, -3712, -3712, -3712, -3712,
4774
4437
   number is the opposite.  If zero, do what YYDEFACT says.
4775
4438
   If YYTABLE_NINF, syntax error.  */
4776
4439
#define YYTABLE_NINF -2298
4777
 
static const short yytable[] =
 
4440
static const yytype_int16 yytable[] =
4778
4441
{
4779
4442
      80,  1564,   944,  1042,  1147,  1814,  1212,  1513,  1514,    79,
4780
4443
     873,   344,  1449,  1515,   791,  1822,   343,   885,  1900,  2239,
13283
12946
       0,    55
13284
12947
};
13285
12948
 
13286
 
static const short yycheck[] =
 
12949
static const yytype_int16 yycheck[] =
13287
12950
{
13288
12951
       2,  1097,   165,   244,   816,  1252,   854,  1052,  1052,     2,
13289
12952
     151,    78,  1001,  1054,   117,  1259,    78,   152,  1323,  1629,
21794
21457
 
21795
21458
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
21796
21459
   symbol of state STATE-NUM.  */
21797
 
static const unsigned short yystos[] =
 
21460
static const yytype_uint16 yystos[] =
21798
21461
{
21799
21462
       0,   506,   973,     0,     5,    25,    35,    36,    41,    43,
21800
21463
      44,    47,    48,    49,    50,    51,    52,    53,    54,    55,
22224
21887
     498
22225
21888
};
22226
21889
 
22227
 
#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
22228
 
# define YYSIZE_T __SIZE_TYPE__
22229
 
#endif
22230
 
#if ! defined (YYSIZE_T) && defined (size_t)
22231
 
# define YYSIZE_T size_t
22232
 
#endif
22233
 
#if ! defined (YYSIZE_T)
22234
 
# if defined (__STDC__) || defined (__cplusplus)
22235
 
#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
22236
 
#  define YYSIZE_T size_t
22237
 
# endif
22238
 
#endif
22239
 
#if ! defined (YYSIZE_T)
22240
 
# define YYSIZE_T unsigned int
22241
 
#endif
22242
 
 
22243
21890
#define yyerrok         (yyerrstatus = 0)
22244
21891
#define yyclearin       (yychar = YYEMPTY)
22245
21892
#define YYEMPTY         (-2)
22247
21894
 
22248
21895
#define YYACCEPT        goto yyacceptlab
22249
21896
#define YYABORT         goto yyabortlab
22250
 
#define YYERROR         goto yyerrlab1
 
21897
#define YYERROR         goto yyerrorlab
 
21898
 
22251
21899
 
22252
21900
/* Like YYERROR except do call yyerror.  This remains here temporarily
22253
21901
   to ease the transition to the new meaning of YYERROR, for GCC.
22264
21912
      yychar = (Token);                                         \
22265
21913
      yylval = (Value);                                         \
22266
21914
      yytoken = YYTRANSLATE (yychar);                           \
22267
 
      YYPOPSTACK;                                               \
 
21915
      YYPOPSTACK (1);                                           \
22268
21916
      goto yybackup;                                            \
22269
21917
    }                                                           \
22270
21918
  else                                                          \
22271
 
    {                                                           \
22272
 
      yyerror ("syntax error: cannot back up");\
 
21919
    {                                                           \
 
21920
      yyerror (YY_("syntax error: cannot back up")); \
22273
21921
      YYERROR;                                                  \
22274
21922
    }                                                           \
22275
 
while (0)
 
21923
while (YYID (0))
 
21924
 
22276
21925
 
22277
21926
#define YYTERROR        1
22278
21927
#define YYERRCODE       256
22279
21928
 
22280
 
/* YYLLOC_DEFAULT -- Compute the default location (before the actions
22281
 
   are run).  */
22282
 
 
 
21929
 
 
21930
/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
 
21931
   If N is 0, then set CURRENT to the empty location which ends
 
21932
   the previous symbol: RHS[0] (always defined).  */
 
21933
 
 
21934
#define YYRHSLOC(Rhs, K) ((Rhs)[K])
22283
21935
#ifndef YYLLOC_DEFAULT
22284
 
# define YYLLOC_DEFAULT(Current, Rhs, N)         \
22285
 
  Current.first_line   = Rhs[1].first_line;      \
22286
 
  Current.first_column = Rhs[1].first_column;    \
22287
 
  Current.last_line    = Rhs[N].last_line;       \
22288
 
  Current.last_column  = Rhs[N].last_column;
22289
 
#endif
 
21936
# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
 
21937
    do                                                                  \
 
21938
      if (YYID (N))                                                    \
 
21939
        {                                                               \
 
21940
          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
 
21941
          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
 
21942
          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
 
21943
          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
 
21944
        }                                                               \
 
21945
      else                                                              \
 
21946
        {                                                               \
 
21947
          (Current).first_line   = (Current).last_line   =              \
 
21948
            YYRHSLOC (Rhs, 0).last_line;                                \
 
21949
          (Current).first_column = (Current).last_column =              \
 
21950
            YYRHSLOC (Rhs, 0).last_column;                              \
 
21951
        }                                                               \
 
21952
    while (YYID (0))
 
21953
#endif
 
21954
 
 
21955
 
 
21956
/* YY_LOCATION_PRINT -- Print the location on the stream.
 
21957
   This macro was not mandated originally: define only if we know
 
21958
   we won't break user code: when these are the locations we know.  */
 
21959
 
 
21960
#ifndef YY_LOCATION_PRINT
 
21961
# if YYLTYPE_IS_TRIVIAL
 
21962
#  define YY_LOCATION_PRINT(File, Loc)                  \
 
21963
     fprintf (File, "%d.%d-%d.%d",                      \
 
21964
              (Loc).first_line, (Loc).first_column,     \
 
21965
              (Loc).last_line,  (Loc).last_column)
 
21966
# else
 
21967
#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
 
21968
# endif
 
21969
#endif
 
21970
 
22290
21971
 
22291
21972
/* YYLEX -- calling `yylex' with the right arguments.  */
22292
21973
 
22308
21989
do {                                            \
22309
21990
  if (yydebug)                                  \
22310
21991
    YYFPRINTF Args;                             \
22311
 
} while (0)
22312
 
 
22313
 
# define YYDSYMPRINT(Args)                      \
22314
 
do {                                            \
22315
 
  if (yydebug)                                  \
22316
 
    yysymprint Args;                            \
22317
 
} while (0)
22318
 
 
22319
 
# define YYDSYMPRINTF(Title, Token, Value, Location)            \
22320
 
do {                                                            \
22321
 
  if (yydebug)                                                  \
22322
 
    {                                                           \
22323
 
      YYFPRINTF (stderr, "%s ", Title);                         \
22324
 
      yysymprint (stderr,                                       \
22325
 
                  Token, Value, Location);      \
22326
 
      YYFPRINTF (stderr, "\n");                                 \
22327
 
    }                                                           \
22328
 
} while (0)
 
21992
} while (YYID (0))
 
21993
 
 
21994
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
 
21995
do {                                                                      \
 
21996
  if (yydebug)                                                            \
 
21997
    {                                                                     \
 
21998
      YYFPRINTF (stderr, "%s ", Title);                                   \
 
21999
      yy_symbol_print (stderr,                                            \
 
22000
                  Type, Value, Location); \
 
22001
      YYFPRINTF (stderr, "\n");                                           \
 
22002
    }                                                                     \
 
22003
} while (YYID (0))
 
22004
 
 
22005
 
 
22006
/*--------------------------------.
 
22007
| Print this symbol on YYOUTPUT.  |
 
22008
`--------------------------------*/
 
22009
 
 
22010
/*ARGSUSED*/
 
22011
#if (defined __STDC__ || defined __C99__FUNC__ \
 
22012
     || defined __cplusplus || defined _MSC_VER)
 
22013
static void
 
22014
yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
 
22015
#else
 
22016
static void
 
22017
yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp)
 
22018
    FILE *yyoutput;
 
22019
    int yytype;
 
22020
    YYSTYPE const * const yyvaluep;
 
22021
    YYLTYPE const * const yylocationp;
 
22022
#endif
 
22023
{
 
22024
  if (!yyvaluep)
 
22025
    return;
 
22026
  YYUSE (yylocationp);
 
22027
# ifdef YYPRINT
 
22028
  if (yytype < YYNTOKENS)
 
22029
    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 
22030
# else
 
22031
  YYUSE (yyoutput);
 
22032
# endif
 
22033
  switch (yytype)
 
22034
    {
 
22035
      default:
 
22036
        break;
 
22037
    }
 
22038
}
 
22039
 
 
22040
 
 
22041
/*--------------------------------.
 
22042
| Print this symbol on YYOUTPUT.  |
 
22043
`--------------------------------*/
 
22044
 
 
22045
#if (defined __STDC__ || defined __C99__FUNC__ \
 
22046
     || defined __cplusplus || defined _MSC_VER)
 
22047
static void
 
22048
yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
 
22049
#else
 
22050
static void
 
22051
yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp)
 
22052
    FILE *yyoutput;
 
22053
    int yytype;
 
22054
    YYSTYPE const * const yyvaluep;
 
22055
    YYLTYPE const * const yylocationp;
 
22056
#endif
 
22057
{
 
22058
  if (yytype < YYNTOKENS)
 
22059
    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
 
22060
  else
 
22061
    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 
22062
 
 
22063
  YY_LOCATION_PRINT (yyoutput, *yylocationp);
 
22064
  YYFPRINTF (yyoutput, ": ");
 
22065
  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp);
 
22066
  YYFPRINTF (yyoutput, ")");
 
22067
}
22329
22068
 
22330
22069
/*------------------------------------------------------------------.
22331
22070
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
22332
 
| TOP (cinluded).                                                   |
 
22071
| TOP (included).                                                   |
22333
22072
`------------------------------------------------------------------*/
22334
22073
 
22335
 
#if defined (__STDC__) || defined (__cplusplus)
 
22074
#if (defined __STDC__ || defined __C99__FUNC__ \
 
22075
     || defined __cplusplus || defined _MSC_VER)
22336
22076
static void
22337
 
yy_stack_print (short *bottom, short *top)
 
22077
yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
22338
22078
#else
22339
22079
static void
22340
 
yy_stack_print (bottom, top)
22341
 
    short *bottom;
22342
 
    short *top;
 
22080
yy_stack_print (yybottom, yytop)
 
22081
    yytype_int16 *yybottom;
 
22082
    yytype_int16 *yytop;
22343
22083
#endif
22344
22084
{
22345
22085
  YYFPRINTF (stderr, "Stack now");
22346
 
  for (/* Nothing. */; bottom <= top; ++bottom)
22347
 
    YYFPRINTF (stderr, " %d", *bottom);
 
22086
  for (; yybottom <= yytop; yybottom++)
 
22087
    {
 
22088
      int yybot = *yybottom;
 
22089
      YYFPRINTF (stderr, " %d", yybot);
 
22090
    }
22348
22091
  YYFPRINTF (stderr, "\n");
22349
22092
}
22350
22093
 
22352
22095
do {                                                            \
22353
22096
  if (yydebug)                                                  \
22354
22097
    yy_stack_print ((Bottom), (Top));                           \
22355
 
} while (0)
 
22098
} while (YYID (0))
22356
22099
 
22357
22100
 
22358
22101
/*------------------------------------------------.
22359
22102
| Report that the YYRULE is going to be reduced.  |
22360
22103
`------------------------------------------------*/
22361
22104
 
22362
 
#if defined (__STDC__) || defined (__cplusplus)
 
22105
#if (defined __STDC__ || defined __C99__FUNC__ \
 
22106
     || defined __cplusplus || defined _MSC_VER)
22363
22107
static void
22364
 
yy_reduce_print (int yyrule)
 
22108
yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule)
22365
22109
#else
22366
22110
static void
22367
 
yy_reduce_print (yyrule)
 
22111
yy_reduce_print (yyvsp, yylsp, yyrule)
 
22112
    YYSTYPE *yyvsp;
 
22113
    YYLTYPE *yylsp;
22368
22114
    int yyrule;
22369
22115
#endif
22370
22116
{
 
22117
  int yynrhs = yyr2[yyrule];
22371
22118
  int yyi;
22372
 
  unsigned int yylineno = yyrline[yyrule];
22373
 
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
22374
 
             yyrule - 1, yylineno);
22375
 
  /* Print the symbols being reduced, and their result.  */
22376
 
  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
22377
 
    YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
22378
 
  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
 
22119
  unsigned long int yylno = yyrline[yyrule];
 
22120
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
 
22121
             yyrule - 1, yylno);
 
22122
  /* The symbols being reduced.  */
 
22123
  for (yyi = 0; yyi < yynrhs; yyi++)
 
22124
    {
 
22125
      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
 
22126
      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
 
22127
                       &(yyvsp[(yyi + 1) - (yynrhs)])
 
22128
                       , &(yylsp[(yyi + 1) - (yynrhs)])                );
 
22129
      YYFPRINTF (stderr, "\n");
 
22130
    }
22379
22131
}
22380
22132
 
22381
22133
# define YY_REDUCE_PRINT(Rule)          \
22382
22134
do {                                    \
22383
22135
  if (yydebug)                          \
22384
 
    yy_reduce_print (Rule);             \
22385
 
} while (0)
 
22136
    yy_reduce_print (yyvsp, yylsp, Rule); \
 
22137
} while (YYID (0))
22386
22138
 
22387
22139
/* Nonzero means print parse trace.  It is left uninitialized so that
22388
22140
   multiple parsers can coexist.  */
22389
22141
int yydebug;
22390
22142
#else /* !YYDEBUG */
22391
22143
# define YYDPRINTF(Args)
22392
 
# define YYDSYMPRINT(Args)
22393
 
# define YYDSYMPRINTF(Title, Token, Value, Location)
 
22144
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
22394
22145
# define YY_STACK_PRINT(Bottom, Top)
22395
22146
# define YY_REDUCE_PRINT(Rule)
22396
22147
#endif /* !YYDEBUG */
22405
22156
   if the built-in stack extension method is used).
22406
22157
 
22407
22158
   Do not make this value too large; the results are undefined if
22408
 
   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
 
22159
   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
22409
22160
   evaluated with infinite-precision integer arithmetic.  */
22410
22161
 
22411
 
#if YYMAXDEPTH == 0
22412
 
# undef YYMAXDEPTH
22413
 
#endif
22414
 
 
22415
22162
#ifndef YYMAXDEPTH
22416
22163
# define YYMAXDEPTH 10000
22417
22164
#endif
22421
22168
#if YYERROR_VERBOSE
22422
22169
 
22423
22170
# ifndef yystrlen
22424
 
#  if defined (__GLIBC__) && defined (_STRING_H)
 
22171
#  if defined __GLIBC__ && defined _STRING_H
22425
22172
#   define yystrlen strlen
22426
22173
#  else
22427
22174
/* Return the length of YYSTR.  */
 
22175
#if (defined __STDC__ || defined __C99__FUNC__ \
 
22176
     || defined __cplusplus || defined _MSC_VER)
22428
22177
static YYSIZE_T
22429
 
#   if defined (__STDC__) || defined (__cplusplus)
22430
22178
yystrlen (const char *yystr)
22431
 
#   else
 
22179
#else
 
22180
static YYSIZE_T
22432
22181
yystrlen (yystr)
22433
 
     const char *yystr;
22434
 
#   endif
 
22182
    const char *yystr;
 
22183
#endif
22435
22184
{
22436
 
  register const char *yys = yystr;
22437
 
 
22438
 
  while (*yys++ != '\0')
 
22185
  YYSIZE_T yylen;
 
22186
  for (yylen = 0; yystr[yylen]; yylen++)
22439
22187
    continue;
22440
 
 
22441
 
  return yys - yystr - 1;
 
22188
  return yylen;
22442
22189
}
22443
22190
#  endif
22444
22191
# endif
22445
22192
 
22446
22193
# ifndef yystpcpy
22447
 
#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
 
22194
#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
22448
22195
#   define yystpcpy stpcpy
22449
22196
#  else
22450
22197
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
22451
22198
   YYDEST.  */
 
22199
#if (defined __STDC__ || defined __C99__FUNC__ \
 
22200
     || defined __cplusplus || defined _MSC_VER)
22452
22201
static char *
22453
 
#   if defined (__STDC__) || defined (__cplusplus)
22454
22202
yystpcpy (char *yydest, const char *yysrc)
22455
 
#   else
 
22203
#else
 
22204
static char *
22456
22205
yystpcpy (yydest, yysrc)
22457
 
     char *yydest;
22458
 
     const char *yysrc;
22459
 
#   endif
 
22206
    char *yydest;
 
22207
    const char *yysrc;
 
22208
#endif
22460
22209
{
22461
 
  register char *yyd = yydest;
22462
 
  register const char *yys = yysrc;
 
22210
  char *yyd = yydest;
 
22211
  const char *yys = yysrc;
22463
22212
 
22464
22213
  while ((*yyd++ = *yys++) != '\0')
22465
22214
    continue;
22469
22218
#  endif
22470
22219
# endif
22471
22220
 
22472
 
#endif /* !YYERROR_VERBOSE */
22473
 
 
 
22221
# ifndef yytnamerr
 
22222
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
 
22223
   quotes and backslashes, so that it's suitable for yyerror.  The
 
22224
   heuristic is that double-quoting is unnecessary unless the string
 
22225
   contains an apostrophe, a comma, or backslash (other than
 
22226
   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
 
22227
   null, do not copy; instead, return the length of what the result
 
22228
   would have been.  */
 
22229
static YYSIZE_T
 
22230
yytnamerr (char *yyres, const char *yystr)
 
22231
{
 
22232
  if (*yystr == '"')
 
22233
    {
 
22234
      YYSIZE_T yyn = 0;
 
22235
      char const *yyp = yystr;
 
22236
 
 
22237
      for (;;)
 
22238
        switch (*++yyp)
 
22239
          {
 
22240
          case '\'':
 
22241
          case ',':
 
22242
            goto do_not_strip_quotes;
 
22243
 
 
22244
          case '\\':
 
22245
            if (*++yyp != '\\')
 
22246
              goto do_not_strip_quotes;
 
22247
            /* Fall through.  */
 
22248
          default:
 
22249
            if (yyres)
 
22250
              yyres[yyn] = *yyp;
 
22251
            yyn++;
 
22252
            break;
 
22253
 
 
22254
          case '"':
 
22255
            if (yyres)
 
22256
              yyres[yyn] = '\0';
 
22257
            return yyn;
 
22258
          }
 
22259
    do_not_strip_quotes: ;
 
22260
    }
 
22261
 
 
22262
  if (! yyres)
 
22263
    return yystrlen (yystr);
 
22264
 
 
22265
  return yystpcpy (yyres, yystr) - yyres;
 
22266
}
 
22267
# endif
 
22268
 
 
22269
/* Copy into YYRESULT an error message about the unexpected token
 
22270
   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
 
22271
   including the terminating null byte.  If YYRESULT is null, do not
 
22272
   copy anything; just return the number of bytes that would be
 
22273
   copied.  As a special case, return 0 if an ordinary "syntax error"
 
22274
   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
 
22275
   size calculation.  */
 
22276
static YYSIZE_T
 
22277
yysyntax_error (char *yyresult, int yystate, int yychar)
 
22278
{
 
22279
  int yyn = yypact[yystate];
 
22280
 
 
22281
  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
 
22282
    return 0;
 
22283
  else
 
22284
    {
 
22285
      int yytype = YYTRANSLATE (yychar);
 
22286
      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
 
22287
      YYSIZE_T yysize = yysize0;
 
22288
      YYSIZE_T yysize1;
 
22289
      int yysize_overflow = 0;
 
22290
      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
 
22291
      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
 
22292
      int yyx;
 
22293
 
 
22294
# if 0
 
22295
      /* This is so xgettext sees the translatable formats that are
 
22296
         constructed on the fly.  */
 
22297
      YY_("syntax error, unexpected %s");
 
22298
      YY_("syntax error, unexpected %s, expecting %s");
 
22299
      YY_("syntax error, unexpected %s, expecting %s or %s");
 
22300
      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
 
22301
      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
 
22302
# endif
 
22303
      char *yyfmt;
 
22304
      char const *yyf;
 
22305
      static char const yyunexpected[] = "syntax error, unexpected %s";
 
22306
      static char const yyexpecting[] = ", expecting %s";
 
22307
      static char const yyor[] = " or %s";
 
22308
      char yyformat[sizeof yyunexpected
 
22309
                    + sizeof yyexpecting - 1
 
22310
                    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
 
22311
                       * (sizeof yyor - 1))];
 
22312
      char const *yyprefix = yyexpecting;
 
22313
 
 
22314
      /* Start YYX at -YYN if negative to avoid negative indexes in
 
22315
         YYCHECK.  */
 
22316
      int yyxbegin = yyn < 0 ? -yyn : 0;
 
22317
 
 
22318
      /* Stay within bounds of both yycheck and yytname.  */
 
22319
      int yychecklim = YYLAST - yyn + 1;
 
22320
      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
 
22321
      int yycount = 1;
 
22322
 
 
22323
      yyarg[0] = yytname[yytype];
 
22324
      yyfmt = yystpcpy (yyformat, yyunexpected);
 
22325
 
 
22326
      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
 
22327
        if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
 
22328
          {
 
22329
            if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
 
22330
              {
 
22331
                yycount = 1;
 
22332
                yysize = yysize0;
 
22333
                yyformat[sizeof yyunexpected - 1] = '\0';
 
22334
                break;
 
22335
              }
 
22336
            yyarg[yycount++] = yytname[yyx];
 
22337
            yysize1 = yysize + yytnamerr (0, yytname[yyx]);
 
22338
            yysize_overflow |= (yysize1 < yysize);
 
22339
            yysize = yysize1;
 
22340
            yyfmt = yystpcpy (yyfmt, yyprefix);
 
22341
            yyprefix = yyor;
 
22342
          }
 
22343
 
 
22344
      yyf = YY_(yyformat);
 
22345
      yysize1 = yysize + yystrlen (yyf);
 
22346
      yysize_overflow |= (yysize1 < yysize);
 
22347
      yysize = yysize1;
 
22348
 
 
22349
      if (yysize_overflow)
 
22350
        return YYSIZE_MAXIMUM;
 
22351
 
 
22352
      if (yyresult)
 
22353
        {
 
22354
          /* Avoid sprintf, as that infringes on the user's name space.
 
22355
             Don't have undefined behavior even if the translation
 
22356
             produced a string with the wrong number of "%s"s.  */
 
22357
          char *yyp = yyresult;
 
22358
          int yyi = 0;
 
22359
          while ((*yyp = *yyf) != '\0')
 
22360
            {
 
22361
              if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
 
22362
                {
 
22363
                  yyp += yytnamerr (yyp, yyarg[yyi++]);
 
22364
                  yyf += 2;
 
22365
                }
 
22366
              else
 
22367
                {
 
22368
                  yyp++;
 
22369
                  yyf++;
 
22370
                }
 
22371
            }
 
22372
        }
 
22373
      return yysize;
 
22374
    }
 
22375
}
 
22376
#endif /* YYERROR_VERBOSE */
22474
22377
 
22475
22378
 
22476
 
#if YYDEBUG
22477
 
/*--------------------------------.
22478
 
| Print this symbol on YYOUTPUT.  |
22479
 
`--------------------------------*/
22480
 
 
22481
 
#if defined (__STDC__) || defined (__cplusplus)
22482
 
static void
22483
 
yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
22484
 
#else
22485
 
static void
22486
 
yysymprint (yyoutput, yytype, yyvaluep, yylocationp)
22487
 
    FILE *yyoutput;
22488
 
    int yytype;
22489
 
    YYSTYPE *yyvaluep;
22490
 
    YYLTYPE *yylocationp;
22491
 
#endif
22492
 
{
22493
 
  /* Pacify ``unused variable'' warnings.  */
22494
 
  (void) yyvaluep;
22495
 
  (void) yylocationp;
22496
 
 
22497
 
  if (yytype < YYNTOKENS)
22498
 
    {
22499
 
      YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
22500
 
# ifdef YYPRINT
22501
 
      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
22502
 
# endif
22503
 
    }
22504
 
  else
22505
 
    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
22506
 
 
22507
 
  switch (yytype)
22508
 
    {
22509
 
      default:
22510
 
        break;
22511
 
    }
22512
 
  YYFPRINTF (yyoutput, ")");
22513
 
}
22514
 
 
22515
 
#endif /* ! YYDEBUG */
22516
22379
/*-----------------------------------------------.
22517
22380
| Release the memory associated to this symbol.  |
22518
22381
`-----------------------------------------------*/
22519
22382
 
22520
 
#if defined (__STDC__) || defined (__cplusplus)
 
22383
/*ARGSUSED*/
 
22384
#if (defined __STDC__ || defined __C99__FUNC__ \
 
22385
     || defined __cplusplus || defined _MSC_VER)
22521
22386
static void
22522
 
yydestruct (int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
 
22387
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
22523
22388
#else
22524
22389
static void
22525
 
yydestruct (yytype, yyvaluep, yylocationp)
 
22390
yydestruct (yymsg, yytype, yyvaluep, yylocationp)
 
22391
    const char *yymsg;
22526
22392
    int yytype;
22527
22393
    YYSTYPE *yyvaluep;
22528
22394
    YYLTYPE *yylocationp;
22529
22395
#endif
22530
22396
{
22531
 
  /* Pacify ``unused variable'' warnings.  */
22532
 
  (void) yyvaluep;
22533
 
  (void) yylocationp;
 
22397
  YYUSE (yyvaluep);
 
22398
  YYUSE (yylocationp);
 
22399
 
 
22400
  if (!yymsg)
 
22401
    yymsg = "Deleting";
 
22402
  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
22534
22403
 
22535
22404
  switch (yytype)
22536
22405
    {
22537
22406
 
22538
22407
      default:
22539
 
        break;
 
22408
        break;
22540
22409
    }
22541
22410
}
22542
 
 
22543
22411
 
22544
22412
/* Prevent warnings from -Wmissing-prototypes.  */
22545
 
 
22546
22413
#ifdef YYPARSE_PARAM
22547
 
# if defined (__STDC__) || defined (__cplusplus)
 
22414
#if defined __STDC__ || defined __cplusplus
22548
22415
int yyparse (void *YYPARSE_PARAM);
22549
 
# else
 
22416
#else
22550
22417
int yyparse ();
22551
 
# endif
 
22418
#endif
22552
22419
#else /* ! YYPARSE_PARAM */
22553
 
#if defined (__STDC__) || defined (__cplusplus)
 
22420
#if defined __STDC__ || defined __cplusplus
22554
22421
int yyparse (void);
22555
22422
#else
22556
22423
int yyparse ();
22558
22425
#endif /* ! YYPARSE_PARAM */
22559
22426
 
22560
22427
 
22561
 
 
22562
22428
/* The lookahead symbol.  */
22563
22429
int yychar;
22564
22430
 
22565
22431
/* The semantic value of the lookahead symbol.  */
22566
22432
YYSTYPE yylval;
22567
22433
 
 
22434
/* Location data for the lookahead symbol.  */
 
22435
YYLTYPE yylloc;
 
22436
 
22568
22437
/* Number of syntax errors so far.  */
22569
22438
int yynerrs;
22570
 
/* Location data for the lookahead symbol.  */
22571
 
YYLTYPE yylloc;
22572
 
 
22573
 
 
22574
 
 
22575
 
/*----------.
22576
 
| yyparse.  |
22577
 
`----------*/
 
22439
 
 
22440
 
 
22441
 
 
22442
/*-------------------------.
 
22443
| yyparse or yypush_parse.  |
 
22444
`-------------------------*/
22578
22445
 
22579
22446
#ifdef YYPARSE_PARAM
22580
 
# if defined (__STDC__) || defined (__cplusplus)
22581
 
int yyparse (void *YYPARSE_PARAM)
22582
 
# else
22583
 
int yyparse (YYPARSE_PARAM)
22584
 
  void *YYPARSE_PARAM;
22585
 
# endif
 
22447
#if (defined __STDC__ || defined __C99__FUNC__ \
 
22448
     || defined __cplusplus || defined _MSC_VER)
 
22449
int
 
22450
yyparse (void *YYPARSE_PARAM)
 
22451
#else
 
22452
int
 
22453
yyparse (YYPARSE_PARAM)
 
22454
    void *YYPARSE_PARAM;
 
22455
#endif
22586
22456
#else /* ! YYPARSE_PARAM */
22587
 
#if defined (__STDC__) || defined (__cplusplus)
 
22457
#if (defined __STDC__ || defined __C99__FUNC__ \
 
22458
     || defined __cplusplus || defined _MSC_VER)
22588
22459
int
22589
22460
yyparse (void)
22590
22461
#else
22594
22465
#endif
22595
22466
#endif
22596
22467
{
22597
 
  
22598
 
  register int yystate;
22599
 
  register int yyn;
 
22468
 
 
22469
 
 
22470
    int yystate;
 
22471
    /* Number of tokens to shift before error messages enabled.  */
 
22472
    int yyerrstatus;
 
22473
 
 
22474
    /* The stacks and their tools:
 
22475
       `yyss': related to states.
 
22476
       `yyvs': related to semantic values.
 
22477
       `yyls': related to locations.
 
22478
 
 
22479
       Refer to the stacks thru separate pointers, to allow yyoverflow
 
22480
       to reallocate them elsewhere.  */
 
22481
 
 
22482
    /* The state stack.  */
 
22483
    yytype_int16 yyssa[YYINITDEPTH];
 
22484
    yytype_int16 *yyss;
 
22485
    yytype_int16 *yyssp;
 
22486
 
 
22487
    /* The semantic value stack.  */
 
22488
    YYSTYPE yyvsa[YYINITDEPTH];
 
22489
    YYSTYPE *yyvs;
 
22490
    YYSTYPE *yyvsp;
 
22491
 
 
22492
    /* The location stack.  */
 
22493
    YYLTYPE yylsa[YYINITDEPTH];
 
22494
    YYLTYPE *yyls;
 
22495
    YYLTYPE *yylsp;
 
22496
 
 
22497
    /* The locations where the error started and ended.  */
 
22498
    YYLTYPE yyerror_range[2];
 
22499
 
 
22500
    YYSIZE_T yystacksize;
 
22501
 
 
22502
  int yyn;
22600
22503
  int yyresult;
22601
 
  /* Number of tokens to shift before error messages enabled.  */
22602
 
  int yyerrstatus;
22603
22504
  /* Lookahead token as an internal (translated) token number.  */
22604
 
  int yytoken = 0;
22605
 
 
22606
 
  /* Three stacks and their tools:
22607
 
     `yyss': related to states,
22608
 
     `yyvs': related to semantic values,
22609
 
     `yyls': related to locations.
22610
 
 
22611
 
     Refer to the stacks thru separate pointers, to allow yyoverflow
22612
 
     to reallocate them elsewhere.  */
22613
 
 
22614
 
  /* The state stack.  */
22615
 
  short yyssa[YYINITDEPTH];
22616
 
  short *yyss = yyssa;
22617
 
  register short *yyssp;
22618
 
 
22619
 
  /* The semantic value stack.  */
22620
 
  YYSTYPE yyvsa[YYINITDEPTH];
22621
 
  YYSTYPE *yyvs = yyvsa;
22622
 
  register YYSTYPE *yyvsp;
22623
 
 
22624
 
  /* The location stack.  */
22625
 
  YYLTYPE yylsa[YYINITDEPTH];
22626
 
  YYLTYPE *yyls = yylsa;
22627
 
  YYLTYPE *yylsp;
22628
 
  YYLTYPE *yylerrsp;
22629
 
 
22630
 
#define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
22631
 
 
22632
 
  YYSIZE_T yystacksize = YYINITDEPTH;
22633
 
 
 
22505
  int yytoken;
22634
22506
  /* The variables used to return semantic value and location from the
22635
22507
     action routines.  */
22636
22508
  YYSTYPE yyval;
22637
22509
  YYLTYPE yyloc;
22638
22510
 
22639
 
  /* When reducing, the number of symbols on the RHS of the reduced
22640
 
     rule.  */
22641
 
  int yylen;
 
22511
#if YYERROR_VERBOSE
 
22512
  /* Buffer for error messages, and its allocated size.  */
 
22513
  char yymsgbuf[128];
 
22514
  char *yymsg = yymsgbuf;
 
22515
  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
 
22516
#endif
 
22517
 
 
22518
#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
 
22519
 
 
22520
  /* The number of symbols on the RHS of the reduced rule.
 
22521
     Keep to zero when no symbol should be popped.  */
 
22522
  int yylen = 0;
 
22523
 
 
22524
  yytoken = 0;
 
22525
  yyss = yyssa;
 
22526
  yyvs = yyvsa;
 
22527
  yyls = yylsa;
 
22528
  yystacksize = YYINITDEPTH;
22642
22529
 
22643
22530
  YYDPRINTF ((stderr, "Starting parse\n"));
22644
22531
 
22645
22532
  yystate = 0;
22646
22533
  yyerrstatus = 0;
22647
22534
  yynerrs = 0;
22648
 
  yychar = YYEMPTY;             /* Cause a token to be read.  */
 
22535
  yychar = YYEMPTY; /* Cause a token to be read.  */
22649
22536
 
22650
22537
  /* Initialize stack pointers.
22651
22538
     Waste one element of value and location stack
22652
22539
     so that they stay on the same level as the state stack.
22653
22540
     The wasted elements are never initialized.  */
22654
 
 
22655
22541
  yyssp = yyss;
22656
22542
  yyvsp = yyvs;
22657
22543
  yylsp = yyls;
 
22544
 
 
22545
#if YYLTYPE_IS_TRIVIAL
 
22546
  /* Initialize the default location before parsing starts.  */
 
22547
  yylloc.first_line   = yylloc.last_line   = 1;
 
22548
  yylloc.first_column = yylloc.last_column = 1;
 
22549
#endif
 
22550
 
22658
22551
  goto yysetstate;
22659
22552
 
22660
22553
/*------------------------------------------------------------.
22662
22555
`------------------------------------------------------------*/
22663
22556
 yynewstate:
22664
22557
  /* In all cases, when you get here, the value and location stacks
22665
 
     have just been pushed. so pushing a state here evens the stacks.
22666
 
     */
 
22558
     have just been pushed.  So pushing a state here evens the stacks.  */
22667
22559
  yyssp++;
22668
22560
 
22669
22561
 yysetstate:
22676
22568
 
22677
22569
#ifdef yyoverflow
22678
22570
      {
22679
 
        /* Give user a chance to reallocate the stack. Use copies of
 
22571
        /* Give user a chance to reallocate the stack.  Use copies of
22680
22572
           these so that the &'s don't force the real ones into
22681
22573
           memory.  */
22682
22574
        YYSTYPE *yyvs1 = yyvs;
22683
 
        short *yyss1 = yyss;
 
22575
        yytype_int16 *yyss1 = yyss;
22684
22576
        YYLTYPE *yyls1 = yyls;
22685
22577
 
22686
22578
        /* Each stack pointer address is followed by the size of the
22687
22579
           data in use in that stack, in bytes.  This used to be a
22688
22580
           conditional around just the two extra args, but that might
22689
22581
           be undefined if yyoverflow is a macro.  */
22690
 
        yyoverflow ("parser stack overflow",
 
22582
        yyoverflow (YY_("memory exhausted"),
22691
22583
                    &yyss1, yysize * sizeof (*yyssp),
22692
22584
                    &yyvs1, yysize * sizeof (*yyvsp),
22693
22585
                    &yyls1, yysize * sizeof (*yylsp),
22694
22586
                    &yystacksize);
 
22587
 
22695
22588
        yyls = yyls1;
22696
22589
        yyss = yyss1;
22697
22590
        yyvs = yyvs1;
22698
22591
      }
22699
22592
#else /* no yyoverflow */
22700
22593
# ifndef YYSTACK_RELOCATE
22701
 
      goto yyoverflowlab;
 
22594
      goto yyexhaustedlab;
22702
22595
# else
22703
22596
      /* Extend the stack our own way.  */
22704
22597
      if (YYMAXDEPTH <= yystacksize)
22705
 
        goto yyoverflowlab;
 
22598
        goto yyexhaustedlab;
22706
22599
      yystacksize *= 2;
22707
22600
      if (YYMAXDEPTH < yystacksize)
22708
22601
        yystacksize = YYMAXDEPTH;
22709
22602
 
22710
22603
      {
22711
 
        short *yyss1 = yyss;
 
22604
        yytype_int16 *yyss1 = yyss;
22712
22605
        union yyalloc *yyptr =
22713
22606
          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
22714
22607
        if (! yyptr)
22715
 
          goto yyoverflowlab;
22716
 
        YYSTACK_RELOCATE (yyss);
22717
 
        YYSTACK_RELOCATE (yyvs);
22718
 
        YYSTACK_RELOCATE (yyls);
 
22608
          goto yyexhaustedlab;
 
22609
        YYSTACK_RELOCATE (yyss_alloc, yyss);
 
22610
        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
 
22611
        YYSTACK_RELOCATE (yyls_alloc, yyls);
22719
22612
#  undef YYSTACK_RELOCATE
22720
22613
        if (yyss1 != yyssa)
22721
22614
          YYSTACK_FREE (yyss1);
22736
22629
 
22737
22630
  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
22738
22631
 
 
22632
  if (yystate == YYFINAL)
 
22633
    YYACCEPT;
 
22634
 
22739
22635
  goto yybackup;
22740
22636
 
22741
22637
/*-----------.
22743
22639
`-----------*/
22744
22640
yybackup:
22745
22641
 
22746
 
/* Do appropriate processing given the current state.  */
22747
 
/* Read a lookahead token if we need one and don't already have one.  */
22748
 
/* yyresume: */
 
22642
  /* Do appropriate processing given the current state.  Read a
 
22643
     lookahead token if we need one and don't already have one.  */
22749
22644
 
22750
22645
  /* First try to decide what to do without reference to lookahead token.  */
22751
 
 
22752
22646
  yyn = yypact[yystate];
22753
22647
  if (yyn == YYPACT_NINF)
22754
22648
    goto yydefault;
22770
22664
  else
22771
22665
    {
22772
22666
      yytoken = YYTRANSLATE (yychar);
22773
 
      YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
 
22667
      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
22774
22668
    }
22775
22669
 
22776
22670
  /* If the proper action on seeing token YYTOKEN is to reduce or to
22787
22681
      goto yyreduce;
22788
22682
    }
22789
22683
 
22790
 
  if (yyn == YYFINAL)
22791
 
    YYACCEPT;
22792
 
 
22793
 
  /* Shift the lookahead token.  */
22794
 
  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
22795
 
 
22796
 
  /* Discard the token being shifted unless it is eof.  */
22797
 
  if (yychar != YYEOF)
22798
 
    yychar = YYEMPTY;
22799
 
 
22800
 
  *++yyvsp = yylval;
22801
 
  *++yylsp = yylloc;
22802
 
 
22803
22684
  /* Count tokens shifted since error; after three, turn off error
22804
22685
     status.  */
22805
22686
  if (yyerrstatus)
22806
22687
    yyerrstatus--;
22807
22688
 
 
22689
  /* Shift the lookahead token.  */
 
22690
  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 
22691
 
 
22692
  /* Discard the shifted token.  */
 
22693
  yychar = YYEMPTY;
 
22694
 
22808
22695
  yystate = yyn;
 
22696
  *++yyvsp = yylval;
 
22697
  *++yylsp = yylloc;
22809
22698
  goto yynewstate;
22810
22699
 
22811
22700
 
22836
22725
     GCC warning that YYVAL may be used uninitialized.  */
22837
22726
  yyval = yyvsp[1-yylen];
22838
22727
 
22839
 
  /* Default location. */
 
22728
  /* Default location.  */
22840
22729
  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
22841
22730
  YY_REDUCE_PRINT (yyn);
22842
22731
  switch (yyn)
22843
22732
    {
22844
22733
        case 3:
 
22734
 
 
22735
/* Line 1455 of yacc.c  */
22845
22736
#line 1192 "preproc.y"
22846
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22737
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22847
22738
    break;
22848
22739
 
22849
22740
  case 4:
 
22741
 
 
22742
/* Line 1455 of yacc.c  */
22850
22743
#line 1194 "preproc.y"
22851
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22744
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22852
22745
    break;
22853
22746
 
22854
22747
  case 5:
 
22748
 
 
22749
/* Line 1455 of yacc.c  */
22855
22750
#line 1196 "preproc.y"
22856
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22751
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22857
22752
    break;
22858
22753
 
22859
22754
  case 6:
 
22755
 
 
22756
/* Line 1455 of yacc.c  */
22860
22757
#line 1198 "preproc.y"
22861
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22758
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22862
22759
    break;
22863
22760
 
22864
22761
  case 7:
 
22762
 
 
22763
/* Line 1455 of yacc.c  */
22865
22764
#line 1200 "preproc.y"
22866
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22765
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22867
22766
    break;
22868
22767
 
22869
22768
  case 8:
 
22769
 
 
22770
/* Line 1455 of yacc.c  */
22870
22771
#line 1202 "preproc.y"
22871
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22772
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22872
22773
    break;
22873
22774
 
22874
22775
  case 9:
 
22776
 
 
22777
/* Line 1455 of yacc.c  */
22875
22778
#line 1204 "preproc.y"
22876
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22779
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22877
22780
    break;
22878
22781
 
22879
22782
  case 10:
 
22783
 
 
22784
/* Line 1455 of yacc.c  */
22880
22785
#line 1206 "preproc.y"
22881
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22786
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22882
22787
    break;
22883
22788
 
22884
22789
  case 11:
 
22790
 
 
22791
/* Line 1455 of yacc.c  */
22885
22792
#line 1208 "preproc.y"
22886
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22793
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22887
22794
    break;
22888
22795
 
22889
22796
  case 12:
 
22797
 
 
22798
/* Line 1455 of yacc.c  */
22890
22799
#line 1210 "preproc.y"
22891
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22800
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22892
22801
    break;
22893
22802
 
22894
22803
  case 13:
 
22804
 
 
22805
/* Line 1455 of yacc.c  */
22895
22806
#line 1212 "preproc.y"
22896
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22807
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22897
22808
    break;
22898
22809
 
22899
22810
  case 14:
 
22811
 
 
22812
/* Line 1455 of yacc.c  */
22900
22813
#line 1214 "preproc.y"
22901
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22814
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22902
22815
    break;
22903
22816
 
22904
22817
  case 15:
 
22818
 
 
22819
/* Line 1455 of yacc.c  */
22905
22820
#line 1216 "preproc.y"
22906
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22821
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22907
22822
    break;
22908
22823
 
22909
22824
  case 16:
 
22825
 
 
22826
/* Line 1455 of yacc.c  */
22910
22827
#line 1218 "preproc.y"
22911
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22828
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22912
22829
    break;
22913
22830
 
22914
22831
  case 17:
 
22832
 
 
22833
/* Line 1455 of yacc.c  */
22915
22834
#line 1220 "preproc.y"
22916
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22835
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22917
22836
    break;
22918
22837
 
22919
22838
  case 18:
 
22839
 
 
22840
/* Line 1455 of yacc.c  */
22920
22841
#line 1222 "preproc.y"
22921
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22842
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22922
22843
    break;
22923
22844
 
22924
22845
  case 19:
 
22846
 
 
22847
/* Line 1455 of yacc.c  */
22925
22848
#line 1224 "preproc.y"
22926
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22849
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22927
22850
    break;
22928
22851
 
22929
22852
  case 20:
 
22853
 
 
22854
/* Line 1455 of yacc.c  */
22930
22855
#line 1226 "preproc.y"
22931
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22856
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22932
22857
    break;
22933
22858
 
22934
22859
  case 21:
 
22860
 
 
22861
/* Line 1455 of yacc.c  */
22935
22862
#line 1228 "preproc.y"
22936
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22863
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22937
22864
    break;
22938
22865
 
22939
22866
  case 22:
 
22867
 
 
22868
/* Line 1455 of yacc.c  */
22940
22869
#line 1230 "preproc.y"
22941
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22870
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22942
22871
    break;
22943
22872
 
22944
22873
  case 23:
 
22874
 
 
22875
/* Line 1455 of yacc.c  */
22945
22876
#line 1232 "preproc.y"
22946
22877
    {
22947
22878
                if (INFORMIX_MODE)
22948
22879
                {
22949
 
                        if (pg_strcasecmp(yyvsp[0].str+strlen("close "), "database") == 0)
 
22880
                        if (pg_strcasecmp((yyvsp[(1) - (1)].str)+strlen("close "), "database") == 0)
22950
22881
                        {
22951
22882
                                if (connection)
22952
22883
                                        mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in CLOSE DATABASE statement");
22953
22884
 
22954
22885
                                fprintf(yyout, "{ ECPGdisconnect(__LINE__, \"CURRENT\");");
22955
22886
                                whenever_action(2);
22956
 
                                free(yyvsp[0].str);
 
22887
                                free((yyvsp[(1) - (1)].str));
22957
22888
                                break;
22958
22889
                        }
22959
22890
                }
22960
22891
 
22961
 
                output_statement(yyvsp[0].str, 0, ECPGst_normal);
 
22892
                output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal);
22962
22893
        ;}
22963
22894
    break;
22964
22895
 
22965
22896
  case 24:
 
22897
 
 
22898
/* Line 1455 of yacc.c  */
22966
22899
#line 1250 "preproc.y"
22967
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22900
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22968
22901
    break;
22969
22902
 
22970
22903
  case 25:
 
22904
 
 
22905
/* Line 1455 of yacc.c  */
22971
22906
#line 1252 "preproc.y"
22972
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22907
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22973
22908
    break;
22974
22909
 
22975
22910
  case 26:
 
22911
 
 
22912
/* Line 1455 of yacc.c  */
22976
22913
#line 1254 "preproc.y"
22977
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22914
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22978
22915
    break;
22979
22916
 
22980
22917
  case 27:
 
22918
 
 
22919
/* Line 1455 of yacc.c  */
22981
22920
#line 1256 "preproc.y"
22982
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22921
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22983
22922
    break;
22984
22923
 
22985
22924
  case 28:
 
22925
 
 
22926
/* Line 1455 of yacc.c  */
22986
22927
#line 1258 "preproc.y"
22987
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22928
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22988
22929
    break;
22989
22930
 
22990
22931
  case 29:
 
22932
 
 
22933
/* Line 1455 of yacc.c  */
22991
22934
#line 1260 "preproc.y"
22992
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22935
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22993
22936
    break;
22994
22937
 
22995
22938
  case 30:
 
22939
 
 
22940
/* Line 1455 of yacc.c  */
22996
22941
#line 1262 "preproc.y"
22997
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22942
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
22998
22943
    break;
22999
22944
 
23000
22945
  case 31:
 
22946
 
 
22947
/* Line 1455 of yacc.c  */
23001
22948
#line 1264 "preproc.y"
23002
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22949
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23003
22950
    break;
23004
22951
 
23005
22952
  case 32:
 
22953
 
 
22954
/* Line 1455 of yacc.c  */
23006
22955
#line 1266 "preproc.y"
23007
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22956
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23008
22957
    break;
23009
22958
 
23010
22959
  case 33:
 
22960
 
 
22961
/* Line 1455 of yacc.c  */
23011
22962
#line 1268 "preproc.y"
23012
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22963
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23013
22964
    break;
23014
22965
 
23015
22966
  case 34:
 
22967
 
 
22968
/* Line 1455 of yacc.c  */
23016
22969
#line 1270 "preproc.y"
23017
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22970
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23018
22971
    break;
23019
22972
 
23020
22973
  case 35:
 
22974
 
 
22975
/* Line 1455 of yacc.c  */
23021
22976
#line 1272 "preproc.y"
23022
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22977
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23023
22978
    break;
23024
22979
 
23025
22980
  case 36:
 
22981
 
 
22982
/* Line 1455 of yacc.c  */
23026
22983
#line 1274 "preproc.y"
23027
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22984
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23028
22985
    break;
23029
22986
 
23030
22987
  case 37:
 
22988
 
 
22989
/* Line 1455 of yacc.c  */
23031
22990
#line 1276 "preproc.y"
23032
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22991
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23033
22992
    break;
23034
22993
 
23035
22994
  case 38:
 
22995
 
 
22996
/* Line 1455 of yacc.c  */
23036
22997
#line 1278 "preproc.y"
23037
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
22998
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23038
22999
    break;
23039
23000
 
23040
23001
  case 39:
 
23002
 
 
23003
/* Line 1455 of yacc.c  */
23041
23004
#line 1280 "preproc.y"
23042
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23005
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23043
23006
    break;
23044
23007
 
23045
23008
  case 40:
 
23009
 
 
23010
/* Line 1455 of yacc.c  */
23046
23011
#line 1282 "preproc.y"
23047
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23012
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23048
23013
    break;
23049
23014
 
23050
23015
  case 41:
 
23016
 
 
23017
/* Line 1455 of yacc.c  */
23051
23018
#line 1284 "preproc.y"
23052
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23019
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23053
23020
    break;
23054
23021
 
23055
23022
  case 42:
 
23023
 
 
23024
/* Line 1455 of yacc.c  */
23056
23025
#line 1286 "preproc.y"
23057
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23026
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23058
23027
    break;
23059
23028
 
23060
23029
  case 43:
 
23030
 
 
23031
/* Line 1455 of yacc.c  */
23061
23032
#line 1288 "preproc.y"
23062
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23033
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23063
23034
    break;
23064
23035
 
23065
23036
  case 44:
 
23037
 
 
23038
/* Line 1455 of yacc.c  */
23066
23039
#line 1290 "preproc.y"
23067
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23040
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23068
23041
    break;
23069
23042
 
23070
23043
  case 45:
 
23044
 
 
23045
/* Line 1455 of yacc.c  */
23071
23046
#line 1292 "preproc.y"
23072
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23047
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23073
23048
    break;
23074
23049
 
23075
23050
  case 46:
 
23051
 
 
23052
/* Line 1455 of yacc.c  */
23076
23053
#line 1294 "preproc.y"
23077
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23054
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23078
23055
    break;
23079
23056
 
23080
23057
  case 47:
 
23058
 
 
23059
/* Line 1455 of yacc.c  */
23081
23060
#line 1296 "preproc.y"
23082
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23061
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23083
23062
    break;
23084
23063
 
23085
23064
  case 48:
 
23065
 
 
23066
/* Line 1455 of yacc.c  */
23086
23067
#line 1298 "preproc.y"
23087
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23068
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23088
23069
    break;
23089
23070
 
23090
23071
  case 49:
 
23072
 
 
23073
/* Line 1455 of yacc.c  */
23091
23074
#line 1300 "preproc.y"
23092
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23075
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23093
23076
    break;
23094
23077
 
23095
23078
  case 50:
 
23079
 
 
23080
/* Line 1455 of yacc.c  */
23096
23081
#line 1302 "preproc.y"
23097
23082
    {
23098
23083
                if (connection)
23099
23084
                        mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in DEALLOCATE statement");
23100
23085
 
23101
 
                output_deallocate_prepare_statement(yyvsp[0].str);
 
23086
                output_deallocate_prepare_statement((yyvsp[(1) - (1)].str));
23102
23087
        ;}
23103
23088
    break;
23104
23089
 
23105
23090
  case 51:
 
23091
 
 
23092
/* Line 1455 of yacc.c  */
23106
23093
#line 1309 "preproc.y"
23107
 
    { output_simple_statement(yyvsp[0].str); ;}
 
23094
    { output_simple_statement((yyvsp[(1) - (1)].str)); ;}
23108
23095
    break;
23109
23096
 
23110
23097
  case 52:
 
23098
 
 
23099
/* Line 1455 of yacc.c  */
23111
23100
#line 1311 "preproc.y"
23112
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23101
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23113
23102
    break;
23114
23103
 
23115
23104
  case 53:
 
23105
 
 
23106
/* Line 1455 of yacc.c  */
23116
23107
#line 1313 "preproc.y"
23117
 
    { output_statement(yyvsp[0].str, 1, ECPGst_normal); ;}
 
23108
    { output_statement((yyvsp[(1) - (1)].str), 1, ECPGst_normal); ;}
23118
23109
    break;
23119
23110
 
23120
23111
  case 54:
 
23112
 
 
23113
/* Line 1455 of yacc.c  */
23121
23114
#line 1315 "preproc.y"
23122
 
    { output_statement(yyvsp[0].str, 1, ECPGst_normal); ;}
 
23115
    { output_statement((yyvsp[(1) - (1)].str), 1, ECPGst_normal); ;}
23123
23116
    break;
23124
23117
 
23125
23118
  case 55:
 
23119
 
 
23120
/* Line 1455 of yacc.c  */
23126
23121
#line 1317 "preproc.y"
23127
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23122
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23128
23123
    break;
23129
23124
 
23130
23125
  case 56:
 
23126
 
 
23127
/* Line 1455 of yacc.c  */
23131
23128
#line 1319 "preproc.y"
23132
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23129
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23133
23130
    break;
23134
23131
 
23135
23132
  case 57:
 
23133
 
 
23134
/* Line 1455 of yacc.c  */
23136
23135
#line 1321 "preproc.y"
23137
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23136
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23138
23137
    break;
23139
23138
 
23140
23139
  case 58:
 
23140
 
 
23141
/* Line 1455 of yacc.c  */
23141
23142
#line 1323 "preproc.y"
23142
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23143
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23143
23144
    break;
23144
23145
 
23145
23146
  case 59:
 
23147
 
 
23148
/* Line 1455 of yacc.c  */
23146
23149
#line 1325 "preproc.y"
23147
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23150
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23148
23151
    break;
23149
23152
 
23150
23153
  case 60:
 
23154
 
 
23155
/* Line 1455 of yacc.c  */
23151
23156
#line 1327 "preproc.y"
23152
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23157
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23153
23158
    break;
23154
23159
 
23155
23160
  case 61:
 
23161
 
 
23162
/* Line 1455 of yacc.c  */
23156
23163
#line 1329 "preproc.y"
23157
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23164
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23158
23165
    break;
23159
23166
 
23160
23167
  case 62:
 
23168
 
 
23169
/* Line 1455 of yacc.c  */
23161
23170
#line 1331 "preproc.y"
23162
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23171
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23163
23172
    break;
23164
23173
 
23165
23174
  case 63:
 
23175
 
 
23176
/* Line 1455 of yacc.c  */
23166
23177
#line 1333 "preproc.y"
23167
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23178
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23168
23179
    break;
23169
23180
 
23170
23181
  case 64:
 
23182
 
 
23183
/* Line 1455 of yacc.c  */
23171
23184
#line 1335 "preproc.y"
23172
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23185
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23173
23186
    break;
23174
23187
 
23175
23188
  case 65:
 
23189
 
 
23190
/* Line 1455 of yacc.c  */
23176
23191
#line 1337 "preproc.y"
23177
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23192
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23178
23193
    break;
23179
23194
 
23180
23195
  case 66:
 
23196
 
 
23197
/* Line 1455 of yacc.c  */
23181
23198
#line 1339 "preproc.y"
23182
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23199
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23183
23200
    break;
23184
23201
 
23185
23202
  case 67:
 
23203
 
 
23204
/* Line 1455 of yacc.c  */
23186
23205
#line 1341 "preproc.y"
23187
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23206
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23188
23207
    break;
23189
23208
 
23190
23209
  case 68:
 
23210
 
 
23211
/* Line 1455 of yacc.c  */
23191
23212
#line 1343 "preproc.y"
23192
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23213
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23193
23214
    break;
23194
23215
 
23195
23216
  case 69:
 
23217
 
 
23218
/* Line 1455 of yacc.c  */
23196
23219
#line 1345 "preproc.y"
23197
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23220
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23198
23221
    break;
23199
23222
 
23200
23223
  case 70:
 
23224
 
 
23225
/* Line 1455 of yacc.c  */
23201
23226
#line 1347 "preproc.y"
23202
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23227
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23203
23228
    break;
23204
23229
 
23205
23230
  case 71:
 
23231
 
 
23232
/* Line 1455 of yacc.c  */
23206
23233
#line 1349 "preproc.y"
23207
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23234
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23208
23235
    break;
23209
23236
 
23210
23237
  case 72:
 
23238
 
 
23239
/* Line 1455 of yacc.c  */
23211
23240
#line 1351 "preproc.y"
23212
 
    { output_statement(yyvsp[0].str, 1, ECPGst_execute); ;}
 
23241
    { output_statement((yyvsp[(1) - (1)].str), 1, ECPGst_execute); ;}
23213
23242
    break;
23214
23243
 
23215
23244
  case 73:
 
23245
 
 
23246
/* Line 1455 of yacc.c  */
23216
23247
#line 1353 "preproc.y"
23217
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23248
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23218
23249
    break;
23219
23250
 
23220
23251
  case 74:
 
23252
 
 
23253
/* Line 1455 of yacc.c  */
23221
23254
#line 1355 "preproc.y"
23222
 
    { output_statement(yyvsp[0].str, 1, ECPGst_normal); ;}
 
23255
    { output_statement((yyvsp[(1) - (1)].str), 1, ECPGst_normal); ;}
23223
23256
    break;
23224
23257
 
23225
23258
  case 75:
 
23259
 
 
23260
/* Line 1455 of yacc.c  */
23226
23261
#line 1357 "preproc.y"
23227
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23262
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23228
23263
    break;
23229
23264
 
23230
23265
  case 76:
 
23266
 
 
23267
/* Line 1455 of yacc.c  */
23231
23268
#line 1359 "preproc.y"
23232
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23269
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23233
23270
    break;
23234
23271
 
23235
23272
  case 77:
 
23273
 
 
23274
/* Line 1455 of yacc.c  */
23236
23275
#line 1361 "preproc.y"
23237
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23276
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23238
23277
    break;
23239
23278
 
23240
23279
  case 78:
 
23280
 
 
23281
/* Line 1455 of yacc.c  */
23241
23282
#line 1363 "preproc.y"
23242
 
    { output_statement(yyvsp[0].str, 1, ECPGst_normal); ;}
 
23283
    { output_statement((yyvsp[(1) - (1)].str), 1, ECPGst_normal); ;}
23243
23284
    break;
23244
23285
 
23245
23286
  case 79:
 
23287
 
 
23288
/* Line 1455 of yacc.c  */
23246
23289
#line 1365 "preproc.y"
23247
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23290
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23248
23291
    break;
23249
23292
 
23250
23293
  case 80:
 
23294
 
 
23295
/* Line 1455 of yacc.c  */
23251
23296
#line 1367 "preproc.y"
23252
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23297
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23253
23298
    break;
23254
23299
 
23255
23300
  case 81:
 
23301
 
 
23302
/* Line 1455 of yacc.c  */
23256
23303
#line 1369 "preproc.y"
23257
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23304
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23258
23305
    break;
23259
23306
 
23260
23307
  case 82:
 
23308
 
 
23309
/* Line 1455 of yacc.c  */
23261
23310
#line 1371 "preproc.y"
23262
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23311
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23263
23312
    break;
23264
23313
 
23265
23314
  case 83:
 
23315
 
 
23316
/* Line 1455 of yacc.c  */
23266
23317
#line 1373 "preproc.y"
23267
23318
    {
23268
 
                if (yyvsp[0].prep.type == NULL || strlen(yyvsp[0].prep.type) == 0)
23269
 
                        output_prepare_statement(yyvsp[0].prep.name, yyvsp[0].prep.stmt);
 
23319
                if ((yyvsp[(1) - (1)].prep).type == NULL || strlen((yyvsp[(1) - (1)].prep).type) == 0)
 
23320
                        output_prepare_statement((yyvsp[(1) - (1)].prep).name, (yyvsp[(1) - (1)].prep).stmt);
23270
23321
                else    
23271
 
                        output_statement(cat_str(5, make_str("prepare"), yyvsp[0].prep.name, yyvsp[0].prep.type, make_str("as"), yyvsp[0].prep.stmt), 0, ECPGst_normal);
 
23322
                        output_statement(cat_str(5, make_str("prepare"), (yyvsp[(1) - (1)].prep).name, (yyvsp[(1) - (1)].prep).type, make_str("as"), (yyvsp[(1) - (1)].prep).stmt), 0, ECPGst_normal);
23272
23323
        ;}
23273
23324
    break;
23274
23325
 
23275
23326
  case 84:
 
23327
 
 
23328
/* Line 1455 of yacc.c  */
23276
23329
#line 1380 "preproc.y"
23277
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23330
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23278
23331
    break;
23279
23332
 
23280
23333
  case 85:
 
23334
 
 
23335
/* Line 1455 of yacc.c  */
23281
23336
#line 1382 "preproc.y"
23282
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23337
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23283
23338
    break;
23284
23339
 
23285
23340
  case 86:
 
23341
 
 
23342
/* Line 1455 of yacc.c  */
23286
23343
#line 1384 "preproc.y"
23287
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23344
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23288
23345
    break;
23289
23346
 
23290
23347
  case 87:
 
23348
 
 
23349
/* Line 1455 of yacc.c  */
23291
23350
#line 1386 "preproc.y"
23292
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23351
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23293
23352
    break;
23294
23353
 
23295
23354
  case 88:
 
23355
 
 
23356
/* Line 1455 of yacc.c  */
23296
23357
#line 1388 "preproc.y"
23297
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23358
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23298
23359
    break;
23299
23360
 
23300
23361
  case 89:
 
23362
 
 
23363
/* Line 1455 of yacc.c  */
23301
23364
#line 1390 "preproc.y"
23302
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23365
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23303
23366
    break;
23304
23367
 
23305
23368
  case 90:
 
23369
 
 
23370
/* Line 1455 of yacc.c  */
23306
23371
#line 1392 "preproc.y"
23307
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23372
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23308
23373
    break;
23309
23374
 
23310
23375
  case 91:
 
23376
 
 
23377
/* Line 1455 of yacc.c  */
23311
23378
#line 1394 "preproc.y"
23312
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23379
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23313
23380
    break;
23314
23381
 
23315
23382
  case 92:
 
23383
 
 
23384
/* Line 1455 of yacc.c  */
23316
23385
#line 1396 "preproc.y"
23317
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23386
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23318
23387
    break;
23319
23388
 
23320
23389
  case 93:
 
23390
 
 
23391
/* Line 1455 of yacc.c  */
23321
23392
#line 1398 "preproc.y"
23322
 
    { output_statement(yyvsp[0].str, 1, ECPGst_normal); ;}
 
23393
    { output_statement((yyvsp[(1) - (1)].str), 1, ECPGst_normal); ;}
23323
23394
    break;
23324
23395
 
23325
23396
  case 94:
 
23397
 
 
23398
/* Line 1455 of yacc.c  */
23326
23399
#line 1400 "preproc.y"
23327
23400
    {
23328
 
                fprintf(yyout, "{ ECPGtrans(__LINE__, %s, \"%s\");", connection ? connection : "NULL", yyvsp[0].str);
 
23401
                fprintf(yyout, "{ ECPGtrans(__LINE__, %s, \"%s\");", connection ? connection : "NULL", (yyvsp[(1) - (1)].str));
23329
23402
                whenever_action(2);
23330
 
                free(yyvsp[0].str);
 
23403
                free((yyvsp[(1) - (1)].str));
23331
23404
        ;}
23332
23405
    break;
23333
23406
 
23334
23407
  case 95:
 
23408
 
 
23409
/* Line 1455 of yacc.c  */
23335
23410
#line 1406 "preproc.y"
23336
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23411
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23337
23412
    break;
23338
23413
 
23339
23414
  case 96:
 
23415
 
 
23416
/* Line 1455 of yacc.c  */
23340
23417
#line 1408 "preproc.y"
23341
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23418
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23342
23419
    break;
23343
23420
 
23344
23421
  case 97:
 
23422
 
 
23423
/* Line 1455 of yacc.c  */
23345
23424
#line 1410 "preproc.y"
23346
 
    { output_statement(yyvsp[0].str, 1, ECPGst_normal); ;}
 
23425
    { output_statement((yyvsp[(1) - (1)].str), 1, ECPGst_normal); ;}
23347
23426
    break;
23348
23427
 
23349
23428
  case 98:
 
23429
 
 
23430
/* Line 1455 of yacc.c  */
23350
23431
#line 1412 "preproc.y"
23351
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23432
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23352
23433
    break;
23353
23434
 
23354
23435
  case 99:
 
23436
 
 
23437
/* Line 1455 of yacc.c  */
23355
23438
#line 1414 "preproc.y"
23356
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23439
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23357
23440
    break;
23358
23441
 
23359
23442
  case 100:
 
23443
 
 
23444
/* Line 1455 of yacc.c  */
23360
23445
#line 1416 "preproc.y"
23361
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23446
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23362
23447
    break;
23363
23448
 
23364
23449
  case 101:
 
23450
 
 
23451
/* Line 1455 of yacc.c  */
23365
23452
#line 1418 "preproc.y"
23366
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23453
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23367
23454
    break;
23368
23455
 
23369
23456
  case 102:
 
23457
 
 
23458
/* Line 1455 of yacc.c  */
23370
23459
#line 1420 "preproc.y"
23371
 
    { output_statement(yyvsp[0].str, 0, ECPGst_normal); ;}
 
23460
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_normal); ;}
23372
23461
    break;
23373
23462
 
23374
23463
  case 103:
 
23464
 
 
23465
/* Line 1455 of yacc.c  */
23375
23466
#line 1422 "preproc.y"
23376
23467
    {
23377
 
                fprintf(yyout,"ECPGallocate_desc(__LINE__, %s);",yyvsp[0].str);
 
23468
                fprintf(yyout,"ECPGallocate_desc(__LINE__, %s);",(yyvsp[(1) - (1)].str));
23378
23469
                whenever_action(0);
23379
 
                free(yyvsp[0].str);
 
23470
                free((yyvsp[(1) - (1)].str));
23380
23471
        ;}
23381
23472
    break;
23382
23473
 
23383
23474
  case 104:
 
23475
 
 
23476
/* Line 1455 of yacc.c  */
23384
23477
#line 1428 "preproc.y"
23385
23478
    {
23386
23479
                if (connection)
23387
23480
                        mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in CONNECT statement");
23388
23481
 
23389
 
                fprintf(yyout, "{ ECPGconnect(__LINE__, %d, %s, %d); ", compat, yyvsp[0].str, autocommit);
 
23482
                fprintf(yyout, "{ ECPGconnect(__LINE__, %d, %s, %d); ", compat, (yyvsp[(1) - (1)].str), autocommit);
23390
23483
                reset_variables();
23391
23484
                whenever_action(2);
23392
 
                free(yyvsp[0].str);
 
23485
                free((yyvsp[(1) - (1)].str));
23393
23486
        ;}
23394
23487
    break;
23395
23488
 
23396
23489
  case 105:
 
23490
 
 
23491
/* Line 1455 of yacc.c  */
23397
23492
#line 1438 "preproc.y"
23398
23493
    {
23399
 
                output_simple_statement(yyvsp[0].str);
 
23494
                output_simple_statement((yyvsp[(1) - (1)].str));
23400
23495
        ;}
23401
23496
    break;
23402
23497
 
23403
23498
  case 106:
 
23499
 
 
23500
/* Line 1455 of yacc.c  */
23404
23501
#line 1442 "preproc.y"
23405
23502
    {
23406
23503
                if (connection)
23407
23504
                        mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in DEALLOCATE statement");
23408
 
                fprintf(yyout,"ECPGdeallocate_desc(__LINE__, %s);",yyvsp[0].str);
 
23505
                fprintf(yyout,"ECPGdeallocate_desc(__LINE__, %s);",(yyvsp[(1) - (1)].str));
23409
23506
                whenever_action(0);
23410
 
                free(yyvsp[0].str);
 
23507
                free((yyvsp[(1) - (1)].str));
23411
23508
        ;}
23412
23509
    break;
23413
23510
 
23414
23511
  case 107:
 
23512
 
 
23513
/* Line 1455 of yacc.c  */
23415
23514
#line 1450 "preproc.y"
23416
23515
    {
23417
 
                output_simple_statement(yyvsp[0].str);
 
23516
                output_simple_statement((yyvsp[(1) - (1)].str));
23418
23517
        ;}
23419
23518
    break;
23420
23519
 
23421
23520
  case 108:
 
23521
 
 
23522
/* Line 1455 of yacc.c  */
23422
23523
#line 1454 "preproc.y"
23423
23524
    {
23424
 
                fprintf(yyout, "{ ECPGdescribe(__LINE__, %s,", yyvsp[0].str);
 
23525
                fprintf(yyout, "{ ECPGdescribe(__LINE__, %s,", (yyvsp[(1) - (1)].str));
23425
23526
                dump_variables(argsresult, 1);
23426
23527
                fputs("ECPGt_EORT);", yyout);
23427
23528
                fprintf(yyout, "}");
23428
23529
                output_line_number();
23429
23530
 
23430
 
                free(yyvsp[0].str);
 
23531
                free((yyvsp[(1) - (1)].str));
23431
23532
        ;}
23432
23533
    break;
23433
23534
 
23434
23535
  case 109:
 
23536
 
 
23537
/* Line 1455 of yacc.c  */
23435
23538
#line 1464 "preproc.y"
23436
23539
    {
23437
23540
                if (connection)
23438
23541
                        mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in DISCONNECT statement");
23439
23542
 
23440
23543
                fprintf(yyout, "{ ECPGdisconnect(__LINE__, %s);",
23441
 
                                yyvsp[0].str ? yyvsp[0].str : "\"CURRENT\"");
 
23544
                                (yyvsp[(1) - (1)].str) ? (yyvsp[(1) - (1)].str) : "\"CURRENT\"");
23442
23545
                whenever_action(2);
23443
 
                free(yyvsp[0].str);
 
23546
                free((yyvsp[(1) - (1)].str));
23444
23547
        ;}
23445
23548
    break;
23446
23549
 
23447
23550
  case 110:
 
23551
 
 
23552
/* Line 1455 of yacc.c  */
23448
23553
#line 1473 "preproc.y"
23449
 
    { output_statement(yyvsp[0].str, 0, ECPGst_exec_immediate); ;}
 
23554
    { output_statement((yyvsp[(1) - (1)].str), 0, ECPGst_exec_immediate); ;}
23450
23555
    break;
23451
23556
 
23452
23557
  case 111:
 
23558
 
 
23559
/* Line 1455 of yacc.c  */
23453
23560
#line 1475 "preproc.y"
23454
23561
    {
23455
23562
                const char *con = connection ? connection : "NULL";
23456
 
                if (strcmp(yyvsp[0].str, "all"))
23457
 
                        fprintf(yyout, "{ ECPGdeallocate(__LINE__, %d, %s, \"%s\");", compat, con, yyvsp[0].str);
 
23563
                if (strcmp((yyvsp[(1) - (1)].str), "all"))
 
23564
                        fprintf(yyout, "{ ECPGdeallocate(__LINE__, %d, %s, \"%s\");", compat, con, (yyvsp[(1) - (1)].str));
23458
23565
                else
23459
23566
                        fprintf(yyout, "{ ECPGdeallocate_all(__LINE__, %d, %s);", compat, con);
23460
23567
 
23461
23568
                whenever_action(2);
23462
 
                free(yyvsp[0].str);
 
23569
                free((yyvsp[(1) - (1)].str));
23463
23570
        ;}
23464
23571
    break;
23465
23572
 
23466
23573
  case 112:
 
23574
 
 
23575
/* Line 1455 of yacc.c  */
23467
23576
#line 1486 "preproc.y"
23468
23577
    {
23469
 
                lookup_descriptor(yyvsp[0].descriptor.name, connection);
23470
 
                output_get_descr(yyvsp[0].descriptor.name, yyvsp[0].descriptor.str);
23471
 
                free(yyvsp[0].descriptor.name);
23472
 
                free(yyvsp[0].descriptor.str);
 
23578
                lookup_descriptor((yyvsp[(1) - (1)].descriptor).name, connection);
 
23579
                output_get_descr((yyvsp[(1) - (1)].descriptor).name, (yyvsp[(1) - (1)].descriptor).str);
 
23580
                free((yyvsp[(1) - (1)].descriptor).name);
 
23581
                free((yyvsp[(1) - (1)].descriptor).str);
23473
23582
        ;}
23474
23583
    break;
23475
23584
 
23476
23585
  case 113:
 
23586
 
 
23587
/* Line 1455 of yacc.c  */
23477
23588
#line 1493 "preproc.y"
23478
23589
    {
23479
 
                lookup_descriptor(yyvsp[0].str, connection);
23480
 
                output_get_descr_header(yyvsp[0].str);
23481
 
                free(yyvsp[0].str);
 
23590
                lookup_descriptor((yyvsp[(1) - (1)].str), connection);
 
23591
                output_get_descr_header((yyvsp[(1) - (1)].str));
 
23592
                free((yyvsp[(1) - (1)].str));
23482
23593
        ;}
23483
23594
    break;
23484
23595
 
23485
23596
  case 114:
 
23597
 
 
23598
/* Line 1455 of yacc.c  */
23486
23599
#line 1499 "preproc.y"
23487
23600
    {
23488
23601
                struct cursor *ptr;
23489
23602
 
23490
 
                if ((ptr = add_additional_variables(yyvsp[0].str, true)) != NULL)
 
23603
                if ((ptr = add_additional_variables((yyvsp[(1) - (1)].str), true)) != NULL)
23491
23604
                {
23492
23605
                        connection = ptr->connection ? mm_strdup(ptr->connection) : NULL;
23493
23606
                        output_statement(mm_strdup(ptr->command), 0, 0);
23497
23610
    break;
23498
23611
 
23499
23612
  case 115:
 
23613
 
 
23614
/* Line 1455 of yacc.c  */
23500
23615
#line 1510 "preproc.y"
23501
23616
    {
23502
 
                fprintf(yyout, "{ ECPGsetcommit(__LINE__, \"%s\", %s);", yyvsp[0].str, connection ? connection : "NULL");
 
23617
                fprintf(yyout, "{ ECPGsetcommit(__LINE__, \"%s\", %s);", (yyvsp[(1) - (1)].str), connection ? connection : "NULL");
23503
23618
                whenever_action(2);
23504
 
                free(yyvsp[0].str);
 
23619
                free((yyvsp[(1) - (1)].str));
23505
23620
        ;}
23506
23621
    break;
23507
23622
 
23508
23623
  case 116:
 
23624
 
 
23625
/* Line 1455 of yacc.c  */
23509
23626
#line 1516 "preproc.y"
23510
23627
    {
23511
23628
                if (connection)
23512
23629
                        mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in SET CONNECTION statement");
23513
23630
 
23514
 
                fprintf(yyout, "{ ECPGsetconn(__LINE__, %s);", yyvsp[0].str);
 
23631
                fprintf(yyout, "{ ECPGsetconn(__LINE__, %s);", (yyvsp[(1) - (1)].str));
23515
23632
                whenever_action(2);
23516
 
                free(yyvsp[0].str);
 
23633
                free((yyvsp[(1) - (1)].str));
23517
23634
        ;}
23518
23635
    break;
23519
23636
 
23520
23637
  case 117:
 
23638
 
 
23639
/* Line 1455 of yacc.c  */
23521
23640
#line 1525 "preproc.y"
23522
23641
    {
23523
 
                lookup_descriptor(yyvsp[0].descriptor.name, connection);
23524
 
                output_set_descr(yyvsp[0].descriptor.name, yyvsp[0].descriptor.str);
23525
 
                free(yyvsp[0].descriptor.name);
23526
 
                free(yyvsp[0].descriptor.str);
 
23642
                lookup_descriptor((yyvsp[(1) - (1)].descriptor).name, connection);
 
23643
                output_set_descr((yyvsp[(1) - (1)].descriptor).name, (yyvsp[(1) - (1)].descriptor).str);
 
23644
                free((yyvsp[(1) - (1)].descriptor).name);
 
23645
                free((yyvsp[(1) - (1)].descriptor).str);
23527
23646
        ;}
23528
23647
    break;
23529
23648
 
23530
23649
  case 118:
 
23650
 
 
23651
/* Line 1455 of yacc.c  */
23531
23652
#line 1532 "preproc.y"
23532
23653
    {
23533
 
                lookup_descriptor(yyvsp[0].str, connection);
23534
 
                output_set_descr_header(yyvsp[0].str);
23535
 
                free(yyvsp[0].str);
 
23654
                lookup_descriptor((yyvsp[(1) - (1)].str), connection);
 
23655
                output_set_descr_header((yyvsp[(1) - (1)].str));
 
23656
                free((yyvsp[(1) - (1)].str));
23536
23657
        ;}
23537
23658
    break;
23538
23659
 
23539
23660
  case 119:
 
23661
 
 
23662
/* Line 1455 of yacc.c  */
23540
23663
#line 1538 "preproc.y"
23541
23664
    {
23542
23665
                if (connection)
23543
23666
                        mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in TYPE statement");
23544
23667
 
23545
 
                fprintf(yyout, "%s", yyvsp[0].str);
23546
 
                free(yyvsp[0].str);
 
23668
                fprintf(yyout, "%s", (yyvsp[(1) - (1)].str));
 
23669
                free((yyvsp[(1) - (1)].str));
23547
23670
                output_line_number();
23548
23671
        ;}
23549
23672
    break;
23550
23673
 
23551
23674
  case 120:
 
23675
 
 
23676
/* Line 1455 of yacc.c  */
23552
23677
#line 1547 "preproc.y"
23553
23678
    {
23554
23679
                if (connection)
23555
23680
                        mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in VAR statement");
23556
23681
 
23557
 
                output_simple_statement(yyvsp[0].str);
 
23682
                output_simple_statement((yyvsp[(1) - (1)].str));
23558
23683
        ;}
23559
23684
    break;
23560
23685
 
23561
23686
  case 121:
 
23687
 
 
23688
/* Line 1455 of yacc.c  */
23562
23689
#line 1554 "preproc.y"
23563
23690
    {
23564
23691
                if (connection)
23565
23692
                        mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in WHENEVER statement");
23566
23693
 
23567
 
                output_simple_statement(yyvsp[0].str);
 
23694
                output_simple_statement((yyvsp[(1) - (1)].str));
23568
23695
        ;}
23569
23696
    break;
23570
23697
 
23571
23698
  case 122:
 
23699
 
 
23700
/* Line 1455 of yacc.c  */
23572
23701
#line 1561 "preproc.y"
23573
 
    { yyval.str = NULL; ;}
 
23702
    { (yyval.str) = NULL; ;}
23574
23703
    break;
23575
23704
 
23576
23705
  case 123:
 
23706
 
 
23707
/* Line 1455 of yacc.c  */
23577
23708
#line 1567 "preproc.y"
23578
23709
    { 
23579
 
 yyval.str = cat_str(4,make_str("create role"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
23710
 (yyval.str) = cat_str(4,make_str("create role"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
23580
23711
;}
23581
23712
    break;
23582
23713
 
23583
23714
  case 124:
 
23715
 
 
23716
/* Line 1455 of yacc.c  */
23584
23717
#line 1575 "preproc.y"
23585
23718
    { 
23586
 
 yyval.str = make_str("with");
 
23719
 (yyval.str) = make_str("with");
23587
23720
;}
23588
23721
    break;
23589
23722
 
23590
23723
  case 125:
 
23724
 
 
23725
/* Line 1455 of yacc.c  */
23591
23726
#line 1579 "preproc.y"
23592
23727
    { 
23593
 
 yyval.str=EMPTY; ;}
 
23728
 (yyval.str)=EMPTY; ;}
23594
23729
    break;
23595
23730
 
23596
23731
  case 126:
 
23732
 
 
23733
/* Line 1455 of yacc.c  */
23597
23734
#line 1586 "preproc.y"
23598
23735
    { 
23599
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
23736
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
23600
23737
;}
23601
23738
    break;
23602
23739
 
23603
23740
  case 127:
 
23741
 
 
23742
/* Line 1455 of yacc.c  */
23604
23743
#line 1590 "preproc.y"
23605
23744
    { 
23606
 
 yyval.str=EMPTY; ;}
 
23745
 (yyval.str)=EMPTY; ;}
23607
23746
    break;
23608
23747
 
23609
23748
  case 128:
 
23749
 
 
23750
/* Line 1455 of yacc.c  */
23610
23751
#line 1597 "preproc.y"
23611
23752
    { 
23612
 
 yyval.str = cat_str(2,make_str("password"),yyvsp[0].str);
 
23753
 (yyval.str) = cat_str(2,make_str("password"),(yyvsp[(2) - (2)].str));
23613
23754
;}
23614
23755
    break;
23615
23756
 
23616
23757
  case 129:
 
23758
 
 
23759
/* Line 1455 of yacc.c  */
23617
23760
#line 1601 "preproc.y"
23618
23761
    { 
23619
 
 yyval.str = make_str("password null");
 
23762
 (yyval.str) = make_str("password null");
23620
23763
;}
23621
23764
    break;
23622
23765
 
23623
23766
  case 130:
 
23767
 
 
23768
/* Line 1455 of yacc.c  */
23624
23769
#line 1605 "preproc.y"
23625
23770
    { 
23626
 
 yyval.str = cat_str(2,make_str("encrypted password"),yyvsp[0].str);
 
23771
 (yyval.str) = cat_str(2,make_str("encrypted password"),(yyvsp[(3) - (3)].str));
23627
23772
;}
23628
23773
    break;
23629
23774
 
23630
23775
  case 131:
 
23776
 
 
23777
/* Line 1455 of yacc.c  */
23631
23778
#line 1609 "preproc.y"
23632
23779
    { 
23633
 
 yyval.str = cat_str(2,make_str("unencrypted password"),yyvsp[0].str);
 
23780
 (yyval.str) = cat_str(2,make_str("unencrypted password"),(yyvsp[(3) - (3)].str));
23634
23781
;}
23635
23782
    break;
23636
23783
 
23637
23784
  case 132:
 
23785
 
 
23786
/* Line 1455 of yacc.c  */
23638
23787
#line 1613 "preproc.y"
23639
23788
    { 
23640
 
 yyval.str = make_str("superuser");
 
23789
 (yyval.str) = make_str("superuser");
23641
23790
;}
23642
23791
    break;
23643
23792
 
23644
23793
  case 133:
 
23794
 
 
23795
/* Line 1455 of yacc.c  */
23645
23796
#line 1617 "preproc.y"
23646
23797
    { 
23647
 
 yyval.str = make_str("nosuperuser");
 
23798
 (yyval.str) = make_str("nosuperuser");
23648
23799
;}
23649
23800
    break;
23650
23801
 
23651
23802
  case 134:
 
23803
 
 
23804
/* Line 1455 of yacc.c  */
23652
23805
#line 1621 "preproc.y"
23653
23806
    { 
23654
 
 yyval.str = make_str("inherit");
 
23807
 (yyval.str) = make_str("inherit");
23655
23808
;}
23656
23809
    break;
23657
23810
 
23658
23811
  case 135:
 
23812
 
 
23813
/* Line 1455 of yacc.c  */
23659
23814
#line 1625 "preproc.y"
23660
23815
    { 
23661
 
 yyval.str = make_str("noinherit");
 
23816
 (yyval.str) = make_str("noinherit");
23662
23817
;}
23663
23818
    break;
23664
23819
 
23665
23820
  case 136:
 
23821
 
 
23822
/* Line 1455 of yacc.c  */
23666
23823
#line 1629 "preproc.y"
23667
23824
    { 
23668
 
 yyval.str = make_str("createdb");
 
23825
 (yyval.str) = make_str("createdb");
23669
23826
;}
23670
23827
    break;
23671
23828
 
23672
23829
  case 137:
 
23830
 
 
23831
/* Line 1455 of yacc.c  */
23673
23832
#line 1633 "preproc.y"
23674
23833
    { 
23675
 
 yyval.str = make_str("nocreatedb");
 
23834
 (yyval.str) = make_str("nocreatedb");
23676
23835
;}
23677
23836
    break;
23678
23837
 
23679
23838
  case 138:
 
23839
 
 
23840
/* Line 1455 of yacc.c  */
23680
23841
#line 1637 "preproc.y"
23681
23842
    { 
23682
 
 yyval.str = make_str("createrole");
 
23843
 (yyval.str) = make_str("createrole");
23683
23844
;}
23684
23845
    break;
23685
23846
 
23686
23847
  case 139:
 
23848
 
 
23849
/* Line 1455 of yacc.c  */
23687
23850
#line 1641 "preproc.y"
23688
23851
    { 
23689
 
 yyval.str = make_str("nocreaterole");
 
23852
 (yyval.str) = make_str("nocreaterole");
23690
23853
;}
23691
23854
    break;
23692
23855
 
23693
23856
  case 140:
 
23857
 
 
23858
/* Line 1455 of yacc.c  */
23694
23859
#line 1645 "preproc.y"
23695
23860
    { 
23696
 
 yyval.str = make_str("createuser");
 
23861
 (yyval.str) = make_str("createuser");
23697
23862
;}
23698
23863
    break;
23699
23864
 
23700
23865
  case 141:
 
23866
 
 
23867
/* Line 1455 of yacc.c  */
23701
23868
#line 1649 "preproc.y"
23702
23869
    { 
23703
 
 yyval.str = make_str("nocreateuser");
 
23870
 (yyval.str) = make_str("nocreateuser");
23704
23871
;}
23705
23872
    break;
23706
23873
 
23707
23874
  case 142:
 
23875
 
 
23876
/* Line 1455 of yacc.c  */
23708
23877
#line 1653 "preproc.y"
23709
23878
    { 
23710
 
 yyval.str = make_str("login");
 
23879
 (yyval.str) = make_str("login");
23711
23880
;}
23712
23881
    break;
23713
23882
 
23714
23883
  case 143:
 
23884
 
 
23885
/* Line 1455 of yacc.c  */
23715
23886
#line 1657 "preproc.y"
23716
23887
    { 
23717
 
 yyval.str = make_str("nologin");
 
23888
 (yyval.str) = make_str("nologin");
23718
23889
;}
23719
23890
    break;
23720
23891
 
23721
23892
  case 144:
 
23893
 
 
23894
/* Line 1455 of yacc.c  */
23722
23895
#line 1661 "preproc.y"
23723
23896
    { 
23724
 
 yyval.str = cat_str(2,make_str("connection limit"),yyvsp[0].str);
 
23897
 (yyval.str) = cat_str(2,make_str("connection limit"),(yyvsp[(3) - (3)].str));
23725
23898
;}
23726
23899
    break;
23727
23900
 
23728
23901
  case 145:
 
23902
 
 
23903
/* Line 1455 of yacc.c  */
23729
23904
#line 1665 "preproc.y"
23730
23905
    { 
23731
 
 yyval.str = cat_str(2,make_str("valid until"),yyvsp[0].str);
 
23906
 (yyval.str) = cat_str(2,make_str("valid until"),(yyvsp[(3) - (3)].str));
23732
23907
;}
23733
23908
    break;
23734
23909
 
23735
23910
  case 146:
 
23911
 
 
23912
/* Line 1455 of yacc.c  */
23736
23913
#line 1669 "preproc.y"
23737
23914
    { 
23738
 
 yyval.str = cat_str(2,make_str("user"),yyvsp[0].str);
 
23915
 (yyval.str) = cat_str(2,make_str("user"),(yyvsp[(2) - (2)].str));
23739
23916
;}
23740
23917
    break;
23741
23918
 
23742
23919
  case 147:
 
23920
 
 
23921
/* Line 1455 of yacc.c  */
23743
23922
#line 1673 "preproc.y"
23744
23923
    { 
23745
 
 yyval.str = cat_str(2,make_str("sysid"),yyvsp[0].str);
 
23924
 (yyval.str) = cat_str(2,make_str("sysid"),(yyvsp[(2) - (2)].str));
23746
23925
;}
23747
23926
    break;
23748
23927
 
23749
23928
  case 148:
 
23929
 
 
23930
/* Line 1455 of yacc.c  */
23750
23931
#line 1677 "preproc.y"
23751
23932
    { 
23752
 
 yyval.str = cat_str(2,make_str("admin"),yyvsp[0].str);
 
23933
 (yyval.str) = cat_str(2,make_str("admin"),(yyvsp[(2) - (2)].str));
23753
23934
;}
23754
23935
    break;
23755
23936
 
23756
23937
  case 149:
 
23938
 
 
23939
/* Line 1455 of yacc.c  */
23757
23940
#line 1681 "preproc.y"
23758
23941
    { 
23759
 
 yyval.str = cat_str(2,make_str("role"),yyvsp[0].str);
 
23942
 (yyval.str) = cat_str(2,make_str("role"),(yyvsp[(2) - (2)].str));
23760
23943
;}
23761
23944
    break;
23762
23945
 
23763
23946
  case 150:
 
23947
 
 
23948
/* Line 1455 of yacc.c  */
23764
23949
#line 1685 "preproc.y"
23765
23950
    { 
23766
 
 yyval.str = cat_str(2,make_str("in role"),yyvsp[0].str);
 
23951
 (yyval.str) = cat_str(2,make_str("in role"),(yyvsp[(3) - (3)].str));
23767
23952
;}
23768
23953
    break;
23769
23954
 
23770
23955
  case 151:
 
23956
 
 
23957
/* Line 1455 of yacc.c  */
23771
23958
#line 1689 "preproc.y"
23772
23959
    { 
23773
 
 yyval.str = cat_str(2,make_str("in group"),yyvsp[0].str);
 
23960
 (yyval.str) = cat_str(2,make_str("in group"),(yyvsp[(3) - (3)].str));
23774
23961
;}
23775
23962
    break;
23776
23963
 
23777
23964
  case 152:
 
23965
 
 
23966
/* Line 1455 of yacc.c  */
23778
23967
#line 1697 "preproc.y"
23779
23968
    { 
23780
 
 yyval.str = cat_str(4,make_str("create user"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
23969
 (yyval.str) = cat_str(4,make_str("create user"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
23781
23970
;}
23782
23971
    break;
23783
23972
 
23784
23973
  case 153:
 
23974
 
 
23975
/* Line 1455 of yacc.c  */
23785
23976
#line 1705 "preproc.y"
23786
23977
    { 
23787
 
 yyval.str = cat_str(4,make_str("alter role"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
23978
 (yyval.str) = cat_str(4,make_str("alter role"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
23788
23979
;}
23789
23980
    break;
23790
23981
 
23791
23982
  case 154:
 
23983
 
 
23984
/* Line 1455 of yacc.c  */
23792
23985
#line 1713 "preproc.y"
23793
23986
    { 
23794
 
 yyval.str = cat_str(3,make_str("alter role"),yyvsp[-1].str,yyvsp[0].str);
 
23987
 (yyval.str) = cat_str(3,make_str("alter role"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
23795
23988
;}
23796
23989
    break;
23797
23990
 
23798
23991
  case 155:
 
23992
 
 
23993
/* Line 1455 of yacc.c  */
23799
23994
#line 1721 "preproc.y"
23800
23995
    { 
23801
 
 yyval.str = cat_str(4,make_str("alter user"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
23996
 (yyval.str) = cat_str(4,make_str("alter user"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
23802
23997
;}
23803
23998
    break;
23804
23999
 
23805
24000
  case 156:
 
24001
 
 
24002
/* Line 1455 of yacc.c  */
23806
24003
#line 1729 "preproc.y"
23807
24004
    { 
23808
 
 yyval.str = cat_str(3,make_str("alter user"),yyvsp[-1].str,yyvsp[0].str);
 
24005
 (yyval.str) = cat_str(3,make_str("alter user"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
23809
24006
;}
23810
24007
    break;
23811
24008
 
23812
24009
  case 157:
 
24010
 
 
24011
/* Line 1455 of yacc.c  */
23813
24012
#line 1737 "preproc.y"
23814
24013
    { 
23815
 
 yyval.str = cat_str(2,make_str("drop role"),yyvsp[0].str);
 
24014
 (yyval.str) = cat_str(2,make_str("drop role"),(yyvsp[(3) - (3)].str));
23816
24015
;}
23817
24016
    break;
23818
24017
 
23819
24018
  case 158:
 
24019
 
 
24020
/* Line 1455 of yacc.c  */
23820
24021
#line 1741 "preproc.y"
23821
24022
    { 
23822
 
 yyval.str = cat_str(2,make_str("drop role if exists"),yyvsp[0].str);
 
24023
 (yyval.str) = cat_str(2,make_str("drop role if exists"),(yyvsp[(5) - (5)].str));
23823
24024
;}
23824
24025
    break;
23825
24026
 
23826
24027
  case 159:
 
24028
 
 
24029
/* Line 1455 of yacc.c  */
23827
24030
#line 1749 "preproc.y"
23828
24031
    { 
23829
 
 yyval.str = cat_str(2,make_str("drop user"),yyvsp[0].str);
 
24032
 (yyval.str) = cat_str(2,make_str("drop user"),(yyvsp[(3) - (3)].str));
23830
24033
;}
23831
24034
    break;
23832
24035
 
23833
24036
  case 160:
 
24037
 
 
24038
/* Line 1455 of yacc.c  */
23834
24039
#line 1753 "preproc.y"
23835
24040
    { 
23836
 
 yyval.str = cat_str(2,make_str("drop user if exists"),yyvsp[0].str);
 
24041
 (yyval.str) = cat_str(2,make_str("drop user if exists"),(yyvsp[(5) - (5)].str));
23837
24042
;}
23838
24043
    break;
23839
24044
 
23840
24045
  case 161:
 
24046
 
 
24047
/* Line 1455 of yacc.c  */
23841
24048
#line 1761 "preproc.y"
23842
24049
    { 
23843
 
 yyval.str = cat_str(4,make_str("create group"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
24050
 (yyval.str) = cat_str(4,make_str("create group"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
23844
24051
;}
23845
24052
    break;
23846
24053
 
23847
24054
  case 162:
 
24055
 
 
24056
/* Line 1455 of yacc.c  */
23848
24057
#line 1769 "preproc.y"
23849
24058
    { 
23850
 
 yyval.str = cat_str(5,make_str("alter group"),yyvsp[-3].str,yyvsp[-2].str,make_str("user"),yyvsp[0].str);
 
24059
 (yyval.str) = cat_str(5,make_str("alter group"),(yyvsp[(3) - (6)].str),(yyvsp[(4) - (6)].str),make_str("user"),(yyvsp[(6) - (6)].str));
23851
24060
;}
23852
24061
    break;
23853
24062
 
23854
24063
  case 163:
 
24064
 
 
24065
/* Line 1455 of yacc.c  */
23855
24066
#line 1777 "preproc.y"
23856
24067
    { 
23857
 
 yyval.str = make_str("add");
 
24068
 (yyval.str) = make_str("add");
23858
24069
;}
23859
24070
    break;
23860
24071
 
23861
24072
  case 164:
 
24073
 
 
24074
/* Line 1455 of yacc.c  */
23862
24075
#line 1781 "preproc.y"
23863
24076
    { 
23864
 
 yyval.str = make_str("drop");
 
24077
 (yyval.str) = make_str("drop");
23865
24078
;}
23866
24079
    break;
23867
24080
 
23868
24081
  case 165:
 
24082
 
 
24083
/* Line 1455 of yacc.c  */
23869
24084
#line 1789 "preproc.y"
23870
24085
    { 
23871
 
 yyval.str = cat_str(2,make_str("drop group"),yyvsp[0].str);
 
24086
 (yyval.str) = cat_str(2,make_str("drop group"),(yyvsp[(3) - (3)].str));
23872
24087
;}
23873
24088
    break;
23874
24089
 
23875
24090
  case 166:
 
24091
 
 
24092
/* Line 1455 of yacc.c  */
23876
24093
#line 1793 "preproc.y"
23877
24094
    { 
23878
 
 yyval.str = cat_str(2,make_str("drop group if exists"),yyvsp[0].str);
 
24095
 (yyval.str) = cat_str(2,make_str("drop group if exists"),(yyvsp[(5) - (5)].str));
23879
24096
;}
23880
24097
    break;
23881
24098
 
23882
24099
  case 167:
 
24100
 
 
24101
/* Line 1455 of yacc.c  */
23883
24102
#line 1801 "preproc.y"
23884
24103
    { 
23885
 
 yyval.str = cat_str(5,make_str("create schema"),yyvsp[-3].str,make_str("authorization"),yyvsp[-1].str,yyvsp[0].str);
 
24104
 (yyval.str) = cat_str(5,make_str("create schema"),(yyvsp[(3) - (6)].str),make_str("authorization"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str));
23886
24105
;}
23887
24106
    break;
23888
24107
 
23889
24108
  case 168:
 
24109
 
 
24110
/* Line 1455 of yacc.c  */
23890
24111
#line 1805 "preproc.y"
23891
24112
    { 
23892
 
 yyval.str = cat_str(3,make_str("create schema"),yyvsp[-1].str,yyvsp[0].str);
 
24113
 (yyval.str) = cat_str(3,make_str("create schema"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
23893
24114
;}
23894
24115
    break;
23895
24116
 
23896
24117
  case 169:
 
24118
 
 
24119
/* Line 1455 of yacc.c  */
23897
24120
#line 1813 "preproc.y"
23898
24121
    { 
23899
 
 yyval.str = yyvsp[0].str;
 
24122
 (yyval.str) = (yyvsp[(1) - (1)].str);
23900
24123
;}
23901
24124
    break;
23902
24125
 
23903
24126
  case 170:
 
24127
 
 
24128
/* Line 1455 of yacc.c  */
23904
24129
#line 1817 "preproc.y"
23905
24130
    { 
23906
 
 yyval.str=EMPTY; ;}
 
24131
 (yyval.str)=EMPTY; ;}
23907
24132
    break;
23908
24133
 
23909
24134
  case 171:
 
24135
 
 
24136
/* Line 1455 of yacc.c  */
23910
24137
#line 1824 "preproc.y"
23911
24138
    { 
23912
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
24139
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
23913
24140
;}
23914
24141
    break;
23915
24142
 
23916
24143
  case 172:
 
24144
 
 
24145
/* Line 1455 of yacc.c  */
23917
24146
#line 1828 "preproc.y"
23918
24147
    { 
23919
 
 yyval.str=EMPTY; ;}
 
24148
 (yyval.str)=EMPTY; ;}
23920
24149
    break;
23921
24150
 
23922
24151
  case 173:
 
24152
 
 
24153
/* Line 1455 of yacc.c  */
23923
24154
#line 1835 "preproc.y"
23924
24155
    { 
23925
 
 yyval.str = yyvsp[0].str;
 
24156
 (yyval.str) = (yyvsp[(1) - (1)].str);
23926
24157
;}
23927
24158
    break;
23928
24159
 
23929
24160
  case 174:
 
24161
 
 
24162
/* Line 1455 of yacc.c  */
23930
24163
#line 1839 "preproc.y"
23931
24164
    { 
23932
 
 yyval.str = yyvsp[0].str;
 
24165
 (yyval.str) = (yyvsp[(1) - (1)].str);
23933
24166
;}
23934
24167
    break;
23935
24168
 
23936
24169
  case 175:
 
24170
 
 
24171
/* Line 1455 of yacc.c  */
23937
24172
#line 1843 "preproc.y"
23938
24173
    { 
23939
 
 yyval.str = yyvsp[0].str;
 
24174
 (yyval.str) = (yyvsp[(1) - (1)].str);
23940
24175
;}
23941
24176
    break;
23942
24177
 
23943
24178
  case 176:
 
24179
 
 
24180
/* Line 1455 of yacc.c  */
23944
24181
#line 1847 "preproc.y"
23945
24182
    { 
23946
 
 yyval.str = yyvsp[0].str;
 
24183
 (yyval.str) = (yyvsp[(1) - (1)].str);
23947
24184
;}
23948
24185
    break;
23949
24186
 
23950
24187
  case 177:
 
24188
 
 
24189
/* Line 1455 of yacc.c  */
23951
24190
#line 1851 "preproc.y"
23952
24191
    { 
23953
 
 yyval.str = yyvsp[0].str;
 
24192
 (yyval.str) = (yyvsp[(1) - (1)].str);
23954
24193
;}
23955
24194
    break;
23956
24195
 
23957
24196
  case 178:
 
24197
 
 
24198
/* Line 1455 of yacc.c  */
23958
24199
#line 1855 "preproc.y"
23959
24200
    { 
23960
 
 yyval.str = yyvsp[0].str;
 
24201
 (yyval.str) = (yyvsp[(1) - (1)].str);
23961
24202
;}
23962
24203
    break;
23963
24204
 
23964
24205
  case 179:
 
24206
 
 
24207
/* Line 1455 of yacc.c  */
23965
24208
#line 1863 "preproc.y"
23966
24209
    { 
23967
 
 yyval.str = cat_str(2,make_str("set"),yyvsp[0].str);
 
24210
 (yyval.str) = cat_str(2,make_str("set"),(yyvsp[(2) - (2)].str));
23968
24211
;}
23969
24212
    break;
23970
24213
 
23971
24214
  case 180:
 
24215
 
 
24216
/* Line 1455 of yacc.c  */
23972
24217
#line 1867 "preproc.y"
23973
24218
    { 
23974
 
 yyval.str = cat_str(2,make_str("set local"),yyvsp[0].str);
 
24219
 (yyval.str) = cat_str(2,make_str("set local"),(yyvsp[(3) - (3)].str));
23975
24220
;}
23976
24221
    break;
23977
24222
 
23978
24223
  case 181:
 
24224
 
 
24225
/* Line 1455 of yacc.c  */
23979
24226
#line 1871 "preproc.y"
23980
24227
    { 
23981
 
 yyval.str = cat_str(2,make_str("set session"),yyvsp[0].str);
 
24228
 (yyval.str) = cat_str(2,make_str("set session"),(yyvsp[(3) - (3)].str));
23982
24229
;}
23983
24230
    break;
23984
24231
 
23985
24232
  case 182:
 
24233
 
 
24234
/* Line 1455 of yacc.c  */
23986
24235
#line 1879 "preproc.y"
23987
24236
    { 
23988
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("to"),yyvsp[0].str);
 
24237
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("to"),(yyvsp[(3) - (3)].str));
23989
24238
;}
23990
24239
    break;
23991
24240
 
23992
24241
  case 183:
 
24242
 
 
24243
/* Line 1455 of yacc.c  */
23993
24244
#line 1883 "preproc.y"
23994
24245
    { 
23995
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("="),yyvsp[0].str);
 
24246
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("="),(yyvsp[(3) - (3)].str));
23996
24247
;}
23997
24248
    break;
23998
24249
 
23999
24250
  case 184:
 
24251
 
 
24252
/* Line 1455 of yacc.c  */
24000
24253
#line 1887 "preproc.y"
24001
24254
    { 
24002
 
 yyval.str = cat_str(2,yyvsp[-2].str,make_str("to default"));
 
24255
 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("to default"));
24003
24256
;}
24004
24257
    break;
24005
24258
 
24006
24259
  case 185:
 
24260
 
 
24261
/* Line 1455 of yacc.c  */
24007
24262
#line 1891 "preproc.y"
24008
24263
    { 
24009
 
 yyval.str = cat_str(2,yyvsp[-2].str,make_str("= default"));
 
24264
 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("= default"));
24010
24265
;}
24011
24266
    break;
24012
24267
 
24013
24268
  case 186:
 
24269
 
 
24270
/* Line 1455 of yacc.c  */
24014
24271
#line 1895 "preproc.y"
24015
24272
    { 
24016
 
 yyval.str = cat_str(2,yyvsp[-2].str,make_str("from current"));
 
24273
 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("from current"));
24017
24274
;}
24018
24275
    break;
24019
24276
 
24020
24277
  case 187:
 
24278
 
 
24279
/* Line 1455 of yacc.c  */
24021
24280
#line 1899 "preproc.y"
24022
24281
    { 
24023
 
 yyval.str = cat_str(2,make_str("time zone"),yyvsp[0].str);
 
24282
 (yyval.str) = cat_str(2,make_str("time zone"),(yyvsp[(3) - (3)].str));
24024
24283
;}
24025
24284
    break;
24026
24285
 
24027
24286
  case 188:
 
24287
 
 
24288
/* Line 1455 of yacc.c  */
24028
24289
#line 1903 "preproc.y"
24029
24290
    { 
24030
 
 yyval.str = cat_str(2,make_str("transaction"),yyvsp[0].str);
 
24291
 (yyval.str) = cat_str(2,make_str("transaction"),(yyvsp[(2) - (2)].str));
24031
24292
;}
24032
24293
    break;
24033
24294
 
24034
24295
  case 189:
 
24296
 
 
24297
/* Line 1455 of yacc.c  */
24035
24298
#line 1907 "preproc.y"
24036
24299
    { 
24037
 
 yyval.str = cat_str(2,make_str("session characteristics as transaction"),yyvsp[0].str);
 
24300
 (yyval.str) = cat_str(2,make_str("session characteristics as transaction"),(yyvsp[(5) - (5)].str));
24038
24301
;}
24039
24302
    break;
24040
24303
 
24041
24304
  case 190:
 
24305
 
 
24306
/* Line 1455 of yacc.c  */
24042
24307
#line 1911 "preproc.y"
24043
24308
    { 
24044
24309
mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
24045
 
 yyval.str = cat_str(2,make_str("catalog"),yyvsp[0].str);
 
24310
 (yyval.str) = cat_str(2,make_str("catalog"),(yyvsp[(2) - (2)].str));
24046
24311
;}
24047
24312
    break;
24048
24313
 
24049
24314
  case 191:
 
24315
 
 
24316
/* Line 1455 of yacc.c  */
24050
24317
#line 1916 "preproc.y"
24051
24318
    { 
24052
 
 yyval.str = cat_str(2,make_str("schema"),yyvsp[0].str);
 
24319
 (yyval.str) = cat_str(2,make_str("schema"),(yyvsp[(2) - (2)].str));
24053
24320
;}
24054
24321
    break;
24055
24322
 
24056
24323
  case 192:
 
24324
 
 
24325
/* Line 1455 of yacc.c  */
24057
24326
#line 1920 "preproc.y"
24058
24327
    { 
24059
 
 yyval.str = cat_str(2,make_str("names"),yyvsp[0].str);
 
24328
 (yyval.str) = cat_str(2,make_str("names"),(yyvsp[(2) - (2)].str));
24060
24329
;}
24061
24330
    break;
24062
24331
 
24063
24332
  case 193:
 
24333
 
 
24334
/* Line 1455 of yacc.c  */
24064
24335
#line 1924 "preproc.y"
24065
24336
    { 
24066
 
 yyval.str = cat_str(2,make_str("role"),yyvsp[0].str);
 
24337
 (yyval.str) = cat_str(2,make_str("role"),(yyvsp[(2) - (2)].str));
24067
24338
;}
24068
24339
    break;
24069
24340
 
24070
24341
  case 194:
 
24342
 
 
24343
/* Line 1455 of yacc.c  */
24071
24344
#line 1928 "preproc.y"
24072
24345
    { 
24073
 
 yyval.str = cat_str(2,make_str("session authorization"),yyvsp[0].str);
 
24346
 (yyval.str) = cat_str(2,make_str("session authorization"),(yyvsp[(3) - (3)].str));
24074
24347
;}
24075
24348
    break;
24076
24349
 
24077
24350
  case 195:
 
24351
 
 
24352
/* Line 1455 of yacc.c  */
24078
24353
#line 1932 "preproc.y"
24079
24354
    { 
24080
 
 yyval.str = make_str("session authorization default");
 
24355
 (yyval.str) = make_str("session authorization default");
24081
24356
;}
24082
24357
    break;
24083
24358
 
24084
24359
  case 196:
 
24360
 
 
24361
/* Line 1455 of yacc.c  */
24085
24362
#line 1936 "preproc.y"
24086
24363
    { 
24087
 
 yyval.str = cat_str(2,make_str("xml option"),yyvsp[0].str);
 
24364
 (yyval.str) = cat_str(2,make_str("xml option"),(yyvsp[(3) - (3)].str));
24088
24365
;}
24089
24366
    break;
24090
24367
 
24091
24368
  case 197:
 
24369
 
 
24370
/* Line 1455 of yacc.c  */
24092
24371
#line 1944 "preproc.y"
24093
24372
    { 
24094
 
 yyval.str = yyvsp[0].str;
 
24373
 (yyval.str) = (yyvsp[(1) - (1)].str);
24095
24374
;}
24096
24375
    break;
24097
24376
 
24098
24377
  case 198:
 
24378
 
 
24379
/* Line 1455 of yacc.c  */
24099
24380
#line 1948 "preproc.y"
24100
24381
    { 
24101
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("."),yyvsp[0].str);
 
24382
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("."),(yyvsp[(3) - (3)].str));
24102
24383
;}
24103
24384
    break;
24104
24385
 
24105
24386
  case 199:
 
24387
 
 
24388
/* Line 1455 of yacc.c  */
24106
24389
#line 1956 "preproc.y"
24107
24390
    { 
24108
 
 yyval.str = yyvsp[0].str;
 
24391
 (yyval.str) = (yyvsp[(1) - (1)].str);
24109
24392
;}
24110
24393
    break;
24111
24394
 
24112
24395
  case 200:
 
24396
 
 
24397
/* Line 1455 of yacc.c  */
24113
24398
#line 1960 "preproc.y"
24114
24399
    { 
24115
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
24400
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
24116
24401
;}
24117
24402
    break;
24118
24403
 
24119
24404
  case 201:
 
24405
 
 
24406
/* Line 1455 of yacc.c  */
24120
24407
#line 1968 "preproc.y"
24121
24408
    { 
24122
 
 yyval.str = yyvsp[0].str;
 
24409
 (yyval.str) = (yyvsp[(1) - (1)].str);
24123
24410
;}
24124
24411
    break;
24125
24412
 
24126
24413
  case 202:
 
24414
 
 
24415
/* Line 1455 of yacc.c  */
24127
24416
#line 1972 "preproc.y"
24128
24417
    { 
24129
 
 yyval.str = yyvsp[0].str;
 
24418
 (yyval.str) = (yyvsp[(1) - (1)].str);
24130
24419
;}
24131
24420
    break;
24132
24421
 
24133
24422
  case 203:
 
24423
 
 
24424
/* Line 1455 of yacc.c  */
24134
24425
#line 1976 "preproc.y"
24135
24426
    { 
24136
 
                if (yyvsp[0].str[0] == '$')
 
24427
                if ((yyvsp[(1) - (1)].str)[0] == '$')
24137
24428
                {
24138
 
                        free(yyvsp[0].str);
24139
 
                        yyvsp[0].str = make_str("$0");
 
24429
                        free((yyvsp[(1) - (1)].str));
 
24430
                        (yyvsp[(1) - (1)].str) = make_str("$0");
24140
24431
                }
24141
24432
 
24142
 
 yyval.str = yyvsp[0].str;
 
24433
 (yyval.str) = (yyvsp[(1) - (1)].str);
24143
24434
;}
24144
24435
    break;
24145
24436
 
24146
24437
  case 204:
 
24438
 
 
24439
/* Line 1455 of yacc.c  */
24147
24440
#line 1990 "preproc.y"
24148
24441
    { 
24149
 
 yyval.str = make_str("read uncommitted");
 
24442
 (yyval.str) = make_str("read uncommitted");
24150
24443
;}
24151
24444
    break;
24152
24445
 
24153
24446
  case 205:
 
24447
 
 
24448
/* Line 1455 of yacc.c  */
24154
24449
#line 1994 "preproc.y"
24155
24450
    { 
24156
 
 yyval.str = make_str("read committed");
 
24451
 (yyval.str) = make_str("read committed");
24157
24452
;}
24158
24453
    break;
24159
24454
 
24160
24455
  case 206:
 
24456
 
 
24457
/* Line 1455 of yacc.c  */
24161
24458
#line 1998 "preproc.y"
24162
24459
    { 
24163
 
 yyval.str = make_str("repeatable read");
 
24460
 (yyval.str) = make_str("repeatable read");
24164
24461
;}
24165
24462
    break;
24166
24463
 
24167
24464
  case 207:
 
24465
 
 
24466
/* Line 1455 of yacc.c  */
24168
24467
#line 2002 "preproc.y"
24169
24468
    { 
24170
 
 yyval.str = make_str("serializable");
 
24469
 (yyval.str) = make_str("serializable");
24171
24470
;}
24172
24471
    break;
24173
24472
 
24174
24473
  case 208:
 
24474
 
 
24475
/* Line 1455 of yacc.c  */
24175
24476
#line 2010 "preproc.y"
24176
24477
    { 
24177
 
 yyval.str = make_str("true");
 
24478
 (yyval.str) = make_str("true");
24178
24479
;}
24179
24480
    break;
24180
24481
 
24181
24482
  case 209:
 
24483
 
 
24484
/* Line 1455 of yacc.c  */
24182
24485
#line 2014 "preproc.y"
24183
24486
    { 
24184
 
 yyval.str = make_str("false");
 
24487
 (yyval.str) = make_str("false");
24185
24488
;}
24186
24489
    break;
24187
24490
 
24188
24491
  case 210:
 
24492
 
 
24493
/* Line 1455 of yacc.c  */
24189
24494
#line 2018 "preproc.y"
24190
24495
    { 
24191
 
 yyval.str = make_str("on");
 
24496
 (yyval.str) = make_str("on");
24192
24497
;}
24193
24498
    break;
24194
24499
 
24195
24500
  case 211:
 
24501
 
 
24502
/* Line 1455 of yacc.c  */
24196
24503
#line 2022 "preproc.y"
24197
24504
    { 
24198
 
 yyval.str = make_str("off");
 
24505
 (yyval.str) = make_str("off");
24199
24506
;}
24200
24507
    break;
24201
24508
 
24202
24509
  case 212:
 
24510
 
 
24511
/* Line 1455 of yacc.c  */
24203
24512
#line 2030 "preproc.y"
24204
24513
    { 
24205
 
 yyval.str = yyvsp[0].str;
 
24514
 (yyval.str) = (yyvsp[(1) - (1)].str);
24206
24515
;}
24207
24516
    break;
24208
24517
 
24209
24518
  case 213:
 
24519
 
 
24520
/* Line 1455 of yacc.c  */
24210
24521
#line 2034 "preproc.y"
24211
24522
    { 
24212
 
 yyval.str = yyvsp[0].str;
 
24523
 (yyval.str) = (yyvsp[(1) - (1)].str);
24213
24524
;}
24214
24525
    break;
24215
24526
 
24216
24527
  case 214:
 
24528
 
 
24529
/* Line 1455 of yacc.c  */
24217
24530
#line 2038 "preproc.y"
24218
24531
    { 
24219
 
 yyval.str = cat_str(3,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
24532
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
24220
24533
;}
24221
24534
    break;
24222
24535
 
24223
24536
  case 215:
 
24537
 
 
24538
/* Line 1455 of yacc.c  */
24224
24539
#line 2042 "preproc.y"
24225
24540
    { 
24226
 
 yyval.str = cat_str(6,yyvsp[-5].str,make_str("("),yyvsp[-3].str,make_str(")"),yyvsp[-1].str,yyvsp[0].str);
 
24541
 (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));
24227
24542
;}
24228
24543
    break;
24229
24544
 
24230
24545
  case 216:
 
24546
 
 
24547
/* Line 1455 of yacc.c  */
24231
24548
#line 2046 "preproc.y"
24232
24549
    { 
24233
 
 yyval.str = yyvsp[0].str;
 
24550
 (yyval.str) = (yyvsp[(1) - (1)].str);
24234
24551
;}
24235
24552
    break;
24236
24553
 
24237
24554
  case 217:
 
24555
 
 
24556
/* Line 1455 of yacc.c  */
24238
24557
#line 2050 "preproc.y"
24239
24558
    { 
24240
 
 yyval.str = make_str("default");
 
24559
 (yyval.str) = make_str("default");
24241
24560
;}
24242
24561
    break;
24243
24562
 
24244
24563
  case 218:
 
24564
 
 
24565
/* Line 1455 of yacc.c  */
24245
24566
#line 2054 "preproc.y"
24246
24567
    { 
24247
 
 yyval.str = make_str("local");
 
24568
 (yyval.str) = make_str("local");
24248
24569
;}
24249
24570
    break;
24250
24571
 
24251
24572
  case 219:
 
24573
 
 
24574
/* Line 1455 of yacc.c  */
24252
24575
#line 2062 "preproc.y"
24253
24576
    { 
24254
 
 yyval.str = yyvsp[0].str;
 
24577
 (yyval.str) = (yyvsp[(1) - (1)].str);
24255
24578
;}
24256
24579
    break;
24257
24580
 
24258
24581
  case 220:
 
24582
 
 
24583
/* Line 1455 of yacc.c  */
24259
24584
#line 2066 "preproc.y"
24260
24585
    { 
24261
 
 yyval.str = make_str("default");
 
24586
 (yyval.str) = make_str("default");
24262
24587
;}
24263
24588
    break;
24264
24589
 
24265
24590
  case 221:
 
24591
 
 
24592
/* Line 1455 of yacc.c  */
24266
24593
#line 2070 "preproc.y"
24267
24594
    { 
24268
 
 yyval.str=EMPTY; ;}
 
24595
 (yyval.str)=EMPTY; ;}
24269
24596
    break;
24270
24597
 
24271
24598
  case 222:
 
24599
 
 
24600
/* Line 1455 of yacc.c  */
24272
24601
#line 2077 "preproc.y"
24273
24602
    { 
24274
 
 yyval.str = yyvsp[0].str;
 
24603
 (yyval.str) = (yyvsp[(1) - (1)].str);
24275
24604
;}
24276
24605
    break;
24277
24606
 
24278
24607
  case 223:
 
24608
 
 
24609
/* Line 1455 of yacc.c  */
24279
24610
#line 2081 "preproc.y"
24280
24611
    { 
24281
 
 yyval.str = yyvsp[0].str;
 
24612
 (yyval.str) = (yyvsp[(1) - (1)].str);
24282
24613
;}
24283
24614
    break;
24284
24615
 
24285
24616
  case 224:
 
24617
 
 
24618
/* Line 1455 of yacc.c  */
24286
24619
#line 2089 "preproc.y"
24287
24620
    { 
24288
 
 yyval.str = cat_str(2,make_str("reset"),yyvsp[0].str);
 
24621
 (yyval.str) = cat_str(2,make_str("reset"),(yyvsp[(2) - (2)].str));
24289
24622
;}
24290
24623
    break;
24291
24624
 
24292
24625
  case 225:
 
24626
 
 
24627
/* Line 1455 of yacc.c  */
24293
24628
#line 2093 "preproc.y"
24294
24629
    { 
24295
 
 yyval.str = make_str("reset time zone");
 
24630
 (yyval.str) = make_str("reset time zone");
24296
24631
;}
24297
24632
    break;
24298
24633
 
24299
24634
  case 226:
 
24635
 
 
24636
/* Line 1455 of yacc.c  */
24300
24637
#line 2097 "preproc.y"
24301
24638
    { 
24302
 
 yyval.str = make_str("reset transaction isolation level");
 
24639
 (yyval.str) = make_str("reset transaction isolation level");
24303
24640
;}
24304
24641
    break;
24305
24642
 
24306
24643
  case 227:
 
24644
 
 
24645
/* Line 1455 of yacc.c  */
24307
24646
#line 2101 "preproc.y"
24308
24647
    { 
24309
 
 yyval.str = make_str("reset session authorization");
 
24648
 (yyval.str) = make_str("reset session authorization");
24310
24649
;}
24311
24650
    break;
24312
24651
 
24313
24652
  case 228:
 
24653
 
 
24654
/* Line 1455 of yacc.c  */
24314
24655
#line 2105 "preproc.y"
24315
24656
    { 
24316
 
 yyval.str = make_str("reset all");
 
24657
 (yyval.str) = make_str("reset all");
24317
24658
;}
24318
24659
    break;
24319
24660
 
24320
24661
  case 229:
 
24662
 
 
24663
/* Line 1455 of yacc.c  */
24321
24664
#line 2113 "preproc.y"
24322
24665
    { 
24323
 
 yyval.str = cat_str(2,make_str("set"),yyvsp[0].str);
 
24666
 (yyval.str) = cat_str(2,make_str("set"),(yyvsp[(2) - (2)].str));
24324
24667
;}
24325
24668
    break;
24326
24669
 
24327
24670
  case 230:
 
24671
 
 
24672
/* Line 1455 of yacc.c  */
24328
24673
#line 2117 "preproc.y"
24329
24674
    { 
24330
 
 yyval.str = yyvsp[0].str;
 
24675
 (yyval.str) = (yyvsp[(1) - (1)].str);
24331
24676
;}
24332
24677
    break;
24333
24678
 
24334
24679
  case 231:
 
24680
 
 
24681
/* Line 1455 of yacc.c  */
24335
24682
#line 2125 "preproc.y"
24336
24683
    { 
24337
 
 yyval.str = cat_str(2,make_str("show"),yyvsp[-1].str);
 
24684
 (yyval.str) = cat_str(2,make_str("show"),(yyvsp[(2) - (3)].str));
24338
24685
;}
24339
24686
    break;
24340
24687
 
24341
24688
  case 232:
 
24689
 
 
24690
/* Line 1455 of yacc.c  */
24342
24691
#line 2129 "preproc.y"
24343
24692
    { 
24344
 
 yyval.str = make_str("show time zone");
 
24693
 (yyval.str) = make_str("show time zone");
24345
24694
;}
24346
24695
    break;
24347
24696
 
24348
24697
  case 233:
 
24698
 
 
24699
/* Line 1455 of yacc.c  */
24349
24700
#line 2133 "preproc.y"
24350
24701
    { 
24351
 
 yyval.str = make_str("show transaction isolation level");
 
24702
 (yyval.str) = make_str("show transaction isolation level");
24352
24703
;}
24353
24704
    break;
24354
24705
 
24355
24706
  case 234:
 
24707
 
 
24708
/* Line 1455 of yacc.c  */
24356
24709
#line 2137 "preproc.y"
24357
24710
    { 
24358
 
 yyval.str = make_str("show session authorization");
 
24711
 (yyval.str) = make_str("show session authorization");
24359
24712
;}
24360
24713
    break;
24361
24714
 
24362
24715
  case 235:
 
24716
 
 
24717
/* Line 1455 of yacc.c  */
24363
24718
#line 2141 "preproc.y"
24364
24719
    {
24365
24720
                mmerror(PARSE_ERROR, ET_ERROR, "SHOW ALL is not implemented");
24366
 
                yyval.str = EMPTY;
 
24721
                (yyval.str) = EMPTY;
24367
24722
        ;}
24368
24723
    break;
24369
24724
 
24370
24725
  case 236:
 
24726
 
 
24727
/* Line 1455 of yacc.c  */
24371
24728
#line 2150 "preproc.y"
24372
24729
    { 
24373
 
 yyval.str = cat_str(3,make_str("set constraints"),yyvsp[-1].str,yyvsp[0].str);
 
24730
 (yyval.str) = cat_str(3,make_str("set constraints"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
24374
24731
;}
24375
24732
    break;
24376
24733
 
24377
24734
  case 237:
 
24735
 
 
24736
/* Line 1455 of yacc.c  */
24378
24737
#line 2158 "preproc.y"
24379
24738
    { 
24380
 
 yyval.str = make_str("all");
 
24739
 (yyval.str) = make_str("all");
24381
24740
;}
24382
24741
    break;
24383
24742
 
24384
24743
  case 238:
 
24744
 
 
24745
/* Line 1455 of yacc.c  */
24385
24746
#line 2162 "preproc.y"
24386
24747
    { 
24387
 
 yyval.str = yyvsp[0].str;
 
24748
 (yyval.str) = (yyvsp[(1) - (1)].str);
24388
24749
;}
24389
24750
    break;
24390
24751
 
24391
24752
  case 239:
 
24753
 
 
24754
/* Line 1455 of yacc.c  */
24392
24755
#line 2170 "preproc.y"
24393
24756
    { 
24394
 
 yyval.str = make_str("deferred");
 
24757
 (yyval.str) = make_str("deferred");
24395
24758
;}
24396
24759
    break;
24397
24760
 
24398
24761
  case 240:
 
24762
 
 
24763
/* Line 1455 of yacc.c  */
24399
24764
#line 2174 "preproc.y"
24400
24765
    { 
24401
 
 yyval.str = make_str("immediate");
 
24766
 (yyval.str) = make_str("immediate");
24402
24767
;}
24403
24768
    break;
24404
24769
 
24405
24770
  case 241:
 
24771
 
 
24772
/* Line 1455 of yacc.c  */
24406
24773
#line 2182 "preproc.y"
24407
24774
    { 
24408
 
 yyval.str = make_str("checkpoint");
 
24775
 (yyval.str) = make_str("checkpoint");
24409
24776
;}
24410
24777
    break;
24411
24778
 
24412
24779
  case 242:
 
24780
 
 
24781
/* Line 1455 of yacc.c  */
24413
24782
#line 2190 "preproc.y"
24414
24783
    { 
24415
 
 yyval.str = make_str("discard all");
 
24784
 (yyval.str) = make_str("discard all");
24416
24785
;}
24417
24786
    break;
24418
24787
 
24419
24788
  case 243:
 
24789
 
 
24790
/* Line 1455 of yacc.c  */
24420
24791
#line 2194 "preproc.y"
24421
24792
    { 
24422
 
 yyval.str = make_str("discard temp");
 
24793
 (yyval.str) = make_str("discard temp");
24423
24794
;}
24424
24795
    break;
24425
24796
 
24426
24797
  case 244:
 
24798
 
 
24799
/* Line 1455 of yacc.c  */
24427
24800
#line 2198 "preproc.y"
24428
24801
    { 
24429
 
 yyval.str = make_str("discard temporary");
 
24802
 (yyval.str) = make_str("discard temporary");
24430
24803
;}
24431
24804
    break;
24432
24805
 
24433
24806
  case 245:
 
24807
 
 
24808
/* Line 1455 of yacc.c  */
24434
24809
#line 2202 "preproc.y"
24435
24810
    { 
24436
 
 yyval.str = make_str("discard plans");
 
24811
 (yyval.str) = make_str("discard plans");
24437
24812
;}
24438
24813
    break;
24439
24814
 
24440
24815
  case 246:
 
24816
 
 
24817
/* Line 1455 of yacc.c  */
24441
24818
#line 2210 "preproc.y"
24442
24819
    { 
24443
 
 yyval.str = cat_str(3,make_str("alter table"),yyvsp[-1].str,yyvsp[0].str);
 
24820
 (yyval.str) = cat_str(3,make_str("alter table"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
24444
24821
;}
24445
24822
    break;
24446
24823
 
24447
24824
  case 247:
 
24825
 
 
24826
/* Line 1455 of yacc.c  */
24448
24827
#line 2214 "preproc.y"
24449
24828
    { 
24450
 
 yyval.str = cat_str(3,make_str("alter index"),yyvsp[-1].str,yyvsp[0].str);
 
24829
 (yyval.str) = cat_str(3,make_str("alter index"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
24451
24830
;}
24452
24831
    break;
24453
24832
 
24454
24833
  case 248:
 
24834
 
 
24835
/* Line 1455 of yacc.c  */
24455
24836
#line 2218 "preproc.y"
24456
24837
    { 
24457
 
 yyval.str = cat_str(3,make_str("alter sequence"),yyvsp[-1].str,yyvsp[0].str);
 
24838
 (yyval.str) = cat_str(3,make_str("alter sequence"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
24458
24839
;}
24459
24840
    break;
24460
24841
 
24461
24842
  case 249:
 
24843
 
 
24844
/* Line 1455 of yacc.c  */
24462
24845
#line 2222 "preproc.y"
24463
24846
    { 
24464
 
 yyval.str = cat_str(3,make_str("alter view"),yyvsp[-1].str,yyvsp[0].str);
 
24847
 (yyval.str) = cat_str(3,make_str("alter view"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
24465
24848
;}
24466
24849
    break;
24467
24850
 
24468
24851
  case 250:
 
24852
 
 
24853
/* Line 1455 of yacc.c  */
24469
24854
#line 2230 "preproc.y"
24470
24855
    { 
24471
 
 yyval.str = yyvsp[0].str;
 
24856
 (yyval.str) = (yyvsp[(1) - (1)].str);
24472
24857
;}
24473
24858
    break;
24474
24859
 
24475
24860
  case 251:
 
24861
 
 
24862
/* Line 1455 of yacc.c  */
24476
24863
#line 2234 "preproc.y"
24477
24864
    { 
24478
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
24865
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
24479
24866
;}
24480
24867
    break;
24481
24868
 
24482
24869
  case 252:
 
24870
 
 
24871
/* Line 1455 of yacc.c  */
24483
24872
#line 2242 "preproc.y"
24484
24873
    { 
24485
 
 yyval.str = cat_str(3,make_str("add"),yyvsp[-1].str,yyvsp[0].str);
 
24874
 (yyval.str) = cat_str(3,make_str("add"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
24486
24875
;}
24487
24876
    break;
24488
24877
 
24489
24878
  case 253:
 
24879
 
 
24880
/* Line 1455 of yacc.c  */
24490
24881
#line 2246 "preproc.y"
24491
24882
    { 
24492
 
 yyval.str = cat_str(4,make_str("alter"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
24883
 (yyval.str) = cat_str(4,make_str("alter"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
24493
24884
;}
24494
24885
    break;
24495
24886
 
24496
24887
  case 254:
 
24888
 
 
24889
/* Line 1455 of yacc.c  */
24497
24890
#line 2250 "preproc.y"
24498
24891
    { 
24499
 
 yyval.str = cat_str(4,make_str("alter"),yyvsp[-4].str,yyvsp[-3].str,make_str("drop not null"));
 
24892
 (yyval.str) = cat_str(4,make_str("alter"),(yyvsp[(2) - (6)].str),(yyvsp[(3) - (6)].str),make_str("drop not null"));
24500
24893
;}
24501
24894
    break;
24502
24895
 
24503
24896
  case 255:
 
24897
 
 
24898
/* Line 1455 of yacc.c  */
24504
24899
#line 2254 "preproc.y"
24505
24900
    { 
24506
 
 yyval.str = cat_str(4,make_str("alter"),yyvsp[-4].str,yyvsp[-3].str,make_str("set not null"));
 
24901
 (yyval.str) = cat_str(4,make_str("alter"),(yyvsp[(2) - (6)].str),(yyvsp[(3) - (6)].str),make_str("set not null"));
24507
24902
;}
24508
24903
    break;
24509
24904
 
24510
24905
  case 256:
 
24906
 
 
24907
/* Line 1455 of yacc.c  */
24511
24908
#line 2258 "preproc.y"
24512
24909
    { 
24513
 
 yyval.str = cat_str(5,make_str("alter"),yyvsp[-4].str,yyvsp[-3].str,make_str("set statistics"),yyvsp[0].str);
 
24910
 (yyval.str) = cat_str(5,make_str("alter"),(yyvsp[(2) - (6)].str),(yyvsp[(3) - (6)].str),make_str("set statistics"),(yyvsp[(6) - (6)].str));
24514
24911
;}
24515
24912
    break;
24516
24913
 
24517
24914
  case 257:
 
24915
 
 
24916
/* Line 1455 of yacc.c  */
24518
24917
#line 2262 "preproc.y"
24519
24918
    { 
24520
 
 yyval.str = cat_str(5,make_str("alter"),yyvsp[-4].str,yyvsp[-3].str,make_str("set storage"),yyvsp[0].str);
 
24919
 (yyval.str) = cat_str(5,make_str("alter"),(yyvsp[(2) - (6)].str),(yyvsp[(3) - (6)].str),make_str("set storage"),(yyvsp[(6) - (6)].str));
24521
24920
;}
24522
24921
    break;
24523
24922
 
24524
24923
  case 258:
 
24924
 
 
24925
/* Line 1455 of yacc.c  */
24525
24926
#line 2266 "preproc.y"
24526
24927
    { 
24527
 
 yyval.str = cat_str(4,make_str("drop"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
24928
 (yyval.str) = cat_str(4,make_str("drop"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
24528
24929
;}
24529
24930
    break;
24530
24931
 
24531
24932
  case 259:
 
24933
 
 
24934
/* Line 1455 of yacc.c  */
24532
24935
#line 2270 "preproc.y"
24533
24936
    { 
24534
 
 yyval.str = cat_str(7,make_str("alter"),yyvsp[-5].str,yyvsp[-4].str,yyvsp[-3].str,make_str("type"),yyvsp[-1].str,yyvsp[0].str);
 
24937
 (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));
24535
24938
;}
24536
24939
    break;
24537
24940
 
24538
24941
  case 260:
 
24942
 
 
24943
/* Line 1455 of yacc.c  */
24539
24944
#line 2274 "preproc.y"
24540
24945
    { 
24541
 
 yyval.str = cat_str(2,make_str("add"),yyvsp[0].str);
 
24946
 (yyval.str) = cat_str(2,make_str("add"),(yyvsp[(2) - (2)].str));
24542
24947
;}
24543
24948
    break;
24544
24949
 
24545
24950
  case 261:
 
24951
 
 
24952
/* Line 1455 of yacc.c  */
24546
24953
#line 2278 "preproc.y"
24547
24954
    { 
24548
 
 yyval.str = cat_str(3,make_str("drop constraint"),yyvsp[-1].str,yyvsp[0].str);
 
24955
 (yyval.str) = cat_str(3,make_str("drop constraint"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
24549
24956
;}
24550
24957
    break;
24551
24958
 
24552
24959
  case 262:
 
24960
 
 
24961
/* Line 1455 of yacc.c  */
24553
24962
#line 2282 "preproc.y"
24554
24963
    { 
24555
 
 yyval.str = make_str("set with oids");
 
24964
 (yyval.str) = make_str("set with oids");
24556
24965
;}
24557
24966
    break;
24558
24967
 
24559
24968
  case 263:
 
24969
 
 
24970
/* Line 1455 of yacc.c  */
24560
24971
#line 2286 "preproc.y"
24561
24972
    { 
24562
 
 yyval.str = make_str("set without oids");
 
24973
 (yyval.str) = make_str("set without oids");
24563
24974
;}
24564
24975
    break;
24565
24976
 
24566
24977
  case 264:
 
24978
 
 
24979
/* Line 1455 of yacc.c  */
24567
24980
#line 2290 "preproc.y"
24568
24981
    { 
24569
 
 yyval.str = cat_str(2,make_str("cluster on"),yyvsp[0].str);
 
24982
 (yyval.str) = cat_str(2,make_str("cluster on"),(yyvsp[(3) - (3)].str));
24570
24983
;}
24571
24984
    break;
24572
24985
 
24573
24986
  case 265:
 
24987
 
 
24988
/* Line 1455 of yacc.c  */
24574
24989
#line 2294 "preproc.y"
24575
24990
    { 
24576
 
 yyval.str = make_str("set without cluster");
 
24991
 (yyval.str) = make_str("set without cluster");
24577
24992
;}
24578
24993
    break;
24579
24994
 
24580
24995
  case 266:
 
24996
 
 
24997
/* Line 1455 of yacc.c  */
24581
24998
#line 2298 "preproc.y"
24582
24999
    { 
24583
 
 yyval.str = cat_str(2,make_str("enable trigger"),yyvsp[0].str);
 
25000
 (yyval.str) = cat_str(2,make_str("enable trigger"),(yyvsp[(3) - (3)].str));
24584
25001
;}
24585
25002
    break;
24586
25003
 
24587
25004
  case 267:
 
25005
 
 
25006
/* Line 1455 of yacc.c  */
24588
25007
#line 2302 "preproc.y"
24589
25008
    { 
24590
 
 yyval.str = cat_str(2,make_str("enable always trigger"),yyvsp[0].str);
 
25009
 (yyval.str) = cat_str(2,make_str("enable always trigger"),(yyvsp[(4) - (4)].str));
24591
25010
;}
24592
25011
    break;
24593
25012
 
24594
25013
  case 268:
 
25014
 
 
25015
/* Line 1455 of yacc.c  */
24595
25016
#line 2306 "preproc.y"
24596
25017
    { 
24597
 
 yyval.str = cat_str(2,make_str("enable replica trigger"),yyvsp[0].str);
 
25018
 (yyval.str) = cat_str(2,make_str("enable replica trigger"),(yyvsp[(4) - (4)].str));
24598
25019
;}
24599
25020
    break;
24600
25021
 
24601
25022
  case 269:
 
25023
 
 
25024
/* Line 1455 of yacc.c  */
24602
25025
#line 2310 "preproc.y"
24603
25026
    { 
24604
 
 yyval.str = make_str("enable trigger all");
 
25027
 (yyval.str) = make_str("enable trigger all");
24605
25028
;}
24606
25029
    break;
24607
25030
 
24608
25031
  case 270:
 
25032
 
 
25033
/* Line 1455 of yacc.c  */
24609
25034
#line 2314 "preproc.y"
24610
25035
    { 
24611
 
 yyval.str = make_str("enable trigger user");
 
25036
 (yyval.str) = make_str("enable trigger user");
24612
25037
;}
24613
25038
    break;
24614
25039
 
24615
25040
  case 271:
 
25041
 
 
25042
/* Line 1455 of yacc.c  */
24616
25043
#line 2318 "preproc.y"
24617
25044
    { 
24618
 
 yyval.str = cat_str(2,make_str("disable trigger"),yyvsp[0].str);
 
25045
 (yyval.str) = cat_str(2,make_str("disable trigger"),(yyvsp[(3) - (3)].str));
24619
25046
;}
24620
25047
    break;
24621
25048
 
24622
25049
  case 272:
 
25050
 
 
25051
/* Line 1455 of yacc.c  */
24623
25052
#line 2322 "preproc.y"
24624
25053
    { 
24625
 
 yyval.str = make_str("disable trigger all");
 
25054
 (yyval.str) = make_str("disable trigger all");
24626
25055
;}
24627
25056
    break;
24628
25057
 
24629
25058
  case 273:
 
25059
 
 
25060
/* Line 1455 of yacc.c  */
24630
25061
#line 2326 "preproc.y"
24631
25062
    { 
24632
 
 yyval.str = make_str("disable trigger user");
 
25063
 (yyval.str) = make_str("disable trigger user");
24633
25064
;}
24634
25065
    break;
24635
25066
 
24636
25067
  case 274:
 
25068
 
 
25069
/* Line 1455 of yacc.c  */
24637
25070
#line 2330 "preproc.y"
24638
25071
    { 
24639
 
 yyval.str = cat_str(2,make_str("enable rule"),yyvsp[0].str);
 
25072
 (yyval.str) = cat_str(2,make_str("enable rule"),(yyvsp[(3) - (3)].str));
24640
25073
;}
24641
25074
    break;
24642
25075
 
24643
25076
  case 275:
 
25077
 
 
25078
/* Line 1455 of yacc.c  */
24644
25079
#line 2334 "preproc.y"
24645
25080
    { 
24646
 
 yyval.str = cat_str(2,make_str("enable always rule"),yyvsp[0].str);
 
25081
 (yyval.str) = cat_str(2,make_str("enable always rule"),(yyvsp[(4) - (4)].str));
24647
25082
;}
24648
25083
    break;
24649
25084
 
24650
25085
  case 276:
 
25086
 
 
25087
/* Line 1455 of yacc.c  */
24651
25088
#line 2338 "preproc.y"
24652
25089
    { 
24653
 
 yyval.str = cat_str(2,make_str("enable replica rule"),yyvsp[0].str);
 
25090
 (yyval.str) = cat_str(2,make_str("enable replica rule"),(yyvsp[(4) - (4)].str));
24654
25091
;}
24655
25092
    break;
24656
25093
 
24657
25094
  case 277:
 
25095
 
 
25096
/* Line 1455 of yacc.c  */
24658
25097
#line 2342 "preproc.y"
24659
25098
    { 
24660
 
 yyval.str = cat_str(2,make_str("disable rule"),yyvsp[0].str);
 
25099
 (yyval.str) = cat_str(2,make_str("disable rule"),(yyvsp[(3) - (3)].str));
24661
25100
;}
24662
25101
    break;
24663
25102
 
24664
25103
  case 278:
 
25104
 
 
25105
/* Line 1455 of yacc.c  */
24665
25106
#line 2346 "preproc.y"
24666
25107
    { 
24667
 
 yyval.str = cat_str(2,make_str("inherit"),yyvsp[0].str);
 
25108
 (yyval.str) = cat_str(2,make_str("inherit"),(yyvsp[(2) - (2)].str));
24668
25109
;}
24669
25110
    break;
24670
25111
 
24671
25112
  case 279:
 
25113
 
 
25114
/* Line 1455 of yacc.c  */
24672
25115
#line 2350 "preproc.y"
24673
25116
    { 
24674
 
 yyval.str = cat_str(2,make_str("no inherit"),yyvsp[0].str);
 
25117
 (yyval.str) = cat_str(2,make_str("no inherit"),(yyvsp[(3) - (3)].str));
24675
25118
;}
24676
25119
    break;
24677
25120
 
24678
25121
  case 280:
 
25122
 
 
25123
/* Line 1455 of yacc.c  */
24679
25124
#line 2354 "preproc.y"
24680
25125
    { 
24681
 
 yyval.str = cat_str(2,make_str("owner to"),yyvsp[0].str);
 
25126
 (yyval.str) = cat_str(2,make_str("owner to"),(yyvsp[(3) - (3)].str));
24682
25127
;}
24683
25128
    break;
24684
25129
 
24685
25130
  case 281:
 
25131
 
 
25132
/* Line 1455 of yacc.c  */
24686
25133
#line 2358 "preproc.y"
24687
25134
    { 
24688
 
 yyval.str = cat_str(2,make_str("set tablespace"),yyvsp[0].str);
 
25135
 (yyval.str) = cat_str(2,make_str("set tablespace"),(yyvsp[(3) - (3)].str));
24689
25136
;}
24690
25137
    break;
24691
25138
 
24692
25139
  case 282:
 
25140
 
 
25141
/* Line 1455 of yacc.c  */
24693
25142
#line 2362 "preproc.y"
24694
25143
    { 
24695
 
 yyval.str = cat_str(2,make_str("set"),yyvsp[0].str);
 
25144
 (yyval.str) = cat_str(2,make_str("set"),(yyvsp[(2) - (2)].str));
24696
25145
;}
24697
25146
    break;
24698
25147
 
24699
25148
  case 283:
 
25149
 
 
25150
/* Line 1455 of yacc.c  */
24700
25151
#line 2366 "preproc.y"
24701
25152
    { 
24702
 
 yyval.str = cat_str(2,make_str("reset"),yyvsp[0].str);
 
25153
 (yyval.str) = cat_str(2,make_str("reset"),(yyvsp[(2) - (2)].str));
24703
25154
;}
24704
25155
    break;
24705
25156
 
24706
25157
  case 284:
 
25158
 
 
25159
/* Line 1455 of yacc.c  */
24707
25160
#line 2374 "preproc.y"
24708
25161
    { 
24709
 
 yyval.str = cat_str(2,make_str("set default"),yyvsp[0].str);
 
25162
 (yyval.str) = cat_str(2,make_str("set default"),(yyvsp[(3) - (3)].str));
24710
25163
;}
24711
25164
    break;
24712
25165
 
24713
25166
  case 285:
 
25167
 
 
25168
/* Line 1455 of yacc.c  */
24714
25169
#line 2378 "preproc.y"
24715
25170
    { 
24716
 
 yyval.str = make_str("drop default");
 
25171
 (yyval.str) = make_str("drop default");
24717
25172
;}
24718
25173
    break;
24719
25174
 
24720
25175
  case 286:
 
25176
 
 
25177
/* Line 1455 of yacc.c  */
24721
25178
#line 2386 "preproc.y"
24722
25179
    { 
24723
 
 yyval.str = make_str("cascade");
 
25180
 (yyval.str) = make_str("cascade");
24724
25181
;}
24725
25182
    break;
24726
25183
 
24727
25184
  case 287:
 
25185
 
 
25186
/* Line 1455 of yacc.c  */
24728
25187
#line 2390 "preproc.y"
24729
25188
    { 
24730
 
 yyval.str = make_str("restrict");
 
25189
 (yyval.str) = make_str("restrict");
24731
25190
;}
24732
25191
    break;
24733
25192
 
24734
25193
  case 288:
 
25194
 
 
25195
/* Line 1455 of yacc.c  */
24735
25196
#line 2394 "preproc.y"
24736
25197
    { 
24737
 
 yyval.str=EMPTY; ;}
 
25198
 (yyval.str)=EMPTY; ;}
24738
25199
    break;
24739
25200
 
24740
25201
  case 289:
 
25202
 
 
25203
/* Line 1455 of yacc.c  */
24741
25204
#line 2401 "preproc.y"
24742
25205
    { 
24743
 
 yyval.str = cat_str(2,make_str("using"),yyvsp[0].str);
 
25206
 (yyval.str) = cat_str(2,make_str("using"),(yyvsp[(2) - (2)].str));
24744
25207
;}
24745
25208
    break;
24746
25209
 
24747
25210
  case 290:
 
25211
 
 
25212
/* Line 1455 of yacc.c  */
24748
25213
#line 2405 "preproc.y"
24749
25214
    { 
24750
 
 yyval.str=EMPTY; ;}
 
25215
 (yyval.str)=EMPTY; ;}
24751
25216
    break;
24752
25217
 
24753
25218
  case 291:
 
25219
 
 
25220
/* Line 1455 of yacc.c  */
24754
25221
#line 2412 "preproc.y"
24755
25222
    { 
24756
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
25223
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
24757
25224
;}
24758
25225
    break;
24759
25226
 
24760
25227
  case 292:
 
25228
 
 
25229
/* Line 1455 of yacc.c  */
24761
25230
#line 2420 "preproc.y"
24762
25231
    { 
24763
 
 yyval.str = cat_str(2,make_str("with"),yyvsp[0].str);
 
25232
 (yyval.str) = cat_str(2,make_str("with"),(yyvsp[(2) - (2)].str));
24764
25233
;}
24765
25234
    break;
24766
25235
 
24767
25236
  case 293:
 
25237
 
 
25238
/* Line 1455 of yacc.c  */
24768
25239
#line 2424 "preproc.y"
24769
25240
    { 
24770
 
 yyval.str=EMPTY; ;}
 
25241
 (yyval.str)=EMPTY; ;}
24771
25242
    break;
24772
25243
 
24773
25244
  case 294:
 
25245
 
 
25246
/* Line 1455 of yacc.c  */
24774
25247
#line 2431 "preproc.y"
24775
25248
    { 
24776
 
 yyval.str = yyvsp[0].str;
 
25249
 (yyval.str) = (yyvsp[(1) - (1)].str);
24777
25250
;}
24778
25251
    break;
24779
25252
 
24780
25253
  case 295:
 
25254
 
 
25255
/* Line 1455 of yacc.c  */
24781
25256
#line 2435 "preproc.y"
24782
25257
    { 
24783
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
25258
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
24784
25259
;}
24785
25260
    break;
24786
25261
 
24787
25262
  case 296:
 
25263
 
 
25264
/* Line 1455 of yacc.c  */
24788
25265
#line 2443 "preproc.y"
24789
25266
    { 
24790
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("="),yyvsp[0].str);
 
25267
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("="),(yyvsp[(3) - (3)].str));
24791
25268
;}
24792
25269
    break;
24793
25270
 
24794
25271
  case 297:
 
25272
 
 
25273
/* Line 1455 of yacc.c  */
24795
25274
#line 2447 "preproc.y"
24796
25275
    { 
24797
 
 yyval.str = yyvsp[0].str;
 
25276
 (yyval.str) = (yyvsp[(1) - (1)].str);
24798
25277
;}
24799
25278
    break;
24800
25279
 
24801
25280
  case 298:
 
25281
 
 
25282
/* Line 1455 of yacc.c  */
24802
25283
#line 2451 "preproc.y"
24803
25284
    { 
24804
 
 yyval.str = cat_str(5,yyvsp[-4].str,make_str("."),yyvsp[-2].str,make_str("="),yyvsp[0].str);
 
25285
 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),make_str("."),(yyvsp[(3) - (5)].str),make_str("="),(yyvsp[(5) - (5)].str));
24805
25286
;}
24806
25287
    break;
24807
25288
 
24808
25289
  case 299:
 
25290
 
 
25291
/* Line 1455 of yacc.c  */
24809
25292
#line 2455 "preproc.y"
24810
25293
    { 
24811
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("."),yyvsp[0].str);
 
25294
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("."),(yyvsp[(3) - (3)].str));
24812
25295
;}
24813
25296
    break;
24814
25297
 
24815
25298
  case 300:
 
25299
 
 
25300
/* Line 1455 of yacc.c  */
24816
25301
#line 2463 "preproc.y"
24817
25302
    { 
24818
 
 yyval.str = cat_str(2,make_str("close"),yyvsp[0].str);
 
25303
 (yyval.str) = cat_str(2,make_str("close"),(yyvsp[(2) - (2)].str));
24819
25304
;}
24820
25305
    break;
24821
25306
 
24822
25307
  case 301:
 
25308
 
 
25309
/* Line 1455 of yacc.c  */
24823
25310
#line 2467 "preproc.y"
24824
25311
    { 
24825
 
 yyval.str = make_str("close all");
 
25312
 (yyval.str) = make_str("close all");
24826
25313
;}
24827
25314
    break;
24828
25315
 
24829
25316
  case 302:
 
25317
 
 
25318
/* Line 1455 of yacc.c  */
24830
25319
#line 2475 "preproc.y"
24831
25320
    { 
24832
 
                        if (strcmp(yyvsp[-4].str, "to") == 0 && strcmp(yyvsp[-3].str, "stdin") == 0)
 
25321
                        if (strcmp((yyvsp[(6) - (10)].str), "to") == 0 && strcmp((yyvsp[(7) - (10)].str), "stdin") == 0)
24833
25322
                                mmerror(PARSE_ERROR, ET_ERROR, "COPY TO STDIN is not possible");
24834
 
                        else if (strcmp(yyvsp[-4].str, "from") == 0 && strcmp(yyvsp[-3].str, "stdout") == 0)
 
25323
                        else if (strcmp((yyvsp[(6) - (10)].str), "from") == 0 && strcmp((yyvsp[(7) - (10)].str), "stdout") == 0)
24835
25324
                                mmerror(PARSE_ERROR, ET_ERROR, "COPY FROM STDOUT is not possible");
24836
 
                        else if (strcmp(yyvsp[-4].str, "from") == 0 && strcmp(yyvsp[-3].str, "stdin") == 0)
 
25325
                        else if (strcmp((yyvsp[(6) - (10)].str), "from") == 0 && strcmp((yyvsp[(7) - (10)].str), "stdin") == 0)
24837
25326
                                mmerror(PARSE_ERROR, ET_WARNING, "COPY FROM STDIN is not implemented");
24838
25327
 
24839
 
 yyval.str = cat_str(10,make_str("copy"),yyvsp[-8].str,yyvsp[-7].str,yyvsp[-6].str,yyvsp[-5].str,yyvsp[-4].str,yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
25328
 (yyval.str) = cat_str(10,make_str("copy"),(yyvsp[(2) - (10)].str),(yyvsp[(3) - (10)].str),(yyvsp[(4) - (10)].str),(yyvsp[(5) - (10)].str),(yyvsp[(6) - (10)].str),(yyvsp[(7) - (10)].str),(yyvsp[(8) - (10)].str),(yyvsp[(9) - (10)].str),(yyvsp[(10) - (10)].str));
24840
25329
;}
24841
25330
    break;
24842
25331
 
24843
25332
  case 303:
 
25333
 
 
25334
/* Line 1455 of yacc.c  */
24844
25335
#line 2486 "preproc.y"
24845
25336
    { 
24846
 
                        if (strcmp(yyvsp[-2].str, "stdin") == 0)
 
25337
                        if (strcmp((yyvsp[(4) - (6)].str), "stdin") == 0)
24847
25338
                                mmerror(PARSE_ERROR, ET_ERROR, "COPY TO STDIN is not possible");
24848
25339
 
24849
 
 yyval.str = cat_str(6,make_str("copy"),yyvsp[-4].str,make_str("to"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
25340
 (yyval.str) = cat_str(6,make_str("copy"),(yyvsp[(2) - (6)].str),make_str("to"),(yyvsp[(4) - (6)].str),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str));
24850
25341
;}
24851
25342
    break;
24852
25343
 
24853
25344
  case 304:
 
25345
 
 
25346
/* Line 1455 of yacc.c  */
24854
25347
#line 2497 "preproc.y"
24855
25348
    { 
24856
 
 yyval.str = make_str("from");
 
25349
 (yyval.str) = make_str("from");
24857
25350
;}
24858
25351
    break;
24859
25352
 
24860
25353
  case 305:
 
25354
 
 
25355
/* Line 1455 of yacc.c  */
24861
25356
#line 2501 "preproc.y"
24862
25357
    { 
24863
 
 yyval.str = make_str("to");
 
25358
 (yyval.str) = make_str("to");
24864
25359
;}
24865
25360
    break;
24866
25361
 
24867
25362
  case 306:
 
25363
 
 
25364
/* Line 1455 of yacc.c  */
24868
25365
#line 2509 "preproc.y"
24869
25366
    { 
24870
 
 yyval.str = yyvsp[0].str;
 
25367
 (yyval.str) = (yyvsp[(1) - (1)].str);
24871
25368
;}
24872
25369
    break;
24873
25370
 
24874
25371
  case 307:
 
25372
 
 
25373
/* Line 1455 of yacc.c  */
24875
25374
#line 2513 "preproc.y"
24876
25375
    { 
24877
 
 yyval.str = make_str("stdin");
 
25376
 (yyval.str) = make_str("stdin");
24878
25377
;}
24879
25378
    break;
24880
25379
 
24881
25380
  case 308:
 
25381
 
 
25382
/* Line 1455 of yacc.c  */
24882
25383
#line 2517 "preproc.y"
24883
25384
    { 
24884
 
 yyval.str = make_str("stdout");
 
25385
 (yyval.str) = make_str("stdout");
24885
25386
;}
24886
25387
    break;
24887
25388
 
24888
25389
  case 309:
 
25390
 
 
25391
/* Line 1455 of yacc.c  */
24889
25392
#line 2525 "preproc.y"
24890
25393
    { 
24891
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
25394
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
24892
25395
;}
24893
25396
    break;
24894
25397
 
24895
25398
  case 310:
 
25399
 
 
25400
/* Line 1455 of yacc.c  */
24896
25401
#line 2529 "preproc.y"
24897
25402
    { 
24898
 
 yyval.str=EMPTY; ;}
 
25403
 (yyval.str)=EMPTY; ;}
24899
25404
    break;
24900
25405
 
24901
25406
  case 311:
 
25407
 
 
25408
/* Line 1455 of yacc.c  */
24902
25409
#line 2536 "preproc.y"
24903
25410
    { 
24904
 
 yyval.str = make_str("binary");
 
25411
 (yyval.str) = make_str("binary");
24905
25412
;}
24906
25413
    break;
24907
25414
 
24908
25415
  case 312:
 
25416
 
 
25417
/* Line 1455 of yacc.c  */
24909
25418
#line 2540 "preproc.y"
24910
25419
    { 
24911
 
 yyval.str = make_str("oids");
 
25420
 (yyval.str) = make_str("oids");
24912
25421
;}
24913
25422
    break;
24914
25423
 
24915
25424
  case 313:
 
25425
 
 
25426
/* Line 1455 of yacc.c  */
24916
25427
#line 2544 "preproc.y"
24917
25428
    { 
24918
 
 yyval.str = cat_str(3,make_str("delimiter"),yyvsp[-1].str,yyvsp[0].str);
 
25429
 (yyval.str) = cat_str(3,make_str("delimiter"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
24919
25430
;}
24920
25431
    break;
24921
25432
 
24922
25433
  case 314:
 
25434
 
 
25435
/* Line 1455 of yacc.c  */
24923
25436
#line 2548 "preproc.y"
24924
25437
    { 
24925
 
 yyval.str = cat_str(3,make_str("null"),yyvsp[-1].str,yyvsp[0].str);
 
25438
 (yyval.str) = cat_str(3,make_str("null"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
24926
25439
;}
24927
25440
    break;
24928
25441
 
24929
25442
  case 315:
 
25443
 
 
25444
/* Line 1455 of yacc.c  */
24930
25445
#line 2552 "preproc.y"
24931
25446
    { 
24932
 
 yyval.str = make_str("csv");
 
25447
 (yyval.str) = make_str("csv");
24933
25448
;}
24934
25449
    break;
24935
25450
 
24936
25451
  case 316:
 
25452
 
 
25453
/* Line 1455 of yacc.c  */
24937
25454
#line 2556 "preproc.y"
24938
25455
    { 
24939
 
 yyval.str = make_str("header");
 
25456
 (yyval.str) = make_str("header");
24940
25457
;}
24941
25458
    break;
24942
25459
 
24943
25460
  case 317:
 
25461
 
 
25462
/* Line 1455 of yacc.c  */
24944
25463
#line 2560 "preproc.y"
24945
25464
    { 
24946
 
 yyval.str = cat_str(3,make_str("quote"),yyvsp[-1].str,yyvsp[0].str);
 
25465
 (yyval.str) = cat_str(3,make_str("quote"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
24947
25466
;}
24948
25467
    break;
24949
25468
 
24950
25469
  case 318:
 
25470
 
 
25471
/* Line 1455 of yacc.c  */
24951
25472
#line 2564 "preproc.y"
24952
25473
    { 
24953
 
 yyval.str = cat_str(3,make_str("escape"),yyvsp[-1].str,yyvsp[0].str);
 
25474
 (yyval.str) = cat_str(3,make_str("escape"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
24954
25475
;}
24955
25476
    break;
24956
25477
 
24957
25478
  case 319:
 
25479
 
 
25480
/* Line 1455 of yacc.c  */
24958
25481
#line 2568 "preproc.y"
24959
25482
    { 
24960
 
 yyval.str = cat_str(2,make_str("force quote"),yyvsp[0].str);
 
25483
 (yyval.str) = cat_str(2,make_str("force quote"),(yyvsp[(3) - (3)].str));
24961
25484
;}
24962
25485
    break;
24963
25486
 
24964
25487
  case 320:
 
25488
 
 
25489
/* Line 1455 of yacc.c  */
24965
25490
#line 2572 "preproc.y"
24966
25491
    { 
24967
 
 yyval.str = cat_str(2,make_str("force not null"),yyvsp[0].str);
 
25492
 (yyval.str) = cat_str(2,make_str("force not null"),(yyvsp[(4) - (4)].str));
24968
25493
;}
24969
25494
    break;
24970
25495
 
24971
25496
  case 321:
 
25497
 
 
25498
/* Line 1455 of yacc.c  */
24972
25499
#line 2580 "preproc.y"
24973
25500
    { 
24974
 
 yyval.str = make_str("binary");
 
25501
 (yyval.str) = make_str("binary");
24975
25502
;}
24976
25503
    break;
24977
25504
 
24978
25505
  case 322:
 
25506
 
 
25507
/* Line 1455 of yacc.c  */
24979
25508
#line 2584 "preproc.y"
24980
25509
    { 
24981
 
 yyval.str=EMPTY; ;}
 
25510
 (yyval.str)=EMPTY; ;}
24982
25511
    break;
24983
25512
 
24984
25513
  case 323:
 
25514
 
 
25515
/* Line 1455 of yacc.c  */
24985
25516
#line 2591 "preproc.y"
24986
25517
    { 
24987
 
 yyval.str = make_str("with oids");
 
25518
 (yyval.str) = make_str("with oids");
24988
25519
;}
24989
25520
    break;
24990
25521
 
24991
25522
  case 324:
 
25523
 
 
25524
/* Line 1455 of yacc.c  */
24992
25525
#line 2595 "preproc.y"
24993
25526
    { 
24994
 
 yyval.str=EMPTY; ;}
 
25527
 (yyval.str)=EMPTY; ;}
24995
25528
    break;
24996
25529
 
24997
25530
  case 325:
 
25531
 
 
25532
/* Line 1455 of yacc.c  */
24998
25533
#line 2602 "preproc.y"
24999
25534
    { 
25000
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("delimiters"),yyvsp[0].str);
 
25535
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("delimiters"),(yyvsp[(3) - (3)].str));
25001
25536
;}
25002
25537
    break;
25003
25538
 
25004
25539
  case 326:
 
25540
 
 
25541
/* Line 1455 of yacc.c  */
25005
25542
#line 2606 "preproc.y"
25006
25543
    { 
25007
 
 yyval.str=EMPTY; ;}
 
25544
 (yyval.str)=EMPTY; ;}
25008
25545
    break;
25009
25546
 
25010
25547
  case 327:
 
25548
 
 
25549
/* Line 1455 of yacc.c  */
25011
25550
#line 2613 "preproc.y"
25012
25551
    { 
25013
 
 yyval.str = make_str("using");
 
25552
 (yyval.str) = make_str("using");
25014
25553
;}
25015
25554
    break;
25016
25555
 
25017
25556
  case 328:
 
25557
 
 
25558
/* Line 1455 of yacc.c  */
25018
25559
#line 2617 "preproc.y"
25019
25560
    { 
25020
 
 yyval.str=EMPTY; ;}
 
25561
 (yyval.str)=EMPTY; ;}
25021
25562
    break;
25022
25563
 
25023
25564
  case 329:
 
25565
 
 
25566
/* Line 1455 of yacc.c  */
25024
25567
#line 2624 "preproc.y"
25025
25568
    { 
25026
 
 yyval.str = cat_str(11,make_str("create"),yyvsp[-9].str,make_str("table"),yyvsp[-7].str,make_str("("),yyvsp[-5].str,make_str(")"),yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
25569
 (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));
25027
25570
;}
25028
25571
    break;
25029
25572
 
25030
25573
  case 330:
 
25574
 
 
25575
/* Line 1455 of yacc.c  */
25031
25576
#line 2628 "preproc.y"
25032
25577
    { 
25033
 
 yyval.str = cat_str(12,make_str("create"),yyvsp[-10].str,make_str("table"),yyvsp[-8].str,make_str("of"),yyvsp[-6].str,make_str("("),yyvsp[-4].str,make_str(")"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
25578
 (yyval.str) = cat_str(12,make_str("create"),(yyvsp[(2) - (12)].str),make_str("table"),(yyvsp[(4) - (12)].str),make_str("of"),(yyvsp[(6) - (12)].str),make_str("("),(yyvsp[(8) - (12)].str),make_str(")"),(yyvsp[(10) - (12)].str),(yyvsp[(11) - (12)].str),(yyvsp[(12) - (12)].str));
25034
25579
;}
25035
25580
    break;
25036
25581
 
25037
25582
  case 331:
 
25583
 
 
25584
/* Line 1455 of yacc.c  */
25038
25585
#line 2636 "preproc.y"
25039
25586
    { 
25040
 
 yyval.str = make_str("temporary");
 
25587
 (yyval.str) = make_str("temporary");
25041
25588
;}
25042
25589
    break;
25043
25590
 
25044
25591
  case 332:
 
25592
 
 
25593
/* Line 1455 of yacc.c  */
25045
25594
#line 2640 "preproc.y"
25046
25595
    { 
25047
 
 yyval.str = make_str("temp");
 
25596
 (yyval.str) = make_str("temp");
25048
25597
;}
25049
25598
    break;
25050
25599
 
25051
25600
  case 333:
 
25601
 
 
25602
/* Line 1455 of yacc.c  */
25052
25603
#line 2644 "preproc.y"
25053
25604
    { 
25054
 
 yyval.str = make_str("local temporary");
 
25605
 (yyval.str) = make_str("local temporary");
25055
25606
;}
25056
25607
    break;
25057
25608
 
25058
25609
  case 334:
 
25610
 
 
25611
/* Line 1455 of yacc.c  */
25059
25612
#line 2648 "preproc.y"
25060
25613
    { 
25061
 
 yyval.str = make_str("local temp");
 
25614
 (yyval.str) = make_str("local temp");
25062
25615
;}
25063
25616
    break;
25064
25617
 
25065
25618
  case 335:
 
25619
 
 
25620
/* Line 1455 of yacc.c  */
25066
25621
#line 2652 "preproc.y"
25067
25622
    { 
25068
 
 yyval.str = make_str("global temporary");
 
25623
 (yyval.str) = make_str("global temporary");
25069
25624
;}
25070
25625
    break;
25071
25626
 
25072
25627
  case 336:
 
25628
 
 
25629
/* Line 1455 of yacc.c  */
25073
25630
#line 2656 "preproc.y"
25074
25631
    { 
25075
 
 yyval.str = make_str("global temp");
 
25632
 (yyval.str) = make_str("global temp");
25076
25633
;}
25077
25634
    break;
25078
25635
 
25079
25636
  case 337:
 
25637
 
 
25638
/* Line 1455 of yacc.c  */
25080
25639
#line 2660 "preproc.y"
25081
25640
    { 
25082
 
 yyval.str=EMPTY; ;}
 
25641
 (yyval.str)=EMPTY; ;}
25083
25642
    break;
25084
25643
 
25085
25644
  case 338:
 
25645
 
 
25646
/* Line 1455 of yacc.c  */
25086
25647
#line 2667 "preproc.y"
25087
25648
    { 
25088
 
 yyval.str = yyvsp[0].str;
 
25649
 (yyval.str) = (yyvsp[(1) - (1)].str);
25089
25650
;}
25090
25651
    break;
25091
25652
 
25092
25653
  case 339:
 
25654
 
 
25655
/* Line 1455 of yacc.c  */
25093
25656
#line 2671 "preproc.y"
25094
25657
    { 
25095
 
 yyval.str=EMPTY; ;}
 
25658
 (yyval.str)=EMPTY; ;}
25096
25659
    break;
25097
25660
 
25098
25661
  case 340:
 
25662
 
 
25663
/* Line 1455 of yacc.c  */
25099
25664
#line 2678 "preproc.y"
25100
25665
    { 
25101
 
 yyval.str = yyvsp[0].str;
 
25666
 (yyval.str) = (yyvsp[(1) - (1)].str);
25102
25667
;}
25103
25668
    break;
25104
25669
 
25105
25670
  case 341:
 
25671
 
 
25672
/* Line 1455 of yacc.c  */
25106
25673
#line 2682 "preproc.y"
25107
25674
    { 
25108
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
25675
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
25109
25676
;}
25110
25677
    break;
25111
25678
 
25112
25679
  case 342:
 
25680
 
 
25681
/* Line 1455 of yacc.c  */
25113
25682
#line 2690 "preproc.y"
25114
25683
    { 
25115
 
 yyval.str = yyvsp[0].str;
 
25684
 (yyval.str) = (yyvsp[(1) - (1)].str);
25116
25685
;}
25117
25686
    break;
25118
25687
 
25119
25688
  case 343:
 
25689
 
 
25690
/* Line 1455 of yacc.c  */
25120
25691
#line 2694 "preproc.y"
25121
25692
    { 
25122
 
 yyval.str = yyvsp[0].str;
 
25693
 (yyval.str) = (yyvsp[(1) - (1)].str);
25123
25694
;}
25124
25695
    break;
25125
25696
 
25126
25697
  case 344:
 
25698
 
 
25699
/* Line 1455 of yacc.c  */
25127
25700
#line 2698 "preproc.y"
25128
25701
    { 
25129
 
 yyval.str = yyvsp[0].str;
 
25702
 (yyval.str) = (yyvsp[(1) - (1)].str);
25130
25703
;}
25131
25704
    break;
25132
25705
 
25133
25706
  case 345:
 
25707
 
 
25708
/* Line 1455 of yacc.c  */
25134
25709
#line 2706 "preproc.y"
25135
25710
    { 
25136
 
 yyval.str = cat_str(3,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
25711
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
25137
25712
;}
25138
25713
    break;
25139
25714
 
25140
25715
  case 346:
 
25716
 
 
25717
/* Line 1455 of yacc.c  */
25141
25718
#line 2714 "preproc.y"
25142
25719
    { 
25143
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
25720
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
25144
25721
;}
25145
25722
    break;
25146
25723
 
25147
25724
  case 347:
 
25725
 
 
25726
/* Line 1455 of yacc.c  */
25148
25727
#line 2718 "preproc.y"
25149
25728
    { 
25150
 
 yyval.str=EMPTY; ;}
 
25729
 (yyval.str)=EMPTY; ;}
25151
25730
    break;
25152
25731
 
25153
25732
  case 348:
 
25733
 
 
25734
/* Line 1455 of yacc.c  */
25154
25735
#line 2725 "preproc.y"
25155
25736
    { 
25156
 
 yyval.str = cat_str(3,make_str("constraint"),yyvsp[-1].str,yyvsp[0].str);
 
25737
 (yyval.str) = cat_str(3,make_str("constraint"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
25157
25738
;}
25158
25739
    break;
25159
25740
 
25160
25741
  case 349:
 
25742
 
 
25743
/* Line 1455 of yacc.c  */
25161
25744
#line 2729 "preproc.y"
25162
25745
    { 
25163
 
 yyval.str = yyvsp[0].str;
 
25746
 (yyval.str) = (yyvsp[(1) - (1)].str);
25164
25747
;}
25165
25748
    break;
25166
25749
 
25167
25750
  case 350:
 
25751
 
 
25752
/* Line 1455 of yacc.c  */
25168
25753
#line 2733 "preproc.y"
25169
25754
    { 
25170
 
 yyval.str = yyvsp[0].str;
 
25755
 (yyval.str) = (yyvsp[(1) - (1)].str);
25171
25756
;}
25172
25757
    break;
25173
25758
 
25174
25759
  case 351:
 
25760
 
 
25761
/* Line 1455 of yacc.c  */
25175
25762
#line 2741 "preproc.y"
25176
25763
    { 
25177
 
 yyval.str = make_str("not null");
 
25764
 (yyval.str) = make_str("not null");
25178
25765
;}
25179
25766
    break;
25180
25767
 
25181
25768
  case 352:
 
25769
 
 
25770
/* Line 1455 of yacc.c  */
25182
25771
#line 2745 "preproc.y"
25183
25772
    { 
25184
 
 yyval.str = make_str("null");
 
25773
 (yyval.str) = make_str("null");
25185
25774
;}
25186
25775
    break;
25187
25776
 
25188
25777
  case 353:
 
25778
 
 
25779
/* Line 1455 of yacc.c  */
25189
25780
#line 2749 "preproc.y"
25190
25781
    { 
25191
 
 yyval.str = cat_str(3,make_str("unique"),yyvsp[-1].str,yyvsp[0].str);
 
25782
 (yyval.str) = cat_str(3,make_str("unique"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
25192
25783
;}
25193
25784
    break;
25194
25785
 
25195
25786
  case 354:
 
25787
 
 
25788
/* Line 1455 of yacc.c  */
25196
25789
#line 2753 "preproc.y"
25197
25790
    { 
25198
 
 yyval.str = cat_str(3,make_str("primary key"),yyvsp[-1].str,yyvsp[0].str);
 
25791
 (yyval.str) = cat_str(3,make_str("primary key"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
25199
25792
;}
25200
25793
    break;
25201
25794
 
25202
25795
  case 355:
 
25796
 
 
25797
/* Line 1455 of yacc.c  */
25203
25798
#line 2757 "preproc.y"
25204
25799
    { 
25205
 
 yyval.str = cat_str(3,make_str("check ("),yyvsp[-1].str,make_str(")"));
 
25800
 (yyval.str) = cat_str(3,make_str("check ("),(yyvsp[(3) - (4)].str),make_str(")"));
25206
25801
;}
25207
25802
    break;
25208
25803
 
25209
25804
  case 356:
 
25805
 
 
25806
/* Line 1455 of yacc.c  */
25210
25807
#line 2761 "preproc.y"
25211
25808
    { 
25212
 
 yyval.str = cat_str(2,make_str("default"),yyvsp[0].str);
 
25809
 (yyval.str) = cat_str(2,make_str("default"),(yyvsp[(2) - (2)].str));
25213
25810
;}
25214
25811
    break;
25215
25812
 
25216
25813
  case 357:
 
25814
 
 
25815
/* Line 1455 of yacc.c  */
25217
25816
#line 2765 "preproc.y"
25218
25817
    { 
25219
 
 yyval.str = cat_str(5,make_str("references"),yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
25818
 (yyval.str) = cat_str(5,make_str("references"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
25220
25819
;}
25221
25820
    break;
25222
25821
 
25223
25822
  case 358:
 
25823
 
 
25824
/* Line 1455 of yacc.c  */
25224
25825
#line 2773 "preproc.y"
25225
25826
    { 
25226
 
 yyval.str = make_str("deferrable");
 
25827
 (yyval.str) = make_str("deferrable");
25227
25828
;}
25228
25829
    break;
25229
25830
 
25230
25831
  case 359:
 
25832
 
 
25833
/* Line 1455 of yacc.c  */
25231
25834
#line 2777 "preproc.y"
25232
25835
    { 
25233
 
 yyval.str = make_str("not deferrable");
 
25836
 (yyval.str) = make_str("not deferrable");
25234
25837
;}
25235
25838
    break;
25236
25839
 
25237
25840
  case 360:
 
25841
 
 
25842
/* Line 1455 of yacc.c  */
25238
25843
#line 2781 "preproc.y"
25239
25844
    { 
25240
 
 yyval.str = make_str("initially deferred");
 
25845
 (yyval.str) = make_str("initially deferred");
25241
25846
;}
25242
25847
    break;
25243
25848
 
25244
25849
  case 361:
 
25850
 
 
25851
/* Line 1455 of yacc.c  */
25245
25852
#line 2785 "preproc.y"
25246
25853
    { 
25247
 
 yyval.str = make_str("initially immediate");
 
25854
 (yyval.str) = make_str("initially immediate");
25248
25855
;}
25249
25856
    break;
25250
25857
 
25251
25858
  case 362:
 
25859
 
 
25860
/* Line 1455 of yacc.c  */
25252
25861
#line 2793 "preproc.y"
25253
25862
    { 
25254
 
 yyval.str = cat_str(3,make_str("like"),yyvsp[-1].str,yyvsp[0].str);
 
25863
 (yyval.str) = cat_str(3,make_str("like"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
25255
25864
;}
25256
25865
    break;
25257
25866
 
25258
25867
  case 363:
 
25868
 
 
25869
/* Line 1455 of yacc.c  */
25259
25870
#line 2801 "preproc.y"
25260
25871
    { 
25261
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
25872
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
25262
25873
;}
25263
25874
    break;
25264
25875
 
25265
25876
  case 364:
 
25877
 
 
25878
/* Line 1455 of yacc.c  */
25266
25879
#line 2805 "preproc.y"
25267
25880
    { 
25268
 
 yyval.str=EMPTY; ;}
 
25881
 (yyval.str)=EMPTY; ;}
25269
25882
    break;
25270
25883
 
25271
25884
  case 365:
 
25885
 
 
25886
/* Line 1455 of yacc.c  */
25272
25887
#line 2812 "preproc.y"
25273
25888
    { 
25274
 
 yyval.str = make_str("including defaults");
 
25889
 (yyval.str) = make_str("including defaults");
25275
25890
;}
25276
25891
    break;
25277
25892
 
25278
25893
  case 366:
 
25894
 
 
25895
/* Line 1455 of yacc.c  */
25279
25896
#line 2816 "preproc.y"
25280
25897
    { 
25281
 
 yyval.str = make_str("excluding defaults");
 
25898
 (yyval.str) = make_str("excluding defaults");
25282
25899
;}
25283
25900
    break;
25284
25901
 
25285
25902
  case 367:
 
25903
 
 
25904
/* Line 1455 of yacc.c  */
25286
25905
#line 2820 "preproc.y"
25287
25906
    { 
25288
 
 yyval.str = make_str("including constraints");
 
25907
 (yyval.str) = make_str("including constraints");
25289
25908
;}
25290
25909
    break;
25291
25910
 
25292
25911
  case 368:
 
25912
 
 
25913
/* Line 1455 of yacc.c  */
25293
25914
#line 2824 "preproc.y"
25294
25915
    { 
25295
 
 yyval.str = make_str("excluding constraints");
 
25916
 (yyval.str) = make_str("excluding constraints");
25296
25917
;}
25297
25918
    break;
25298
25919
 
25299
25920
  case 369:
 
25921
 
 
25922
/* Line 1455 of yacc.c  */
25300
25923
#line 2828 "preproc.y"
25301
25924
    { 
25302
 
 yyval.str = make_str("including indexes");
 
25925
 (yyval.str) = make_str("including indexes");
25303
25926
;}
25304
25927
    break;
25305
25928
 
25306
25929
  case 370:
 
25930
 
 
25931
/* Line 1455 of yacc.c  */
25307
25932
#line 2832 "preproc.y"
25308
25933
    { 
25309
 
 yyval.str = make_str("excluding indexes");
 
25934
 (yyval.str) = make_str("excluding indexes");
25310
25935
;}
25311
25936
    break;
25312
25937
 
25313
25938
  case 371:
 
25939
 
 
25940
/* Line 1455 of yacc.c  */
25314
25941
#line 2840 "preproc.y"
25315
25942
    { 
25316
 
 yyval.str = cat_str(3,make_str("constraint"),yyvsp[-1].str,yyvsp[0].str);
 
25943
 (yyval.str) = cat_str(3,make_str("constraint"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
25317
25944
;}
25318
25945
    break;
25319
25946
 
25320
25947
  case 372:
 
25948
 
 
25949
/* Line 1455 of yacc.c  */
25321
25950
#line 2844 "preproc.y"
25322
25951
    { 
25323
 
 yyval.str = yyvsp[0].str;
 
25952
 (yyval.str) = (yyvsp[(1) - (1)].str);
25324
25953
;}
25325
25954
    break;
25326
25955
 
25327
25956
  case 373:
 
25957
 
 
25958
/* Line 1455 of yacc.c  */
25328
25959
#line 2852 "preproc.y"
25329
25960
    { 
25330
 
 yyval.str = cat_str(3,make_str("check ("),yyvsp[-1].str,make_str(")"));
 
25961
 (yyval.str) = cat_str(3,make_str("check ("),(yyvsp[(3) - (4)].str),make_str(")"));
25331
25962
;}
25332
25963
    break;
25333
25964
 
25334
25965
  case 374:
 
25966
 
 
25967
/* Line 1455 of yacc.c  */
25335
25968
#line 2856 "preproc.y"
25336
25969
    { 
25337
 
 yyval.str = cat_str(5,make_str("unique ("),yyvsp[-3].str,make_str(")"),yyvsp[-1].str,yyvsp[0].str);
 
25970
 (yyval.str) = cat_str(5,make_str("unique ("),(yyvsp[(3) - (6)].str),make_str(")"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str));
25338
25971
;}
25339
25972
    break;
25340
25973
 
25341
25974
  case 375:
 
25975
 
 
25976
/* Line 1455 of yacc.c  */
25342
25977
#line 2860 "preproc.y"
25343
25978
    { 
25344
 
 yyval.str = cat_str(5,make_str("primary key ("),yyvsp[-3].str,make_str(")"),yyvsp[-1].str,yyvsp[0].str);
 
25979
 (yyval.str) = cat_str(5,make_str("primary key ("),(yyvsp[(4) - (7)].str),make_str(")"),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str));
25345
25980
;}
25346
25981
    break;
25347
25982
 
25348
25983
  case 376:
 
25984
 
 
25985
/* Line 1455 of yacc.c  */
25349
25986
#line 2864 "preproc.y"
25350
25987
    { 
25351
 
 yyval.str = cat_str(8,make_str("foreign key ("),yyvsp[-7].str,make_str(") references"),yyvsp[-4].str,yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
25988
 (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));
25352
25989
;}
25353
25990
    break;
25354
25991
 
25355
25992
  case 377:
 
25993
 
 
25994
/* Line 1455 of yacc.c  */
25356
25995
#line 2872 "preproc.y"
25357
25996
    { 
25358
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
25997
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
25359
25998
;}
25360
25999
    break;
25361
26000
 
25362
26001
  case 378:
 
26002
 
 
26003
/* Line 1455 of yacc.c  */
25363
26004
#line 2876 "preproc.y"
25364
26005
    { 
25365
 
 yyval.str=EMPTY; ;}
 
26006
 (yyval.str)=EMPTY; ;}
25366
26007
    break;
25367
26008
 
25368
26009
  case 379:
 
26010
 
 
26011
/* Line 1455 of yacc.c  */
25369
26012
#line 2883 "preproc.y"
25370
26013
    { 
25371
 
 yyval.str = yyvsp[0].str;
 
26014
 (yyval.str) = (yyvsp[(1) - (1)].str);
25372
26015
;}
25373
26016
    break;
25374
26017
 
25375
26018
  case 380:
 
26019
 
 
26020
/* Line 1455 of yacc.c  */
25376
26021
#line 2887 "preproc.y"
25377
26022
    { 
25378
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
26023
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
25379
26024
;}
25380
26025
    break;
25381
26026
 
25382
26027
  case 381:
 
26028
 
 
26029
/* Line 1455 of yacc.c  */
25383
26030
#line 2895 "preproc.y"
25384
26031
    { 
25385
 
 yyval.str = yyvsp[0].str;
 
26032
 (yyval.str) = (yyvsp[(1) - (1)].str);
25386
26033
;}
25387
26034
    break;
25388
26035
 
25389
26036
  case 382:
 
26037
 
 
26038
/* Line 1455 of yacc.c  */
25390
26039
#line 2903 "preproc.y"
25391
26040
    { 
25392
 
 yyval.str = make_str("match full");
 
26041
 (yyval.str) = make_str("match full");
25393
26042
;}
25394
26043
    break;
25395
26044
 
25396
26045
  case 383:
 
26046
 
 
26047
/* Line 1455 of yacc.c  */
25397
26048
#line 2907 "preproc.y"
25398
26049
    { 
25399
26050
mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
25400
 
 yyval.str = make_str("match partial");
 
26051
 (yyval.str) = make_str("match partial");
25401
26052
;}
25402
26053
    break;
25403
26054
 
25404
26055
  case 384:
 
26056
 
 
26057
/* Line 1455 of yacc.c  */
25405
26058
#line 2912 "preproc.y"
25406
26059
    { 
25407
 
 yyval.str = make_str("match simple");
 
26060
 (yyval.str) = make_str("match simple");
25408
26061
;}
25409
26062
    break;
25410
26063
 
25411
26064
  case 385:
 
26065
 
 
26066
/* Line 1455 of yacc.c  */
25412
26067
#line 2916 "preproc.y"
25413
26068
    { 
25414
 
 yyval.str=EMPTY; ;}
 
26069
 (yyval.str)=EMPTY; ;}
25415
26070
    break;
25416
26071
 
25417
26072
  case 386:
 
26073
 
 
26074
/* Line 1455 of yacc.c  */
25418
26075
#line 2923 "preproc.y"
25419
26076
    { 
25420
 
 yyval.str = yyvsp[0].str;
 
26077
 (yyval.str) = (yyvsp[(1) - (1)].str);
25421
26078
;}
25422
26079
    break;
25423
26080
 
25424
26081
  case 387:
 
26082
 
 
26083
/* Line 1455 of yacc.c  */
25425
26084
#line 2927 "preproc.y"
25426
26085
    { 
25427
 
 yyval.str = yyvsp[0].str;
 
26086
 (yyval.str) = (yyvsp[(1) - (1)].str);
25428
26087
;}
25429
26088
    break;
25430
26089
 
25431
26090
  case 388:
 
26091
 
 
26092
/* Line 1455 of yacc.c  */
25432
26093
#line 2931 "preproc.y"
25433
26094
    { 
25434
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
26095
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
25435
26096
;}
25436
26097
    break;
25437
26098
 
25438
26099
  case 389:
 
26100
 
 
26101
/* Line 1455 of yacc.c  */
25439
26102
#line 2935 "preproc.y"
25440
26103
    { 
25441
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
26104
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
25442
26105
;}
25443
26106
    break;
25444
26107
 
25445
26108
  case 390:
 
26109
 
 
26110
/* Line 1455 of yacc.c  */
25446
26111
#line 2939 "preproc.y"
25447
26112
    { 
25448
 
 yyval.str=EMPTY; ;}
 
26113
 (yyval.str)=EMPTY; ;}
25449
26114
    break;
25450
26115
 
25451
26116
  case 391:
 
26117
 
 
26118
/* Line 1455 of yacc.c  */
25452
26119
#line 2946 "preproc.y"
25453
26120
    { 
25454
 
 yyval.str = cat_str(2,make_str("on update"),yyvsp[0].str);
 
26121
 (yyval.str) = cat_str(2,make_str("on update"),(yyvsp[(3) - (3)].str));
25455
26122
;}
25456
26123
    break;
25457
26124
 
25458
26125
  case 392:
 
26126
 
 
26127
/* Line 1455 of yacc.c  */
25459
26128
#line 2954 "preproc.y"
25460
26129
    { 
25461
 
 yyval.str = cat_str(2,make_str("on delete"),yyvsp[0].str);
 
26130
 (yyval.str) = cat_str(2,make_str("on delete"),(yyvsp[(3) - (3)].str));
25462
26131
;}
25463
26132
    break;
25464
26133
 
25465
26134
  case 393:
 
26135
 
 
26136
/* Line 1455 of yacc.c  */
25466
26137
#line 2962 "preproc.y"
25467
26138
    { 
25468
 
 yyval.str = make_str("no action");
 
26139
 (yyval.str) = make_str("no action");
25469
26140
;}
25470
26141
    break;
25471
26142
 
25472
26143
  case 394:
 
26144
 
 
26145
/* Line 1455 of yacc.c  */
25473
26146
#line 2966 "preproc.y"
25474
26147
    { 
25475
 
 yyval.str = make_str("restrict");
 
26148
 (yyval.str) = make_str("restrict");
25476
26149
;}
25477
26150
    break;
25478
26151
 
25479
26152
  case 395:
 
26153
 
 
26154
/* Line 1455 of yacc.c  */
25480
26155
#line 2970 "preproc.y"
25481
26156
    { 
25482
 
 yyval.str = make_str("cascade");
 
26157
 (yyval.str) = make_str("cascade");
25483
26158
;}
25484
26159
    break;
25485
26160
 
25486
26161
  case 396:
 
26162
 
 
26163
/* Line 1455 of yacc.c  */
25487
26164
#line 2974 "preproc.y"
25488
26165
    { 
25489
 
 yyval.str = make_str("set null");
 
26166
 (yyval.str) = make_str("set null");
25490
26167
;}
25491
26168
    break;
25492
26169
 
25493
26170
  case 397:
 
26171
 
 
26172
/* Line 1455 of yacc.c  */
25494
26173
#line 2978 "preproc.y"
25495
26174
    { 
25496
 
 yyval.str = make_str("set default");
 
26175
 (yyval.str) = make_str("set default");
25497
26176
;}
25498
26177
    break;
25499
26178
 
25500
26179
  case 398:
 
26180
 
 
26181
/* Line 1455 of yacc.c  */
25501
26182
#line 2986 "preproc.y"
25502
26183
    { 
25503
 
 yyval.str = cat_str(3,make_str("inherits ("),yyvsp[-1].str,make_str(")"));
 
26184
 (yyval.str) = cat_str(3,make_str("inherits ("),(yyvsp[(3) - (4)].str),make_str(")"));
25504
26185
;}
25505
26186
    break;
25506
26187
 
25507
26188
  case 399:
 
26189
 
 
26190
/* Line 1455 of yacc.c  */
25508
26191
#line 2990 "preproc.y"
25509
26192
    { 
25510
 
 yyval.str=EMPTY; ;}
 
26193
 (yyval.str)=EMPTY; ;}
25511
26194
    break;
25512
26195
 
25513
26196
  case 400:
 
26197
 
 
26198
/* Line 1455 of yacc.c  */
25514
26199
#line 2997 "preproc.y"
25515
26200
    { 
25516
 
 yyval.str = cat_str(2,make_str("with"),yyvsp[0].str);
 
26201
 (yyval.str) = cat_str(2,make_str("with"),(yyvsp[(2) - (2)].str));
25517
26202
;}
25518
26203
    break;
25519
26204
 
25520
26205
  case 401:
 
26206
 
 
26207
/* Line 1455 of yacc.c  */
25521
26208
#line 3001 "preproc.y"
25522
26209
    { 
25523
 
 yyval.str = make_str("with oids");
 
26210
 (yyval.str) = make_str("with oids");
25524
26211
;}
25525
26212
    break;
25526
26213
 
25527
26214
  case 402:
 
26215
 
 
26216
/* Line 1455 of yacc.c  */
25528
26217
#line 3005 "preproc.y"
25529
26218
    { 
25530
 
 yyval.str = make_str("without oids");
 
26219
 (yyval.str) = make_str("without oids");
25531
26220
;}
25532
26221
    break;
25533
26222
 
25534
26223
  case 403:
 
26224
 
 
26225
/* Line 1455 of yacc.c  */
25535
26226
#line 3009 "preproc.y"
25536
26227
    { 
25537
 
 yyval.str=EMPTY; ;}
 
26228
 (yyval.str)=EMPTY; ;}
25538
26229
    break;
25539
26230
 
25540
26231
  case 404:
 
26232
 
 
26233
/* Line 1455 of yacc.c  */
25541
26234
#line 3016 "preproc.y"
25542
26235
    { 
25543
 
 yyval.str = make_str("on commit drop");
 
26236
 (yyval.str) = make_str("on commit drop");
25544
26237
;}
25545
26238
    break;
25546
26239
 
25547
26240
  case 405:
 
26241
 
 
26242
/* Line 1455 of yacc.c  */
25548
26243
#line 3020 "preproc.y"
25549
26244
    { 
25550
 
 yyval.str = make_str("on commit delete rows");
 
26245
 (yyval.str) = make_str("on commit delete rows");
25551
26246
;}
25552
26247
    break;
25553
26248
 
25554
26249
  case 406:
 
26250
 
 
26251
/* Line 1455 of yacc.c  */
25555
26252
#line 3024 "preproc.y"
25556
26253
    { 
25557
 
 yyval.str = make_str("on commit preserve rows");
 
26254
 (yyval.str) = make_str("on commit preserve rows");
25558
26255
;}
25559
26256
    break;
25560
26257
 
25561
26258
  case 407:
 
26259
 
 
26260
/* Line 1455 of yacc.c  */
25562
26261
#line 3028 "preproc.y"
25563
26262
    { 
25564
 
 yyval.str=EMPTY; ;}
 
26263
 (yyval.str)=EMPTY; ;}
25565
26264
    break;
25566
26265
 
25567
26266
  case 408:
 
26267
 
 
26268
/* Line 1455 of yacc.c  */
25568
26269
#line 3035 "preproc.y"
25569
26270
    { 
25570
 
 yyval.str = cat_str(2,make_str("tablespace"),yyvsp[0].str);
 
26271
 (yyval.str) = cat_str(2,make_str("tablespace"),(yyvsp[(2) - (2)].str));
25571
26272
;}
25572
26273
    break;
25573
26274
 
25574
26275
  case 409:
 
26276
 
 
26277
/* Line 1455 of yacc.c  */
25575
26278
#line 3039 "preproc.y"
25576
26279
    { 
25577
 
 yyval.str=EMPTY; ;}
 
26280
 (yyval.str)=EMPTY; ;}
25578
26281
    break;
25579
26282
 
25580
26283
  case 410:
 
26284
 
 
26285
/* Line 1455 of yacc.c  */
25581
26286
#line 3046 "preproc.y"
25582
26287
    { 
25583
 
 yyval.str = cat_str(2,make_str("using index tablespace"),yyvsp[0].str);
 
26288
 (yyval.str) = cat_str(2,make_str("using index tablespace"),(yyvsp[(4) - (4)].str));
25584
26289
;}
25585
26290
    break;
25586
26291
 
25587
26292
  case 411:
 
26293
 
 
26294
/* Line 1455 of yacc.c  */
25588
26295
#line 3050 "preproc.y"
25589
26296
    { 
25590
 
 yyval.str=EMPTY; ;}
 
26297
 (yyval.str)=EMPTY; ;}
25591
26298
    break;
25592
26299
 
25593
26300
  case 412:
 
26301
 
 
26302
/* Line 1455 of yacc.c  */
25594
26303
#line 3057 "preproc.y"
25595
26304
    { 
25596
 
 yyval.str = cat_str(5,yyvsp[-4].str,yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
26305
 (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));
25597
26306
;}
25598
26307
    break;
25599
26308
 
25600
26309
  case 413:
 
26310
 
 
26311
/* Line 1455 of yacc.c  */
25601
26312
#line 3065 "preproc.y"
25602
26313
    { 
25603
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
26314
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
25604
26315
;}
25605
26316
    break;
25606
26317
 
25607
26318
  case 414:
 
26319
 
 
26320
/* Line 1455 of yacc.c  */
25608
26321
#line 3069 "preproc.y"
25609
26322
    { 
25610
 
 yyval.str=EMPTY; ;}
 
26323
 (yyval.str)=EMPTY; ;}
25611
26324
    break;
25612
26325
 
25613
26326
  case 415:
 
26327
 
 
26328
/* Line 1455 of yacc.c  */
25614
26329
#line 3076 "preproc.y"
25615
26330
    { 
25616
 
 yyval.str = yyvsp[0].str;
 
26331
 (yyval.str) = (yyvsp[(1) - (1)].str);
25617
26332
;}
25618
26333
    break;
25619
26334
 
25620
26335
  case 416:
 
26336
 
 
26337
/* Line 1455 of yacc.c  */
25621
26338
#line 3080 "preproc.y"
25622
26339
    { 
25623
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
26340
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
25624
26341
;}
25625
26342
    break;
25626
26343
 
25627
26344
  case 417:
 
26345
 
 
26346
/* Line 1455 of yacc.c  */
25628
26347
#line 3088 "preproc.y"
25629
26348
    { 
25630
 
 yyval.str = yyvsp[0].str;
 
26349
 (yyval.str) = (yyvsp[(1) - (1)].str);
25631
26350
;}
25632
26351
    break;
25633
26352
 
25634
26353
  case 418:
 
26354
 
 
26355
/* Line 1455 of yacc.c  */
25635
26356
#line 3096 "preproc.y"
25636
26357
    { 
25637
 
 yyval.str = make_str("with data");
 
26358
 (yyval.str) = make_str("with data");
25638
26359
;}
25639
26360
    break;
25640
26361
 
25641
26362
  case 419:
 
26363
 
 
26364
/* Line 1455 of yacc.c  */
25642
26365
#line 3100 "preproc.y"
25643
26366
    { 
25644
 
 yyval.str = make_str("with no data");
 
26367
 (yyval.str) = make_str("with no data");
25645
26368
;}
25646
26369
    break;
25647
26370
 
25648
26371
  case 420:
 
26372
 
 
26373
/* Line 1455 of yacc.c  */
25649
26374
#line 3104 "preproc.y"
25650
26375
    { 
25651
 
 yyval.str=EMPTY; ;}
 
26376
 (yyval.str)=EMPTY; ;}
25652
26377
    break;
25653
26378
 
25654
26379
  case 421:
 
26380
 
 
26381
/* Line 1455 of yacc.c  */
25655
26382
#line 3111 "preproc.y"
25656
26383
    { 
25657
 
 yyval.str = cat_str(5,make_str("create"),yyvsp[-3].str,make_str("sequence"),yyvsp[-1].str,yyvsp[0].str);
 
26384
 (yyval.str) = cat_str(5,make_str("create"),(yyvsp[(2) - (5)].str),make_str("sequence"),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
25658
26385
;}
25659
26386
    break;
25660
26387
 
25661
26388
  case 422:
 
26389
 
 
26390
/* Line 1455 of yacc.c  */
25662
26391
#line 3119 "preproc.y"
25663
26392
    { 
25664
 
 yyval.str = cat_str(3,make_str("alter sequence"),yyvsp[-1].str,yyvsp[0].str);
 
26393
 (yyval.str) = cat_str(3,make_str("alter sequence"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
25665
26394
;}
25666
26395
    break;
25667
26396
 
25668
26397
  case 423:
 
26398
 
 
26399
/* Line 1455 of yacc.c  */
25669
26400
#line 3127 "preproc.y"
25670
26401
    { 
25671
 
 yyval.str = yyvsp[0].str;
 
26402
 (yyval.str) = (yyvsp[(1) - (1)].str);
25672
26403
;}
25673
26404
    break;
25674
26405
 
25675
26406
  case 424:
 
26407
 
 
26408
/* Line 1455 of yacc.c  */
25676
26409
#line 3131 "preproc.y"
25677
26410
    { 
25678
 
 yyval.str=EMPTY; ;}
 
26411
 (yyval.str)=EMPTY; ;}
25679
26412
    break;
25680
26413
 
25681
26414
  case 425:
 
26415
 
 
26416
/* Line 1455 of yacc.c  */
25682
26417
#line 3138 "preproc.y"
25683
26418
    { 
25684
 
 yyval.str = yyvsp[0].str;
 
26419
 (yyval.str) = (yyvsp[(1) - (1)].str);
25685
26420
;}
25686
26421
    break;
25687
26422
 
25688
26423
  case 426:
 
26424
 
 
26425
/* Line 1455 of yacc.c  */
25689
26426
#line 3142 "preproc.y"
25690
26427
    { 
25691
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
26428
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
25692
26429
;}
25693
26430
    break;
25694
26431
 
25695
26432
  case 427:
 
26433
 
 
26434
/* Line 1455 of yacc.c  */
25696
26435
#line 3150 "preproc.y"
25697
26436
    { 
25698
 
 yyval.str = cat_str(2,make_str("cache"),yyvsp[0].str);
 
26437
 (yyval.str) = cat_str(2,make_str("cache"),(yyvsp[(2) - (2)].str));
25699
26438
;}
25700
26439
    break;
25701
26440
 
25702
26441
  case 428:
 
26442
 
 
26443
/* Line 1455 of yacc.c  */
25703
26444
#line 3154 "preproc.y"
25704
26445
    { 
25705
 
 yyval.str = make_str("cycle");
 
26446
 (yyval.str) = make_str("cycle");
25706
26447
;}
25707
26448
    break;
25708
26449
 
25709
26450
  case 429:
 
26451
 
 
26452
/* Line 1455 of yacc.c  */
25710
26453
#line 3158 "preproc.y"
25711
26454
    { 
25712
 
 yyval.str = make_str("no cycle");
 
26455
 (yyval.str) = make_str("no cycle");
25713
26456
;}
25714
26457
    break;
25715
26458
 
25716
26459
  case 430:
 
26460
 
 
26461
/* Line 1455 of yacc.c  */
25717
26462
#line 3162 "preproc.y"
25718
26463
    { 
25719
 
 yyval.str = cat_str(3,make_str("increment"),yyvsp[-1].str,yyvsp[0].str);
 
26464
 (yyval.str) = cat_str(3,make_str("increment"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
25720
26465
;}
25721
26466
    break;
25722
26467
 
25723
26468
  case 431:
 
26469
 
 
26470
/* Line 1455 of yacc.c  */
25724
26471
#line 3166 "preproc.y"
25725
26472
    { 
25726
 
 yyval.str = cat_str(2,make_str("maxvalue"),yyvsp[0].str);
 
26473
 (yyval.str) = cat_str(2,make_str("maxvalue"),(yyvsp[(2) - (2)].str));
25727
26474
;}
25728
26475
    break;
25729
26476
 
25730
26477
  case 432:
 
26478
 
 
26479
/* Line 1455 of yacc.c  */
25731
26480
#line 3170 "preproc.y"
25732
26481
    { 
25733
 
 yyval.str = cat_str(2,make_str("minvalue"),yyvsp[0].str);
 
26482
 (yyval.str) = cat_str(2,make_str("minvalue"),(yyvsp[(2) - (2)].str));
25734
26483
;}
25735
26484
    break;
25736
26485
 
25737
26486
  case 433:
 
26487
 
 
26488
/* Line 1455 of yacc.c  */
25738
26489
#line 3174 "preproc.y"
25739
26490
    { 
25740
 
 yyval.str = make_str("no maxvalue");
 
26491
 (yyval.str) = make_str("no maxvalue");
25741
26492
;}
25742
26493
    break;
25743
26494
 
25744
26495
  case 434:
 
26496
 
 
26497
/* Line 1455 of yacc.c  */
25745
26498
#line 3178 "preproc.y"
25746
26499
    { 
25747
 
 yyval.str = make_str("no minvalue");
 
26500
 (yyval.str) = make_str("no minvalue");
25748
26501
;}
25749
26502
    break;
25750
26503
 
25751
26504
  case 435:
 
26505
 
 
26506
/* Line 1455 of yacc.c  */
25752
26507
#line 3182 "preproc.y"
25753
26508
    { 
25754
 
 yyval.str = cat_str(2,make_str("owned by"),yyvsp[0].str);
 
26509
 (yyval.str) = cat_str(2,make_str("owned by"),(yyvsp[(3) - (3)].str));
25755
26510
;}
25756
26511
    break;
25757
26512
 
25758
26513
  case 436:
 
26514
 
 
26515
/* Line 1455 of yacc.c  */
25759
26516
#line 3186 "preproc.y"
25760
26517
    { 
25761
 
 yyval.str = cat_str(3,make_str("start"),yyvsp[-1].str,yyvsp[0].str);
 
26518
 (yyval.str) = cat_str(3,make_str("start"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
25762
26519
;}
25763
26520
    break;
25764
26521
 
25765
26522
  case 437:
 
26523
 
 
26524
/* Line 1455 of yacc.c  */
25766
26525
#line 3190 "preproc.y"
25767
26526
    { 
25768
 
 yyval.str = make_str("restart");
 
26527
 (yyval.str) = make_str("restart");
25769
26528
;}
25770
26529
    break;
25771
26530
 
25772
26531
  case 438:
 
26532
 
 
26533
/* Line 1455 of yacc.c  */
25773
26534
#line 3194 "preproc.y"
25774
26535
    { 
25775
 
 yyval.str = cat_str(3,make_str("restart"),yyvsp[-1].str,yyvsp[0].str);
 
26536
 (yyval.str) = cat_str(3,make_str("restart"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
25776
26537
;}
25777
26538
    break;
25778
26539
 
25779
26540
  case 439:
 
26541
 
 
26542
/* Line 1455 of yacc.c  */
25780
26543
#line 3202 "preproc.y"
25781
26544
    { 
25782
 
 yyval.str = make_str("by");
 
26545
 (yyval.str) = make_str("by");
25783
26546
;}
25784
26547
    break;
25785
26548
 
25786
26549
  case 440:
 
26550
 
 
26551
/* Line 1455 of yacc.c  */
25787
26552
#line 3206 "preproc.y"
25788
26553
    { 
25789
 
 yyval.str=EMPTY; ;}
 
26554
 (yyval.str)=EMPTY; ;}
25790
26555
    break;
25791
26556
 
25792
26557
  case 441:
 
26558
 
 
26559
/* Line 1455 of yacc.c  */
25793
26560
#line 3213 "preproc.y"
25794
26561
    { 
25795
 
 yyval.str = yyvsp[0].str;
 
26562
 (yyval.str) = (yyvsp[(1) - (1)].str);
25796
26563
;}
25797
26564
    break;
25798
26565
 
25799
26566
  case 442:
 
26567
 
 
26568
/* Line 1455 of yacc.c  */
25800
26569
#line 3217 "preproc.y"
25801
26570
    { 
25802
 
 yyval.str = cat_str(2,make_str("-"),yyvsp[0].str);
 
26571
 (yyval.str) = cat_str(2,make_str("-"),(yyvsp[(2) - (2)].str));
25803
26572
;}
25804
26573
    break;
25805
26574
 
25806
26575
  case 443:
 
26576
 
 
26577
/* Line 1455 of yacc.c  */
25807
26578
#line 3221 "preproc.y"
25808
26579
    { 
25809
 
 yyval.str = yyvsp[0].str;
 
26580
 (yyval.str) = (yyvsp[(1) - (1)].str);
25810
26581
;}
25811
26582
    break;
25812
26583
 
25813
26584
  case 444:
 
26585
 
 
26586
/* Line 1455 of yacc.c  */
25814
26587
#line 3232 "preproc.y"
25815
26588
    { 
25816
 
 yyval.str = cat_str(5,make_str("create"),yyvsp[-3].str,yyvsp[-2].str,make_str("language"),yyvsp[0].str);
 
26589
 (yyval.str) = cat_str(5,make_str("create"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),make_str("language"),(yyvsp[(5) - (5)].str));
25817
26590
;}
25818
26591
    break;
25819
26592
 
25820
26593
  case 445:
 
26594
 
 
26595
/* Line 1455 of yacc.c  */
25821
26596
#line 3236 "preproc.y"
25822
26597
    { 
25823
 
 yyval.str = cat_str(9,make_str("create"),yyvsp[-7].str,yyvsp[-6].str,make_str("language"),yyvsp[-4].str,make_str("handler"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
26598
 (yyval.str) = cat_str(9,make_str("create"),(yyvsp[(2) - (9)].str),(yyvsp[(3) - (9)].str),make_str("language"),(yyvsp[(5) - (9)].str),make_str("handler"),(yyvsp[(7) - (9)].str),(yyvsp[(8) - (9)].str),(yyvsp[(9) - (9)].str));
25824
26599
;}
25825
26600
    break;
25826
26601
 
25827
26602
  case 446:
 
26603
 
 
26604
/* Line 1455 of yacc.c  */
25828
26605
#line 3244 "preproc.y"
25829
26606
    { 
25830
 
 yyval.str = make_str("trusted");
 
26607
 (yyval.str) = make_str("trusted");
25831
26608
;}
25832
26609
    break;
25833
26610
 
25834
26611
  case 447:
 
26612
 
 
26613
/* Line 1455 of yacc.c  */
25835
26614
#line 3248 "preproc.y"
25836
26615
    { 
25837
 
 yyval.str=EMPTY; ;}
 
26616
 (yyval.str)=EMPTY; ;}
25838
26617
    break;
25839
26618
 
25840
26619
  case 448:
 
26620
 
 
26621
/* Line 1455 of yacc.c  */
25841
26622
#line 3255 "preproc.y"
25842
26623
    { 
25843
 
 yyval.str = yyvsp[0].str;
 
26624
 (yyval.str) = (yyvsp[(1) - (1)].str);
25844
26625
;}
25845
26626
    break;
25846
26627
 
25847
26628
  case 449:
 
26629
 
 
26630
/* Line 1455 of yacc.c  */
25848
26631
#line 3259 "preproc.y"
25849
26632
    { 
25850
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
26633
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
25851
26634
;}
25852
26635
    break;
25853
26636
 
25854
26637
  case 450:
 
26638
 
 
26639
/* Line 1455 of yacc.c  */
25855
26640
#line 3267 "preproc.y"
25856
26641
    { 
25857
 
 yyval.str = cat_str(2,make_str("validator"),yyvsp[0].str);
 
26642
 (yyval.str) = cat_str(2,make_str("validator"),(yyvsp[(2) - (2)].str));
25858
26643
;}
25859
26644
    break;
25860
26645
 
25861
26646
  case 451:
 
26647
 
 
26648
/* Line 1455 of yacc.c  */
25862
26649
#line 3271 "preproc.y"
25863
26650
    { 
25864
 
 yyval.str = make_str("no validator");
 
26651
 (yyval.str) = make_str("no validator");
25865
26652
;}
25866
26653
    break;
25867
26654
 
25868
26655
  case 452:
 
26656
 
 
26657
/* Line 1455 of yacc.c  */
25869
26658
#line 3279 "preproc.y"
25870
26659
    { 
25871
 
 yyval.str = yyvsp[0].str;
 
26660
 (yyval.str) = (yyvsp[(1) - (1)].str);
25872
26661
;}
25873
26662
    break;
25874
26663
 
25875
26664
  case 453:
 
26665
 
 
26666
/* Line 1455 of yacc.c  */
25876
26667
#line 3283 "preproc.y"
25877
26668
    { 
25878
 
 yyval.str=EMPTY; ;}
 
26669
 (yyval.str)=EMPTY; ;}
25879
26670
    break;
25880
26671
 
25881
26672
  case 454:
 
26673
 
 
26674
/* Line 1455 of yacc.c  */
25882
26675
#line 3290 "preproc.y"
25883
26676
    { 
25884
 
 yyval.str = cat_str(2,make_str("lancompiler"),yyvsp[0].str);
 
26677
 (yyval.str) = cat_str(2,make_str("lancompiler"),(yyvsp[(2) - (2)].str));
25885
26678
;}
25886
26679
    break;
25887
26680
 
25888
26681
  case 455:
 
26682
 
 
26683
/* Line 1455 of yacc.c  */
25889
26684
#line 3294 "preproc.y"
25890
26685
    { 
25891
 
 yyval.str=EMPTY; ;}
 
26686
 (yyval.str)=EMPTY; ;}
25892
26687
    break;
25893
26688
 
25894
26689
  case 456:
 
26690
 
 
26691
/* Line 1455 of yacc.c  */
25895
26692
#line 3301 "preproc.y"
25896
26693
    { 
25897
 
 yyval.str = cat_str(5,make_str("drop"),yyvsp[-3].str,make_str("language"),yyvsp[-1].str,yyvsp[0].str);
 
26694
 (yyval.str) = cat_str(5,make_str("drop"),(yyvsp[(2) - (5)].str),make_str("language"),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
25898
26695
;}
25899
26696
    break;
25900
26697
 
25901
26698
  case 457:
 
26699
 
 
26700
/* Line 1455 of yacc.c  */
25902
26701
#line 3305 "preproc.y"
25903
26702
    { 
25904
 
 yyval.str = cat_str(5,make_str("drop"),yyvsp[-5].str,make_str("language if exists"),yyvsp[-1].str,yyvsp[0].str);
 
26703
 (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));
25905
26704
;}
25906
26705
    break;
25907
26706
 
25908
26707
  case 458:
 
26708
 
 
26709
/* Line 1455 of yacc.c  */
25909
26710
#line 3313 "preproc.y"
25910
26711
    { 
25911
 
 yyval.str = make_str("procedural");
 
26712
 (yyval.str) = make_str("procedural");
25912
26713
;}
25913
26714
    break;
25914
26715
 
25915
26716
  case 459:
 
26717
 
 
26718
/* Line 1455 of yacc.c  */
25916
26719
#line 3317 "preproc.y"
25917
26720
    { 
25918
 
 yyval.str=EMPTY; ;}
 
26721
 (yyval.str)=EMPTY; ;}
25919
26722
    break;
25920
26723
 
25921
26724
  case 460:
 
26725
 
 
26726
/* Line 1455 of yacc.c  */
25922
26727
#line 3324 "preproc.y"
25923
26728
    { 
25924
 
 yyval.str = cat_str(5,make_str("create tablespace"),yyvsp[-3].str,yyvsp[-2].str,make_str("location"),yyvsp[0].str);
 
26729
 (yyval.str) = cat_str(5,make_str("create tablespace"),(yyvsp[(3) - (6)].str),(yyvsp[(4) - (6)].str),make_str("location"),(yyvsp[(6) - (6)].str));
25925
26730
;}
25926
26731
    break;
25927
26732
 
25928
26733
  case 461:
 
26734
 
 
26735
/* Line 1455 of yacc.c  */
25929
26736
#line 3332 "preproc.y"
25930
26737
    { 
25931
 
 yyval.str = cat_str(2,make_str("owner"),yyvsp[0].str);
 
26738
 (yyval.str) = cat_str(2,make_str("owner"),(yyvsp[(2) - (2)].str));
25932
26739
;}
25933
26740
    break;
25934
26741
 
25935
26742
  case 462:
 
26743
 
 
26744
/* Line 1455 of yacc.c  */
25936
26745
#line 3336 "preproc.y"
25937
26746
    { 
25938
 
 yyval.str=EMPTY; ;}
 
26747
 (yyval.str)=EMPTY; ;}
25939
26748
    break;
25940
26749
 
25941
26750
  case 463:
 
26751
 
 
26752
/* Line 1455 of yacc.c  */
25942
26753
#line 3343 "preproc.y"
25943
26754
    { 
25944
 
 yyval.str = cat_str(2,make_str("drop tablespace"),yyvsp[0].str);
 
26755
 (yyval.str) = cat_str(2,make_str("drop tablespace"),(yyvsp[(3) - (3)].str));
25945
26756
;}
25946
26757
    break;
25947
26758
 
25948
26759
  case 464:
 
26760
 
 
26761
/* Line 1455 of yacc.c  */
25949
26762
#line 3347 "preproc.y"
25950
26763
    { 
25951
 
 yyval.str = cat_str(2,make_str("drop tablespace if exists"),yyvsp[0].str);
 
26764
 (yyval.str) = cat_str(2,make_str("drop tablespace if exists"),(yyvsp[(5) - (5)].str));
25952
26765
;}
25953
26766
    break;
25954
26767
 
25955
26768
  case 465:
 
26769
 
 
26770
/* Line 1455 of yacc.c  */
25956
26771
#line 3355 "preproc.y"
25957
26772
    { 
25958
 
 yyval.str = cat_str(4,make_str("create foreign data wrapper"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
26773
 (yyval.str) = cat_str(4,make_str("create foreign data wrapper"),(yyvsp[(5) - (7)].str),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str));
25959
26774
;}
25960
26775
    break;
25961
26776
 
25962
26777
  case 466:
 
26778
 
 
26779
/* Line 1455 of yacc.c  */
25963
26780
#line 3363 "preproc.y"
25964
26781
    { 
25965
 
 yyval.str = cat_str(3,make_str("drop foreign data wrapper"),yyvsp[-1].str,yyvsp[0].str);
 
26782
 (yyval.str) = cat_str(3,make_str("drop foreign data wrapper"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str));
25966
26783
;}
25967
26784
    break;
25968
26785
 
25969
26786
  case 467:
 
26787
 
 
26788
/* Line 1455 of yacc.c  */
25970
26789
#line 3367 "preproc.y"
25971
26790
    { 
25972
 
 yyval.str = cat_str(3,make_str("drop foreign data wrapper if exists"),yyvsp[-1].str,yyvsp[0].str);
 
26791
 (yyval.str) = cat_str(3,make_str("drop foreign data wrapper if exists"),(yyvsp[(7) - (8)].str),(yyvsp[(8) - (8)].str));
25973
26792
;}
25974
26793
    break;
25975
26794
 
25976
26795
  case 468:
 
26796
 
 
26797
/* Line 1455 of yacc.c  */
25977
26798
#line 3375 "preproc.y"
25978
26799
    { 
25979
 
 yyval.str = cat_str(4,make_str("alter foreign data wrapper"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
26800
 (yyval.str) = cat_str(4,make_str("alter foreign data wrapper"),(yyvsp[(5) - (7)].str),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str));
25980
26801
;}
25981
26802
    break;
25982
26803
 
25983
26804
  case 469:
 
26805
 
 
26806
/* Line 1455 of yacc.c  */
25984
26807
#line 3379 "preproc.y"
25985
26808
    { 
25986
 
 yyval.str = cat_str(3,make_str("alter foreign data wrapper"),yyvsp[-1].str,yyvsp[0].str);
 
26809
 (yyval.str) = cat_str(3,make_str("alter foreign data wrapper"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str));
25987
26810
;}
25988
26811
    break;
25989
26812
 
25990
26813
  case 470:
 
26814
 
 
26815
/* Line 1455 of yacc.c  */
25991
26816
#line 3383 "preproc.y"
25992
26817
    { 
25993
 
 yyval.str = cat_str(3,make_str("alter foreign data wrapper"),yyvsp[-1].str,yyvsp[0].str);
 
26818
 (yyval.str) = cat_str(3,make_str("alter foreign data wrapper"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str));
25994
26819
;}
25995
26820
    break;
25996
26821
 
25997
26822
  case 471:
 
26823
 
 
26824
/* Line 1455 of yacc.c  */
25998
26825
#line 3391 "preproc.y"
25999
26826
    { 
26000
 
 yyval.str = cat_str(3,make_str("options ("),yyvsp[-1].str,make_str(")"));
 
26827
 (yyval.str) = cat_str(3,make_str("options ("),(yyvsp[(3) - (4)].str),make_str(")"));
26001
26828
;}
26002
26829
    break;
26003
26830
 
26004
26831
  case 472:
 
26832
 
 
26833
/* Line 1455 of yacc.c  */
26005
26834
#line 3395 "preproc.y"
26006
26835
    { 
26007
 
 yyval.str=EMPTY; ;}
 
26836
 (yyval.str)=EMPTY; ;}
26008
26837
    break;
26009
26838
 
26010
26839
  case 473:
 
26840
 
 
26841
/* Line 1455 of yacc.c  */
26011
26842
#line 3402 "preproc.y"
26012
26843
    { 
26013
 
 yyval.str = yyvsp[0].str;
 
26844
 (yyval.str) = (yyvsp[(1) - (1)].str);
26014
26845
;}
26015
26846
    break;
26016
26847
 
26017
26848
  case 474:
 
26849
 
 
26850
/* Line 1455 of yacc.c  */
26018
26851
#line 3406 "preproc.y"
26019
26852
    { 
26020
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
26853
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
26021
26854
;}
26022
26855
    break;
26023
26856
 
26024
26857
  case 475:
 
26858
 
 
26859
/* Line 1455 of yacc.c  */
26025
26860
#line 3414 "preproc.y"
26026
26861
    { 
26027
 
 yyval.str = cat_str(3,make_str("options ("),yyvsp[-1].str,make_str(")"));
 
26862
 (yyval.str) = cat_str(3,make_str("options ("),(yyvsp[(3) - (4)].str),make_str(")"));
26028
26863
;}
26029
26864
    break;
26030
26865
 
26031
26866
  case 476:
 
26867
 
 
26868
/* Line 1455 of yacc.c  */
26032
26869
#line 3422 "preproc.y"
26033
26870
    { 
26034
 
 yyval.str = yyvsp[0].str;
 
26871
 (yyval.str) = (yyvsp[(1) - (1)].str);
26035
26872
;}
26036
26873
    break;
26037
26874
 
26038
26875
  case 477:
 
26876
 
 
26877
/* Line 1455 of yacc.c  */
26039
26878
#line 3426 "preproc.y"
26040
26879
    { 
26041
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
26880
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
26042
26881
;}
26043
26882
    break;
26044
26883
 
26045
26884
  case 478:
 
26885
 
 
26886
/* Line 1455 of yacc.c  */
26046
26887
#line 3434 "preproc.y"
26047
26888
    { 
26048
 
 yyval.str = yyvsp[0].str;
 
26889
 (yyval.str) = (yyvsp[(1) - (1)].str);
26049
26890
;}
26050
26891
    break;
26051
26892
 
26052
26893
  case 479:
 
26894
 
 
26895
/* Line 1455 of yacc.c  */
26053
26896
#line 3438 "preproc.y"
26054
26897
    { 
26055
 
 yyval.str = cat_str(2,make_str("set"),yyvsp[0].str);
 
26898
 (yyval.str) = cat_str(2,make_str("set"),(yyvsp[(2) - (2)].str));
26056
26899
;}
26057
26900
    break;
26058
26901
 
26059
26902
  case 480:
 
26903
 
 
26904
/* Line 1455 of yacc.c  */
26060
26905
#line 3442 "preproc.y"
26061
26906
    { 
26062
 
 yyval.str = cat_str(2,make_str("add"),yyvsp[0].str);
 
26907
 (yyval.str) = cat_str(2,make_str("add"),(yyvsp[(2) - (2)].str));
26063
26908
;}
26064
26909
    break;
26065
26910
 
26066
26911
  case 481:
 
26912
 
 
26913
/* Line 1455 of yacc.c  */
26067
26914
#line 3446 "preproc.y"
26068
26915
    { 
26069
 
 yyval.str = cat_str(2,make_str("drop"),yyvsp[0].str);
 
26916
 (yyval.str) = cat_str(2,make_str("drop"),(yyvsp[(2) - (2)].str));
26070
26917
;}
26071
26918
    break;
26072
26919
 
26073
26920
  case 482:
 
26921
 
 
26922
/* Line 1455 of yacc.c  */
26074
26923
#line 3454 "preproc.y"
26075
26924
    { 
26076
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
26925
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
26077
26926
;}
26078
26927
    break;
26079
26928
 
26080
26929
  case 483:
 
26930
 
 
26931
/* Line 1455 of yacc.c  */
26081
26932
#line 3462 "preproc.y"
26082
26933
    { 
26083
 
 yyval.str = yyvsp[0].str;
 
26934
 (yyval.str) = (yyvsp[(1) - (1)].str);
26084
26935
;}
26085
26936
    break;
26086
26937
 
26087
26938
  case 484:
 
26939
 
 
26940
/* Line 1455 of yacc.c  */
26088
26941
#line 3470 "preproc.y"
26089
26942
    { 
26090
 
 yyval.str = yyvsp[0].str;
 
26943
 (yyval.str) = (yyvsp[(1) - (1)].str);
26091
26944
;}
26092
26945
    break;
26093
26946
 
26094
26947
  case 485:
 
26948
 
 
26949
/* Line 1455 of yacc.c  */
26095
26950
#line 3478 "preproc.y"
26096
26951
    { 
26097
 
 yyval.str = cat_str(7,make_str("create server"),yyvsp[-7].str,yyvsp[-6].str,yyvsp[-5].str,make_str("foreign data wrapper"),yyvsp[-1].str,yyvsp[0].str);
 
26952
 (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));
26098
26953
;}
26099
26954
    break;
26100
26955
 
26101
26956
  case 486:
 
26957
 
 
26958
/* Line 1455 of yacc.c  */
26102
26959
#line 3486 "preproc.y"
26103
26960
    { 
26104
 
 yyval.str = cat_str(2,make_str("type"),yyvsp[0].str);
 
26961
 (yyval.str) = cat_str(2,make_str("type"),(yyvsp[(2) - (2)].str));
26105
26962
;}
26106
26963
    break;
26107
26964
 
26108
26965
  case 487:
 
26966
 
 
26967
/* Line 1455 of yacc.c  */
26109
26968
#line 3490 "preproc.y"
26110
26969
    { 
26111
 
 yyval.str=EMPTY; ;}
 
26970
 (yyval.str)=EMPTY; ;}
26112
26971
    break;
26113
26972
 
26114
26973
  case 488:
 
26974
 
 
26975
/* Line 1455 of yacc.c  */
26115
26976
#line 3497 "preproc.y"
26116
26977
    { 
26117
 
 yyval.str = cat_str(2,make_str("version"),yyvsp[0].str);
 
26978
 (yyval.str) = cat_str(2,make_str("version"),(yyvsp[(2) - (2)].str));
26118
26979
;}
26119
26980
    break;
26120
26981
 
26121
26982
  case 489:
 
26983
 
 
26984
/* Line 1455 of yacc.c  */
26122
26985
#line 3501 "preproc.y"
26123
26986
    { 
26124
 
 yyval.str = make_str("version null");
 
26987
 (yyval.str) = make_str("version null");
26125
26988
;}
26126
26989
    break;
26127
26990
 
26128
26991
  case 490:
 
26992
 
 
26993
/* Line 1455 of yacc.c  */
26129
26994
#line 3509 "preproc.y"
26130
26995
    { 
26131
 
 yyval.str = yyvsp[0].str;
 
26996
 (yyval.str) = (yyvsp[(1) - (1)].str);
26132
26997
;}
26133
26998
    break;
26134
26999
 
26135
27000
  case 491:
 
27001
 
 
27002
/* Line 1455 of yacc.c  */
26136
27003
#line 3513 "preproc.y"
26137
27004
    { 
26138
 
 yyval.str=EMPTY; ;}
 
27005
 (yyval.str)=EMPTY; ;}
26139
27006
    break;
26140
27007
 
26141
27008
  case 492:
 
27009
 
 
27010
/* Line 1455 of yacc.c  */
26142
27011
#line 3520 "preproc.y"
26143
27012
    { 
26144
 
 yyval.str = cat_str(3,make_str("drop server"),yyvsp[-1].str,yyvsp[0].str);
 
27013
 (yyval.str) = cat_str(3,make_str("drop server"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
26145
27014
;}
26146
27015
    break;
26147
27016
 
26148
27017
  case 493:
 
27018
 
 
27019
/* Line 1455 of yacc.c  */
26149
27020
#line 3524 "preproc.y"
26150
27021
    { 
26151
 
 yyval.str = cat_str(3,make_str("drop server if exists"),yyvsp[-1].str,yyvsp[0].str);
 
27022
 (yyval.str) = cat_str(3,make_str("drop server if exists"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str));
26152
27023
;}
26153
27024
    break;
26154
27025
 
26155
27026
  case 494:
 
27027
 
 
27028
/* Line 1455 of yacc.c  */
26156
27029
#line 3532 "preproc.y"
26157
27030
    { 
26158
 
 yyval.str = cat_str(4,make_str("alter server"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
27031
 (yyval.str) = cat_str(4,make_str("alter server"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
26159
27032
;}
26160
27033
    break;
26161
27034
 
26162
27035
  case 495:
 
27036
 
 
27037
/* Line 1455 of yacc.c  */
26163
27038
#line 3536 "preproc.y"
26164
27039
    { 
26165
 
 yyval.str = cat_str(3,make_str("alter server"),yyvsp[-1].str,yyvsp[0].str);
 
27040
 (yyval.str) = cat_str(3,make_str("alter server"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
26166
27041
;}
26167
27042
    break;
26168
27043
 
26169
27044
  case 496:
 
27045
 
 
27046
/* Line 1455 of yacc.c  */
26170
27047
#line 3540 "preproc.y"
26171
27048
    { 
26172
 
 yyval.str = cat_str(3,make_str("alter server"),yyvsp[-1].str,yyvsp[0].str);
 
27049
 (yyval.str) = cat_str(3,make_str("alter server"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
26173
27050
;}
26174
27051
    break;
26175
27052
 
26176
27053
  case 497:
 
27054
 
 
27055
/* Line 1455 of yacc.c  */
26177
27056
#line 3548 "preproc.y"
26178
27057
    { 
26179
 
 yyval.str = cat_str(5,make_str("create user mapping for"),yyvsp[-3].str,make_str("server"),yyvsp[-1].str,yyvsp[0].str);
 
27058
 (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));
26180
27059
;}
26181
27060
    break;
26182
27061
 
26183
27062
  case 498:
 
27063
 
 
27064
/* Line 1455 of yacc.c  */
26184
27065
#line 3556 "preproc.y"
26185
27066
    { 
26186
 
 yyval.str = make_str("current_user");
 
27067
 (yyval.str) = make_str("current_user");
26187
27068
;}
26188
27069
    break;
26189
27070
 
26190
27071
  case 499:
 
27072
 
 
27073
/* Line 1455 of yacc.c  */
26191
27074
#line 3560 "preproc.y"
26192
27075
    { 
26193
 
 yyval.str = make_str("user");
 
27076
 (yyval.str) = make_str("user");
26194
27077
;}
26195
27078
    break;
26196
27079
 
26197
27080
  case 500:
 
27081
 
 
27082
/* Line 1455 of yacc.c  */
26198
27083
#line 3564 "preproc.y"
26199
27084
    { 
26200
 
 yyval.str = yyvsp[0].str;
 
27085
 (yyval.str) = (yyvsp[(1) - (1)].str);
26201
27086
;}
26202
27087
    break;
26203
27088
 
26204
27089
  case 501:
 
27090
 
 
27091
/* Line 1455 of yacc.c  */
26205
27092
#line 3572 "preproc.y"
26206
27093
    { 
26207
 
 yyval.str = cat_str(4,make_str("drop user mapping for"),yyvsp[-2].str,make_str("server"),yyvsp[0].str);
 
27094
 (yyval.str) = cat_str(4,make_str("drop user mapping for"),(yyvsp[(5) - (7)].str),make_str("server"),(yyvsp[(7) - (7)].str));
26208
27095
;}
26209
27096
    break;
26210
27097
 
26211
27098
  case 502:
 
27099
 
 
27100
/* Line 1455 of yacc.c  */
26212
27101
#line 3576 "preproc.y"
26213
27102
    { 
26214
 
 yyval.str = cat_str(4,make_str("drop user mapping if exists for"),yyvsp[-2].str,make_str("server"),yyvsp[0].str);
 
27103
 (yyval.str) = cat_str(4,make_str("drop user mapping if exists for"),(yyvsp[(7) - (9)].str),make_str("server"),(yyvsp[(9) - (9)].str));
26215
27104
;}
26216
27105
    break;
26217
27106
 
26218
27107
  case 503:
 
27108
 
 
27109
/* Line 1455 of yacc.c  */
26219
27110
#line 3584 "preproc.y"
26220
27111
    { 
26221
 
 yyval.str = cat_str(5,make_str("alter user mapping for"),yyvsp[-3].str,make_str("server"),yyvsp[-1].str,yyvsp[0].str);
 
27112
 (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));
26222
27113
;}
26223
27114
    break;
26224
27115
 
26225
27116
  case 504:
 
27117
 
 
27118
/* Line 1455 of yacc.c  */
26226
27119
#line 3592 "preproc.y"
26227
27120
    { 
26228
 
 yyval.str = cat_str(12,make_str("create trigger"),yyvsp[-11].str,yyvsp[-10].str,yyvsp[-9].str,make_str("on"),yyvsp[-7].str,yyvsp[-6].str,make_str("execute procedure"),yyvsp[-3].str,make_str("("),yyvsp[-1].str,make_str(")"));
 
27121
 (yyval.str) = cat_str(12,make_str("create trigger"),(yyvsp[(3) - (14)].str),(yyvsp[(4) - (14)].str),(yyvsp[(5) - (14)].str),make_str("on"),(yyvsp[(7) - (14)].str),(yyvsp[(8) - (14)].str),make_str("execute procedure"),(yyvsp[(11) - (14)].str),make_str("("),(yyvsp[(13) - (14)].str),make_str(")"));
26229
27122
;}
26230
27123
    break;
26231
27124
 
26232
27125
  case 505:
 
27126
 
 
27127
/* Line 1455 of yacc.c  */
26233
27128
#line 3596 "preproc.y"
26234
27129
    { 
26235
 
 yyval.str = cat_str(13,make_str("create constraint trigger"),yyvsp[-15].str,make_str("after"),yyvsp[-13].str,make_str("on"),yyvsp[-11].str,yyvsp[-10].str,yyvsp[-9].str,make_str("for each row execute procedure"),yyvsp[-3].str,make_str("("),yyvsp[-1].str,make_str(")"));
 
27130
 (yyval.str) = cat_str(13,make_str("create constraint trigger"),(yyvsp[(4) - (19)].str),make_str("after"),(yyvsp[(6) - (19)].str),make_str("on"),(yyvsp[(8) - (19)].str),(yyvsp[(9) - (19)].str),(yyvsp[(10) - (19)].str),make_str("for each row execute procedure"),(yyvsp[(16) - (19)].str),make_str("("),(yyvsp[(18) - (19)].str),make_str(")"));
26236
27131
;}
26237
27132
    break;
26238
27133
 
26239
27134
  case 506:
 
27135
 
 
27136
/* Line 1455 of yacc.c  */
26240
27137
#line 3604 "preproc.y"
26241
27138
    { 
26242
 
 yyval.str = make_str("before");
 
27139
 (yyval.str) = make_str("before");
26243
27140
;}
26244
27141
    break;
26245
27142
 
26246
27143
  case 507:
 
27144
 
 
27145
/* Line 1455 of yacc.c  */
26247
27146
#line 3608 "preproc.y"
26248
27147
    { 
26249
 
 yyval.str = make_str("after");
 
27148
 (yyval.str) = make_str("after");
26250
27149
;}
26251
27150
    break;
26252
27151
 
26253
27152
  case 508:
 
27153
 
 
27154
/* Line 1455 of yacc.c  */
26254
27155
#line 3616 "preproc.y"
26255
27156
    { 
26256
 
 yyval.str = yyvsp[0].str;
 
27157
 (yyval.str) = (yyvsp[(1) - (1)].str);
26257
27158
;}
26258
27159
    break;
26259
27160
 
26260
27161
  case 509:
 
27162
 
 
27163
/* Line 1455 of yacc.c  */
26261
27164
#line 3620 "preproc.y"
26262
27165
    { 
26263
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("or"),yyvsp[0].str);
 
27166
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("or"),(yyvsp[(3) - (3)].str));
26264
27167
;}
26265
27168
    break;
26266
27169
 
26267
27170
  case 510:
 
27171
 
 
27172
/* Line 1455 of yacc.c  */
26268
27173
#line 3628 "preproc.y"
26269
27174
    { 
26270
 
 yyval.str = make_str("insert");
 
27175
 (yyval.str) = make_str("insert");
26271
27176
;}
26272
27177
    break;
26273
27178
 
26274
27179
  case 511:
 
27180
 
 
27181
/* Line 1455 of yacc.c  */
26275
27182
#line 3632 "preproc.y"
26276
27183
    { 
26277
 
 yyval.str = make_str("delete");
 
27184
 (yyval.str) = make_str("delete");
26278
27185
;}
26279
27186
    break;
26280
27187
 
26281
27188
  case 512:
 
27189
 
 
27190
/* Line 1455 of yacc.c  */
26282
27191
#line 3636 "preproc.y"
26283
27192
    { 
26284
 
 yyval.str = make_str("update");
 
27193
 (yyval.str) = make_str("update");
26285
27194
;}
26286
27195
    break;
26287
27196
 
26288
27197
  case 513:
 
27198
 
 
27199
/* Line 1455 of yacc.c  */
26289
27200
#line 3640 "preproc.y"
26290
27201
    { 
26291
 
 yyval.str = make_str("truncate");
 
27202
 (yyval.str) = make_str("truncate");
26292
27203
;}
26293
27204
    break;
26294
27205
 
26295
27206
  case 514:
 
27207
 
 
27208
/* Line 1455 of yacc.c  */
26296
27209
#line 3648 "preproc.y"
26297
27210
    { 
26298
 
 yyval.str = cat_str(3,make_str("for"),yyvsp[-1].str,yyvsp[0].str);
 
27211
 (yyval.str) = cat_str(3,make_str("for"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
26299
27212
;}
26300
27213
    break;
26301
27214
 
26302
27215
  case 515:
 
27216
 
 
27217
/* Line 1455 of yacc.c  */
26303
27218
#line 3652 "preproc.y"
26304
27219
    { 
26305
 
 yyval.str=EMPTY; ;}
 
27220
 (yyval.str)=EMPTY; ;}
26306
27221
    break;
26307
27222
 
26308
27223
  case 516:
 
27224
 
 
27225
/* Line 1455 of yacc.c  */
26309
27226
#line 3659 "preproc.y"
26310
27227
    { 
26311
 
 yyval.str = make_str("each");
 
27228
 (yyval.str) = make_str("each");
26312
27229
;}
26313
27230
    break;
26314
27231
 
26315
27232
  case 517:
 
27233
 
 
27234
/* Line 1455 of yacc.c  */
26316
27235
#line 3663 "preproc.y"
26317
27236
    { 
26318
 
 yyval.str=EMPTY; ;}
 
27237
 (yyval.str)=EMPTY; ;}
26319
27238
    break;
26320
27239
 
26321
27240
  case 518:
 
27241
 
 
27242
/* Line 1455 of yacc.c  */
26322
27243
#line 3670 "preproc.y"
26323
27244
    { 
26324
 
 yyval.str = make_str("row");
 
27245
 (yyval.str) = make_str("row");
26325
27246
;}
26326
27247
    break;
26327
27248
 
26328
27249
  case 519:
 
27250
 
 
27251
/* Line 1455 of yacc.c  */
26329
27252
#line 3674 "preproc.y"
26330
27253
    { 
26331
 
 yyval.str = make_str("statement");
 
27254
 (yyval.str) = make_str("statement");
26332
27255
;}
26333
27256
    break;
26334
27257
 
26335
27258
  case 520:
 
27259
 
 
27260
/* Line 1455 of yacc.c  */
26336
27261
#line 3682 "preproc.y"
26337
27262
    { 
26338
 
 yyval.str = yyvsp[0].str;
 
27263
 (yyval.str) = (yyvsp[(1) - (1)].str);
26339
27264
;}
26340
27265
    break;
26341
27266
 
26342
27267
  case 521:
 
27268
 
 
27269
/* Line 1455 of yacc.c  */
26343
27270
#line 3686 "preproc.y"
26344
27271
    { 
26345
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
27272
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
26346
27273
;}
26347
27274
    break;
26348
27275
 
26349
27276
  case 522:
 
27277
 
 
27278
/* Line 1455 of yacc.c  */
26350
27279
#line 3690 "preproc.y"
26351
27280
    { 
26352
 
 yyval.str=EMPTY; ;}
 
27281
 (yyval.str)=EMPTY; ;}
26353
27282
    break;
26354
27283
 
26355
27284
  case 523:
 
27285
 
 
27286
/* Line 1455 of yacc.c  */
26356
27287
#line 3697 "preproc.y"
26357
27288
    { 
26358
 
 yyval.str = yyvsp[0].str;
 
27289
 (yyval.str) = (yyvsp[(1) - (1)].str);
26359
27290
;}
26360
27291
    break;
26361
27292
 
26362
27293
  case 524:
 
27294
 
 
27295
/* Line 1455 of yacc.c  */
26363
27296
#line 3701 "preproc.y"
26364
27297
    { 
26365
 
 yyval.str = yyvsp[0].str;
 
27298
 (yyval.str) = (yyvsp[(1) - (1)].str);
26366
27299
;}
26367
27300
    break;
26368
27301
 
26369
27302
  case 525:
 
27303
 
 
27304
/* Line 1455 of yacc.c  */
26370
27305
#line 3705 "preproc.y"
26371
27306
    { 
26372
 
 yyval.str = yyvsp[0].str;
 
27307
 (yyval.str) = (yyvsp[(1) - (1)].str);
26373
27308
;}
26374
27309
    break;
26375
27310
 
26376
27311
  case 526:
 
27312
 
 
27313
/* Line 1455 of yacc.c  */
26377
27314
#line 3709 "preproc.y"
26378
27315
    { 
26379
 
 yyval.str = yyvsp[0].str;
 
27316
 (yyval.str) = (yyvsp[(1) - (1)].str);
26380
27317
;}
26381
27318
    break;
26382
27319
 
26383
27320
  case 527:
 
27321
 
 
27322
/* Line 1455 of yacc.c  */
26384
27323
#line 3713 "preproc.y"
26385
27324
    { 
26386
 
 yyval.str = make_str("xconst");
 
27325
 (yyval.str) = make_str("xconst");
26387
27326
;}
26388
27327
    break;
26389
27328
 
26390
27329
  case 528:
 
27330
 
 
27331
/* Line 1455 of yacc.c  */
26391
27332
#line 3717 "preproc.y"
26392
27333
    { 
26393
 
 yyval.str = yyvsp[0].str;
 
27334
 (yyval.str) = (yyvsp[(1) - (1)].str);
26394
27335
;}
26395
27336
    break;
26396
27337
 
26397
27338
  case 529:
 
27339
 
 
27340
/* Line 1455 of yacc.c  */
26398
27341
#line 3725 "preproc.y"
26399
27342
    { 
26400
 
 yyval.str = cat_str(2,make_str("from"),yyvsp[0].str);
 
27343
 (yyval.str) = cat_str(2,make_str("from"),(yyvsp[(2) - (2)].str));
26401
27344
;}
26402
27345
    break;
26403
27346
 
26404
27347
  case 530:
 
27348
 
 
27349
/* Line 1455 of yacc.c  */
26405
27350
#line 3729 "preproc.y"
26406
27351
    { 
26407
 
 yyval.str=EMPTY; ;}
 
27352
 (yyval.str)=EMPTY; ;}
26408
27353
    break;
26409
27354
 
26410
27355
  case 531:
 
27356
 
 
27357
/* Line 1455 of yacc.c  */
26411
27358
#line 3736 "preproc.y"
26412
27359
    { 
26413
 
 yyval.str = yyvsp[0].str;
 
27360
 (yyval.str) = (yyvsp[(1) - (1)].str);
26414
27361
;}
26415
27362
    break;
26416
27363
 
26417
27364
  case 532:
 
27365
 
 
27366
/* Line 1455 of yacc.c  */
26418
27367
#line 3740 "preproc.y"
26419
27368
    { 
26420
 
                        if (strcmp(yyvsp[-1].str, "deferrable") != 0 && strcmp(yyvsp[0].str, "initially deferrable") == 0 )
 
27369
                        if (strcmp((yyvsp[(1) - (2)].str), "deferrable") != 0 && strcmp((yyvsp[(2) - (2)].str), "initially deferrable") == 0 )
26421
27370
                                mmerror(PARSE_ERROR, ET_ERROR, "constraint declared INITIALLY DEFERRED must be DEFERRABLE");
26422
27371
 
26423
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
27372
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
26424
27373
;}
26425
27374
    break;
26426
27375
 
26427
27376
  case 533:
 
27377
 
 
27378
/* Line 1455 of yacc.c  */
26428
27379
#line 3747 "preproc.y"
26429
27380
    { 
26430
 
 yyval.str = yyvsp[0].str;
 
27381
 (yyval.str) = (yyvsp[(1) - (1)].str);
26431
27382
;}
26432
27383
    break;
26433
27384
 
26434
27385
  case 534:
 
27386
 
 
27387
/* Line 1455 of yacc.c  */
26435
27388
#line 3751 "preproc.y"
26436
27389
    { 
26437
 
                        if (strcmp(yyvsp[0].str, "deferrable") != 0 && strcmp(yyvsp[-1].str, "initially deferrable") == 0 )
 
27390
                        if (strcmp((yyvsp[(2) - (2)].str), "deferrable") != 0 && strcmp((yyvsp[(1) - (2)].str), "initially deferrable") == 0 )
26438
27391
                                mmerror(PARSE_ERROR, ET_ERROR, "constraint declared INITIALLY DEFERRED must be DEFERRABLE");
26439
27392
 
26440
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
27393
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
26441
27394
;}
26442
27395
    break;
26443
27396
 
26444
27397
  case 535:
 
27398
 
 
27399
/* Line 1455 of yacc.c  */
26445
27400
#line 3758 "preproc.y"
26446
27401
    { 
26447
 
 yyval.str=EMPTY; ;}
 
27402
 (yyval.str)=EMPTY; ;}
26448
27403
    break;
26449
27404
 
26450
27405
  case 536:
 
27406
 
 
27407
/* Line 1455 of yacc.c  */
26451
27408
#line 3765 "preproc.y"
26452
27409
    { 
26453
 
 yyval.str = make_str("not deferrable");
 
27410
 (yyval.str) = make_str("not deferrable");
26454
27411
;}
26455
27412
    break;
26456
27413
 
26457
27414
  case 537:
 
27415
 
 
27416
/* Line 1455 of yacc.c  */
26458
27417
#line 3769 "preproc.y"
26459
27418
    { 
26460
 
 yyval.str = make_str("deferrable");
 
27419
 (yyval.str) = make_str("deferrable");
26461
27420
;}
26462
27421
    break;
26463
27422
 
26464
27423
  case 538:
 
27424
 
 
27425
/* Line 1455 of yacc.c  */
26465
27426
#line 3777 "preproc.y"
26466
27427
    { 
26467
 
 yyval.str = make_str("initially immediate");
 
27428
 (yyval.str) = make_str("initially immediate");
26468
27429
;}
26469
27430
    break;
26470
27431
 
26471
27432
  case 539:
 
27433
 
 
27434
/* Line 1455 of yacc.c  */
26472
27435
#line 3781 "preproc.y"
26473
27436
    { 
26474
 
 yyval.str = make_str("initially deferred");
 
27437
 (yyval.str) = make_str("initially deferred");
26475
27438
;}
26476
27439
    break;
26477
27440
 
26478
27441
  case 540:
 
27442
 
 
27443
/* Line 1455 of yacc.c  */
26479
27444
#line 3789 "preproc.y"
26480
27445
    { 
26481
 
 yyval.str = cat_str(5,make_str("drop trigger"),yyvsp[-3].str,make_str("on"),yyvsp[-1].str,yyvsp[0].str);
 
27446
 (yyval.str) = cat_str(5,make_str("drop trigger"),(yyvsp[(3) - (6)].str),make_str("on"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str));
26482
27447
;}
26483
27448
    break;
26484
27449
 
26485
27450
  case 541:
 
27451
 
 
27452
/* Line 1455 of yacc.c  */
26486
27453
#line 3793 "preproc.y"
26487
27454
    { 
26488
 
 yyval.str = cat_str(5,make_str("drop trigger if exists"),yyvsp[-3].str,make_str("on"),yyvsp[-1].str,yyvsp[0].str);
 
27455
 (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));
26489
27456
;}
26490
27457
    break;
26491
27458
 
26492
27459
  case 542:
 
27460
 
 
27461
/* Line 1455 of yacc.c  */
26493
27462
#line 3801 "preproc.y"
26494
27463
    { 
26495
27464
mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
26496
 
 yyval.str = cat_str(6,make_str("create assertion"),yyvsp[-5].str,make_str("check ("),yyvsp[-2].str,make_str(")"),yyvsp[0].str);
 
27465
 (yyval.str) = cat_str(6,make_str("create assertion"),(yyvsp[(3) - (8)].str),make_str("check ("),(yyvsp[(6) - (8)].str),make_str(")"),(yyvsp[(8) - (8)].str));
26497
27466
;}
26498
27467
    break;
26499
27468
 
26500
27469
  case 543:
 
27470
 
 
27471
/* Line 1455 of yacc.c  */
26501
27472
#line 3810 "preproc.y"
26502
27473
    { 
26503
27474
mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
26504
 
 yyval.str = cat_str(3,make_str("drop assertion"),yyvsp[-1].str,yyvsp[0].str);
 
27475
 (yyval.str) = cat_str(3,make_str("drop assertion"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
26505
27476
;}
26506
27477
    break;
26507
27478
 
26508
27479
  case 544:
 
27480
 
 
27481
/* Line 1455 of yacc.c  */
26509
27482
#line 3819 "preproc.y"
26510
27483
    { 
26511
 
 yyval.str = cat_str(4,make_str("create aggregate"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
27484
 (yyval.str) = cat_str(4,make_str("create aggregate"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
26512
27485
;}
26513
27486
    break;
26514
27487
 
26515
27488
  case 545:
 
27489
 
 
27490
/* Line 1455 of yacc.c  */
26516
27491
#line 3823 "preproc.y"
26517
27492
    { 
26518
 
 yyval.str = cat_str(3,make_str("create aggregate"),yyvsp[-1].str,yyvsp[0].str);
 
27493
 (yyval.str) = cat_str(3,make_str("create aggregate"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
26519
27494
;}
26520
27495
    break;
26521
27496
 
26522
27497
  case 546:
 
27498
 
 
27499
/* Line 1455 of yacc.c  */
26523
27500
#line 3827 "preproc.y"
26524
27501
    { 
26525
 
 yyval.str = cat_str(3,make_str("create operator"),yyvsp[-1].str,yyvsp[0].str);
 
27502
 (yyval.str) = cat_str(3,make_str("create operator"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
26526
27503
;}
26527
27504
    break;
26528
27505
 
26529
27506
  case 547:
 
27507
 
 
27508
/* Line 1455 of yacc.c  */
26530
27509
#line 3831 "preproc.y"
26531
27510
    { 
26532
 
 yyval.str = cat_str(3,make_str("create type"),yyvsp[-1].str,yyvsp[0].str);
 
27511
 (yyval.str) = cat_str(3,make_str("create type"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
26533
27512
;}
26534
27513
    break;
26535
27514
 
26536
27515
  case 548:
 
27516
 
 
27517
/* Line 1455 of yacc.c  */
26537
27518
#line 3835 "preproc.y"
26538
27519
    { 
26539
 
 yyval.str = cat_str(2,make_str("create type"),yyvsp[0].str);
 
27520
 (yyval.str) = cat_str(2,make_str("create type"),(yyvsp[(3) - (3)].str));
26540
27521
;}
26541
27522
    break;
26542
27523
 
26543
27524
  case 549:
 
27525
 
 
27526
/* Line 1455 of yacc.c  */
26544
27527
#line 3839 "preproc.y"
26545
27528
    { 
26546
 
 yyval.str = cat_str(5,make_str("create type"),yyvsp[-4].str,make_str("as ("),yyvsp[-1].str,make_str(")"));
 
27529
 (yyval.str) = cat_str(5,make_str("create type"),(yyvsp[(3) - (7)].str),make_str("as ("),(yyvsp[(6) - (7)].str),make_str(")"));
26547
27530
;}
26548
27531
    break;
26549
27532
 
26550
27533
  case 550:
 
27534
 
 
27535
/* Line 1455 of yacc.c  */
26551
27536
#line 3843 "preproc.y"
26552
27537
    { 
26553
 
 yyval.str = cat_str(5,make_str("create type"),yyvsp[-5].str,make_str("as enum ("),yyvsp[-1].str,make_str(")"));
 
27538
 (yyval.str) = cat_str(5,make_str("create type"),(yyvsp[(3) - (8)].str),make_str("as enum ("),(yyvsp[(7) - (8)].str),make_str(")"));
26554
27539
;}
26555
27540
    break;
26556
27541
 
26557
27542
  case 551:
 
27543
 
 
27544
/* Line 1455 of yacc.c  */
26558
27545
#line 3847 "preproc.y"
26559
27546
    { 
26560
 
 yyval.str = cat_str(3,make_str("create text search parser"),yyvsp[-1].str,yyvsp[0].str);
 
27547
 (yyval.str) = cat_str(3,make_str("create text search parser"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str));
26561
27548
;}
26562
27549
    break;
26563
27550
 
26564
27551
  case 552:
 
27552
 
 
27553
/* Line 1455 of yacc.c  */
26565
27554
#line 3851 "preproc.y"
26566
27555
    { 
26567
 
 yyval.str = cat_str(3,make_str("create text search dictionary"),yyvsp[-1].str,yyvsp[0].str);
 
27556
 (yyval.str) = cat_str(3,make_str("create text search dictionary"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str));
26568
27557
;}
26569
27558
    break;
26570
27559
 
26571
27560
  case 553:
 
27561
 
 
27562
/* Line 1455 of yacc.c  */
26572
27563
#line 3855 "preproc.y"
26573
27564
    { 
26574
 
 yyval.str = cat_str(3,make_str("create text search template"),yyvsp[-1].str,yyvsp[0].str);
 
27565
 (yyval.str) = cat_str(3,make_str("create text search template"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str));
26575
27566
;}
26576
27567
    break;
26577
27568
 
26578
27569
  case 554:
 
27570
 
 
27571
/* Line 1455 of yacc.c  */
26579
27572
#line 3859 "preproc.y"
26580
27573
    { 
26581
 
 yyval.str = cat_str(3,make_str("create text search configuration"),yyvsp[-1].str,yyvsp[0].str);
 
27574
 (yyval.str) = cat_str(3,make_str("create text search configuration"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str));
26582
27575
;}
26583
27576
    break;
26584
27577
 
26585
27578
  case 555:
 
27579
 
 
27580
/* Line 1455 of yacc.c  */
26586
27581
#line 3867 "preproc.y"
26587
27582
    { 
26588
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
27583
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
26589
27584
;}
26590
27585
    break;
26591
27586
 
26592
27587
  case 556:
 
27588
 
 
27589
/* Line 1455 of yacc.c  */
26593
27590
#line 3875 "preproc.y"
26594
27591
    { 
26595
 
 yyval.str = yyvsp[0].str;
 
27592
 (yyval.str) = (yyvsp[(1) - (1)].str);
26596
27593
;}
26597
27594
    break;
26598
27595
 
26599
27596
  case 557:
 
27597
 
 
27598
/* Line 1455 of yacc.c  */
26600
27599
#line 3879 "preproc.y"
26601
27600
    { 
26602
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
27601
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
26603
27602
;}
26604
27603
    break;
26605
27604
 
26606
27605
  case 558:
 
27606
 
 
27607
/* Line 1455 of yacc.c  */
26607
27608
#line 3887 "preproc.y"
26608
27609
    { 
26609
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("="),yyvsp[0].str);
 
27610
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("="),(yyvsp[(3) - (3)].str));
26610
27611
;}
26611
27612
    break;
26612
27613
 
26613
27614
  case 559:
 
27615
 
 
27616
/* Line 1455 of yacc.c  */
26614
27617
#line 3891 "preproc.y"
26615
27618
    { 
26616
 
 yyval.str = yyvsp[0].str;
 
27619
 (yyval.str) = (yyvsp[(1) - (1)].str);
26617
27620
;}
26618
27621
    break;
26619
27622
 
26620
27623
  case 560:
 
27624
 
 
27625
/* Line 1455 of yacc.c  */
26621
27626
#line 3899 "preproc.y"
26622
27627
    { 
26623
 
 yyval.str = yyvsp[0].str;
 
27628
 (yyval.str) = (yyvsp[(1) - (1)].str);
26624
27629
;}
26625
27630
    break;
26626
27631
 
26627
27632
  case 561:
 
27633
 
 
27634
/* Line 1455 of yacc.c  */
26628
27635
#line 3903 "preproc.y"
26629
27636
    { 
26630
 
 yyval.str = yyvsp[0].str;
 
27637
 (yyval.str) = (yyvsp[(1) - (1)].str);
26631
27638
;}
26632
27639
    break;
26633
27640
 
26634
27641
  case 562:
 
27642
 
 
27643
/* Line 1455 of yacc.c  */
26635
27644
#line 3907 "preproc.y"
26636
27645
    { 
26637
 
 yyval.str = yyvsp[0].str;
 
27646
 (yyval.str) = (yyvsp[(1) - (1)].str);
26638
27647
;}
26639
27648
    break;
26640
27649
 
26641
27650
  case 563:
 
27651
 
 
27652
/* Line 1455 of yacc.c  */
26642
27653
#line 3911 "preproc.y"
26643
27654
    { 
26644
 
 yyval.str = yyvsp[0].str;
 
27655
 (yyval.str) = (yyvsp[(1) - (1)].str);
26645
27656
;}
26646
27657
    break;
26647
27658
 
26648
27659
  case 564:
 
27660
 
 
27661
/* Line 1455 of yacc.c  */
26649
27662
#line 3915 "preproc.y"
26650
27663
    { 
26651
 
 yyval.str = yyvsp[0].str;
 
27664
 (yyval.str) = (yyvsp[(1) - (1)].str);
26652
27665
;}
26653
27666
    break;
26654
27667
 
26655
27668
  case 565:
 
27669
 
 
27670
/* Line 1455 of yacc.c  */
26656
27671
#line 3923 "preproc.y"
26657
27672
    { 
26658
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
27673
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
26659
27674
;}
26660
27675
    break;
26661
27676
 
26662
27677
  case 566:
 
27678
 
 
27679
/* Line 1455 of yacc.c  */
26663
27680
#line 3927 "preproc.y"
26664
27681
    { 
26665
 
 yyval.str = make_str("( * )");
 
27682
 (yyval.str) = make_str("( * )");
26666
27683
;}
26667
27684
    break;
26668
27685
 
26669
27686
  case 567:
 
27687
 
 
27688
/* Line 1455 of yacc.c  */
26670
27689
#line 3935 "preproc.y"
26671
27690
    { 
26672
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
27691
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
26673
27692
;}
26674
27693
    break;
26675
27694
 
26676
27695
  case 568:
 
27696
 
 
27697
/* Line 1455 of yacc.c  */
26677
27698
#line 3943 "preproc.y"
26678
27699
    { 
26679
 
 yyval.str = yyvsp[0].str;
 
27700
 (yyval.str) = (yyvsp[(1) - (1)].str);
26680
27701
;}
26681
27702
    break;
26682
27703
 
26683
27704
  case 569:
 
27705
 
 
27706
/* Line 1455 of yacc.c  */
26684
27707
#line 3947 "preproc.y"
26685
27708
    { 
26686
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
27709
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
26687
27710
;}
26688
27711
    break;
26689
27712
 
26690
27713
  case 570:
 
27714
 
 
27715
/* Line 1455 of yacc.c  */
26691
27716
#line 3955 "preproc.y"
26692
27717
    { 
26693
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("="),yyvsp[0].str);
 
27718
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("="),(yyvsp[(3) - (3)].str));
26694
27719
;}
26695
27720
    break;
26696
27721
 
26697
27722
  case 571:
 
27723
 
 
27724
/* Line 1455 of yacc.c  */
26698
27725
#line 3963 "preproc.y"
26699
27726
    { 
26700
 
 yyval.str = yyvsp[0].str;
 
27727
 (yyval.str) = (yyvsp[(1) - (1)].str);
26701
27728
;}
26702
27729
    break;
26703
27730
 
26704
27731
  case 572:
 
27732
 
 
27733
/* Line 1455 of yacc.c  */
26705
27734
#line 3967 "preproc.y"
26706
27735
    { 
26707
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
27736
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
26708
27737
;}
26709
27738
    break;
26710
27739
 
26711
27740
  case 573:
 
27741
 
 
27742
/* Line 1455 of yacc.c  */
26712
27743
#line 3975 "preproc.y"
26713
27744
    { 
26714
 
 yyval.str = cat_str(10,make_str("create operator class"),yyvsp[-9].str,yyvsp[-8].str,make_str("for type"),yyvsp[-5].str,make_str("using"),yyvsp[-3].str,yyvsp[-2].str,make_str("as"),yyvsp[0].str);
 
27745
 (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));
26715
27746
;}
26716
27747
    break;
26717
27748
 
26718
27749
  case 574:
 
27750
 
 
27751
/* Line 1455 of yacc.c  */
26719
27752
#line 3983 "preproc.y"
26720
27753
    { 
26721
 
 yyval.str = yyvsp[0].str;
 
27754
 (yyval.str) = (yyvsp[(1) - (1)].str);
26722
27755
;}
26723
27756
    break;
26724
27757
 
26725
27758
  case 575:
 
27759
 
 
27760
/* Line 1455 of yacc.c  */
26726
27761
#line 3987 "preproc.y"
26727
27762
    { 
26728
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
27763
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
26729
27764
;}
26730
27765
    break;
26731
27766
 
26732
27767
  case 576:
 
27768
 
 
27769
/* Line 1455 of yacc.c  */
26733
27770
#line 3995 "preproc.y"
26734
27771
    { 
26735
 
 yyval.str = cat_str(4,make_str("operator"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
27772
 (yyval.str) = cat_str(4,make_str("operator"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
26736
27773
;}
26737
27774
    break;
26738
27775
 
26739
27776
  case 577:
 
27777
 
 
27778
/* Line 1455 of yacc.c  */
26740
27779
#line 3999 "preproc.y"
26741
27780
    { 
26742
 
 yyval.str = cat_str(5,make_str("operator"),yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
27781
 (yyval.str) = cat_str(5,make_str("operator"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
26743
27782
;}
26744
27783
    break;
26745
27784
 
26746
27785
  case 578:
 
27786
 
 
27787
/* Line 1455 of yacc.c  */
26747
27788
#line 4003 "preproc.y"
26748
27789
    { 
26749
 
 yyval.str = cat_str(4,make_str("function"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
27790
 (yyval.str) = cat_str(4,make_str("function"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
26750
27791
;}
26751
27792
    break;
26752
27793
 
26753
27794
  case 579:
 
27795
 
 
27796
/* Line 1455 of yacc.c  */
26754
27797
#line 4007 "preproc.y"
26755
27798
    { 
26756
 
 yyval.str = cat_str(7,make_str("function"),yyvsp[-5].str,make_str("("),yyvsp[-3].str,make_str(")"),yyvsp[-1].str,yyvsp[0].str);
 
27799
 (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));
26757
27800
;}
26758
27801
    break;
26759
27802
 
26760
27803
  case 580:
 
27804
 
 
27805
/* Line 1455 of yacc.c  */
26761
27806
#line 4011 "preproc.y"
26762
27807
    { 
26763
 
 yyval.str = cat_str(2,make_str("storage"),yyvsp[0].str);
 
27808
 (yyval.str) = cat_str(2,make_str("storage"),(yyvsp[(2) - (2)].str));
26764
27809
;}
26765
27810
    break;
26766
27811
 
26767
27812
  case 581:
 
27813
 
 
27814
/* Line 1455 of yacc.c  */
26768
27815
#line 4019 "preproc.y"
26769
27816
    { 
26770
 
 yyval.str = make_str("default");
 
27817
 (yyval.str) = make_str("default");
26771
27818
;}
26772
27819
    break;
26773
27820
 
26774
27821
  case 582:
 
27822
 
 
27823
/* Line 1455 of yacc.c  */
26775
27824
#line 4023 "preproc.y"
26776
27825
    { 
26777
 
 yyval.str=EMPTY; ;}
 
27826
 (yyval.str)=EMPTY; ;}
26778
27827
    break;
26779
27828
 
26780
27829
  case 583:
 
27830
 
 
27831
/* Line 1455 of yacc.c  */
26781
27832
#line 4030 "preproc.y"
26782
27833
    { 
26783
 
 yyval.str = cat_str(2,make_str("family"),yyvsp[0].str);
 
27834
 (yyval.str) = cat_str(2,make_str("family"),(yyvsp[(2) - (2)].str));
26784
27835
;}
26785
27836
    break;
26786
27837
 
26787
27838
  case 584:
 
27839
 
 
27840
/* Line 1455 of yacc.c  */
26788
27841
#line 4034 "preproc.y"
26789
27842
    { 
26790
 
 yyval.str=EMPTY; ;}
 
27843
 (yyval.str)=EMPTY; ;}
26791
27844
    break;
26792
27845
 
26793
27846
  case 585:
 
27847
 
 
27848
/* Line 1455 of yacc.c  */
26794
27849
#line 4041 "preproc.y"
26795
27850
    { 
26796
27851
mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
26797
 
 yyval.str = make_str("recheck");
 
27852
 (yyval.str) = make_str("recheck");
26798
27853
;}
26799
27854
    break;
26800
27855
 
26801
27856
  case 586:
 
27857
 
 
27858
/* Line 1455 of yacc.c  */
26802
27859
#line 4046 "preproc.y"
26803
27860
    { 
26804
 
 yyval.str=EMPTY; ;}
 
27861
 (yyval.str)=EMPTY; ;}
26805
27862
    break;
26806
27863
 
26807
27864
  case 587:
 
27865
 
 
27866
/* Line 1455 of yacc.c  */
26808
27867
#line 4053 "preproc.y"
26809
27868
    { 
26810
 
 yyval.str = cat_str(4,make_str("create operator family"),yyvsp[-2].str,make_str("using"),yyvsp[0].str);
 
27869
 (yyval.str) = cat_str(4,make_str("create operator family"),(yyvsp[(4) - (6)].str),make_str("using"),(yyvsp[(6) - (6)].str));
26811
27870
;}
26812
27871
    break;
26813
27872
 
26814
27873
  case 588:
 
27874
 
 
27875
/* Line 1455 of yacc.c  */
26815
27876
#line 4061 "preproc.y"
26816
27877
    { 
26817
 
 yyval.str = cat_str(6,make_str("alter operator family"),yyvsp[-4].str,make_str("using"),yyvsp[-2].str,make_str("add"),yyvsp[0].str);
 
27878
 (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));
26818
27879
;}
26819
27880
    break;
26820
27881
 
26821
27882
  case 589:
 
27883
 
 
27884
/* Line 1455 of yacc.c  */
26822
27885
#line 4065 "preproc.y"
26823
27886
    { 
26824
 
 yyval.str = cat_str(6,make_str("alter operator family"),yyvsp[-4].str,make_str("using"),yyvsp[-2].str,make_str("drop"),yyvsp[0].str);
 
27887
 (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));
26825
27888
;}
26826
27889
    break;
26827
27890
 
26828
27891
  case 590:
 
27892
 
 
27893
/* Line 1455 of yacc.c  */
26829
27894
#line 4073 "preproc.y"
26830
27895
    { 
26831
 
 yyval.str = yyvsp[0].str;
 
27896
 (yyval.str) = (yyvsp[(1) - (1)].str);
26832
27897
;}
26833
27898
    break;
26834
27899
 
26835
27900
  case 591:
 
27901
 
 
27902
/* Line 1455 of yacc.c  */
26836
27903
#line 4077 "preproc.y"
26837
27904
    { 
26838
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
27905
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
26839
27906
;}
26840
27907
    break;
26841
27908
 
26842
27909
  case 592:
 
27910
 
 
27911
/* Line 1455 of yacc.c  */
26843
27912
#line 4085 "preproc.y"
26844
27913
    { 
26845
 
 yyval.str = cat_str(5,make_str("operator"),yyvsp[-3].str,make_str("("),yyvsp[-1].str,make_str(")"));
 
27914
 (yyval.str) = cat_str(5,make_str("operator"),(yyvsp[(2) - (5)].str),make_str("("),(yyvsp[(4) - (5)].str),make_str(")"));
26846
27915
;}
26847
27916
    break;
26848
27917
 
26849
27918
  case 593:
 
27919
 
 
27920
/* Line 1455 of yacc.c  */
26850
27921
#line 4089 "preproc.y"
26851
27922
    { 
26852
 
 yyval.str = cat_str(5,make_str("function"),yyvsp[-3].str,make_str("("),yyvsp[-1].str,make_str(")"));
 
27923
 (yyval.str) = cat_str(5,make_str("function"),(yyvsp[(2) - (5)].str),make_str("("),(yyvsp[(4) - (5)].str),make_str(")"));
26853
27924
;}
26854
27925
    break;
26855
27926
 
26856
27927
  case 594:
 
27928
 
 
27929
/* Line 1455 of yacc.c  */
26857
27930
#line 4097 "preproc.y"
26858
27931
    { 
26859
 
 yyval.str = cat_str(5,make_str("drop operator class"),yyvsp[-3].str,make_str("using"),yyvsp[-1].str,yyvsp[0].str);
 
27932
 (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));
26860
27933
;}
26861
27934
    break;
26862
27935
 
26863
27936
  case 595:
 
27937
 
 
27938
/* Line 1455 of yacc.c  */
26864
27939
#line 4101 "preproc.y"
26865
27940
    { 
26866
 
 yyval.str = cat_str(5,make_str("drop operator class if exists"),yyvsp[-3].str,make_str("using"),yyvsp[-1].str,yyvsp[0].str);
 
27941
 (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));
26867
27942
;}
26868
27943
    break;
26869
27944
 
26870
27945
  case 596:
 
27946
 
 
27947
/* Line 1455 of yacc.c  */
26871
27948
#line 4109 "preproc.y"
26872
27949
    { 
26873
 
 yyval.str = cat_str(5,make_str("drop operator family"),yyvsp[-3].str,make_str("using"),yyvsp[-1].str,yyvsp[0].str);
 
27950
 (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));
26874
27951
;}
26875
27952
    break;
26876
27953
 
26877
27954
  case 597:
 
27955
 
 
27956
/* Line 1455 of yacc.c  */
26878
27957
#line 4113 "preproc.y"
26879
27958
    { 
26880
 
 yyval.str = cat_str(5,make_str("drop operator family if exists"),yyvsp[-3].str,make_str("using"),yyvsp[-1].str,yyvsp[0].str);
 
27959
 (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));
26881
27960
;}
26882
27961
    break;
26883
27962
 
26884
27963
  case 598:
 
27964
 
 
27965
/* Line 1455 of yacc.c  */
26885
27966
#line 4121 "preproc.y"
26886
27967
    { 
26887
 
 yyval.str = cat_str(3,make_str("drop owned by"),yyvsp[-1].str,yyvsp[0].str);
 
27968
 (yyval.str) = cat_str(3,make_str("drop owned by"),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
26888
27969
;}
26889
27970
    break;
26890
27971
 
26891
27972
  case 599:
 
27973
 
 
27974
/* Line 1455 of yacc.c  */
26892
27975
#line 4129 "preproc.y"
26893
27976
    { 
26894
 
 yyval.str = cat_str(4,make_str("reassign owned by"),yyvsp[-2].str,make_str("to"),yyvsp[0].str);
 
27977
 (yyval.str) = cat_str(4,make_str("reassign owned by"),(yyvsp[(4) - (6)].str),make_str("to"),(yyvsp[(6) - (6)].str));
26895
27978
;}
26896
27979
    break;
26897
27980
 
26898
27981
  case 600:
 
27982
 
 
27983
/* Line 1455 of yacc.c  */
26899
27984
#line 4137 "preproc.y"
26900
27985
    { 
26901
 
 yyval.str = cat_str(5,make_str("drop"),yyvsp[-4].str,make_str("if exists"),yyvsp[-1].str,yyvsp[0].str);
 
27986
 (yyval.str) = cat_str(5,make_str("drop"),(yyvsp[(2) - (6)].str),make_str("if exists"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str));
26902
27987
;}
26903
27988
    break;
26904
27989
 
26905
27990
  case 601:
 
27991
 
 
27992
/* Line 1455 of yacc.c  */
26906
27993
#line 4141 "preproc.y"
26907
27994
    { 
26908
 
 yyval.str = cat_str(4,make_str("drop"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
27995
 (yyval.str) = cat_str(4,make_str("drop"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
26909
27996
;}
26910
27997
    break;
26911
27998
 
26912
27999
  case 602:
 
28000
 
 
28001
/* Line 1455 of yacc.c  */
26913
28002
#line 4149 "preproc.y"
26914
28003
    { 
26915
 
 yyval.str = make_str("table");
 
28004
 (yyval.str) = make_str("table");
26916
28005
;}
26917
28006
    break;
26918
28007
 
26919
28008
  case 603:
 
28009
 
 
28010
/* Line 1455 of yacc.c  */
26920
28011
#line 4153 "preproc.y"
26921
28012
    { 
26922
 
 yyval.str = make_str("sequence");
 
28013
 (yyval.str) = make_str("sequence");
26923
28014
;}
26924
28015
    break;
26925
28016
 
26926
28017
  case 604:
 
28018
 
 
28019
/* Line 1455 of yacc.c  */
26927
28020
#line 4157 "preproc.y"
26928
28021
    { 
26929
 
 yyval.str = make_str("view");
 
28022
 (yyval.str) = make_str("view");
26930
28023
;}
26931
28024
    break;
26932
28025
 
26933
28026
  case 605:
 
28027
 
 
28028
/* Line 1455 of yacc.c  */
26934
28029
#line 4161 "preproc.y"
26935
28030
    { 
26936
 
 yyval.str = make_str("index");
 
28031
 (yyval.str) = make_str("index");
26937
28032
;}
26938
28033
    break;
26939
28034
 
26940
28035
  case 606:
 
28036
 
 
28037
/* Line 1455 of yacc.c  */
26941
28038
#line 4165 "preproc.y"
26942
28039
    { 
26943
 
 yyval.str = make_str("type");
 
28040
 (yyval.str) = make_str("type");
26944
28041
;}
26945
28042
    break;
26946
28043
 
26947
28044
  case 607:
 
28045
 
 
28046
/* Line 1455 of yacc.c  */
26948
28047
#line 4169 "preproc.y"
26949
28048
    { 
26950
 
 yyval.str = make_str("domain");
 
28049
 (yyval.str) = make_str("domain");
26951
28050
;}
26952
28051
    break;
26953
28052
 
26954
28053
  case 608:
 
28054
 
 
28055
/* Line 1455 of yacc.c  */
26955
28056
#line 4173 "preproc.y"
26956
28057
    { 
26957
 
 yyval.str = make_str("conversion");
 
28058
 (yyval.str) = make_str("conversion");
26958
28059
;}
26959
28060
    break;
26960
28061
 
26961
28062
  case 609:
 
28063
 
 
28064
/* Line 1455 of yacc.c  */
26962
28065
#line 4177 "preproc.y"
26963
28066
    { 
26964
 
 yyval.str = make_str("schema");
 
28067
 (yyval.str) = make_str("schema");
26965
28068
;}
26966
28069
    break;
26967
28070
 
26968
28071
  case 610:
 
28072
 
 
28073
/* Line 1455 of yacc.c  */
26969
28074
#line 4181 "preproc.y"
26970
28075
    { 
26971
 
 yyval.str = make_str("text search parser");
 
28076
 (yyval.str) = make_str("text search parser");
26972
28077
;}
26973
28078
    break;
26974
28079
 
26975
28080
  case 611:
 
28081
 
 
28082
/* Line 1455 of yacc.c  */
26976
28083
#line 4185 "preproc.y"
26977
28084
    { 
26978
 
 yyval.str = make_str("text search dictionary");
 
28085
 (yyval.str) = make_str("text search dictionary");
26979
28086
;}
26980
28087
    break;
26981
28088
 
26982
28089
  case 612:
 
28090
 
 
28091
/* Line 1455 of yacc.c  */
26983
28092
#line 4189 "preproc.y"
26984
28093
    { 
26985
 
 yyval.str = make_str("text search template");
 
28094
 (yyval.str) = make_str("text search template");
26986
28095
;}
26987
28096
    break;
26988
28097
 
26989
28098
  case 613:
 
28099
 
 
28100
/* Line 1455 of yacc.c  */
26990
28101
#line 4193 "preproc.y"
26991
28102
    { 
26992
 
 yyval.str = make_str("text search configuration");
 
28103
 (yyval.str) = make_str("text search configuration");
26993
28104
;}
26994
28105
    break;
26995
28106
 
26996
28107
  case 614:
 
28108
 
 
28109
/* Line 1455 of yacc.c  */
26997
28110
#line 4201 "preproc.y"
26998
28111
    { 
26999
 
 yyval.str = yyvsp[0].str;
 
28112
 (yyval.str) = (yyvsp[(1) - (1)].str);
27000
28113
;}
27001
28114
    break;
27002
28115
 
27003
28116
  case 615:
 
28117
 
 
28118
/* Line 1455 of yacc.c  */
27004
28119
#line 4205 "preproc.y"
27005
28120
    { 
27006
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
28121
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
27007
28122
;}
27008
28123
    break;
27009
28124
 
27010
28125
  case 616:
 
28126
 
 
28127
/* Line 1455 of yacc.c  */
27011
28128
#line 4213 "preproc.y"
27012
28129
    { 
27013
 
 yyval.str = yyvsp[0].str;
 
28130
 (yyval.str) = (yyvsp[(1) - (1)].str);
27014
28131
;}
27015
28132
    break;
27016
28133
 
27017
28134
  case 617:
 
28135
 
 
28136
/* Line 1455 of yacc.c  */
27018
28137
#line 4217 "preproc.y"
27019
28138
    { 
27020
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
28139
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
27021
28140
;}
27022
28141
    break;
27023
28142
 
27024
28143
  case 618:
 
28144
 
 
28145
/* Line 1455 of yacc.c  */
27025
28146
#line 4225 "preproc.y"
27026
28147
    { 
27027
 
 yyval.str = cat_str(2,make_str("."),yyvsp[0].str);
 
28148
 (yyval.str) = cat_str(2,make_str("."),(yyvsp[(2) - (2)].str));
27028
28149
;}
27029
28150
    break;
27030
28151
 
27031
28152
  case 619:
 
28153
 
 
28154
/* Line 1455 of yacc.c  */
27032
28155
#line 4229 "preproc.y"
27033
28156
    { 
27034
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("."),yyvsp[0].str);
 
28157
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("."),(yyvsp[(3) - (3)].str));
27035
28158
;}
27036
28159
    break;
27037
28160
 
27038
28161
  case 620:
 
28162
 
 
28163
/* Line 1455 of yacc.c  */
27039
28164
#line 4237 "preproc.y"
27040
28165
    { 
27041
 
 yyval.str = cat_str(5,make_str("truncate"),yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
28166
 (yyval.str) = cat_str(5,make_str("truncate"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
27042
28167
;}
27043
28168
    break;
27044
28169
 
27045
28170
  case 621:
 
28171
 
 
28172
/* Line 1455 of yacc.c  */
27046
28173
#line 4245 "preproc.y"
27047
28174
    { 
27048
 
 yyval.str = make_str("continue identity");
 
28175
 (yyval.str) = make_str("continue identity");
27049
28176
;}
27050
28177
    break;
27051
28178
 
27052
28179
  case 622:
 
28180
 
 
28181
/* Line 1455 of yacc.c  */
27053
28182
#line 4249 "preproc.y"
27054
28183
    { 
27055
 
 yyval.str = make_str("restart identity");
 
28184
 (yyval.str) = make_str("restart identity");
27056
28185
;}
27057
28186
    break;
27058
28187
 
27059
28188
  case 623:
 
28189
 
 
28190
/* Line 1455 of yacc.c  */
27060
28191
#line 4253 "preproc.y"
27061
28192
    { 
27062
 
 yyval.str=EMPTY; ;}
 
28193
 (yyval.str)=EMPTY; ;}
27063
28194
    break;
27064
28195
 
27065
28196
  case 624:
 
28197
 
 
28198
/* Line 1455 of yacc.c  */
27066
28199
#line 4260 "preproc.y"
27067
28200
    { 
27068
 
 yyval.str = cat_str(5,make_str("comment on"),yyvsp[-3].str,yyvsp[-2].str,make_str("is"),yyvsp[0].str);
 
28201
 (yyval.str) = cat_str(5,make_str("comment on"),(yyvsp[(3) - (6)].str),(yyvsp[(4) - (6)].str),make_str("is"),(yyvsp[(6) - (6)].str));
27069
28202
;}
27070
28203
    break;
27071
28204
 
27072
28205
  case 625:
 
28206
 
 
28207
/* Line 1455 of yacc.c  */
27073
28208
#line 4264 "preproc.y"
27074
28209
    { 
27075
 
 yyval.str = cat_str(5,make_str("comment on aggregate"),yyvsp[-3].str,yyvsp[-2].str,make_str("is"),yyvsp[0].str);
 
28210
 (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));
27076
28211
;}
27077
28212
    break;
27078
28213
 
27079
28214
  case 626:
 
28215
 
 
28216
/* Line 1455 of yacc.c  */
27080
28217
#line 4268 "preproc.y"
27081
28218
    { 
27082
 
 yyval.str = cat_str(5,make_str("comment on function"),yyvsp[-3].str,yyvsp[-2].str,make_str("is"),yyvsp[0].str);
 
28219
 (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));
27083
28220
;}
27084
28221
    break;
27085
28222
 
27086
28223
  case 627:
 
28224
 
 
28225
/* Line 1455 of yacc.c  */
27087
28226
#line 4272 "preproc.y"
27088
28227
    { 
27089
 
 yyval.str = cat_str(5,make_str("comment on operator"),yyvsp[-3].str,yyvsp[-2].str,make_str("is"),yyvsp[0].str);
 
28228
 (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));
27090
28229
;}
27091
28230
    break;
27092
28231
 
27093
28232
  case 628:
 
28233
 
 
28234
/* Line 1455 of yacc.c  */
27094
28235
#line 4276 "preproc.y"
27095
28236
    { 
27096
 
 yyval.str = cat_str(6,make_str("comment on constraint"),yyvsp[-4].str,make_str("on"),yyvsp[-2].str,make_str("is"),yyvsp[0].str);
 
28237
 (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));
27097
28238
;}
27098
28239
    break;
27099
28240
 
27100
28241
  case 629:
 
28242
 
 
28243
/* Line 1455 of yacc.c  */
27101
28244
#line 4280 "preproc.y"
27102
28245
    { 
27103
 
 yyval.str = cat_str(6,make_str("comment on rule"),yyvsp[-4].str,make_str("on"),yyvsp[-2].str,make_str("is"),yyvsp[0].str);
 
28246
 (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));
27104
28247
;}
27105
28248
    break;
27106
28249
 
27107
28250
  case 630:
 
28251
 
 
28252
/* Line 1455 of yacc.c  */
27108
28253
#line 4284 "preproc.y"
27109
28254
    { 
27110
 
 yyval.str = cat_str(4,make_str("comment on rule"),yyvsp[-2].str,make_str("is"),yyvsp[0].str);
 
28255
 (yyval.str) = cat_str(4,make_str("comment on rule"),(yyvsp[(4) - (6)].str),make_str("is"),(yyvsp[(6) - (6)].str));
27111
28256
;}
27112
28257
    break;
27113
28258
 
27114
28259
  case 631:
 
28260
 
 
28261
/* Line 1455 of yacc.c  */
27115
28262
#line 4288 "preproc.y"
27116
28263
    { 
27117
 
 yyval.str = cat_str(6,make_str("comment on trigger"),yyvsp[-4].str,make_str("on"),yyvsp[-2].str,make_str("is"),yyvsp[0].str);
 
28264
 (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));
27118
28265
;}
27119
28266
    break;
27120
28267
 
27121
28268
  case 632:
 
28269
 
 
28270
/* Line 1455 of yacc.c  */
27122
28271
#line 4292 "preproc.y"
27123
28272
    { 
27124
 
 yyval.str = cat_str(6,make_str("comment on operator class"),yyvsp[-4].str,make_str("using"),yyvsp[-2].str,make_str("is"),yyvsp[0].str);
 
28273
 (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));
27125
28274
;}
27126
28275
    break;
27127
28276
 
27128
28277
  case 633:
 
28278
 
 
28279
/* Line 1455 of yacc.c  */
27129
28280
#line 4296 "preproc.y"
27130
28281
    { 
27131
 
 yyval.str = cat_str(6,make_str("comment on operator family"),yyvsp[-4].str,make_str("using"),yyvsp[-2].str,make_str("is"),yyvsp[0].str);
 
28282
 (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));
27132
28283
;}
27133
28284
    break;
27134
28285
 
27135
28286
  case 634:
 
28287
 
 
28288
/* Line 1455 of yacc.c  */
27136
28289
#line 4300 "preproc.y"
27137
28290
    { 
27138
 
 yyval.str = cat_str(4,make_str("comment on large object"),yyvsp[-2].str,make_str("is"),yyvsp[0].str);
 
28291
 (yyval.str) = cat_str(4,make_str("comment on large object"),(yyvsp[(5) - (7)].str),make_str("is"),(yyvsp[(7) - (7)].str));
27139
28292
;}
27140
28293
    break;
27141
28294
 
27142
28295
  case 635:
 
28296
 
 
28297
/* Line 1455 of yacc.c  */
27143
28298
#line 4304 "preproc.y"
27144
28299
    { 
27145
 
 yyval.str = cat_str(6,make_str("comment on cast ("),yyvsp[-5].str,make_str("as"),yyvsp[-3].str,make_str(") is"),yyvsp[0].str);
 
28300
 (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));
27146
28301
;}
27147
28302
    break;
27148
28303
 
27149
28304
  case 636:
 
28305
 
 
28306
/* Line 1455 of yacc.c  */
27150
28307
#line 4308 "preproc.y"
27151
28308
    { 
27152
 
 yyval.str = cat_str(6,make_str("comment on"),yyvsp[-4].str,make_str("language"),yyvsp[-2].str,make_str("is"),yyvsp[0].str);
 
28309
 (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));
27153
28310
;}
27154
28311
    break;
27155
28312
 
27156
28313
  case 637:
 
28314
 
 
28315
/* Line 1455 of yacc.c  */
27157
28316
#line 4312 "preproc.y"
27158
28317
    { 
27159
 
 yyval.str = cat_str(4,make_str("comment on text search parser"),yyvsp[-2].str,make_str("is"),yyvsp[0].str);
 
28318
 (yyval.str) = cat_str(4,make_str("comment on text search parser"),(yyvsp[(6) - (8)].str),make_str("is"),(yyvsp[(8) - (8)].str));
27160
28319
;}
27161
28320
    break;
27162
28321
 
27163
28322
  case 638:
 
28323
 
 
28324
/* Line 1455 of yacc.c  */
27164
28325
#line 4316 "preproc.y"
27165
28326
    { 
27166
 
 yyval.str = cat_str(4,make_str("comment on text search dictionary"),yyvsp[-2].str,make_str("is"),yyvsp[0].str);
 
28327
 (yyval.str) = cat_str(4,make_str("comment on text search dictionary"),(yyvsp[(6) - (8)].str),make_str("is"),(yyvsp[(8) - (8)].str));
27167
28328
;}
27168
28329
    break;
27169
28330
 
27170
28331
  case 639:
 
28332
 
 
28333
/* Line 1455 of yacc.c  */
27171
28334
#line 4320 "preproc.y"
27172
28335
    { 
27173
 
 yyval.str = cat_str(4,make_str("comment on text search template"),yyvsp[-2].str,make_str("is"),yyvsp[0].str);
 
28336
 (yyval.str) = cat_str(4,make_str("comment on text search template"),(yyvsp[(6) - (8)].str),make_str("is"),(yyvsp[(8) - (8)].str));
27174
28337
;}
27175
28338
    break;
27176
28339
 
27177
28340
  case 640:
 
28341
 
 
28342
/* Line 1455 of yacc.c  */
27178
28343
#line 4324 "preproc.y"
27179
28344
    { 
27180
 
 yyval.str = cat_str(4,make_str("comment on text search configuration"),yyvsp[-2].str,make_str("is"),yyvsp[0].str);
 
28345
 (yyval.str) = cat_str(4,make_str("comment on text search configuration"),(yyvsp[(6) - (8)].str),make_str("is"),(yyvsp[(8) - (8)].str));
27181
28346
;}
27182
28347
    break;
27183
28348
 
27184
28349
  case 641:
 
28350
 
 
28351
/* Line 1455 of yacc.c  */
27185
28352
#line 4332 "preproc.y"
27186
28353
    { 
27187
 
 yyval.str = make_str("column");
 
28354
 (yyval.str) = make_str("column");
27188
28355
;}
27189
28356
    break;
27190
28357
 
27191
28358
  case 642:
 
28359
 
 
28360
/* Line 1455 of yacc.c  */
27192
28361
#line 4336 "preproc.y"
27193
28362
    { 
27194
 
 yyval.str = make_str("database");
 
28363
 (yyval.str) = make_str("database");
27195
28364
;}
27196
28365
    break;
27197
28366
 
27198
28367
  case 643:
 
28368
 
 
28369
/* Line 1455 of yacc.c  */
27199
28370
#line 4340 "preproc.y"
27200
28371
    { 
27201
 
 yyval.str = make_str("schema");
 
28372
 (yyval.str) = make_str("schema");
27202
28373
;}
27203
28374
    break;
27204
28375
 
27205
28376
  case 644:
 
28377
 
 
28378
/* Line 1455 of yacc.c  */
27206
28379
#line 4344 "preproc.y"
27207
28380
    { 
27208
 
 yyval.str = make_str("index");
 
28381
 (yyval.str) = make_str("index");
27209
28382
;}
27210
28383
    break;
27211
28384
 
27212
28385
  case 645:
 
28386
 
 
28387
/* Line 1455 of yacc.c  */
27213
28388
#line 4348 "preproc.y"
27214
28389
    { 
27215
 
 yyval.str = make_str("sequence");
 
28390
 (yyval.str) = make_str("sequence");
27216
28391
;}
27217
28392
    break;
27218
28393
 
27219
28394
  case 646:
 
28395
 
 
28396
/* Line 1455 of yacc.c  */
27220
28397
#line 4352 "preproc.y"
27221
28398
    { 
27222
 
 yyval.str = make_str("table");
 
28399
 (yyval.str) = make_str("table");
27223
28400
;}
27224
28401
    break;
27225
28402
 
27226
28403
  case 647:
 
28404
 
 
28405
/* Line 1455 of yacc.c  */
27227
28406
#line 4356 "preproc.y"
27228
28407
    { 
27229
 
 yyval.str = make_str("domain");
 
28408
 (yyval.str) = make_str("domain");
27230
28409
;}
27231
28410
    break;
27232
28411
 
27233
28412
  case 648:
 
28413
 
 
28414
/* Line 1455 of yacc.c  */
27234
28415
#line 4360 "preproc.y"
27235
28416
    { 
27236
 
 yyval.str = make_str("type");
 
28417
 (yyval.str) = make_str("type");
27237
28418
;}
27238
28419
    break;
27239
28420
 
27240
28421
  case 649:
 
28422
 
 
28423
/* Line 1455 of yacc.c  */
27241
28424
#line 4364 "preproc.y"
27242
28425
    { 
27243
 
 yyval.str = make_str("view");
 
28426
 (yyval.str) = make_str("view");
27244
28427
;}
27245
28428
    break;
27246
28429
 
27247
28430
  case 650:
 
28431
 
 
28432
/* Line 1455 of yacc.c  */
27248
28433
#line 4368 "preproc.y"
27249
28434
    { 
27250
 
 yyval.str = make_str("conversion");
 
28435
 (yyval.str) = make_str("conversion");
27251
28436
;}
27252
28437
    break;
27253
28438
 
27254
28439
  case 651:
 
28440
 
 
28441
/* Line 1455 of yacc.c  */
27255
28442
#line 4372 "preproc.y"
27256
28443
    { 
27257
 
 yyval.str = make_str("tablespace");
 
28444
 (yyval.str) = make_str("tablespace");
27258
28445
;}
27259
28446
    break;
27260
28447
 
27261
28448
  case 652:
 
28449
 
 
28450
/* Line 1455 of yacc.c  */
27262
28451
#line 4376 "preproc.y"
27263
28452
    { 
27264
 
 yyval.str = make_str("role");
 
28453
 (yyval.str) = make_str("role");
27265
28454
;}
27266
28455
    break;
27267
28456
 
27268
28457
  case 653:
 
28458
 
 
28459
/* Line 1455 of yacc.c  */
27269
28460
#line 4384 "preproc.y"
27270
28461
    { 
27271
 
 yyval.str = yyvsp[0].str;
 
28462
 (yyval.str) = (yyvsp[(1) - (1)].str);
27272
28463
;}
27273
28464
    break;
27274
28465
 
27275
28466
  case 654:
 
28467
 
 
28468
/* Line 1455 of yacc.c  */
27276
28469
#line 4388 "preproc.y"
27277
28470
    { 
27278
 
 yyval.str = make_str("null");
 
28471
 (yyval.str) = make_str("null");
27279
28472
;}
27280
28473
    break;
27281
28474
 
27282
28475
  case 655:
 
28476
 
 
28477
/* Line 1455 of yacc.c  */
27283
28478
#line 4396 "preproc.y"
27284
28479
    {
27285
 
                add_additional_variables(yyvsp[0].str, false);
27286
 
                yyval.str = cat_str(4, make_str("fetch"), yyvsp[-2].str, yyvsp[-1].str, yyvsp[0].str);
 
28480
                add_additional_variables((yyvsp[(4) - (4)].str), false);
 
28481
                (yyval.str) = cat_str(4, make_str("fetch"), (yyvsp[(2) - (4)].str), (yyvsp[(3) - (4)].str), (yyvsp[(4) - (4)].str));
27287
28482
        ;}
27288
28483
    break;
27289
28484
 
27290
28485
  case 656:
 
28486
 
 
28487
/* Line 1455 of yacc.c  */
27291
28488
#line 4401 "preproc.y"
27292
28489
    {
27293
 
                add_additional_variables(yyvsp[0].str, false);
27294
 
                yyval.str = cat_str(2, make_str("fetch"), yyvsp[0].str);
 
28490
                add_additional_variables((yyvsp[(2) - (2)].str), false);
 
28491
                (yyval.str) = cat_str(2, make_str("fetch"), (yyvsp[(2) - (2)].str));
27295
28492
        ;}
27296
28493
    break;
27297
28494
 
27298
28495
  case 657:
 
28496
 
 
28497
/* Line 1455 of yacc.c  */
27299
28498
#line 4406 "preproc.y"
27300
28499
    { 
27301
 
 yyval.str = cat_str(4,make_str("move"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
28500
 (yyval.str) = cat_str(4,make_str("move"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
27302
28501
;}
27303
28502
    break;
27304
28503
 
27305
28504
  case 658:
 
28505
 
 
28506
/* Line 1455 of yacc.c  */
27306
28507
#line 4410 "preproc.y"
27307
28508
    { 
27308
 
 yyval.str = cat_str(2,make_str("move"),yyvsp[0].str);
 
28509
 (yyval.str) = cat_str(2,make_str("move"),(yyvsp[(2) - (2)].str));
27309
28510
;}
27310
28511
    break;
27311
28512
 
27312
28513
  case 659:
 
28514
 
 
28515
/* Line 1455 of yacc.c  */
27313
28516
#line 4414 "preproc.y"
27314
28517
    {
27315
 
                        add_additional_variables(yyvsp[-1].str, false);
27316
 
                        yyval.str = cat_str(4, make_str("fetch"), yyvsp[-3].str, yyvsp[-2].str, yyvsp[-1].str);
 
28518
                        add_additional_variables((yyvsp[(4) - (5)].str), false);
 
28519
                        (yyval.str) = cat_str(4, make_str("fetch"), (yyvsp[(2) - (5)].str), (yyvsp[(3) - (5)].str), (yyvsp[(4) - (5)].str));
27317
28520
                ;}
27318
28521
    break;
27319
28522
 
27320
28523
  case 660:
 
28524
 
 
28525
/* Line 1455 of yacc.c  */
27321
28526
#line 4419 "preproc.y"
27322
28527
    {
27323
 
                        add_additional_variables(yyvsp[-1].str, false);
27324
 
                        yyval.str = cat_str(4, make_str("fetch"), yyvsp[-2].str, make_str("from"), yyvsp[-1].str);
 
28528
                        add_additional_variables((yyvsp[(3) - (4)].str), false);
 
28529
                        (yyval.str) = cat_str(4, make_str("fetch"), (yyvsp[(2) - (4)].str), make_str("from"), (yyvsp[(3) - (4)].str));
27325
28530
                ;}
27326
28531
    break;
27327
28532
 
27328
28533
  case 661:
 
28534
 
 
28535
/* Line 1455 of yacc.c  */
27329
28536
#line 4424 "preproc.y"
27330
28537
    {
27331
 
                        add_additional_variables(yyvsp[-1].str, false);
27332
 
                        yyval.str = cat_str(3, make_str("fetch"), yyvsp[-2].str, yyvsp[-1].str);
 
28538
                        add_additional_variables((yyvsp[(3) - (4)].str), false);
 
28539
                        (yyval.str) = cat_str(3, make_str("fetch"), (yyvsp[(2) - (4)].str), (yyvsp[(3) - (4)].str));
27333
28540
                ;}
27334
28541
    break;
27335
28542
 
27336
28543
  case 662:
 
28544
 
 
28545
/* Line 1455 of yacc.c  */
27337
28546
#line 4429 "preproc.y"
27338
28547
    {
27339
 
                        add_additional_variables(yyvsp[-1].str, false);
27340
 
                        yyval.str = cat2_str(make_str("fetch"), yyvsp[-1].str);
 
28548
                        add_additional_variables((yyvsp[(2) - (3)].str), false);
 
28549
                        (yyval.str) = cat2_str(make_str("fetch"), (yyvsp[(2) - (3)].str));
27341
28550
                ;}
27342
28551
    break;
27343
28552
 
27344
28553
  case 663:
 
28554
 
 
28555
/* Line 1455 of yacc.c  */
27345
28556
#line 4434 "preproc.y"
27346
28557
    {
27347
 
                        add_additional_variables(yyvsp[0].str, false);
27348
 
                        yyval.str = cat_str(4, make_str("fetch"), yyvsp[-1].str, make_str("from"), yyvsp[0].str);
 
28558
                        add_additional_variables((yyvsp[(3) - (3)].str), false);
 
28559
                        (yyval.str) = cat_str(4, make_str("fetch"), (yyvsp[(2) - (3)].str), make_str("from"), (yyvsp[(3) - (3)].str));
27349
28560
                ;}
27350
28561
    break;
27351
28562
 
27352
28563
  case 664:
 
28564
 
 
28565
/* Line 1455 of yacc.c  */
27353
28566
#line 4439 "preproc.y"
27354
28567
    {
27355
 
                        add_additional_variables(yyvsp[0].str, false);
27356
 
                        yyval.str = cat_str(3, make_str("fetch"), yyvsp[-1].str, yyvsp[0].str);
 
28568
                        add_additional_variables((yyvsp[(3) - (3)].str), false);
 
28569
                        (yyval.str) = cat_str(3, make_str("fetch"), (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str));
27357
28570
                ;}
27358
28571
    break;
27359
28572
 
27360
28573
  case 665:
 
28574
 
 
28575
/* Line 1455 of yacc.c  */
27361
28576
#line 4448 "preproc.y"
27362
28577
    { 
27363
 
 yyval.str = make_str("next");
 
28578
 (yyval.str) = make_str("next");
27364
28579
;}
27365
28580
    break;
27366
28581
 
27367
28582
  case 666:
 
28583
 
 
28584
/* Line 1455 of yacc.c  */
27368
28585
#line 4452 "preproc.y"
27369
28586
    { 
27370
 
 yyval.str = make_str("prior");
 
28587
 (yyval.str) = make_str("prior");
27371
28588
;}
27372
28589
    break;
27373
28590
 
27374
28591
  case 667:
 
28592
 
 
28593
/* Line 1455 of yacc.c  */
27375
28594
#line 4456 "preproc.y"
27376
28595
    { 
27377
 
 yyval.str = make_str("first");
 
28596
 (yyval.str) = make_str("first");
27378
28597
;}
27379
28598
    break;
27380
28599
 
27381
28600
  case 668:
 
28601
 
 
28602
/* Line 1455 of yacc.c  */
27382
28603
#line 4460 "preproc.y"
27383
28604
    { 
27384
 
 yyval.str = make_str("last");
 
28605
 (yyval.str) = make_str("last");
27385
28606
;}
27386
28607
    break;
27387
28608
 
27388
28609
  case 669:
 
28610
 
 
28611
/* Line 1455 of yacc.c  */
27389
28612
#line 4464 "preproc.y"
27390
28613
    { 
27391
 
                if (yyvsp[0].str[0] == '$')
 
28614
                if ((yyvsp[(2) - (2)].str)[0] == '$')
27392
28615
                {
27393
 
                        free(yyvsp[0].str);
27394
 
                        yyvsp[0].str = make_str("$0");
 
28616
                        free((yyvsp[(2) - (2)].str));
 
28617
                        (yyvsp[(2) - (2)].str) = make_str("$0");
27395
28618
                }
27396
28619
 
27397
 
 yyval.str = cat_str(2,make_str("absolute"),yyvsp[0].str);
 
28620
 (yyval.str) = cat_str(2,make_str("absolute"),(yyvsp[(2) - (2)].str));
27398
28621
;}
27399
28622
    break;
27400
28623
 
27401
28624
  case 670:
 
28625
 
 
28626
/* Line 1455 of yacc.c  */
27402
28627
#line 4474 "preproc.y"
27403
28628
    { 
27404
 
                if (yyvsp[0].str[0] == '$')
 
28629
                if ((yyvsp[(2) - (2)].str)[0] == '$')
27405
28630
                {
27406
 
                        free(yyvsp[0].str);
27407
 
                        yyvsp[0].str = make_str("$0");
 
28631
                        free((yyvsp[(2) - (2)].str));
 
28632
                        (yyvsp[(2) - (2)].str) = make_str("$0");
27408
28633
                }
27409
28634
 
27410
 
 yyval.str = cat_str(2,make_str("relative"),yyvsp[0].str);
 
28635
 (yyval.str) = cat_str(2,make_str("relative"),(yyvsp[(2) - (2)].str));
27411
28636
;}
27412
28637
    break;
27413
28638
 
27414
28639
  case 671:
 
28640
 
 
28641
/* Line 1455 of yacc.c  */
27415
28642
#line 4484 "preproc.y"
27416
28643
    { 
27417
 
                if (yyvsp[0].str[0] == '$')
 
28644
                if ((yyvsp[(1) - (1)].str)[0] == '$')
27418
28645
                {
27419
 
                        free(yyvsp[0].str);
27420
 
                        yyvsp[0].str = make_str("$0");
 
28646
                        free((yyvsp[(1) - (1)].str));
 
28647
                        (yyvsp[(1) - (1)].str) = make_str("$0");
27421
28648
                }
27422
28649
 
27423
 
 yyval.str = yyvsp[0].str;
 
28650
 (yyval.str) = (yyvsp[(1) - (1)].str);
27424
28651
;}
27425
28652
    break;
27426
28653
 
27427
28654
  case 672:
 
28655
 
 
28656
/* Line 1455 of yacc.c  */
27428
28657
#line 4494 "preproc.y"
27429
28658
    { 
27430
 
 yyval.str = make_str("all");
 
28659
 (yyval.str) = make_str("all");
27431
28660
;}
27432
28661
    break;
27433
28662
 
27434
28663
  case 673:
 
28664
 
 
28665
/* Line 1455 of yacc.c  */
27435
28666
#line 4498 "preproc.y"
27436
28667
    { 
27437
 
 yyval.str = make_str("forward");
 
28668
 (yyval.str) = make_str("forward");
27438
28669
;}
27439
28670
    break;
27440
28671
 
27441
28672
  case 674:
 
28673
 
 
28674
/* Line 1455 of yacc.c  */
27442
28675
#line 4502 "preproc.y"
27443
28676
    { 
27444
 
                if (yyvsp[0].str[0] == '$')
 
28677
                if ((yyvsp[(2) - (2)].str)[0] == '$')
27445
28678
                {
27446
 
                        free(yyvsp[0].str);
27447
 
                        yyvsp[0].str = make_str("$0");
 
28679
                        free((yyvsp[(2) - (2)].str));
 
28680
                        (yyvsp[(2) - (2)].str) = make_str("$0");
27448
28681
                }
27449
28682
 
27450
 
 yyval.str = cat_str(2,make_str("forward"),yyvsp[0].str);
 
28683
 (yyval.str) = cat_str(2,make_str("forward"),(yyvsp[(2) - (2)].str));
27451
28684
;}
27452
28685
    break;
27453
28686
 
27454
28687
  case 675:
 
28688
 
 
28689
/* Line 1455 of yacc.c  */
27455
28690
#line 4512 "preproc.y"
27456
28691
    { 
27457
 
 yyval.str = make_str("forward all");
 
28692
 (yyval.str) = make_str("forward all");
27458
28693
;}
27459
28694
    break;
27460
28695
 
27461
28696
  case 676:
 
28697
 
 
28698
/* Line 1455 of yacc.c  */
27462
28699
#line 4516 "preproc.y"
27463
28700
    { 
27464
 
 yyval.str = make_str("backward");
 
28701
 (yyval.str) = make_str("backward");
27465
28702
;}
27466
28703
    break;
27467
28704
 
27468
28705
  case 677:
 
28706
 
 
28707
/* Line 1455 of yacc.c  */
27469
28708
#line 4520 "preproc.y"
27470
28709
    { 
27471
 
                if (yyvsp[0].str[0] == '$')
 
28710
                if ((yyvsp[(2) - (2)].str)[0] == '$')
27472
28711
                {
27473
 
                        free(yyvsp[0].str);
27474
 
                        yyvsp[0].str = make_str("$0");
 
28712
                        free((yyvsp[(2) - (2)].str));
 
28713
                        (yyvsp[(2) - (2)].str) = make_str("$0");
27475
28714
                }
27476
28715
 
27477
 
 yyval.str = cat_str(2,make_str("backward"),yyvsp[0].str);
 
28716
 (yyval.str) = cat_str(2,make_str("backward"),(yyvsp[(2) - (2)].str));
27478
28717
;}
27479
28718
    break;
27480
28719
 
27481
28720
  case 678:
 
28721
 
 
28722
/* Line 1455 of yacc.c  */
27482
28723
#line 4530 "preproc.y"
27483
28724
    { 
27484
 
 yyval.str = make_str("backward all");
 
28725
 (yyval.str) = make_str("backward all");
27485
28726
;}
27486
28727
    break;
27487
28728
 
27488
28729
  case 679:
 
28730
 
 
28731
/* Line 1455 of yacc.c  */
27489
28732
#line 4538 "preproc.y"
27490
28733
    { 
27491
 
 yyval.str = make_str("from");
 
28734
 (yyval.str) = make_str("from");
27492
28735
;}
27493
28736
    break;
27494
28737
 
27495
28738
  case 680:
 
28739
 
 
28740
/* Line 1455 of yacc.c  */
27496
28741
#line 4542 "preproc.y"
27497
28742
    { 
27498
 
 yyval.str = make_str("in");
 
28743
 (yyval.str) = make_str("in");
27499
28744
;}
27500
28745
    break;
27501
28746
 
27502
28747
  case 681:
 
28748
 
 
28749
/* Line 1455 of yacc.c  */
27503
28750
#line 4550 "preproc.y"
27504
28751
    { 
27505
 
 yyval.str = cat_str(7,make_str("grant"),yyvsp[-5].str,make_str("on"),yyvsp[-3].str,make_str("to"),yyvsp[-1].str,yyvsp[0].str);
 
28752
 (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));
27506
28753
;}
27507
28754
    break;
27508
28755
 
27509
28756
  case 682:
 
28757
 
 
28758
/* Line 1455 of yacc.c  */
27510
28759
#line 4558 "preproc.y"
27511
28760
    { 
27512
 
 yyval.str = cat_str(7,make_str("revoke"),yyvsp[-5].str,make_str("on"),yyvsp[-3].str,make_str("from"),yyvsp[-1].str,yyvsp[0].str);
 
28761
 (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));
27513
28762
;}
27514
28763
    break;
27515
28764
 
27516
28765
  case 683:
 
28766
 
 
28767
/* Line 1455 of yacc.c  */
27517
28768
#line 4562 "preproc.y"
27518
28769
    { 
27519
 
 yyval.str = cat_str(7,make_str("revoke grant option for"),yyvsp[-5].str,make_str("on"),yyvsp[-3].str,make_str("from"),yyvsp[-1].str,yyvsp[0].str);
 
28770
 (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));
27520
28771
;}
27521
28772
    break;
27522
28773
 
27523
28774
  case 684:
 
28775
 
 
28776
/* Line 1455 of yacc.c  */
27524
28777
#line 4570 "preproc.y"
27525
28778
    { 
27526
 
 yyval.str = yyvsp[0].str;
 
28779
 (yyval.str) = (yyvsp[(1) - (1)].str);
27527
28780
;}
27528
28781
    break;
27529
28782
 
27530
28783
  case 685:
 
28784
 
 
28785
/* Line 1455 of yacc.c  */
27531
28786
#line 4574 "preproc.y"
27532
28787
    { 
27533
 
 yyval.str = make_str("all");
 
28788
 (yyval.str) = make_str("all");
27534
28789
;}
27535
28790
    break;
27536
28791
 
27537
28792
  case 686:
 
28793
 
 
28794
/* Line 1455 of yacc.c  */
27538
28795
#line 4578 "preproc.y"
27539
28796
    { 
27540
 
 yyval.str = make_str("all privileges");
 
28797
 (yyval.str) = make_str("all privileges");
27541
28798
;}
27542
28799
    break;
27543
28800
 
27544
28801
  case 687:
 
28802
 
 
28803
/* Line 1455 of yacc.c  */
27545
28804
#line 4582 "preproc.y"
27546
28805
    { 
27547
 
 yyval.str = cat_str(3,make_str("all ("),yyvsp[-1].str,make_str(")"));
 
28806
 (yyval.str) = cat_str(3,make_str("all ("),(yyvsp[(3) - (4)].str),make_str(")"));
27548
28807
;}
27549
28808
    break;
27550
28809
 
27551
28810
  case 688:
 
28811
 
 
28812
/* Line 1455 of yacc.c  */
27552
28813
#line 4586 "preproc.y"
27553
28814
    { 
27554
 
 yyval.str = cat_str(3,make_str("all privileges ("),yyvsp[-1].str,make_str(")"));
 
28815
 (yyval.str) = cat_str(3,make_str("all privileges ("),(yyvsp[(4) - (5)].str),make_str(")"));
27555
28816
;}
27556
28817
    break;
27557
28818
 
27558
28819
  case 689:
 
28820
 
 
28821
/* Line 1455 of yacc.c  */
27559
28822
#line 4594 "preproc.y"
27560
28823
    { 
27561
 
 yyval.str = yyvsp[0].str;
 
28824
 (yyval.str) = (yyvsp[(1) - (1)].str);
27562
28825
;}
27563
28826
    break;
27564
28827
 
27565
28828
  case 690:
 
28829
 
 
28830
/* Line 1455 of yacc.c  */
27566
28831
#line 4598 "preproc.y"
27567
28832
    { 
27568
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
28833
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
27569
28834
;}
27570
28835
    break;
27571
28836
 
27572
28837
  case 691:
 
28838
 
 
28839
/* Line 1455 of yacc.c  */
27573
28840
#line 4606 "preproc.y"
27574
28841
    { 
27575
 
 yyval.str = cat_str(2,make_str("select"),yyvsp[0].str);
 
28842
 (yyval.str) = cat_str(2,make_str("select"),(yyvsp[(2) - (2)].str));
27576
28843
;}
27577
28844
    break;
27578
28845
 
27579
28846
  case 692:
 
28847
 
 
28848
/* Line 1455 of yacc.c  */
27580
28849
#line 4610 "preproc.y"
27581
28850
    { 
27582
 
 yyval.str = cat_str(2,make_str("references"),yyvsp[0].str);
 
28851
 (yyval.str) = cat_str(2,make_str("references"),(yyvsp[(2) - (2)].str));
27583
28852
;}
27584
28853
    break;
27585
28854
 
27586
28855
  case 693:
 
28856
 
 
28857
/* Line 1455 of yacc.c  */
27587
28858
#line 4614 "preproc.y"
27588
28859
    { 
27589
 
 yyval.str = cat_str(2,make_str("create"),yyvsp[0].str);
 
28860
 (yyval.str) = cat_str(2,make_str("create"),(yyvsp[(2) - (2)].str));
27590
28861
;}
27591
28862
    break;
27592
28863
 
27593
28864
  case 694:
 
28865
 
 
28866
/* Line 1455 of yacc.c  */
27594
28867
#line 4618 "preproc.y"
27595
28868
    { 
27596
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
28869
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
27597
28870
;}
27598
28871
    break;
27599
28872
 
27600
28873
  case 695:
 
28874
 
 
28875
/* Line 1455 of yacc.c  */
27601
28876
#line 4626 "preproc.y"
27602
28877
    { 
27603
 
 yyval.str = yyvsp[0].str;
 
28878
 (yyval.str) = (yyvsp[(1) - (1)].str);
27604
28879
;}
27605
28880
    break;
27606
28881
 
27607
28882
  case 696:
 
28883
 
 
28884
/* Line 1455 of yacc.c  */
27608
28885
#line 4630 "preproc.y"
27609
28886
    { 
27610
 
 yyval.str = cat_str(2,make_str("table"),yyvsp[0].str);
 
28887
 (yyval.str) = cat_str(2,make_str("table"),(yyvsp[(2) - (2)].str));
27611
28888
;}
27612
28889
    break;
27613
28890
 
27614
28891
  case 697:
 
28892
 
 
28893
/* Line 1455 of yacc.c  */
27615
28894
#line 4634 "preproc.y"
27616
28895
    { 
27617
 
 yyval.str = cat_str(2,make_str("sequence"),yyvsp[0].str);
 
28896
 (yyval.str) = cat_str(2,make_str("sequence"),(yyvsp[(2) - (2)].str));
27618
28897
;}
27619
28898
    break;
27620
28899
 
27621
28900
  case 698:
 
28901
 
 
28902
/* Line 1455 of yacc.c  */
27622
28903
#line 4638 "preproc.y"
27623
28904
    { 
27624
 
 yyval.str = cat_str(2,make_str("foreign data wrapper"),yyvsp[0].str);
 
28905
 (yyval.str) = cat_str(2,make_str("foreign data wrapper"),(yyvsp[(4) - (4)].str));
27625
28906
;}
27626
28907
    break;
27627
28908
 
27628
28909
  case 699:
 
28910
 
 
28911
/* Line 1455 of yacc.c  */
27629
28912
#line 4642 "preproc.y"
27630
28913
    { 
27631
 
 yyval.str = cat_str(2,make_str("foreign server"),yyvsp[0].str);
 
28914
 (yyval.str) = cat_str(2,make_str("foreign server"),(yyvsp[(3) - (3)].str));
27632
28915
;}
27633
28916
    break;
27634
28917
 
27635
28918
  case 700:
 
28919
 
 
28920
/* Line 1455 of yacc.c  */
27636
28921
#line 4646 "preproc.y"
27637
28922
    { 
27638
 
 yyval.str = cat_str(2,make_str("function"),yyvsp[0].str);
 
28923
 (yyval.str) = cat_str(2,make_str("function"),(yyvsp[(2) - (2)].str));
27639
28924
;}
27640
28925
    break;
27641
28926
 
27642
28927
  case 701:
 
28928
 
 
28929
/* Line 1455 of yacc.c  */
27643
28930
#line 4650 "preproc.y"
27644
28931
    { 
27645
 
 yyval.str = cat_str(2,make_str("database"),yyvsp[0].str);
 
28932
 (yyval.str) = cat_str(2,make_str("database"),(yyvsp[(2) - (2)].str));
27646
28933
;}
27647
28934
    break;
27648
28935
 
27649
28936
  case 702:
 
28937
 
 
28938
/* Line 1455 of yacc.c  */
27650
28939
#line 4654 "preproc.y"
27651
28940
    { 
27652
 
 yyval.str = cat_str(2,make_str("language"),yyvsp[0].str);
 
28941
 (yyval.str) = cat_str(2,make_str("language"),(yyvsp[(2) - (2)].str));
27653
28942
;}
27654
28943
    break;
27655
28944
 
27656
28945
  case 703:
 
28946
 
 
28947
/* Line 1455 of yacc.c  */
27657
28948
#line 4658 "preproc.y"
27658
28949
    { 
27659
 
 yyval.str = cat_str(2,make_str("schema"),yyvsp[0].str);
 
28950
 (yyval.str) = cat_str(2,make_str("schema"),(yyvsp[(2) - (2)].str));
27660
28951
;}
27661
28952
    break;
27662
28953
 
27663
28954
  case 704:
 
28955
 
 
28956
/* Line 1455 of yacc.c  */
27664
28957
#line 4662 "preproc.y"
27665
28958
    { 
27666
 
 yyval.str = cat_str(2,make_str("tablespace"),yyvsp[0].str);
 
28959
 (yyval.str) = cat_str(2,make_str("tablespace"),(yyvsp[(2) - (2)].str));
27667
28960
;}
27668
28961
    break;
27669
28962
 
27670
28963
  case 705:
 
28964
 
 
28965
/* Line 1455 of yacc.c  */
27671
28966
#line 4670 "preproc.y"
27672
28967
    { 
27673
 
 yyval.str = yyvsp[0].str;
 
28968
 (yyval.str) = (yyvsp[(1) - (1)].str);
27674
28969
;}
27675
28970
    break;
27676
28971
 
27677
28972
  case 706:
 
28973
 
 
28974
/* Line 1455 of yacc.c  */
27678
28975
#line 4674 "preproc.y"
27679
28976
    { 
27680
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
28977
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
27681
28978
;}
27682
28979
    break;
27683
28980
 
27684
28981
  case 707:
 
28982
 
 
28983
/* Line 1455 of yacc.c  */
27685
28984
#line 4682 "preproc.y"
27686
28985
    { 
27687
 
 yyval.str = yyvsp[0].str;
 
28986
 (yyval.str) = (yyvsp[(1) - (1)].str);
27688
28987
;}
27689
28988
    break;
27690
28989
 
27691
28990
  case 708:
 
28991
 
 
28992
/* Line 1455 of yacc.c  */
27692
28993
#line 4686 "preproc.y"
27693
28994
    { 
27694
 
 yyval.str = cat_str(2,make_str("group"),yyvsp[0].str);
 
28995
 (yyval.str) = cat_str(2,make_str("group"),(yyvsp[(2) - (2)].str));
27695
28996
;}
27696
28997
    break;
27697
28998
 
27698
28999
  case 709:
 
29000
 
 
29001
/* Line 1455 of yacc.c  */
27699
29002
#line 4694 "preproc.y"
27700
29003
    { 
27701
 
 yyval.str = make_str("with grant option");
 
29004
 (yyval.str) = make_str("with grant option");
27702
29005
;}
27703
29006
    break;
27704
29007
 
27705
29008
  case 710:
 
29009
 
 
29010
/* Line 1455 of yacc.c  */
27706
29011
#line 4698 "preproc.y"
27707
29012
    { 
27708
 
 yyval.str=EMPTY; ;}
 
29013
 (yyval.str)=EMPTY; ;}
27709
29014
    break;
27710
29015
 
27711
29016
  case 711:
 
29017
 
 
29018
/* Line 1455 of yacc.c  */
27712
29019
#line 4705 "preproc.y"
27713
29020
    { 
27714
 
 yyval.str = yyvsp[0].str;
 
29021
 (yyval.str) = (yyvsp[(1) - (1)].str);
27715
29022
;}
27716
29023
    break;
27717
29024
 
27718
29025
  case 712:
 
29026
 
 
29027
/* Line 1455 of yacc.c  */
27719
29028
#line 4709 "preproc.y"
27720
29029
    { 
27721
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
29030
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
27722
29031
;}
27723
29032
    break;
27724
29033
 
27725
29034
  case 713:
 
29035
 
 
29036
/* Line 1455 of yacc.c  */
27726
29037
#line 4717 "preproc.y"
27727
29038
    { 
27728
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
29039
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
27729
29040
;}
27730
29041
    break;
27731
29042
 
27732
29043
  case 714:
 
29044
 
 
29045
/* Line 1455 of yacc.c  */
27733
29046
#line 4725 "preproc.y"
27734
29047
    { 
27735
 
 yyval.str = cat_str(6,make_str("grant"),yyvsp[-4].str,make_str("to"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29048
 (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));
27736
29049
;}
27737
29050
    break;
27738
29051
 
27739
29052
  case 715:
 
29053
 
 
29054
/* Line 1455 of yacc.c  */
27740
29055
#line 4733 "preproc.y"
27741
29056
    { 
27742
 
 yyval.str = cat_str(6,make_str("revoke"),yyvsp[-4].str,make_str("from"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29057
 (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));
27743
29058
;}
27744
29059
    break;
27745
29060
 
27746
29061
  case 716:
 
29062
 
 
29063
/* Line 1455 of yacc.c  */
27747
29064
#line 4737 "preproc.y"
27748
29065
    { 
27749
 
 yyval.str = cat_str(6,make_str("revoke admin option for"),yyvsp[-4].str,make_str("from"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29066
 (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));
27750
29067
;}
27751
29068
    break;
27752
29069
 
27753
29070
  case 717:
 
29071
 
 
29072
/* Line 1455 of yacc.c  */
27754
29073
#line 4745 "preproc.y"
27755
29074
    { 
27756
 
 yyval.str = make_str("with admin option");
 
29075
 (yyval.str) = make_str("with admin option");
27757
29076
;}
27758
29077
    break;
27759
29078
 
27760
29079
  case 718:
 
29080
 
 
29081
/* Line 1455 of yacc.c  */
27761
29082
#line 4749 "preproc.y"
27762
29083
    { 
27763
 
 yyval.str=EMPTY; ;}
 
29084
 (yyval.str)=EMPTY; ;}
27764
29085
    break;
27765
29086
 
27766
29087
  case 719:
 
29088
 
 
29089
/* Line 1455 of yacc.c  */
27767
29090
#line 4756 "preproc.y"
27768
29091
    { 
27769
 
 yyval.str = cat_str(2,make_str("granted by"),yyvsp[0].str);
 
29092
 (yyval.str) = cat_str(2,make_str("granted by"),(yyvsp[(3) - (3)].str));
27770
29093
;}
27771
29094
    break;
27772
29095
 
27773
29096
  case 720:
 
29097
 
 
29098
/* Line 1455 of yacc.c  */
27774
29099
#line 4760 "preproc.y"
27775
29100
    { 
27776
 
 yyval.str=EMPTY; ;}
 
29101
 (yyval.str)=EMPTY; ;}
27777
29102
    break;
27778
29103
 
27779
29104
  case 721:
 
29105
 
 
29106
/* Line 1455 of yacc.c  */
27780
29107
#line 4767 "preproc.y"
27781
29108
    { 
27782
 
 yyval.str = cat_str(13,make_str("create"),yyvsp[-11].str,make_str("index"),yyvsp[-9].str,make_str("on"),yyvsp[-7].str,yyvsp[-6].str,make_str("("),yyvsp[-4].str,make_str(")"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29109
 (yyval.str) = cat_str(13,make_str("create"),(yyvsp[(2) - (13)].str),make_str("index"),(yyvsp[(4) - (13)].str),make_str("on"),(yyvsp[(6) - (13)].str),(yyvsp[(7) - (13)].str),make_str("("),(yyvsp[(9) - (13)].str),make_str(")"),(yyvsp[(11) - (13)].str),(yyvsp[(12) - (13)].str),(yyvsp[(13) - (13)].str));
27783
29110
;}
27784
29111
    break;
27785
29112
 
27786
29113
  case 722:
 
29114
 
 
29115
/* Line 1455 of yacc.c  */
27787
29116
#line 4771 "preproc.y"
27788
29117
    { 
27789
 
 yyval.str = cat_str(13,make_str("create"),yyvsp[-12].str,make_str("index concurrently"),yyvsp[-9].str,make_str("on"),yyvsp[-7].str,yyvsp[-6].str,make_str("("),yyvsp[-4].str,make_str(")"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29118
 (yyval.str) = cat_str(13,make_str("create"),(yyvsp[(2) - (14)].str),make_str("index concurrently"),(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));
27790
29119
;}
27791
29120
    break;
27792
29121
 
27793
29122
  case 723:
 
29123
 
 
29124
/* Line 1455 of yacc.c  */
27794
29125
#line 4779 "preproc.y"
27795
29126
    { 
27796
 
 yyval.str = make_str("unique");
 
29127
 (yyval.str) = make_str("unique");
27797
29128
;}
27798
29129
    break;
27799
29130
 
27800
29131
  case 724:
 
29132
 
 
29133
/* Line 1455 of yacc.c  */
27801
29134
#line 4783 "preproc.y"
27802
29135
    { 
27803
 
 yyval.str=EMPTY; ;}
 
29136
 (yyval.str)=EMPTY; ;}
27804
29137
    break;
27805
29138
 
27806
29139
  case 725:
 
29140
 
 
29141
/* Line 1455 of yacc.c  */
27807
29142
#line 4790 "preproc.y"
27808
29143
    { 
27809
 
 yyval.str = cat_str(2,make_str("using"),yyvsp[0].str);
 
29144
 (yyval.str) = cat_str(2,make_str("using"),(yyvsp[(2) - (2)].str));
27810
29145
;}
27811
29146
    break;
27812
29147
 
27813
29148
  case 726:
 
29149
 
 
29150
/* Line 1455 of yacc.c  */
27814
29151
#line 4794 "preproc.y"
27815
29152
    { 
27816
 
 yyval.str=EMPTY; ;}
 
29153
 (yyval.str)=EMPTY; ;}
27817
29154
    break;
27818
29155
 
27819
29156
  case 727:
 
29157
 
 
29158
/* Line 1455 of yacc.c  */
27820
29159
#line 4801 "preproc.y"
27821
29160
    { 
27822
 
 yyval.str = yyvsp[0].str;
 
29161
 (yyval.str) = (yyvsp[(1) - (1)].str);
27823
29162
;}
27824
29163
    break;
27825
29164
 
27826
29165
  case 728:
 
29166
 
 
29167
/* Line 1455 of yacc.c  */
27827
29168
#line 4805 "preproc.y"
27828
29169
    { 
27829
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
29170
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
27830
29171
;}
27831
29172
    break;
27832
29173
 
27833
29174
  case 729:
 
29175
 
 
29176
/* Line 1455 of yacc.c  */
27834
29177
#line 4813 "preproc.y"
27835
29178
    { 
27836
 
 yyval.str = cat_str(4,yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29179
 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
27837
29180
;}
27838
29181
    break;
27839
29182
 
27840
29183
  case 730:
 
29184
 
 
29185
/* Line 1455 of yacc.c  */
27841
29186
#line 4817 "preproc.y"
27842
29187
    { 
27843
 
 yyval.str = cat_str(4,yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29188
 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
27844
29189
;}
27845
29190
    break;
27846
29191
 
27847
29192
  case 731:
 
29193
 
 
29194
/* Line 1455 of yacc.c  */
27848
29195
#line 4821 "preproc.y"
27849
29196
    { 
27850
 
 yyval.str = cat_str(6,make_str("("),yyvsp[-4].str,make_str(")"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29197
 (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));
27851
29198
;}
27852
29199
    break;
27853
29200
 
27854
29201
  case 732:
 
29202
 
 
29203
/* Line 1455 of yacc.c  */
27855
29204
#line 4829 "preproc.y"
27856
29205
    { 
27857
 
 yyval.str = yyvsp[0].str;
 
29206
 (yyval.str) = (yyvsp[(1) - (1)].str);
27858
29207
;}
27859
29208
    break;
27860
29209
 
27861
29210
  case 733:
 
29211
 
 
29212
/* Line 1455 of yacc.c  */
27862
29213
#line 4833 "preproc.y"
27863
29214
    { 
27864
 
 yyval.str = cat_str(2,make_str("using"),yyvsp[0].str);
 
29215
 (yyval.str) = cat_str(2,make_str("using"),(yyvsp[(2) - (2)].str));
27865
29216
;}
27866
29217
    break;
27867
29218
 
27868
29219
  case 734:
 
29220
 
 
29221
/* Line 1455 of yacc.c  */
27869
29222
#line 4837 "preproc.y"
27870
29223
    { 
27871
 
 yyval.str=EMPTY; ;}
 
29224
 (yyval.str)=EMPTY; ;}
27872
29225
    break;
27873
29226
 
27874
29227
  case 735:
 
29228
 
 
29229
/* Line 1455 of yacc.c  */
27875
29230
#line 4844 "preproc.y"
27876
29231
    { 
27877
 
 yyval.str = make_str("asc");
 
29232
 (yyval.str) = make_str("asc");
27878
29233
;}
27879
29234
    break;
27880
29235
 
27881
29236
  case 736:
 
29237
 
 
29238
/* Line 1455 of yacc.c  */
27882
29239
#line 4848 "preproc.y"
27883
29240
    { 
27884
 
 yyval.str = make_str("desc");
 
29241
 (yyval.str) = make_str("desc");
27885
29242
;}
27886
29243
    break;
27887
29244
 
27888
29245
  case 737:
 
29246
 
 
29247
/* Line 1455 of yacc.c  */
27889
29248
#line 4852 "preproc.y"
27890
29249
    { 
27891
 
 yyval.str=EMPTY; ;}
 
29250
 (yyval.str)=EMPTY; ;}
27892
29251
    break;
27893
29252
 
27894
29253
  case 738:
 
29254
 
 
29255
/* Line 1455 of yacc.c  */
27895
29256
#line 4859 "preproc.y"
27896
29257
    { 
27897
 
 yyval.str = make_str("nulls first");
 
29258
 (yyval.str) = make_str("nulls first");
27898
29259
;}
27899
29260
    break;
27900
29261
 
27901
29262
  case 739:
 
29263
 
 
29264
/* Line 1455 of yacc.c  */
27902
29265
#line 4863 "preproc.y"
27903
29266
    { 
27904
 
 yyval.str = make_str("nulls last");
 
29267
 (yyval.str) = make_str("nulls last");
27905
29268
;}
27906
29269
    break;
27907
29270
 
27908
29271
  case 740:
 
29272
 
 
29273
/* Line 1455 of yacc.c  */
27909
29274
#line 4867 "preproc.y"
27910
29275
    { 
27911
 
 yyval.str=EMPTY; ;}
 
29276
 (yyval.str)=EMPTY; ;}
27912
29277
    break;
27913
29278
 
27914
29279
  case 741:
 
29280
 
 
29281
/* Line 1455 of yacc.c  */
27915
29282
#line 4874 "preproc.y"
27916
29283
    { 
27917
 
 yyval.str = cat_str(9,make_str("create"),yyvsp[-7].str,make_str("function"),yyvsp[-5].str,yyvsp[-4].str,make_str("returns"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29284
 (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));
27918
29285
;}
27919
29286
    break;
27920
29287
 
27921
29288
  case 742:
 
29289
 
 
29290
/* Line 1455 of yacc.c  */
27922
29291
#line 4878 "preproc.y"
27923
29292
    { 
27924
 
 yyval.str = cat_str(10,make_str("create"),yyvsp[-10].str,make_str("function"),yyvsp[-8].str,yyvsp[-7].str,make_str("returns table ("),yyvsp[-3].str,make_str(")"),yyvsp[-1].str,yyvsp[0].str);
 
29293
 (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));
27925
29294
;}
27926
29295
    break;
27927
29296
 
27928
29297
  case 743:
 
29298
 
 
29299
/* Line 1455 of yacc.c  */
27929
29300
#line 4882 "preproc.y"
27930
29301
    { 
27931
 
 yyval.str = cat_str(7,make_str("create"),yyvsp[-5].str,make_str("function"),yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29302
 (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));
27932
29303
;}
27933
29304
    break;
27934
29305
 
27935
29306
  case 744:
 
29307
 
 
29308
/* Line 1455 of yacc.c  */
27936
29309
#line 4890 "preproc.y"
27937
29310
    { 
27938
 
 yyval.str = make_str("or replace");
 
29311
 (yyval.str) = make_str("or replace");
27939
29312
;}
27940
29313
    break;
27941
29314
 
27942
29315
  case 745:
 
29316
 
 
29317
/* Line 1455 of yacc.c  */
27943
29318
#line 4894 "preproc.y"
27944
29319
    { 
27945
 
 yyval.str=EMPTY; ;}
 
29320
 (yyval.str)=EMPTY; ;}
27946
29321
    break;
27947
29322
 
27948
29323
  case 746:
 
29324
 
 
29325
/* Line 1455 of yacc.c  */
27949
29326
#line 4901 "preproc.y"
27950
29327
    { 
27951
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
29328
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
27952
29329
;}
27953
29330
    break;
27954
29331
 
27955
29332
  case 747:
 
29333
 
 
29334
/* Line 1455 of yacc.c  */
27956
29335
#line 4905 "preproc.y"
27957
29336
    { 
27958
 
 yyval.str = make_str("( )");
 
29337
 (yyval.str) = make_str("( )");
27959
29338
;}
27960
29339
    break;
27961
29340
 
27962
29341
  case 748:
 
29342
 
 
29343
/* Line 1455 of yacc.c  */
27963
29344
#line 4913 "preproc.y"
27964
29345
    { 
27965
 
 yyval.str = yyvsp[0].str;
 
29346
 (yyval.str) = (yyvsp[(1) - (1)].str);
27966
29347
;}
27967
29348
    break;
27968
29349
 
27969
29350
  case 749:
 
29351
 
 
29352
/* Line 1455 of yacc.c  */
27970
29353
#line 4917 "preproc.y"
27971
29354
    { 
27972
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
29355
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
27973
29356
;}
27974
29357
    break;
27975
29358
 
27976
29359
  case 750:
 
29360
 
 
29361
/* Line 1455 of yacc.c  */
27977
29362
#line 4925 "preproc.y"
27978
29363
    { 
27979
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
29364
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
27980
29365
;}
27981
29366
    break;
27982
29367
 
27983
29368
  case 751:
 
29369
 
 
29370
/* Line 1455 of yacc.c  */
27984
29371
#line 4929 "preproc.y"
27985
29372
    { 
27986
 
 yyval.str = make_str("( )");
 
29373
 (yyval.str) = make_str("( )");
27987
29374
;}
27988
29375
    break;
27989
29376
 
27990
29377
  case 752:
 
29378
 
 
29379
/* Line 1455 of yacc.c  */
27991
29380
#line 4937 "preproc.y"
27992
29381
    { 
27993
 
 yyval.str = yyvsp[0].str;
 
29382
 (yyval.str) = (yyvsp[(1) - (1)].str);
27994
29383
;}
27995
29384
    break;
27996
29385
 
27997
29386
  case 753:
 
29387
 
 
29388
/* Line 1455 of yacc.c  */
27998
29389
#line 4941 "preproc.y"
27999
29390
    { 
28000
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
29391
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
28001
29392
;}
28002
29393
    break;
28003
29394
 
28004
29395
  case 754:
 
29396
 
 
29397
/* Line 1455 of yacc.c  */
28005
29398
#line 4949 "preproc.y"
28006
29399
    { 
28007
 
 yyval.str = cat_str(3,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29400
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
28008
29401
;}
28009
29402
    break;
28010
29403
 
28011
29404
  case 755:
 
29405
 
 
29406
/* Line 1455 of yacc.c  */
28012
29407
#line 4953 "preproc.y"
28013
29408
    { 
28014
 
 yyval.str = cat_str(3,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29409
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
28015
29410
;}
28016
29411
    break;
28017
29412
 
28018
29413
  case 756:
 
29414
 
 
29415
/* Line 1455 of yacc.c  */
28019
29416
#line 4957 "preproc.y"
28020
29417
    { 
28021
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
29418
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
28022
29419
;}
28023
29420
    break;
28024
29421
 
28025
29422
  case 757:
 
29423
 
 
29424
/* Line 1455 of yacc.c  */
28026
29425
#line 4961 "preproc.y"
28027
29426
    { 
28028
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
29427
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
28029
29428
;}
28030
29429
    break;
28031
29430
 
28032
29431
  case 758:
 
29432
 
 
29433
/* Line 1455 of yacc.c  */
28033
29434
#line 4965 "preproc.y"
28034
29435
    { 
28035
 
 yyval.str = yyvsp[0].str;
 
29436
 (yyval.str) = (yyvsp[(1) - (1)].str);
28036
29437
;}
28037
29438
    break;
28038
29439
 
28039
29440
  case 759:
 
29441
 
 
29442
/* Line 1455 of yacc.c  */
28040
29443
#line 4973 "preproc.y"
28041
29444
    { 
28042
 
 yyval.str = make_str("in");
 
29445
 (yyval.str) = make_str("in");
28043
29446
;}
28044
29447
    break;
28045
29448
 
28046
29449
  case 760:
 
29450
 
 
29451
/* Line 1455 of yacc.c  */
28047
29452
#line 4977 "preproc.y"
28048
29453
    { 
28049
 
 yyval.str = make_str("out");
 
29454
 (yyval.str) = make_str("out");
28050
29455
;}
28051
29456
    break;
28052
29457
 
28053
29458
  case 761:
 
29459
 
 
29460
/* Line 1455 of yacc.c  */
28054
29461
#line 4981 "preproc.y"
28055
29462
    { 
28056
 
 yyval.str = make_str("inout");
 
29463
 (yyval.str) = make_str("inout");
28057
29464
;}
28058
29465
    break;
28059
29466
 
28060
29467
  case 762:
 
29468
 
 
29469
/* Line 1455 of yacc.c  */
28061
29470
#line 4985 "preproc.y"
28062
29471
    { 
28063
 
 yyval.str = make_str("in out");
 
29472
 (yyval.str) = make_str("in out");
28064
29473
;}
28065
29474
    break;
28066
29475
 
28067
29476
  case 763:
 
29477
 
 
29478
/* Line 1455 of yacc.c  */
28068
29479
#line 4989 "preproc.y"
28069
29480
    { 
28070
 
 yyval.str = make_str("variadic");
 
29481
 (yyval.str) = make_str("variadic");
28071
29482
;}
28072
29483
    break;
28073
29484
 
28074
29485
  case 764:
 
29486
 
 
29487
/* Line 1455 of yacc.c  */
28075
29488
#line 4997 "preproc.y"
28076
29489
    { 
28077
 
 yyval.str = yyvsp[0].str;
 
29490
 (yyval.str) = (yyvsp[(1) - (1)].str);
28078
29491
;}
28079
29492
    break;
28080
29493
 
28081
29494
  case 765:
 
29495
 
 
29496
/* Line 1455 of yacc.c  */
28082
29497
#line 5005 "preproc.y"
28083
29498
    { 
28084
 
 yyval.str = yyvsp[0].str;
 
29499
 (yyval.str) = (yyvsp[(1) - (1)].str);
28085
29500
;}
28086
29501
    break;
28087
29502
 
28088
29503
  case 766:
 
29504
 
 
29505
/* Line 1455 of yacc.c  */
28089
29506
#line 5013 "preproc.y"
28090
29507
    { 
28091
 
 yyval.str = yyvsp[0].str;
 
29508
 (yyval.str) = (yyvsp[(1) - (1)].str);
28092
29509
;}
28093
29510
    break;
28094
29511
 
28095
29512
  case 767:
 
29513
 
 
29514
/* Line 1455 of yacc.c  */
28096
29515
#line 5017 "preproc.y"
28097
29516
    { 
28098
 
 yyval.str = cat_str(3,yyvsp[-3].str,yyvsp[-2].str,make_str("% type"));
 
29517
 (yyval.str) = cat_str(3,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),make_str("% type"));
28099
29518
;}
28100
29519
    break;
28101
29520
 
28102
29521
  case 768:
 
29522
 
 
29523
/* Line 1455 of yacc.c  */
28103
29524
#line 5021 "preproc.y"
28104
29525
    { 
28105
 
 yyval.str = cat_str(4,make_str("setof"),yyvsp[-3].str,yyvsp[-2].str,make_str("% type"));
 
29526
 (yyval.str) = cat_str(4,make_str("setof"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),make_str("% type"));
28106
29527
;}
28107
29528
    break;
28108
29529
 
28109
29530
  case 769:
 
29531
 
 
29532
/* Line 1455 of yacc.c  */
28110
29533
#line 5029 "preproc.y"
28111
29534
    { 
28112
 
 yyval.str = yyvsp[0].str;
 
29535
 (yyval.str) = (yyvsp[(1) - (1)].str);
28113
29536
;}
28114
29537
    break;
28115
29538
 
28116
29539
  case 770:
 
29540
 
 
29541
/* Line 1455 of yacc.c  */
28117
29542
#line 5033 "preproc.y"
28118
29543
    { 
28119
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("default"),yyvsp[0].str);
 
29544
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("default"),(yyvsp[(3) - (3)].str));
28120
29545
;}
28121
29546
    break;
28122
29547
 
28123
29548
  case 771:
 
29549
 
 
29550
/* Line 1455 of yacc.c  */
28124
29551
#line 5037 "preproc.y"
28125
29552
    { 
28126
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("="),yyvsp[0].str);
 
29553
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("="),(yyvsp[(3) - (3)].str));
28127
29554
;}
28128
29555
    break;
28129
29556
 
28130
29557
  case 772:
 
29558
 
 
29559
/* Line 1455 of yacc.c  */
28131
29560
#line 5045 "preproc.y"
28132
29561
    { 
28133
 
 yyval.str = yyvsp[0].str;
 
29562
 (yyval.str) = (yyvsp[(1) - (1)].str);
28134
29563
;}
28135
29564
    break;
28136
29565
 
28137
29566
  case 773:
 
29567
 
 
29568
/* Line 1455 of yacc.c  */
28138
29569
#line 5049 "preproc.y"
28139
29570
    { 
28140
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
29571
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
28141
29572
;}
28142
29573
    break;
28143
29574
 
28144
29575
  case 774:
 
29576
 
 
29577
/* Line 1455 of yacc.c  */
28145
29578
#line 5057 "preproc.y"
28146
29579
    { 
28147
 
 yyval.str = make_str("called on null input");
 
29580
 (yyval.str) = make_str("called on null input");
28148
29581
;}
28149
29582
    break;
28150
29583
 
28151
29584
  case 775:
 
29585
 
 
29586
/* Line 1455 of yacc.c  */
28152
29587
#line 5061 "preproc.y"
28153
29588
    { 
28154
 
 yyval.str = make_str("returns null on null input");
 
29589
 (yyval.str) = make_str("returns null on null input");
28155
29590
;}
28156
29591
    break;
28157
29592
 
28158
29593
  case 776:
 
29594
 
 
29595
/* Line 1455 of yacc.c  */
28159
29596
#line 5065 "preproc.y"
28160
29597
    { 
28161
 
 yyval.str = make_str("strict");
 
29598
 (yyval.str) = make_str("strict");
28162
29599
;}
28163
29600
    break;
28164
29601
 
28165
29602
  case 777:
 
29603
 
 
29604
/* Line 1455 of yacc.c  */
28166
29605
#line 5069 "preproc.y"
28167
29606
    { 
28168
 
 yyval.str = make_str("immutable");
 
29607
 (yyval.str) = make_str("immutable");
28169
29608
;}
28170
29609
    break;
28171
29610
 
28172
29611
  case 778:
 
29612
 
 
29613
/* Line 1455 of yacc.c  */
28173
29614
#line 5073 "preproc.y"
28174
29615
    { 
28175
 
 yyval.str = make_str("stable");
 
29616
 (yyval.str) = make_str("stable");
28176
29617
;}
28177
29618
    break;
28178
29619
 
28179
29620
  case 779:
 
29621
 
 
29622
/* Line 1455 of yacc.c  */
28180
29623
#line 5077 "preproc.y"
28181
29624
    { 
28182
 
 yyval.str = make_str("volatile");
 
29625
 (yyval.str) = make_str("volatile");
28183
29626
;}
28184
29627
    break;
28185
29628
 
28186
29629
  case 780:
 
29630
 
 
29631
/* Line 1455 of yacc.c  */
28187
29632
#line 5081 "preproc.y"
28188
29633
    { 
28189
 
 yyval.str = make_str("external security definer");
 
29634
 (yyval.str) = make_str("external security definer");
28190
29635
;}
28191
29636
    break;
28192
29637
 
28193
29638
  case 781:
 
29639
 
 
29640
/* Line 1455 of yacc.c  */
28194
29641
#line 5085 "preproc.y"
28195
29642
    { 
28196
 
 yyval.str = make_str("external security invoker");
 
29643
 (yyval.str) = make_str("external security invoker");
28197
29644
;}
28198
29645
    break;
28199
29646
 
28200
29647
  case 782:
 
29648
 
 
29649
/* Line 1455 of yacc.c  */
28201
29650
#line 5089 "preproc.y"
28202
29651
    { 
28203
 
 yyval.str = make_str("security definer");
 
29652
 (yyval.str) = make_str("security definer");
28204
29653
;}
28205
29654
    break;
28206
29655
 
28207
29656
  case 783:
 
29657
 
 
29658
/* Line 1455 of yacc.c  */
28208
29659
#line 5093 "preproc.y"
28209
29660
    { 
28210
 
 yyval.str = make_str("security invoker");
 
29661
 (yyval.str) = make_str("security invoker");
28211
29662
;}
28212
29663
    break;
28213
29664
 
28214
29665
  case 784:
 
29666
 
 
29667
/* Line 1455 of yacc.c  */
28215
29668
#line 5097 "preproc.y"
28216
29669
    { 
28217
 
 yyval.str = cat_str(2,make_str("cost"),yyvsp[0].str);
 
29670
 (yyval.str) = cat_str(2,make_str("cost"),(yyvsp[(2) - (2)].str));
28218
29671
;}
28219
29672
    break;
28220
29673
 
28221
29674
  case 785:
 
29675
 
 
29676
/* Line 1455 of yacc.c  */
28222
29677
#line 5101 "preproc.y"
28223
29678
    { 
28224
 
 yyval.str = cat_str(2,make_str("rows"),yyvsp[0].str);
 
29679
 (yyval.str) = cat_str(2,make_str("rows"),(yyvsp[(2) - (2)].str));
28225
29680
;}
28226
29681
    break;
28227
29682
 
28228
29683
  case 786:
 
29684
 
 
29685
/* Line 1455 of yacc.c  */
28229
29686
#line 5105 "preproc.y"
28230
29687
    { 
28231
 
 yyval.str = yyvsp[0].str;
 
29688
 (yyval.str) = (yyvsp[(1) - (1)].str);
28232
29689
;}
28233
29690
    break;
28234
29691
 
28235
29692
  case 787:
 
29693
 
 
29694
/* Line 1455 of yacc.c  */
28236
29695
#line 5113 "preproc.y"
28237
29696
    { 
28238
 
 yyval.str = cat_str(2,make_str("as"),yyvsp[0].str);
 
29697
 (yyval.str) = cat_str(2,make_str("as"),(yyvsp[(2) - (2)].str));
28239
29698
;}
28240
29699
    break;
28241
29700
 
28242
29701
  case 788:
 
29702
 
 
29703
/* Line 1455 of yacc.c  */
28243
29704
#line 5117 "preproc.y"
28244
29705
    { 
28245
 
 yyval.str = cat_str(2,make_str("language"),yyvsp[0].str);
 
29706
 (yyval.str) = cat_str(2,make_str("language"),(yyvsp[(2) - (2)].str));
28246
29707
;}
28247
29708
    break;
28248
29709
 
28249
29710
  case 789:
 
29711
 
 
29712
/* Line 1455 of yacc.c  */
28250
29713
#line 5121 "preproc.y"
28251
29714
    { 
28252
 
 yyval.str = make_str("window");
 
29715
 (yyval.str) = make_str("window");
28253
29716
;}
28254
29717
    break;
28255
29718
 
28256
29719
  case 790:
 
29720
 
 
29721
/* Line 1455 of yacc.c  */
28257
29722
#line 5125 "preproc.y"
28258
29723
    { 
28259
 
 yyval.str = yyvsp[0].str;
 
29724
 (yyval.str) = (yyvsp[(1) - (1)].str);
28260
29725
;}
28261
29726
    break;
28262
29727
 
28263
29728
  case 791:
 
29729
 
 
29730
/* Line 1455 of yacc.c  */
28264
29731
#line 5133 "preproc.y"
28265
29732
    { 
28266
 
 yyval.str = yyvsp[0].str;
 
29733
 (yyval.str) = (yyvsp[(1) - (1)].str);
28267
29734
;}
28268
29735
    break;
28269
29736
 
28270
29737
  case 792:
 
29738
 
 
29739
/* Line 1455 of yacc.c  */
28271
29740
#line 5137 "preproc.y"
28272
29741
    { 
28273
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
29742
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
28274
29743
;}
28275
29744
    break;
28276
29745
 
28277
29746
  case 793:
 
29747
 
 
29748
/* Line 1455 of yacc.c  */
28278
29749
#line 5145 "preproc.y"
28279
29750
    { 
28280
 
 yyval.str = cat_str(2,make_str("with"),yyvsp[0].str);
 
29751
 (yyval.str) = cat_str(2,make_str("with"),(yyvsp[(2) - (2)].str));
28281
29752
;}
28282
29753
    break;
28283
29754
 
28284
29755
  case 794:
 
29756
 
 
29757
/* Line 1455 of yacc.c  */
28285
29758
#line 5149 "preproc.y"
28286
29759
    { 
28287
 
 yyval.str=EMPTY; ;}
 
29760
 (yyval.str)=EMPTY; ;}
28288
29761
    break;
28289
29762
 
28290
29763
  case 795:
 
29764
 
 
29765
/* Line 1455 of yacc.c  */
28291
29766
#line 5156 "preproc.y"
28292
29767
    { 
28293
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
29768
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
28294
29769
;}
28295
29770
    break;
28296
29771
 
28297
29772
  case 796:
 
29773
 
 
29774
/* Line 1455 of yacc.c  */
28298
29775
#line 5164 "preproc.y"
28299
29776
    { 
28300
 
 yyval.str = yyvsp[0].str;
 
29777
 (yyval.str) = (yyvsp[(1) - (1)].str);
28301
29778
;}
28302
29779
    break;
28303
29780
 
28304
29781
  case 797:
 
29782
 
 
29783
/* Line 1455 of yacc.c  */
28305
29784
#line 5168 "preproc.y"
28306
29785
    { 
28307
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
29786
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
28308
29787
;}
28309
29788
    break;
28310
29789
 
28311
29790
  case 798:
 
29791
 
 
29792
/* Line 1455 of yacc.c  */
28312
29793
#line 5176 "preproc.y"
28313
29794
    { 
28314
 
 yyval.str = cat_str(4,make_str("alter function"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29795
 (yyval.str) = cat_str(4,make_str("alter function"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
28315
29796
;}
28316
29797
    break;
28317
29798
 
28318
29799
  case 799:
 
29800
 
 
29801
/* Line 1455 of yacc.c  */
28319
29802
#line 5184 "preproc.y"
28320
29803
    { 
28321
 
 yyval.str = yyvsp[0].str;
 
29804
 (yyval.str) = (yyvsp[(1) - (1)].str);
28322
29805
;}
28323
29806
    break;
28324
29807
 
28325
29808
  case 800:
 
29809
 
 
29810
/* Line 1455 of yacc.c  */
28326
29811
#line 5188 "preproc.y"
28327
29812
    { 
28328
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
29813
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
28329
29814
;}
28330
29815
    break;
28331
29816
 
28332
29817
  case 801:
 
29818
 
 
29819
/* Line 1455 of yacc.c  */
28333
29820
#line 5196 "preproc.y"
28334
29821
    { 
28335
 
 yyval.str = make_str("restrict");
 
29822
 (yyval.str) = make_str("restrict");
28336
29823
;}
28337
29824
    break;
28338
29825
 
28339
29826
  case 802:
 
29827
 
 
29828
/* Line 1455 of yacc.c  */
28340
29829
#line 5200 "preproc.y"
28341
29830
    { 
28342
 
 yyval.str=EMPTY; ;}
 
29831
 (yyval.str)=EMPTY; ;}
28343
29832
    break;
28344
29833
 
28345
29834
  case 803:
 
29835
 
 
29836
/* Line 1455 of yacc.c  */
28346
29837
#line 5207 "preproc.y"
28347
29838
    { 
28348
 
 yyval.str = cat_str(4,make_str("drop function"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29839
 (yyval.str) = cat_str(4,make_str("drop function"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
28349
29840
;}
28350
29841
    break;
28351
29842
 
28352
29843
  case 804:
 
29844
 
 
29845
/* Line 1455 of yacc.c  */
28353
29846
#line 5211 "preproc.y"
28354
29847
    { 
28355
 
 yyval.str = cat_str(4,make_str("drop function if exists"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29848
 (yyval.str) = cat_str(4,make_str("drop function if exists"),(yyvsp[(5) - (7)].str),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str));
28356
29849
;}
28357
29850
    break;
28358
29851
 
28359
29852
  case 805:
 
29853
 
 
29854
/* Line 1455 of yacc.c  */
28360
29855
#line 5219 "preproc.y"
28361
29856
    { 
28362
 
 yyval.str = cat_str(4,make_str("drop aggregate"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29857
 (yyval.str) = cat_str(4,make_str("drop aggregate"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
28363
29858
;}
28364
29859
    break;
28365
29860
 
28366
29861
  case 806:
 
29862
 
 
29863
/* Line 1455 of yacc.c  */
28367
29864
#line 5223 "preproc.y"
28368
29865
    { 
28369
 
 yyval.str = cat_str(4,make_str("drop aggregate if exists"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29866
 (yyval.str) = cat_str(4,make_str("drop aggregate if exists"),(yyvsp[(5) - (7)].str),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str));
28370
29867
;}
28371
29868
    break;
28372
29869
 
28373
29870
  case 807:
 
29871
 
 
29872
/* Line 1455 of yacc.c  */
28374
29873
#line 5231 "preproc.y"
28375
29874
    { 
28376
 
 yyval.str = cat_str(4,make_str("drop operator"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29875
 (yyval.str) = cat_str(4,make_str("drop operator"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
28377
29876
;}
28378
29877
    break;
28379
29878
 
28380
29879
  case 808:
 
29880
 
 
29881
/* Line 1455 of yacc.c  */
28381
29882
#line 5235 "preproc.y"
28382
29883
    { 
28383
 
 yyval.str = cat_str(4,make_str("drop operator if exists"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
29884
 (yyval.str) = cat_str(4,make_str("drop operator if exists"),(yyvsp[(5) - (7)].str),(yyvsp[(6) - (7)].str),(yyvsp[(7) - (7)].str));
28384
29885
;}
28385
29886
    break;
28386
29887
 
28387
29888
  case 809:
 
29889
 
 
29890
/* Line 1455 of yacc.c  */
28388
29891
#line 5243 "preproc.y"
28389
29892
    { 
28390
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
29893
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
28391
29894
;}
28392
29895
    break;
28393
29896
 
28394
29897
  case 810:
 
29898
 
 
29899
/* Line 1455 of yacc.c  */
28395
29900
#line 5247 "preproc.y"
28396
29901
    { 
28397
 
 yyval.str = cat_str(5,make_str("("),yyvsp[-3].str,make_str(","),yyvsp[-1].str,make_str(")"));
 
29902
 (yyval.str) = cat_str(5,make_str("("),(yyvsp[(2) - (5)].str),make_str(","),(yyvsp[(4) - (5)].str),make_str(")"));
28398
29903
;}
28399
29904
    break;
28400
29905
 
28401
29906
  case 811:
 
29907
 
 
29908
/* Line 1455 of yacc.c  */
28402
29909
#line 5251 "preproc.y"
28403
29910
    { 
28404
 
 yyval.str = cat_str(3,make_str("( none ,"),yyvsp[-1].str,make_str(")"));
 
29911
 (yyval.str) = cat_str(3,make_str("( none ,"),(yyvsp[(4) - (5)].str),make_str(")"));
28405
29912
;}
28406
29913
    break;
28407
29914
 
28408
29915
  case 812:
 
29916
 
 
29917
/* Line 1455 of yacc.c  */
28409
29918
#line 5255 "preproc.y"
28410
29919
    { 
28411
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-3].str,make_str(", none )"));
 
29920
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (5)].str),make_str(", none )"));
28412
29921
;}
28413
29922
    break;
28414
29923
 
28415
29924
  case 813:
 
29925
 
 
29926
/* Line 1455 of yacc.c  */
28416
29927
#line 5263 "preproc.y"
28417
29928
    { 
28418
 
 yyval.str = yyvsp[0].str;
 
29929
 (yyval.str) = (yyvsp[(1) - (1)].str);
28419
29930
;}
28420
29931
    break;
28421
29932
 
28422
29933
  case 814:
 
29934
 
 
29935
/* Line 1455 of yacc.c  */
28423
29936
#line 5267 "preproc.y"
28424
29937
    { 
28425
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("."),yyvsp[0].str);
 
29938
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("."),(yyvsp[(3) - (3)].str));
28426
29939
;}
28427
29940
    break;
28428
29941
 
28429
29942
  case 815:
 
29943
 
 
29944
/* Line 1455 of yacc.c  */
28430
29945
#line 5275 "preproc.y"
28431
29946
    { 
28432
 
 yyval.str = cat_str(7,make_str("create cast ("),yyvsp[-7].str,make_str("as"),yyvsp[-5].str,make_str(") with function"),yyvsp[-1].str,yyvsp[0].str);
 
29947
 (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));
28433
29948
;}
28434
29949
    break;
28435
29950
 
28436
29951
  case 816:
 
29952
 
 
29953
/* Line 1455 of yacc.c  */
28437
29954
#line 5279 "preproc.y"
28438
29955
    { 
28439
 
 yyval.str = cat_str(6,make_str("create cast ("),yyvsp[-6].str,make_str("as"),yyvsp[-4].str,make_str(") without function"),yyvsp[0].str);
 
29956
 (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));
28440
29957
;}
28441
29958
    break;
28442
29959
 
28443
29960
  case 817:
 
29961
 
 
29962
/* Line 1455 of yacc.c  */
28444
29963
#line 5283 "preproc.y"
28445
29964
    { 
28446
 
 yyval.str = cat_str(6,make_str("create cast ("),yyvsp[-6].str,make_str("as"),yyvsp[-4].str,make_str(") with inout"),yyvsp[0].str);
 
29965
 (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));
28447
29966
;}
28448
29967
    break;
28449
29968
 
28450
29969
  case 818:
 
29970
 
 
29971
/* Line 1455 of yacc.c  */
28451
29972
#line 5291 "preproc.y"
28452
29973
    { 
28453
 
 yyval.str = make_str("as implicit");
 
29974
 (yyval.str) = make_str("as implicit");
28454
29975
;}
28455
29976
    break;
28456
29977
 
28457
29978
  case 819:
 
29979
 
 
29980
/* Line 1455 of yacc.c  */
28458
29981
#line 5295 "preproc.y"
28459
29982
    { 
28460
 
 yyval.str = make_str("as assignment");
 
29983
 (yyval.str) = make_str("as assignment");
28461
29984
;}
28462
29985
    break;
28463
29986
 
28464
29987
  case 820:
 
29988
 
 
29989
/* Line 1455 of yacc.c  */
28465
29990
#line 5299 "preproc.y"
28466
29991
    { 
28467
 
 yyval.str=EMPTY; ;}
 
29992
 (yyval.str)=EMPTY; ;}
28468
29993
    break;
28469
29994
 
28470
29995
  case 821:
 
29996
 
 
29997
/* Line 1455 of yacc.c  */
28471
29998
#line 5306 "preproc.y"
28472
29999
    { 
28473
 
 yyval.str = cat_str(8,make_str("drop cast"),yyvsp[-6].str,make_str("("),yyvsp[-4].str,make_str("as"),yyvsp[-2].str,make_str(")"),yyvsp[0].str);
 
30000
 (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));
28474
30001
;}
28475
30002
    break;
28476
30003
 
28477
30004
  case 822:
 
30005
 
 
30006
/* Line 1455 of yacc.c  */
28478
30007
#line 5314 "preproc.y"
28479
30008
    { 
28480
 
 yyval.str = make_str("if exists");
 
30009
 (yyval.str) = make_str("if exists");
28481
30010
;}
28482
30011
    break;
28483
30012
 
28484
30013
  case 823:
 
30014
 
 
30015
/* Line 1455 of yacc.c  */
28485
30016
#line 5318 "preproc.y"
28486
30017
    { 
28487
 
 yyval.str=EMPTY; ;}
 
30018
 (yyval.str)=EMPTY; ;}
28488
30019
    break;
28489
30020
 
28490
30021
  case 824:
 
30022
 
 
30023
/* Line 1455 of yacc.c  */
28491
30024
#line 5325 "preproc.y"
28492
30025
    { 
28493
 
 yyval.str = cat_str(4,make_str("reindex"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
30026
 (yyval.str) = cat_str(4,make_str("reindex"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
28494
30027
;}
28495
30028
    break;
28496
30029
 
28497
30030
  case 825:
 
30031
 
 
30032
/* Line 1455 of yacc.c  */
28498
30033
#line 5329 "preproc.y"
28499
30034
    { 
28500
 
 yyval.str = cat_str(3,make_str("reindex system"),yyvsp[-1].str,yyvsp[0].str);
 
30035
 (yyval.str) = cat_str(3,make_str("reindex system"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
28501
30036
;}
28502
30037
    break;
28503
30038
 
28504
30039
  case 826:
 
30040
 
 
30041
/* Line 1455 of yacc.c  */
28505
30042
#line 5333 "preproc.y"
28506
30043
    { 
28507
 
 yyval.str = cat_str(3,make_str("reindex database"),yyvsp[-1].str,yyvsp[0].str);
 
30044
 (yyval.str) = cat_str(3,make_str("reindex database"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
28508
30045
;}
28509
30046
    break;
28510
30047
 
28511
30048
  case 827:
 
30049
 
 
30050
/* Line 1455 of yacc.c  */
28512
30051
#line 5341 "preproc.y"
28513
30052
    { 
28514
 
 yyval.str = make_str("index");
 
30053
 (yyval.str) = make_str("index");
28515
30054
;}
28516
30055
    break;
28517
30056
 
28518
30057
  case 828:
 
30058
 
 
30059
/* Line 1455 of yacc.c  */
28519
30060
#line 5345 "preproc.y"
28520
30061
    { 
28521
 
 yyval.str = make_str("table");
 
30062
 (yyval.str) = make_str("table");
28522
30063
;}
28523
30064
    break;
28524
30065
 
28525
30066
  case 829:
 
30067
 
 
30068
/* Line 1455 of yacc.c  */
28526
30069
#line 5353 "preproc.y"
28527
30070
    { 
28528
 
 yyval.str = make_str("force");
 
30071
 (yyval.str) = make_str("force");
28529
30072
;}
28530
30073
    break;
28531
30074
 
28532
30075
  case 830:
 
30076
 
 
30077
/* Line 1455 of yacc.c  */
28533
30078
#line 5357 "preproc.y"
28534
30079
    { 
28535
 
 yyval.str=EMPTY; ;}
 
30080
 (yyval.str)=EMPTY; ;}
28536
30081
    break;
28537
30082
 
28538
30083
  case 831:
 
30084
 
 
30085
/* Line 1455 of yacc.c  */
28539
30086
#line 5364 "preproc.y"
28540
30087
    { 
28541
 
 yyval.str = cat_str(5,make_str("alter aggregate"),yyvsp[-4].str,yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30088
 (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));
28542
30089
;}
28543
30090
    break;
28544
30091
 
28545
30092
  case 832:
 
30093
 
 
30094
/* Line 1455 of yacc.c  */
28546
30095
#line 5368 "preproc.y"
28547
30096
    { 
28548
 
 yyval.str = cat_str(4,make_str("alter conversion"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30097
 (yyval.str) = cat_str(4,make_str("alter conversion"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str));
28549
30098
;}
28550
30099
    break;
28551
30100
 
28552
30101
  case 833:
 
30102
 
 
30103
/* Line 1455 of yacc.c  */
28553
30104
#line 5372 "preproc.y"
28554
30105
    { 
28555
 
 yyval.str = cat_str(4,make_str("alter database"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30106
 (yyval.str) = cat_str(4,make_str("alter database"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str));
28556
30107
;}
28557
30108
    break;
28558
30109
 
28559
30110
  case 834:
 
30111
 
 
30112
/* Line 1455 of yacc.c  */
28560
30113
#line 5376 "preproc.y"
28561
30114
    { 
28562
 
 yyval.str = cat_str(4,make_str("alter function"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30115
 (yyval.str) = cat_str(4,make_str("alter function"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str));
28563
30116
;}
28564
30117
    break;
28565
30118
 
28566
30119
  case 835:
 
30120
 
 
30121
/* Line 1455 of yacc.c  */
28567
30122
#line 5380 "preproc.y"
28568
30123
    { 
28569
 
 yyval.str = cat_str(4,make_str("alter group"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30124
 (yyval.str) = cat_str(4,make_str("alter group"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str));
28570
30125
;}
28571
30126
    break;
28572
30127
 
28573
30128
  case 836:
 
30129
 
 
30130
/* Line 1455 of yacc.c  */
28574
30131
#line 5384 "preproc.y"
28575
30132
    { 
28576
 
 yyval.str = cat_str(6,make_str("alter"),yyvsp[-5].str,make_str("language"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30133
 (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));
28577
30134
;}
28578
30135
    break;
28579
30136
 
28580
30137
  case 837:
 
30138
 
 
30139
/* Line 1455 of yacc.c  */
28581
30140
#line 5388 "preproc.y"
28582
30141
    { 
28583
 
 yyval.str = cat_str(6,make_str("alter operator class"),yyvsp[-5].str,make_str("using"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30142
 (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));
28584
30143
;}
28585
30144
    break;
28586
30145
 
28587
30146
  case 838:
 
30147
 
 
30148
/* Line 1455 of yacc.c  */
28588
30149
#line 5392 "preproc.y"
28589
30150
    { 
28590
 
 yyval.str = cat_str(6,make_str("alter operator family"),yyvsp[-5].str,make_str("using"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30151
 (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));
28591
30152
;}
28592
30153
    break;
28593
30154
 
28594
30155
  case 839:
 
30156
 
 
30157
/* Line 1455 of yacc.c  */
28595
30158
#line 5396 "preproc.y"
28596
30159
    { 
28597
 
 yyval.str = cat_str(4,make_str("alter schema"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30160
 (yyval.str) = cat_str(4,make_str("alter schema"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str));
28598
30161
;}
28599
30162
    break;
28600
30163
 
28601
30164
  case 840:
 
30165
 
 
30166
/* Line 1455 of yacc.c  */
28602
30167
#line 5400 "preproc.y"
28603
30168
    { 
28604
 
 yyval.str = cat_str(4,make_str("alter table"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30169
 (yyval.str) = cat_str(4,make_str("alter table"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str));
28605
30170
;}
28606
30171
    break;
28607
30172
 
28608
30173
  case 841:
 
30174
 
 
30175
/* Line 1455 of yacc.c  */
28609
30176
#line 5404 "preproc.y"
28610
30177
    { 
28611
 
 yyval.str = cat_str(4,make_str("alter sequence"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30178
 (yyval.str) = cat_str(4,make_str("alter sequence"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str));
28612
30179
;}
28613
30180
    break;
28614
30181
 
28615
30182
  case 842:
 
30183
 
 
30184
/* Line 1455 of yacc.c  */
28616
30185
#line 5408 "preproc.y"
28617
30186
    { 
28618
 
 yyval.str = cat_str(4,make_str("alter view"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30187
 (yyval.str) = cat_str(4,make_str("alter view"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str));
28619
30188
;}
28620
30189
    break;
28621
30190
 
28622
30191
  case 843:
 
30192
 
 
30193
/* Line 1455 of yacc.c  */
28623
30194
#line 5412 "preproc.y"
28624
30195
    { 
28625
 
 yyval.str = cat_str(4,make_str("alter index"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30196
 (yyval.str) = cat_str(4,make_str("alter index"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str));
28626
30197
;}
28627
30198
    break;
28628
30199
 
28629
30200
  case 844:
 
30201
 
 
30202
/* Line 1455 of yacc.c  */
28630
30203
#line 5416 "preproc.y"
28631
30204
    { 
28632
 
 yyval.str = cat_str(7,make_str("alter table"),yyvsp[-5].str,make_str("rename"),yyvsp[-3].str,yyvsp[-2].str,make_str("to"),yyvsp[0].str);
 
30205
 (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));
28633
30206
;}
28634
30207
    break;
28635
30208
 
28636
30209
  case 845:
 
30210
 
 
30211
/* Line 1455 of yacc.c  */
28637
30212
#line 5420 "preproc.y"
28638
30213
    { 
28639
 
 yyval.str = cat_str(6,make_str("alter trigger"),yyvsp[-5].str,make_str("on"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30214
 (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));
28640
30215
;}
28641
30216
    break;
28642
30217
 
28643
30218
  case 846:
 
30219
 
 
30220
/* Line 1455 of yacc.c  */
28644
30221
#line 5424 "preproc.y"
28645
30222
    { 
28646
 
 yyval.str = cat_str(4,make_str("alter role"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30223
 (yyval.str) = cat_str(4,make_str("alter role"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str));
28647
30224
;}
28648
30225
    break;
28649
30226
 
28650
30227
  case 847:
 
30228
 
 
30229
/* Line 1455 of yacc.c  */
28651
30230
#line 5428 "preproc.y"
28652
30231
    { 
28653
 
 yyval.str = cat_str(4,make_str("alter user"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30232
 (yyval.str) = cat_str(4,make_str("alter user"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str));
28654
30233
;}
28655
30234
    break;
28656
30235
 
28657
30236
  case 848:
 
30237
 
 
30238
/* Line 1455 of yacc.c  */
28658
30239
#line 5432 "preproc.y"
28659
30240
    { 
28660
 
 yyval.str = cat_str(4,make_str("alter tablespace"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30241
 (yyval.str) = cat_str(4,make_str("alter tablespace"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str));
28661
30242
;}
28662
30243
    break;
28663
30244
 
28664
30245
  case 849:
 
30246
 
 
30247
/* Line 1455 of yacc.c  */
28665
30248
#line 5436 "preproc.y"
28666
30249
    { 
28667
 
 yyval.str = cat_str(4,make_str("alter text search parser"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30250
 (yyval.str) = cat_str(4,make_str("alter text search parser"),(yyvsp[(5) - (8)].str),make_str("rename to"),(yyvsp[(8) - (8)].str));
28668
30251
;}
28669
30252
    break;
28670
30253
 
28671
30254
  case 850:
 
30255
 
 
30256
/* Line 1455 of yacc.c  */
28672
30257
#line 5440 "preproc.y"
28673
30258
    { 
28674
 
 yyval.str = cat_str(4,make_str("alter text search dictionary"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30259
 (yyval.str) = cat_str(4,make_str("alter text search dictionary"),(yyvsp[(5) - (8)].str),make_str("rename to"),(yyvsp[(8) - (8)].str));
28675
30260
;}
28676
30261
    break;
28677
30262
 
28678
30263
  case 851:
 
30264
 
 
30265
/* Line 1455 of yacc.c  */
28679
30266
#line 5444 "preproc.y"
28680
30267
    { 
28681
 
 yyval.str = cat_str(4,make_str("alter text search template"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30268
 (yyval.str) = cat_str(4,make_str("alter text search template"),(yyvsp[(5) - (8)].str),make_str("rename to"),(yyvsp[(8) - (8)].str));
28682
30269
;}
28683
30270
    break;
28684
30271
 
28685
30272
  case 852:
 
30273
 
 
30274
/* Line 1455 of yacc.c  */
28686
30275
#line 5448 "preproc.y"
28687
30276
    { 
28688
 
 yyval.str = cat_str(4,make_str("alter text search configuration"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30277
 (yyval.str) = cat_str(4,make_str("alter text search configuration"),(yyvsp[(5) - (8)].str),make_str("rename to"),(yyvsp[(8) - (8)].str));
28689
30278
;}
28690
30279
    break;
28691
30280
 
28692
30281
  case 853:
 
30282
 
 
30283
/* Line 1455 of yacc.c  */
28693
30284
#line 5452 "preproc.y"
28694
30285
    { 
28695
 
 yyval.str = cat_str(4,make_str("alter type"),yyvsp[-3].str,make_str("rename to"),yyvsp[0].str);
 
30286
 (yyval.str) = cat_str(4,make_str("alter type"),(yyvsp[(3) - (6)].str),make_str("rename to"),(yyvsp[(6) - (6)].str));
28696
30287
;}
28697
30288
    break;
28698
30289
 
28699
30290
  case 854:
 
30291
 
 
30292
/* Line 1455 of yacc.c  */
28700
30293
#line 5460 "preproc.y"
28701
30294
    { 
28702
 
 yyval.str = make_str("column");
 
30295
 (yyval.str) = make_str("column");
28703
30296
;}
28704
30297
    break;
28705
30298
 
28706
30299
  case 855:
 
30300
 
 
30301
/* Line 1455 of yacc.c  */
28707
30302
#line 5464 "preproc.y"
28708
30303
    { 
28709
 
 yyval.str=EMPTY; ;}
 
30304
 (yyval.str)=EMPTY; ;}
28710
30305
    break;
28711
30306
 
28712
30307
  case 856:
 
30308
 
 
30309
/* Line 1455 of yacc.c  */
28713
30310
#line 5471 "preproc.y"
28714
30311
    { 
28715
 
 yyval.str = make_str("set data");
 
30312
 (yyval.str) = make_str("set data");
28716
30313
;}
28717
30314
    break;
28718
30315
 
28719
30316
  case 857:
 
30317
 
 
30318
/* Line 1455 of yacc.c  */
28720
30319
#line 5475 "preproc.y"
28721
30320
    { 
28722
 
 yyval.str=EMPTY; ;}
 
30321
 (yyval.str)=EMPTY; ;}
28723
30322
    break;
28724
30323
 
28725
30324
  case 858:
 
30325
 
 
30326
/* Line 1455 of yacc.c  */
28726
30327
#line 5482 "preproc.y"
28727
30328
    { 
28728
 
 yyval.str = cat_str(5,make_str("alter aggregate"),yyvsp[-4].str,yyvsp[-3].str,make_str("set schema"),yyvsp[0].str);
 
30329
 (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));
28729
30330
;}
28730
30331
    break;
28731
30332
 
28732
30333
  case 859:
 
30334
 
 
30335
/* Line 1455 of yacc.c  */
28733
30336
#line 5486 "preproc.y"
28734
30337
    { 
28735
 
 yyval.str = cat_str(4,make_str("alter domain"),yyvsp[-3].str,make_str("set schema"),yyvsp[0].str);
 
30338
 (yyval.str) = cat_str(4,make_str("alter domain"),(yyvsp[(3) - (6)].str),make_str("set schema"),(yyvsp[(6) - (6)].str));
28736
30339
;}
28737
30340
    break;
28738
30341
 
28739
30342
  case 860:
 
30343
 
 
30344
/* Line 1455 of yacc.c  */
28740
30345
#line 5490 "preproc.y"
28741
30346
    { 
28742
 
 yyval.str = cat_str(4,make_str("alter function"),yyvsp[-3].str,make_str("set schema"),yyvsp[0].str);
 
30347
 (yyval.str) = cat_str(4,make_str("alter function"),(yyvsp[(3) - (6)].str),make_str("set schema"),(yyvsp[(6) - (6)].str));
28743
30348
;}
28744
30349
    break;
28745
30350
 
28746
30351
  case 861:
 
30352
 
 
30353
/* Line 1455 of yacc.c  */
28747
30354
#line 5494 "preproc.y"
28748
30355
    { 
28749
 
 yyval.str = cat_str(4,make_str("alter table"),yyvsp[-3].str,make_str("set schema"),yyvsp[0].str);
 
30356
 (yyval.str) = cat_str(4,make_str("alter table"),(yyvsp[(3) - (6)].str),make_str("set schema"),(yyvsp[(6) - (6)].str));
28750
30357
;}
28751
30358
    break;
28752
30359
 
28753
30360
  case 862:
 
30361
 
 
30362
/* Line 1455 of yacc.c  */
28754
30363
#line 5498 "preproc.y"
28755
30364
    { 
28756
 
 yyval.str = cat_str(4,make_str("alter sequence"),yyvsp[-3].str,make_str("set schema"),yyvsp[0].str);
 
30365
 (yyval.str) = cat_str(4,make_str("alter sequence"),(yyvsp[(3) - (6)].str),make_str("set schema"),(yyvsp[(6) - (6)].str));
28757
30366
;}
28758
30367
    break;
28759
30368
 
28760
30369
  case 863:
 
30370
 
 
30371
/* Line 1455 of yacc.c  */
28761
30372
#line 5502 "preproc.y"
28762
30373
    { 
28763
 
 yyval.str = cat_str(4,make_str("alter view"),yyvsp[-3].str,make_str("set schema"),yyvsp[0].str);
 
30374
 (yyval.str) = cat_str(4,make_str("alter view"),(yyvsp[(3) - (6)].str),make_str("set schema"),(yyvsp[(6) - (6)].str));
28764
30375
;}
28765
30376
    break;
28766
30377
 
28767
30378
  case 864:
 
30379
 
 
30380
/* Line 1455 of yacc.c  */
28768
30381
#line 5506 "preproc.y"
28769
30382
    { 
28770
 
 yyval.str = cat_str(4,make_str("alter type"),yyvsp[-3].str,make_str("set schema"),yyvsp[0].str);
 
30383
 (yyval.str) = cat_str(4,make_str("alter type"),(yyvsp[(3) - (6)].str),make_str("set schema"),(yyvsp[(6) - (6)].str));
28771
30384
;}
28772
30385
    break;
28773
30386
 
28774
30387
  case 865:
 
30388
 
 
30389
/* Line 1455 of yacc.c  */
28775
30390
#line 5514 "preproc.y"
28776
30391
    { 
28777
 
 yyval.str = cat_str(5,make_str("alter aggregate"),yyvsp[-4].str,yyvsp[-3].str,make_str("owner to"),yyvsp[0].str);
 
30392
 (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));
28778
30393
;}
28779
30394
    break;
28780
30395
 
28781
30396
  case 866:
 
30397
 
 
30398
/* Line 1455 of yacc.c  */
28782
30399
#line 5518 "preproc.y"
28783
30400
    { 
28784
 
 yyval.str = cat_str(4,make_str("alter conversion"),yyvsp[-3].str,make_str("owner to"),yyvsp[0].str);
 
30401
 (yyval.str) = cat_str(4,make_str("alter conversion"),(yyvsp[(3) - (6)].str),make_str("owner to"),(yyvsp[(6) - (6)].str));
28785
30402
;}
28786
30403
    break;
28787
30404
 
28788
30405
  case 867:
 
30406
 
 
30407
/* Line 1455 of yacc.c  */
28789
30408
#line 5522 "preproc.y"
28790
30409
    { 
28791
 
 yyval.str = cat_str(4,make_str("alter database"),yyvsp[-3].str,make_str("owner to"),yyvsp[0].str);
 
30410
 (yyval.str) = cat_str(4,make_str("alter database"),(yyvsp[(3) - (6)].str),make_str("owner to"),(yyvsp[(6) - (6)].str));
28792
30411
;}
28793
30412
    break;
28794
30413
 
28795
30414
  case 868:
 
30415
 
 
30416
/* Line 1455 of yacc.c  */
28796
30417
#line 5526 "preproc.y"
28797
30418
    { 
28798
 
 yyval.str = cat_str(4,make_str("alter domain"),yyvsp[-3].str,make_str("owner to"),yyvsp[0].str);
 
30419
 (yyval.str) = cat_str(4,make_str("alter domain"),(yyvsp[(3) - (6)].str),make_str("owner to"),(yyvsp[(6) - (6)].str));
28799
30420
;}
28800
30421
    break;
28801
30422
 
28802
30423
  case 869:
 
30424
 
 
30425
/* Line 1455 of yacc.c  */
28803
30426
#line 5530 "preproc.y"
28804
30427
    { 
28805
 
 yyval.str = cat_str(4,make_str("alter function"),yyvsp[-3].str,make_str("owner to"),yyvsp[0].str);
 
30428
 (yyval.str) = cat_str(4,make_str("alter function"),(yyvsp[(3) - (6)].str),make_str("owner to"),(yyvsp[(6) - (6)].str));
28806
30429
;}
28807
30430
    break;
28808
30431
 
28809
30432
  case 870:
 
30433
 
 
30434
/* Line 1455 of yacc.c  */
28810
30435
#line 5534 "preproc.y"
28811
30436
    { 
28812
 
 yyval.str = cat_str(6,make_str("alter"),yyvsp[-5].str,make_str("language"),yyvsp[-3].str,make_str("owner to"),yyvsp[0].str);
 
30437
 (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));
28813
30438
;}
28814
30439
    break;
28815
30440
 
28816
30441
  case 871:
 
30442
 
 
30443
/* Line 1455 of yacc.c  */
28817
30444
#line 5538 "preproc.y"
28818
30445
    { 
28819
 
 yyval.str = cat_str(5,make_str("alter operator"),yyvsp[-4].str,yyvsp[-3].str,make_str("owner to"),yyvsp[0].str);
 
30446
 (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));
28820
30447
;}
28821
30448
    break;
28822
30449
 
28823
30450
  case 872:
 
30451
 
 
30452
/* Line 1455 of yacc.c  */
28824
30453
#line 5542 "preproc.y"
28825
30454
    { 
28826
 
 yyval.str = cat_str(6,make_str("alter operator class"),yyvsp[-5].str,make_str("using"),yyvsp[-3].str,make_str("owner to"),yyvsp[0].str);
 
30455
 (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));
28827
30456
;}
28828
30457
    break;
28829
30458
 
28830
30459
  case 873:
 
30460
 
 
30461
/* Line 1455 of yacc.c  */
28831
30462
#line 5546 "preproc.y"
28832
30463
    { 
28833
 
 yyval.str = cat_str(6,make_str("alter operator family"),yyvsp[-5].str,make_str("using"),yyvsp[-3].str,make_str("owner to"),yyvsp[0].str);
 
30464
 (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));
28834
30465
;}
28835
30466
    break;
28836
30467
 
28837
30468
  case 874:
 
30469
 
 
30470
/* Line 1455 of yacc.c  */
28838
30471
#line 5550 "preproc.y"
28839
30472
    { 
28840
 
 yyval.str = cat_str(4,make_str("alter schema"),yyvsp[-3].str,make_str("owner to"),yyvsp[0].str);
 
30473
 (yyval.str) = cat_str(4,make_str("alter schema"),(yyvsp[(3) - (6)].str),make_str("owner to"),(yyvsp[(6) - (6)].str));
28841
30474
;}
28842
30475
    break;
28843
30476
 
28844
30477
  case 875:
 
30478
 
 
30479
/* Line 1455 of yacc.c  */
28845
30480
#line 5554 "preproc.y"
28846
30481
    { 
28847
 
 yyval.str = cat_str(4,make_str("alter type"),yyvsp[-3].str,make_str("owner to"),yyvsp[0].str);
 
30482
 (yyval.str) = cat_str(4,make_str("alter type"),(yyvsp[(3) - (6)].str),make_str("owner to"),(yyvsp[(6) - (6)].str));
28848
30483
;}
28849
30484
    break;
28850
30485
 
28851
30486
  case 876:
 
30487
 
 
30488
/* Line 1455 of yacc.c  */
28852
30489
#line 5558 "preproc.y"
28853
30490
    { 
28854
 
 yyval.str = cat_str(4,make_str("alter tablespace"),yyvsp[-3].str,make_str("owner to"),yyvsp[0].str);
 
30491
 (yyval.str) = cat_str(4,make_str("alter tablespace"),(yyvsp[(3) - (6)].str),make_str("owner to"),(yyvsp[(6) - (6)].str));
28855
30492
;}
28856
30493
    break;
28857
30494
 
28858
30495
  case 877:
 
30496
 
 
30497
/* Line 1455 of yacc.c  */
28859
30498
#line 5562 "preproc.y"
28860
30499
    { 
28861
 
 yyval.str = cat_str(4,make_str("alter text search dictionary"),yyvsp[-3].str,make_str("owner to"),yyvsp[0].str);
 
30500
 (yyval.str) = cat_str(4,make_str("alter text search dictionary"),(yyvsp[(5) - (8)].str),make_str("owner to"),(yyvsp[(8) - (8)].str));
28862
30501
;}
28863
30502
    break;
28864
30503
 
28865
30504
  case 878:
 
30505
 
 
30506
/* Line 1455 of yacc.c  */
28866
30507
#line 5566 "preproc.y"
28867
30508
    { 
28868
 
 yyval.str = cat_str(4,make_str("alter text search configuration"),yyvsp[-3].str,make_str("owner to"),yyvsp[0].str);
 
30509
 (yyval.str) = cat_str(4,make_str("alter text search configuration"),(yyvsp[(5) - (8)].str),make_str("owner to"),(yyvsp[(8) - (8)].str));
28869
30510
;}
28870
30511
    break;
28871
30512
 
28872
30513
  case 879:
 
30514
 
 
30515
/* Line 1455 of yacc.c  */
28873
30516
#line 5570 "preproc.y"
28874
30517
    { 
28875
 
 yyval.str = cat_str(4,make_str("alter foreign data wrapper"),yyvsp[-3].str,make_str("owner to"),yyvsp[0].str);
 
30518
 (yyval.str) = cat_str(4,make_str("alter foreign data wrapper"),(yyvsp[(5) - (8)].str),make_str("owner to"),(yyvsp[(8) - (8)].str));
28876
30519
;}
28877
30520
    break;
28878
30521
 
28879
30522
  case 880:
 
30523
 
 
30524
/* Line 1455 of yacc.c  */
28880
30525
#line 5574 "preproc.y"
28881
30526
    { 
28882
 
 yyval.str = cat_str(4,make_str("alter server"),yyvsp[-3].str,make_str("owner to"),yyvsp[0].str);
 
30527
 (yyval.str) = cat_str(4,make_str("alter server"),(yyvsp[(3) - (6)].str),make_str("owner to"),(yyvsp[(6) - (6)].str));
28883
30528
;}
28884
30529
    break;
28885
30530
 
28886
30531
  case 881:
 
30532
 
 
30533
/* Line 1455 of yacc.c  */
28887
30534
#line 5582 "preproc.y"
28888
30535
    { 
28889
 
 yyval.str = make_str("nothing");
 
30536
 (yyval.str) = make_str("nothing");
28890
30537
;}
28891
30538
    break;
28892
30539
 
28893
30540
  case 882:
 
30541
 
 
30542
/* Line 1455 of yacc.c  */
28894
30543
#line 5586 "preproc.y"
28895
30544
    { 
28896
 
 yyval.str = yyvsp[0].str;
 
30545
 (yyval.str) = (yyvsp[(1) - (1)].str);
28897
30546
;}
28898
30547
    break;
28899
30548
 
28900
30549
  case 883:
 
30550
 
 
30551
/* Line 1455 of yacc.c  */
28901
30552
#line 5590 "preproc.y"
28902
30553
    { 
28903
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
30554
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
28904
30555
;}
28905
30556
    break;
28906
30557
 
28907
30558
  case 884:
 
30559
 
 
30560
/* Line 1455 of yacc.c  */
28908
30561
#line 5598 "preproc.y"
28909
30562
    { 
28910
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(";"),yyvsp[0].str);
 
30563
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(";"),(yyvsp[(3) - (3)].str));
28911
30564
;}
28912
30565
    break;
28913
30566
 
28914
30567
  case 885:
 
30568
 
 
30569
/* Line 1455 of yacc.c  */
28915
30570
#line 5602 "preproc.y"
28916
30571
    { 
28917
 
 yyval.str = yyvsp[0].str;
 
30572
 (yyval.str) = (yyvsp[(1) - (1)].str);
28918
30573
;}
28919
30574
    break;
28920
30575
 
28921
30576
  case 886:
 
30577
 
 
30578
/* Line 1455 of yacc.c  */
28922
30579
#line 5610 "preproc.y"
28923
30580
    { 
28924
 
 yyval.str = yyvsp[0].str;
 
30581
 (yyval.str) = (yyvsp[(1) - (1)].str);
28925
30582
;}
28926
30583
    break;
28927
30584
 
28928
30585
  case 887:
 
30586
 
 
30587
/* Line 1455 of yacc.c  */
28929
30588
#line 5614 "preproc.y"
28930
30589
    { 
28931
 
 yyval.str = yyvsp[0].str;
 
30590
 (yyval.str) = (yyvsp[(1) - (1)].str);
28932
30591
;}
28933
30592
    break;
28934
30593
 
28935
30594
  case 888:
 
30595
 
 
30596
/* Line 1455 of yacc.c  */
28936
30597
#line 5618 "preproc.y"
28937
30598
    { 
28938
 
 yyval.str = yyvsp[0].str;
 
30599
 (yyval.str) = (yyvsp[(1) - (1)].str);
28939
30600
;}
28940
30601
    break;
28941
30602
 
28942
30603
  case 889:
 
30604
 
 
30605
/* Line 1455 of yacc.c  */
28943
30606
#line 5622 "preproc.y"
28944
30607
    { 
28945
 
 yyval.str = yyvsp[0].str;
 
30608
 (yyval.str) = (yyvsp[(1) - (1)].str);
28946
30609
;}
28947
30610
    break;
28948
30611
 
28949
30612
  case 890:
 
30613
 
 
30614
/* Line 1455 of yacc.c  */
28950
30615
#line 5626 "preproc.y"
28951
30616
    { 
28952
 
 yyval.str = yyvsp[0].str;
 
30617
 (yyval.str) = (yyvsp[(1) - (1)].str);
28953
30618
;}
28954
30619
    break;
28955
30620
 
28956
30621
  case 891:
 
30622
 
 
30623
/* Line 1455 of yacc.c  */
28957
30624
#line 5634 "preproc.y"
28958
30625
    { 
28959
 
 yyval.str = yyvsp[0].str;
 
30626
 (yyval.str) = (yyvsp[(1) - (1)].str);
28960
30627
;}
28961
30628
    break;
28962
30629
 
28963
30630
  case 892:
 
30631
 
 
30632
/* Line 1455 of yacc.c  */
28964
30633
#line 5638 "preproc.y"
28965
30634
    { 
28966
 
 yyval.str=EMPTY; ;}
 
30635
 (yyval.str)=EMPTY; ;}
28967
30636
    break;
28968
30637
 
28969
30638
  case 893:
 
30639
 
 
30640
/* Line 1455 of yacc.c  */
28970
30641
#line 5645 "preproc.y"
28971
30642
    { 
28972
 
 yyval.str = make_str("select");
 
30643
 (yyval.str) = make_str("select");
28973
30644
;}
28974
30645
    break;
28975
30646
 
28976
30647
  case 894:
 
30648
 
 
30649
/* Line 1455 of yacc.c  */
28977
30650
#line 5649 "preproc.y"
28978
30651
    { 
28979
 
 yyval.str = make_str("update");
 
30652
 (yyval.str) = make_str("update");
28980
30653
;}
28981
30654
    break;
28982
30655
 
28983
30656
  case 895:
 
30657
 
 
30658
/* Line 1455 of yacc.c  */
28984
30659
#line 5653 "preproc.y"
28985
30660
    { 
28986
 
 yyval.str = make_str("delete");
 
30661
 (yyval.str) = make_str("delete");
28987
30662
;}
28988
30663
    break;
28989
30664
 
28990
30665
  case 896:
 
30666
 
 
30667
/* Line 1455 of yacc.c  */
28991
30668
#line 5657 "preproc.y"
28992
30669
    { 
28993
 
 yyval.str = make_str("insert");
 
30670
 (yyval.str) = make_str("insert");
28994
30671
;}
28995
30672
    break;
28996
30673
 
28997
30674
  case 897:
 
30675
 
 
30676
/* Line 1455 of yacc.c  */
28998
30677
#line 5665 "preproc.y"
28999
30678
    { 
29000
 
 yyval.str = make_str("instead");
 
30679
 (yyval.str) = make_str("instead");
29001
30680
;}
29002
30681
    break;
29003
30682
 
29004
30683
  case 898:
 
30684
 
 
30685
/* Line 1455 of yacc.c  */
29005
30686
#line 5669 "preproc.y"
29006
30687
    { 
29007
 
 yyval.str = make_str("also");
 
30688
 (yyval.str) = make_str("also");
29008
30689
;}
29009
30690
    break;
29010
30691
 
29011
30692
  case 899:
 
30693
 
 
30694
/* Line 1455 of yacc.c  */
29012
30695
#line 5673 "preproc.y"
29013
30696
    { 
29014
 
 yyval.str=EMPTY; ;}
 
30697
 (yyval.str)=EMPTY; ;}
29015
30698
    break;
29016
30699
 
29017
30700
  case 900:
 
30701
 
 
30702
/* Line 1455 of yacc.c  */
29018
30703
#line 5680 "preproc.y"
29019
30704
    { 
29020
 
 yyval.str = cat_str(5,make_str("drop rule"),yyvsp[-3].str,make_str("on"),yyvsp[-1].str,yyvsp[0].str);
 
30705
 (yyval.str) = cat_str(5,make_str("drop rule"),(yyvsp[(3) - (6)].str),make_str("on"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str));
29021
30706
;}
29022
30707
    break;
29023
30708
 
29024
30709
  case 901:
 
30710
 
 
30711
/* Line 1455 of yacc.c  */
29025
30712
#line 5684 "preproc.y"
29026
30713
    { 
29027
 
 yyval.str = cat_str(5,make_str("drop rule if exists"),yyvsp[-3].str,make_str("on"),yyvsp[-1].str,yyvsp[0].str);
 
30714
 (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));
29028
30715
;}
29029
30716
    break;
29030
30717
 
29031
30718
  case 902:
 
30719
 
 
30720
/* Line 1455 of yacc.c  */
29032
30721
#line 5692 "preproc.y"
29033
30722
    { 
29034
 
 yyval.str = cat_str(2,make_str("notify"),yyvsp[0].str);
 
30723
 (yyval.str) = cat_str(2,make_str("notify"),(yyvsp[(2) - (2)].str));
29035
30724
;}
29036
30725
    break;
29037
30726
 
29038
30727
  case 903:
 
30728
 
 
30729
/* Line 1455 of yacc.c  */
29039
30730
#line 5700 "preproc.y"
29040
30731
    { 
29041
 
 yyval.str = cat_str(2,make_str("listen"),yyvsp[0].str);
 
30732
 (yyval.str) = cat_str(2,make_str("listen"),(yyvsp[(2) - (2)].str));
29042
30733
;}
29043
30734
    break;
29044
30735
 
29045
30736
  case 904:
 
30737
 
 
30738
/* Line 1455 of yacc.c  */
29046
30739
#line 5708 "preproc.y"
29047
30740
    { 
29048
 
 yyval.str = cat_str(2,make_str("unlisten"),yyvsp[0].str);
 
30741
 (yyval.str) = cat_str(2,make_str("unlisten"),(yyvsp[(2) - (2)].str));
29049
30742
;}
29050
30743
    break;
29051
30744
 
29052
30745
  case 905:
 
30746
 
 
30747
/* Line 1455 of yacc.c  */
29053
30748
#line 5712 "preproc.y"
29054
30749
    { 
29055
 
 yyval.str = make_str("unlisten *");
 
30750
 (yyval.str) = make_str("unlisten *");
29056
30751
;}
29057
30752
    break;
29058
30753
 
29059
30754
  case 906:
 
30755
 
 
30756
/* Line 1455 of yacc.c  */
29060
30757
#line 5720 "preproc.y"
29061
30758
    { 
29062
 
 yyval.str = cat_str(2,make_str("abort"),yyvsp[0].str);
 
30759
 (yyval.str) = cat_str(2,make_str("abort"),(yyvsp[(2) - (2)].str));
29063
30760
;}
29064
30761
    break;
29065
30762
 
29066
30763
  case 907:
 
30764
 
 
30765
/* Line 1455 of yacc.c  */
29067
30766
#line 5724 "preproc.y"
29068
30767
    { 
29069
 
 yyval.str = cat_str(3,make_str("begin"),yyvsp[-1].str,yyvsp[0].str);
 
30768
 (yyval.str) = cat_str(3,make_str("begin"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
29070
30769
;}
29071
30770
    break;
29072
30771
 
29073
30772
  case 908:
 
30773
 
 
30774
/* Line 1455 of yacc.c  */
29074
30775
#line 5728 "preproc.y"
29075
30776
    { 
29076
 
 yyval.str = cat_str(2,make_str("start transaction"),yyvsp[0].str);
 
30777
 (yyval.str) = cat_str(2,make_str("start transaction"),(yyvsp[(3) - (3)].str));
29077
30778
;}
29078
30779
    break;
29079
30780
 
29080
30781
  case 909:
 
30782
 
 
30783
/* Line 1455 of yacc.c  */
29081
30784
#line 5732 "preproc.y"
29082
30785
    { 
29083
 
 yyval.str = cat_str(2,make_str("commit"),yyvsp[0].str);
 
30786
 (yyval.str) = cat_str(2,make_str("commit"),(yyvsp[(2) - (2)].str));
29084
30787
;}
29085
30788
    break;
29086
30789
 
29087
30790
  case 910:
 
30791
 
 
30792
/* Line 1455 of yacc.c  */
29088
30793
#line 5736 "preproc.y"
29089
30794
    { 
29090
 
 yyval.str = cat_str(2,make_str("end"),yyvsp[0].str);
 
30795
 (yyval.str) = cat_str(2,make_str("end"),(yyvsp[(2) - (2)].str));
29091
30796
;}
29092
30797
    break;
29093
30798
 
29094
30799
  case 911:
 
30800
 
 
30801
/* Line 1455 of yacc.c  */
29095
30802
#line 5740 "preproc.y"
29096
30803
    { 
29097
 
 yyval.str = cat_str(2,make_str("rollback"),yyvsp[0].str);
 
30804
 (yyval.str) = cat_str(2,make_str("rollback"),(yyvsp[(2) - (2)].str));
29098
30805
;}
29099
30806
    break;
29100
30807
 
29101
30808
  case 912:
 
30809
 
 
30810
/* Line 1455 of yacc.c  */
29102
30811
#line 5744 "preproc.y"
29103
30812
    { 
29104
 
 yyval.str = cat_str(2,make_str("savepoint"),yyvsp[0].str);
 
30813
 (yyval.str) = cat_str(2,make_str("savepoint"),(yyvsp[(2) - (2)].str));
29105
30814
;}
29106
30815
    break;
29107
30816
 
29108
30817
  case 913:
 
30818
 
 
30819
/* Line 1455 of yacc.c  */
29109
30820
#line 5748 "preproc.y"
29110
30821
    { 
29111
 
 yyval.str = cat_str(2,make_str("release savepoint"),yyvsp[0].str);
 
30822
 (yyval.str) = cat_str(2,make_str("release savepoint"),(yyvsp[(3) - (3)].str));
29112
30823
;}
29113
30824
    break;
29114
30825
 
29115
30826
  case 914:
 
30827
 
 
30828
/* Line 1455 of yacc.c  */
29116
30829
#line 5752 "preproc.y"
29117
30830
    { 
29118
 
 yyval.str = cat_str(2,make_str("release"),yyvsp[0].str);
 
30831
 (yyval.str) = cat_str(2,make_str("release"),(yyvsp[(2) - (2)].str));
29119
30832
;}
29120
30833
    break;
29121
30834
 
29122
30835
  case 915:
 
30836
 
 
30837
/* Line 1455 of yacc.c  */
29123
30838
#line 5756 "preproc.y"
29124
30839
    { 
29125
 
 yyval.str = cat_str(4,make_str("rollback"),yyvsp[-3].str,make_str("to savepoint"),yyvsp[0].str);
 
30840
 (yyval.str) = cat_str(4,make_str("rollback"),(yyvsp[(2) - (5)].str),make_str("to savepoint"),(yyvsp[(5) - (5)].str));
29126
30841
;}
29127
30842
    break;
29128
30843
 
29129
30844
  case 916:
 
30845
 
 
30846
/* Line 1455 of yacc.c  */
29130
30847
#line 5760 "preproc.y"
29131
30848
    { 
29132
 
 yyval.str = cat_str(4,make_str("rollback"),yyvsp[-2].str,make_str("to"),yyvsp[0].str);
 
30849
 (yyval.str) = cat_str(4,make_str("rollback"),(yyvsp[(2) - (4)].str),make_str("to"),(yyvsp[(4) - (4)].str));
29133
30850
;}
29134
30851
    break;
29135
30852
 
29136
30853
  case 917:
 
30854
 
 
30855
/* Line 1455 of yacc.c  */
29137
30856
#line 5764 "preproc.y"
29138
30857
    { 
29139
 
 yyval.str = cat_str(2,make_str("prepare transaction"),yyvsp[0].str);
 
30858
 (yyval.str) = cat_str(2,make_str("prepare transaction"),(yyvsp[(3) - (3)].str));
29140
30859
;}
29141
30860
    break;
29142
30861
 
29143
30862
  case 918:
 
30863
 
 
30864
/* Line 1455 of yacc.c  */
29144
30865
#line 5768 "preproc.y"
29145
30866
    { 
29146
 
 yyval.str = cat_str(2,make_str("commit prepared"),yyvsp[0].str);
 
30867
 (yyval.str) = cat_str(2,make_str("commit prepared"),(yyvsp[(3) - (3)].str));
29147
30868
;}
29148
30869
    break;
29149
30870
 
29150
30871
  case 919:
 
30872
 
 
30873
/* Line 1455 of yacc.c  */
29151
30874
#line 5772 "preproc.y"
29152
30875
    { 
29153
 
 yyval.str = cat_str(2,make_str("rollback prepared"),yyvsp[0].str);
 
30876
 (yyval.str) = cat_str(2,make_str("rollback prepared"),(yyvsp[(3) - (3)].str));
29154
30877
;}
29155
30878
    break;
29156
30879
 
29157
30880
  case 920:
 
30881
 
 
30882
/* Line 1455 of yacc.c  */
29158
30883
#line 5780 "preproc.y"
29159
30884
    { 
29160
 
 yyval.str = make_str("work");
 
30885
 (yyval.str) = make_str("work");
29161
30886
;}
29162
30887
    break;
29163
30888
 
29164
30889
  case 921:
 
30890
 
 
30891
/* Line 1455 of yacc.c  */
29165
30892
#line 5784 "preproc.y"
29166
30893
    { 
29167
 
 yyval.str = make_str("transaction");
 
30894
 (yyval.str) = make_str("transaction");
29168
30895
;}
29169
30896
    break;
29170
30897
 
29171
30898
  case 922:
 
30899
 
 
30900
/* Line 1455 of yacc.c  */
29172
30901
#line 5788 "preproc.y"
29173
30902
    { 
29174
 
 yyval.str=EMPTY; ;}
 
30903
 (yyval.str)=EMPTY; ;}
29175
30904
    break;
29176
30905
 
29177
30906
  case 923:
 
30907
 
 
30908
/* Line 1455 of yacc.c  */
29178
30909
#line 5795 "preproc.y"
29179
30910
    { 
29180
 
 yyval.str = cat_str(2,make_str("isolation level"),yyvsp[0].str);
 
30911
 (yyval.str) = cat_str(2,make_str("isolation level"),(yyvsp[(3) - (3)].str));
29181
30912
;}
29182
30913
    break;
29183
30914
 
29184
30915
  case 924:
 
30916
 
 
30917
/* Line 1455 of yacc.c  */
29185
30918
#line 5799 "preproc.y"
29186
30919
    { 
29187
 
 yyval.str = make_str("read only");
 
30920
 (yyval.str) = make_str("read only");
29188
30921
;}
29189
30922
    break;
29190
30923
 
29191
30924
  case 925:
 
30925
 
 
30926
/* Line 1455 of yacc.c  */
29192
30927
#line 5803 "preproc.y"
29193
30928
    { 
29194
 
 yyval.str = make_str("read write");
 
30929
 (yyval.str) = make_str("read write");
29195
30930
;}
29196
30931
    break;
29197
30932
 
29198
30933
  case 926:
 
30934
 
 
30935
/* Line 1455 of yacc.c  */
29199
30936
#line 5811 "preproc.y"
29200
30937
    { 
29201
 
 yyval.str = yyvsp[0].str;
 
30938
 (yyval.str) = (yyvsp[(1) - (1)].str);
29202
30939
;}
29203
30940
    break;
29204
30941
 
29205
30942
  case 927:
 
30943
 
 
30944
/* Line 1455 of yacc.c  */
29206
30945
#line 5815 "preproc.y"
29207
30946
    { 
29208
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
30947
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
29209
30948
;}
29210
30949
    break;
29211
30950
 
29212
30951
  case 928:
 
30952
 
 
30953
/* Line 1455 of yacc.c  */
29213
30954
#line 5819 "preproc.y"
29214
30955
    { 
29215
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
30956
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
29216
30957
;}
29217
30958
    break;
29218
30959
 
29219
30960
  case 929:
 
30961
 
 
30962
/* Line 1455 of yacc.c  */
29220
30963
#line 5827 "preproc.y"
29221
30964
    { 
29222
 
 yyval.str = yyvsp[0].str;
 
30965
 (yyval.str) = (yyvsp[(1) - (1)].str);
29223
30966
;}
29224
30967
    break;
29225
30968
 
29226
30969
  case 930:
 
30970
 
 
30971
/* Line 1455 of yacc.c  */
29227
30972
#line 5831 "preproc.y"
29228
30973
    { 
29229
 
 yyval.str=EMPTY; ;}
 
30974
 (yyval.str)=EMPTY; ;}
29230
30975
    break;
29231
30976
 
29232
30977
  case 931:
 
30978
 
 
30979
/* Line 1455 of yacc.c  */
29233
30980
#line 5838 "preproc.y"
29234
30981
    { 
29235
 
 yyval.str = cat_str(8,make_str("create"),yyvsp[-6].str,make_str("view"),yyvsp[-4].str,yyvsp[-3].str,make_str("as"),yyvsp[-1].str,yyvsp[0].str);
 
30982
 (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));
29236
30983
;}
29237
30984
    break;
29238
30985
 
29239
30986
  case 932:
 
30987
 
 
30988
/* Line 1455 of yacc.c  */
29240
30989
#line 5842 "preproc.y"
29241
30990
    { 
29242
 
 yyval.str = cat_str(8,make_str("create or replace"),yyvsp[-6].str,make_str("view"),yyvsp[-4].str,yyvsp[-3].str,make_str("as"),yyvsp[-1].str,yyvsp[0].str);
 
30991
 (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));
29243
30992
;}
29244
30993
    break;
29245
30994
 
29246
30995
  case 933:
 
30996
 
 
30997
/* Line 1455 of yacc.c  */
29247
30998
#line 5850 "preproc.y"
29248
30999
    { 
29249
31000
mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
29250
 
 yyval.str = make_str("with check option");
 
31001
 (yyval.str) = make_str("with check option");
29251
31002
;}
29252
31003
    break;
29253
31004
 
29254
31005
  case 934:
 
31006
 
 
31007
/* Line 1455 of yacc.c  */
29255
31008
#line 5855 "preproc.y"
29256
31009
    { 
29257
31010
mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
29258
 
 yyval.str = make_str("with cascaded check option");
 
31011
 (yyval.str) = make_str("with cascaded check option");
29259
31012
;}
29260
31013
    break;
29261
31014
 
29262
31015
  case 935:
 
31016
 
 
31017
/* Line 1455 of yacc.c  */
29263
31018
#line 5860 "preproc.y"
29264
31019
    { 
29265
31020
mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
29266
 
 yyval.str = make_str("with local check option");
 
31021
 (yyval.str) = make_str("with local check option");
29267
31022
;}
29268
31023
    break;
29269
31024
 
29270
31025
  case 936:
 
31026
 
 
31027
/* Line 1455 of yacc.c  */
29271
31028
#line 5865 "preproc.y"
29272
31029
    { 
29273
 
 yyval.str=EMPTY; ;}
 
31030
 (yyval.str)=EMPTY; ;}
29274
31031
    break;
29275
31032
 
29276
31033
  case 937:
 
31034
 
 
31035
/* Line 1455 of yacc.c  */
29277
31036
#line 5872 "preproc.y"
29278
31037
    { 
29279
 
 yyval.str = cat_str(2,make_str("load"),yyvsp[0].str);
 
31038
 (yyval.str) = cat_str(2,make_str("load"),(yyvsp[(2) - (2)].str));
29280
31039
;}
29281
31040
    break;
29282
31041
 
29283
31042
  case 938:
 
31043
 
 
31044
/* Line 1455 of yacc.c  */
29284
31045
#line 5880 "preproc.y"
29285
31046
    { 
29286
 
 yyval.str = cat_str(4,make_str("create database"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
31047
 (yyval.str) = cat_str(4,make_str("create database"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
29287
31048
;}
29288
31049
    break;
29289
31050
 
29290
31051
  case 939:
 
31052
 
 
31053
/* Line 1455 of yacc.c  */
29291
31054
#line 5888 "preproc.y"
29292
31055
    { 
29293
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
31056
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
29294
31057
;}
29295
31058
    break;
29296
31059
 
29297
31060
  case 940:
 
31061
 
 
31062
/* Line 1455 of yacc.c  */
29298
31063
#line 5892 "preproc.y"
29299
31064
    { 
29300
 
 yyval.str=EMPTY; ;}
 
31065
 (yyval.str)=EMPTY; ;}
29301
31066
    break;
29302
31067
 
29303
31068
  case 941:
 
31069
 
 
31070
/* Line 1455 of yacc.c  */
29304
31071
#line 5899 "preproc.y"
29305
31072
    { 
29306
 
 yyval.str = cat_str(3,make_str("tablespace"),yyvsp[-1].str,yyvsp[0].str);
 
31073
 (yyval.str) = cat_str(3,make_str("tablespace"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
29307
31074
;}
29308
31075
    break;
29309
31076
 
29310
31077
  case 942:
 
31078
 
 
31079
/* Line 1455 of yacc.c  */
29311
31080
#line 5903 "preproc.y"
29312
31081
    { 
29313
 
 yyval.str = cat_str(3,make_str("tablespace"),yyvsp[-1].str,make_str("default"));
 
31082
 (yyval.str) = cat_str(3,make_str("tablespace"),(yyvsp[(2) - (3)].str),make_str("default"));
29314
31083
;}
29315
31084
    break;
29316
31085
 
29317
31086
  case 943:
 
31087
 
 
31088
/* Line 1455 of yacc.c  */
29318
31089
#line 5907 "preproc.y"
29319
31090
    { 
29320
 
 yyval.str = cat_str(3,make_str("location"),yyvsp[-1].str,yyvsp[0].str);
 
31091
 (yyval.str) = cat_str(3,make_str("location"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
29321
31092
;}
29322
31093
    break;
29323
31094
 
29324
31095
  case 944:
 
31096
 
 
31097
/* Line 1455 of yacc.c  */
29325
31098
#line 5911 "preproc.y"
29326
31099
    { 
29327
 
 yyval.str = cat_str(3,make_str("location"),yyvsp[-1].str,make_str("default"));
 
31100
 (yyval.str) = cat_str(3,make_str("location"),(yyvsp[(2) - (3)].str),make_str("default"));
29328
31101
;}
29329
31102
    break;
29330
31103
 
29331
31104
  case 945:
 
31105
 
 
31106
/* Line 1455 of yacc.c  */
29332
31107
#line 5915 "preproc.y"
29333
31108
    { 
29334
 
 yyval.str = cat_str(3,make_str("template"),yyvsp[-1].str,yyvsp[0].str);
 
31109
 (yyval.str) = cat_str(3,make_str("template"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
29335
31110
;}
29336
31111
    break;
29337
31112
 
29338
31113
  case 946:
 
31114
 
 
31115
/* Line 1455 of yacc.c  */
29339
31116
#line 5919 "preproc.y"
29340
31117
    { 
29341
 
 yyval.str = cat_str(3,make_str("template"),yyvsp[-1].str,make_str("default"));
 
31118
 (yyval.str) = cat_str(3,make_str("template"),(yyvsp[(2) - (3)].str),make_str("default"));
29342
31119
;}
29343
31120
    break;
29344
31121
 
29345
31122
  case 947:
 
31123
 
 
31124
/* Line 1455 of yacc.c  */
29346
31125
#line 5923 "preproc.y"
29347
31126
    { 
29348
 
 yyval.str = cat_str(3,make_str("encoding"),yyvsp[-1].str,yyvsp[0].str);
 
31127
 (yyval.str) = cat_str(3,make_str("encoding"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
29349
31128
;}
29350
31129
    break;
29351
31130
 
29352
31131
  case 948:
 
31132
 
 
31133
/* Line 1455 of yacc.c  */
29353
31134
#line 5927 "preproc.y"
29354
31135
    { 
29355
 
 yyval.str = cat_str(3,make_str("encoding"),yyvsp[-1].str,yyvsp[0].str);
 
31136
 (yyval.str) = cat_str(3,make_str("encoding"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
29356
31137
;}
29357
31138
    break;
29358
31139
 
29359
31140
  case 949:
 
31141
 
 
31142
/* Line 1455 of yacc.c  */
29360
31143
#line 5931 "preproc.y"
29361
31144
    { 
29362
 
 yyval.str = cat_str(3,make_str("encoding"),yyvsp[-1].str,make_str("default"));
 
31145
 (yyval.str) = cat_str(3,make_str("encoding"),(yyvsp[(2) - (3)].str),make_str("default"));
29363
31146
;}
29364
31147
    break;
29365
31148
 
29366
31149
  case 950:
 
31150
 
 
31151
/* Line 1455 of yacc.c  */
29367
31152
#line 5935 "preproc.y"
29368
31153
    { 
29369
 
 yyval.str = cat_str(3,make_str("lc_collate"),yyvsp[-1].str,yyvsp[0].str);
 
31154
 (yyval.str) = cat_str(3,make_str("lc_collate"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
29370
31155
;}
29371
31156
    break;
29372
31157
 
29373
31158
  case 951:
 
31159
 
 
31160
/* Line 1455 of yacc.c  */
29374
31161
#line 5939 "preproc.y"
29375
31162
    { 
29376
 
 yyval.str = cat_str(3,make_str("lc_collate"),yyvsp[-1].str,make_str("default"));
 
31163
 (yyval.str) = cat_str(3,make_str("lc_collate"),(yyvsp[(2) - (3)].str),make_str("default"));
29377
31164
;}
29378
31165
    break;
29379
31166
 
29380
31167
  case 952:
 
31168
 
 
31169
/* Line 1455 of yacc.c  */
29381
31170
#line 5943 "preproc.y"
29382
31171
    { 
29383
 
 yyval.str = cat_str(3,make_str("lc_ctype"),yyvsp[-1].str,yyvsp[0].str);
 
31172
 (yyval.str) = cat_str(3,make_str("lc_ctype"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
29384
31173
;}
29385
31174
    break;
29386
31175
 
29387
31176
  case 953:
 
31177
 
 
31178
/* Line 1455 of yacc.c  */
29388
31179
#line 5947 "preproc.y"
29389
31180
    { 
29390
 
 yyval.str = cat_str(3,make_str("lc_ctype"),yyvsp[-1].str,make_str("default"));
 
31181
 (yyval.str) = cat_str(3,make_str("lc_ctype"),(yyvsp[(2) - (3)].str),make_str("default"));
29391
31182
;}
29392
31183
    break;
29393
31184
 
29394
31185
  case 954:
 
31186
 
 
31187
/* Line 1455 of yacc.c  */
29395
31188
#line 5951 "preproc.y"
29396
31189
    { 
29397
 
 yyval.str = cat_str(3,make_str("connection limit"),yyvsp[-1].str,yyvsp[0].str);
 
31190
 (yyval.str) = cat_str(3,make_str("connection limit"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
29398
31191
;}
29399
31192
    break;
29400
31193
 
29401
31194
  case 955:
 
31195
 
 
31196
/* Line 1455 of yacc.c  */
29402
31197
#line 5955 "preproc.y"
29403
31198
    { 
29404
 
 yyval.str = cat_str(3,make_str("owner"),yyvsp[-1].str,yyvsp[0].str);
 
31199
 (yyval.str) = cat_str(3,make_str("owner"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
29405
31200
;}
29406
31201
    break;
29407
31202
 
29408
31203
  case 956:
 
31204
 
 
31205
/* Line 1455 of yacc.c  */
29409
31206
#line 5959 "preproc.y"
29410
31207
    { 
29411
 
 yyval.str = cat_str(3,make_str("owner"),yyvsp[-1].str,make_str("default"));
 
31208
 (yyval.str) = cat_str(3,make_str("owner"),(yyvsp[(2) - (3)].str),make_str("default"));
29412
31209
;}
29413
31210
    break;
29414
31211
 
29415
31212
  case 957:
 
31213
 
 
31214
/* Line 1455 of yacc.c  */
29416
31215
#line 5967 "preproc.y"
29417
31216
    { 
29418
 
 yyval.str = make_str("=");
 
31217
 (yyval.str) = make_str("=");
29419
31218
;}
29420
31219
    break;
29421
31220
 
29422
31221
  case 958:
 
31222
 
 
31223
/* Line 1455 of yacc.c  */
29423
31224
#line 5971 "preproc.y"
29424
31225
    { 
29425
 
 yyval.str=EMPTY; ;}
 
31226
 (yyval.str)=EMPTY; ;}
29426
31227
    break;
29427
31228
 
29428
31229
  case 959:
 
31230
 
 
31231
/* Line 1455 of yacc.c  */
29429
31232
#line 5978 "preproc.y"
29430
31233
    { 
29431
 
 yyval.str = cat_str(4,make_str("alter database"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
31234
 (yyval.str) = cat_str(4,make_str("alter database"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
29432
31235
;}
29433
31236
    break;
29434
31237
 
29435
31238
  case 960:
 
31239
 
 
31240
/* Line 1455 of yacc.c  */
29436
31241
#line 5982 "preproc.y"
29437
31242
    { 
29438
 
 yyval.str = cat_str(4,make_str("alter database"),yyvsp[-3].str,make_str("set tablespace"),yyvsp[0].str);
 
31243
 (yyval.str) = cat_str(4,make_str("alter database"),(yyvsp[(3) - (6)].str),make_str("set tablespace"),(yyvsp[(6) - (6)].str));
29439
31244
;}
29440
31245
    break;
29441
31246
 
29442
31247
  case 961:
 
31248
 
 
31249
/* Line 1455 of yacc.c  */
29443
31250
#line 5990 "preproc.y"
29444
31251
    { 
29445
 
 yyval.str = cat_str(3,make_str("alter database"),yyvsp[-1].str,yyvsp[0].str);
 
31252
 (yyval.str) = cat_str(3,make_str("alter database"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
29446
31253
;}
29447
31254
    break;
29448
31255
 
29449
31256
  case 962:
 
31257
 
 
31258
/* Line 1455 of yacc.c  */
29450
31259
#line 5998 "preproc.y"
29451
31260
    { 
29452
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
31261
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
29453
31262
;}
29454
31263
    break;
29455
31264
 
29456
31265
  case 963:
 
31266
 
 
31267
/* Line 1455 of yacc.c  */
29457
31268
#line 6002 "preproc.y"
29458
31269
    { 
29459
 
 yyval.str=EMPTY; ;}
 
31270
 (yyval.str)=EMPTY; ;}
29460
31271
    break;
29461
31272
 
29462
31273
  case 964:
 
31274
 
 
31275
/* Line 1455 of yacc.c  */
29463
31276
#line 6009 "preproc.y"
29464
31277
    { 
29465
 
 yyval.str = cat_str(3,make_str("connection limit"),yyvsp[-1].str,yyvsp[0].str);
 
31278
 (yyval.str) = cat_str(3,make_str("connection limit"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
29466
31279
;}
29467
31280
    break;
29468
31281
 
29469
31282
  case 965:
 
31283
 
 
31284
/* Line 1455 of yacc.c  */
29470
31285
#line 6017 "preproc.y"
29471
31286
    { 
29472
 
 yyval.str = cat_str(2,make_str("drop database"),yyvsp[0].str);
 
31287
 (yyval.str) = cat_str(2,make_str("drop database"),(yyvsp[(3) - (3)].str));
29473
31288
;}
29474
31289
    break;
29475
31290
 
29476
31291
  case 966:
 
31292
 
 
31293
/* Line 1455 of yacc.c  */
29477
31294
#line 6021 "preproc.y"
29478
31295
    { 
29479
 
 yyval.str = cat_str(2,make_str("drop database if exists"),yyvsp[0].str);
 
31296
 (yyval.str) = cat_str(2,make_str("drop database if exists"),(yyvsp[(5) - (5)].str));
29480
31297
;}
29481
31298
    break;
29482
31299
 
29483
31300
  case 967:
 
31301
 
 
31302
/* Line 1455 of yacc.c  */
29484
31303
#line 6029 "preproc.y"
29485
31304
    { 
29486
 
 yyval.str = cat_str(5,make_str("create domain"),yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
31305
 (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));
29487
31306
;}
29488
31307
    break;
29489
31308
 
29490
31309
  case 968:
 
31310
 
 
31311
/* Line 1455 of yacc.c  */
29491
31312
#line 6037 "preproc.y"
29492
31313
    { 
29493
 
 yyval.str = cat_str(3,make_str("alter domain"),yyvsp[-1].str,yyvsp[0].str);
 
31314
 (yyval.str) = cat_str(3,make_str("alter domain"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
29494
31315
;}
29495
31316
    break;
29496
31317
 
29497
31318
  case 969:
 
31319
 
 
31320
/* Line 1455 of yacc.c  */
29498
31321
#line 6041 "preproc.y"
29499
31322
    { 
29500
 
 yyval.str = cat_str(3,make_str("alter domain"),yyvsp[-3].str,make_str("drop not null"));
 
31323
 (yyval.str) = cat_str(3,make_str("alter domain"),(yyvsp[(3) - (6)].str),make_str("drop not null"));
29501
31324
;}
29502
31325
    break;
29503
31326
 
29504
31327
  case 970:
 
31328
 
 
31329
/* Line 1455 of yacc.c  */
29505
31330
#line 6045 "preproc.y"
29506
31331
    { 
29507
 
 yyval.str = cat_str(3,make_str("alter domain"),yyvsp[-3].str,make_str("set not null"));
 
31332
 (yyval.str) = cat_str(3,make_str("alter domain"),(yyvsp[(3) - (6)].str),make_str("set not null"));
29508
31333
;}
29509
31334
    break;
29510
31335
 
29511
31336
  case 971:
 
31337
 
 
31338
/* Line 1455 of yacc.c  */
29512
31339
#line 6049 "preproc.y"
29513
31340
    { 
29514
 
 yyval.str = cat_str(4,make_str("alter domain"),yyvsp[-2].str,make_str("add"),yyvsp[0].str);
 
31341
 (yyval.str) = cat_str(4,make_str("alter domain"),(yyvsp[(3) - (5)].str),make_str("add"),(yyvsp[(5) - (5)].str));
29515
31342
;}
29516
31343
    break;
29517
31344
 
29518
31345
  case 972:
 
31346
 
 
31347
/* Line 1455 of yacc.c  */
29519
31348
#line 6053 "preproc.y"
29520
31349
    { 
29521
 
 yyval.str = cat_str(5,make_str("alter domain"),yyvsp[-4].str,make_str("drop constraint"),yyvsp[-1].str,yyvsp[0].str);
 
31350
 (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));
29522
31351
;}
29523
31352
    break;
29524
31353
 
29525
31354
  case 973:
 
31355
 
 
31356
/* Line 1455 of yacc.c  */
29526
31357
#line 6061 "preproc.y"
29527
31358
    { 
29528
 
 yyval.str = make_str("as");
 
31359
 (yyval.str) = make_str("as");
29529
31360
;}
29530
31361
    break;
29531
31362
 
29532
31363
  case 974:
 
31364
 
 
31365
/* Line 1455 of yacc.c  */
29533
31366
#line 6065 "preproc.y"
29534
31367
    { 
29535
 
 yyval.str=EMPTY; ;}
 
31368
 (yyval.str)=EMPTY; ;}
29536
31369
    break;
29537
31370
 
29538
31371
  case 975:
 
31372
 
 
31373
/* Line 1455 of yacc.c  */
29539
31374
#line 6072 "preproc.y"
29540
31375
    { 
29541
 
 yyval.str = cat_str(3,make_str("alter text search dictionary"),yyvsp[-1].str,yyvsp[0].str);
 
31376
 (yyval.str) = cat_str(3,make_str("alter text search dictionary"),(yyvsp[(5) - (6)].str),(yyvsp[(6) - (6)].str));
29542
31377
;}
29543
31378
    break;
29544
31379
 
29545
31380
  case 976:
 
31381
 
 
31382
/* Line 1455 of yacc.c  */
29546
31383
#line 6080 "preproc.y"
29547
31384
    { 
29548
 
 yyval.str = cat_str(6,make_str("alter text search configuration"),yyvsp[-6].str,make_str("add mapping for"),yyvsp[-2].str,make_str("with"),yyvsp[0].str);
 
31385
 (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));
29549
31386
;}
29550
31387
    break;
29551
31388
 
29552
31389
  case 977:
 
31390
 
 
31391
/* Line 1455 of yacc.c  */
29553
31392
#line 6084 "preproc.y"
29554
31393
    { 
29555
 
 yyval.str = cat_str(6,make_str("alter text search configuration"),yyvsp[-6].str,make_str("alter mapping for"),yyvsp[-2].str,make_str("with"),yyvsp[0].str);
 
31394
 (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));
29556
31395
;}
29557
31396
    break;
29558
31397
 
29559
31398
  case 978:
 
31399
 
 
31400
/* Line 1455 of yacc.c  */
29560
31401
#line 6088 "preproc.y"
29561
31402
    { 
29562
 
 yyval.str = cat_str(6,make_str("alter text search configuration"),yyvsp[-6].str,make_str("alter mapping replace"),yyvsp[-2].str,make_str("with"),yyvsp[0].str);
 
31403
 (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));
29563
31404
;}
29564
31405
    break;
29565
31406
 
29566
31407
  case 979:
 
31408
 
 
31409
/* Line 1455 of yacc.c  */
29567
31410
#line 6092 "preproc.y"
29568
31411
    { 
29569
 
 yyval.str = cat_str(8,make_str("alter text search configuration"),yyvsp[-8].str,make_str("alter mapping for"),yyvsp[-4].str,make_str("replace"),yyvsp[-2].str,make_str("with"),yyvsp[0].str);
 
31412
 (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));
29570
31413
;}
29571
31414
    break;
29572
31415
 
29573
31416
  case 980:
 
31417
 
 
31418
/* Line 1455 of yacc.c  */
29574
31419
#line 6096 "preproc.y"
29575
31420
    { 
29576
 
 yyval.str = cat_str(4,make_str("alter text search configuration"),yyvsp[-4].str,make_str("drop mapping for"),yyvsp[0].str);
 
31421
 (yyval.str) = cat_str(4,make_str("alter text search configuration"),(yyvsp[(5) - (9)].str),make_str("drop mapping for"),(yyvsp[(9) - (9)].str));
29577
31422
;}
29578
31423
    break;
29579
31424
 
29580
31425
  case 981:
 
31426
 
 
31427
/* Line 1455 of yacc.c  */
29581
31428
#line 6100 "preproc.y"
29582
31429
    { 
29583
 
 yyval.str = cat_str(4,make_str("alter text search configuration"),yyvsp[-6].str,make_str("drop mapping if exists for"),yyvsp[0].str);
 
31430
 (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));
29584
31431
;}
29585
31432
    break;
29586
31433
 
29587
31434
  case 982:
 
31435
 
 
31436
/* Line 1455 of yacc.c  */
29588
31437
#line 6108 "preproc.y"
29589
31438
    { 
29590
 
 yyval.str = cat_str(10,make_str("create"),yyvsp[-8].str,make_str("conversion"),yyvsp[-6].str,make_str("for"),yyvsp[-4].str,make_str("to"),yyvsp[-2].str,make_str("from"),yyvsp[0].str);
 
31439
 (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));
29591
31440
;}
29592
31441
    break;
29593
31442
 
29594
31443
  case 983:
 
31444
 
 
31445
/* Line 1455 of yacc.c  */
29595
31446
#line 6116 "preproc.y"
29596
31447
    { 
29597
 
 yyval.str = cat_str(4,make_str("cluster"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
31448
 (yyval.str) = cat_str(4,make_str("cluster"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
29598
31449
;}
29599
31450
    break;
29600
31451
 
29601
31452
  case 984:
 
31453
 
 
31454
/* Line 1455 of yacc.c  */
29602
31455
#line 6120 "preproc.y"
29603
31456
    { 
29604
 
 yyval.str = cat_str(2,make_str("cluster"),yyvsp[0].str);
 
31457
 (yyval.str) = cat_str(2,make_str("cluster"),(yyvsp[(2) - (2)].str));
29605
31458
;}
29606
31459
    break;
29607
31460
 
29608
31461
  case 985:
 
31462
 
 
31463
/* Line 1455 of yacc.c  */
29609
31464
#line 6124 "preproc.y"
29610
31465
    { 
29611
 
 yyval.str = cat_str(5,make_str("cluster"),yyvsp[-3].str,yyvsp[-2].str,make_str("on"),yyvsp[0].str);
 
31466
 (yyval.str) = cat_str(5,make_str("cluster"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),make_str("on"),(yyvsp[(5) - (5)].str));
29612
31467
;}
29613
31468
    break;
29614
31469
 
29615
31470
  case 986:
 
31471
 
 
31472
/* Line 1455 of yacc.c  */
29616
31473
#line 6132 "preproc.y"
29617
31474
    { 
29618
 
 yyval.str = cat_str(2,make_str("using"),yyvsp[0].str);
 
31475
 (yyval.str) = cat_str(2,make_str("using"),(yyvsp[(2) - (2)].str));
29619
31476
;}
29620
31477
    break;
29621
31478
 
29622
31479
  case 987:
 
31480
 
 
31481
/* Line 1455 of yacc.c  */
29623
31482
#line 6136 "preproc.y"
29624
31483
    { 
29625
 
 yyval.str=EMPTY; ;}
 
31484
 (yyval.str)=EMPTY; ;}
29626
31485
    break;
29627
31486
 
29628
31487
  case 988:
 
31488
 
 
31489
/* Line 1455 of yacc.c  */
29629
31490
#line 6143 "preproc.y"
29630
31491
    { 
29631
 
 yyval.str = cat_str(4,make_str("vacuum"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
31492
 (yyval.str) = cat_str(4,make_str("vacuum"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
29632
31493
;}
29633
31494
    break;
29634
31495
 
29635
31496
  case 989:
 
31497
 
 
31498
/* Line 1455 of yacc.c  */
29636
31499
#line 6147 "preproc.y"
29637
31500
    { 
29638
 
 yyval.str = cat_str(5,make_str("vacuum"),yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
31501
 (yyval.str) = cat_str(5,make_str("vacuum"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
29639
31502
;}
29640
31503
    break;
29641
31504
 
29642
31505
  case 990:
 
31506
 
 
31507
/* Line 1455 of yacc.c  */
29643
31508
#line 6151 "preproc.y"
29644
31509
    { 
29645
 
 yyval.str = cat_str(5,make_str("vacuum"),yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
31510
 (yyval.str) = cat_str(5,make_str("vacuum"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
29646
31511
;}
29647
31512
    break;
29648
31513
 
29649
31514
  case 991:
 
31515
 
 
31516
/* Line 1455 of yacc.c  */
29650
31517
#line 6159 "preproc.y"
29651
31518
    { 
29652
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
31519
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
29653
31520
;}
29654
31521
    break;
29655
31522
 
29656
31523
  case 992:
 
31524
 
 
31525
/* Line 1455 of yacc.c  */
29657
31526
#line 6163 "preproc.y"
29658
31527
    { 
29659
 
 yyval.str = cat_str(4,yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
31528
 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
29660
31529
;}
29661
31530
    break;
29662
31531
 
29663
31532
  case 993:
 
31533
 
 
31534
/* Line 1455 of yacc.c  */
29664
31535
#line 6171 "preproc.y"
29665
31536
    { 
29666
 
 yyval.str = make_str("analyze");
 
31537
 (yyval.str) = make_str("analyze");
29667
31538
;}
29668
31539
    break;
29669
31540
 
29670
31541
  case 994:
 
31542
 
 
31543
/* Line 1455 of yacc.c  */
29671
31544
#line 6175 "preproc.y"
29672
31545
    { 
29673
 
 yyval.str = make_str("analyse");
 
31546
 (yyval.str) = make_str("analyse");
29674
31547
;}
29675
31548
    break;
29676
31549
 
29677
31550
  case 995:
 
31551
 
 
31552
/* Line 1455 of yacc.c  */
29678
31553
#line 6183 "preproc.y"
29679
31554
    { 
29680
 
 yyval.str = make_str("verbose");
 
31555
 (yyval.str) = make_str("verbose");
29681
31556
;}
29682
31557
    break;
29683
31558
 
29684
31559
  case 996:
 
31560
 
 
31561
/* Line 1455 of yacc.c  */
29685
31562
#line 6187 "preproc.y"
29686
31563
    { 
29687
 
 yyval.str=EMPTY; ;}
 
31564
 (yyval.str)=EMPTY; ;}
29688
31565
    break;
29689
31566
 
29690
31567
  case 997:
 
31568
 
 
31569
/* Line 1455 of yacc.c  */
29691
31570
#line 6194 "preproc.y"
29692
31571
    { 
29693
 
 yyval.str = make_str("full");
 
31572
 (yyval.str) = make_str("full");
29694
31573
;}
29695
31574
    break;
29696
31575
 
29697
31576
  case 998:
 
31577
 
 
31578
/* Line 1455 of yacc.c  */
29698
31579
#line 6198 "preproc.y"
29699
31580
    { 
29700
 
 yyval.str=EMPTY; ;}
 
31581
 (yyval.str)=EMPTY; ;}
29701
31582
    break;
29702
31583
 
29703
31584
  case 999:
 
31585
 
 
31586
/* Line 1455 of yacc.c  */
29704
31587
#line 6205 "preproc.y"
29705
31588
    { 
29706
 
 yyval.str = make_str("freeze");
 
31589
 (yyval.str) = make_str("freeze");
29707
31590
;}
29708
31591
    break;
29709
31592
 
29710
31593
  case 1000:
 
31594
 
 
31595
/* Line 1455 of yacc.c  */
29711
31596
#line 6209 "preproc.y"
29712
31597
    { 
29713
 
 yyval.str=EMPTY; ;}
 
31598
 (yyval.str)=EMPTY; ;}
29714
31599
    break;
29715
31600
 
29716
31601
  case 1001:
 
31602
 
 
31603
/* Line 1455 of yacc.c  */
29717
31604
#line 6216 "preproc.y"
29718
31605
    { 
29719
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
31606
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
29720
31607
;}
29721
31608
    break;
29722
31609
 
29723
31610
  case 1002:
 
31611
 
 
31612
/* Line 1455 of yacc.c  */
29724
31613
#line 6220 "preproc.y"
29725
31614
    { 
29726
 
 yyval.str=EMPTY; ;}
 
31615
 (yyval.str)=EMPTY; ;}
29727
31616
    break;
29728
31617
 
29729
31618
  case 1003:
 
31619
 
 
31620
/* Line 1455 of yacc.c  */
29730
31621
#line 6227 "preproc.y"
29731
31622
    { 
29732
 
 yyval.str = cat_str(4,make_str("explain"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
31623
 (yyval.str) = cat_str(4,make_str("explain"),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
29733
31624
;}
29734
31625
    break;
29735
31626
 
29736
31627
  case 1004:
 
31628
 
 
31629
/* Line 1455 of yacc.c  */
29737
31630
#line 6235 "preproc.y"
29738
31631
    { 
29739
 
 yyval.str = yyvsp[0].str;
 
31632
 (yyval.str) = (yyvsp[(1) - (1)].str);
29740
31633
;}
29741
31634
    break;
29742
31635
 
29743
31636
  case 1005:
 
31637
 
 
31638
/* Line 1455 of yacc.c  */
29744
31639
#line 6239 "preproc.y"
29745
31640
    { 
29746
 
 yyval.str = yyvsp[0].str;
 
31641
 (yyval.str) = (yyvsp[(1) - (1)].str);
29747
31642
;}
29748
31643
    break;
29749
31644
 
29750
31645
  case 1006:
 
31646
 
 
31647
/* Line 1455 of yacc.c  */
29751
31648
#line 6243 "preproc.y"
29752
31649
    { 
29753
 
 yyval.str = yyvsp[0].str;
 
31650
 (yyval.str) = (yyvsp[(1) - (1)].str);
29754
31651
;}
29755
31652
    break;
29756
31653
 
29757
31654
  case 1007:
 
31655
 
 
31656
/* Line 1455 of yacc.c  */
29758
31657
#line 6247 "preproc.y"
29759
31658
    { 
29760
 
 yyval.str = yyvsp[0].str;
 
31659
 (yyval.str) = (yyvsp[(1) - (1)].str);
29761
31660
;}
29762
31661
    break;
29763
31662
 
29764
31663
  case 1008:
 
31664
 
 
31665
/* Line 1455 of yacc.c  */
29765
31666
#line 6251 "preproc.y"
29766
31667
    { 
29767
 
 yyval.str = yyvsp[0].str;
 
31668
 (yyval.str) = (yyvsp[(1) - (1)].str);
29768
31669
;}
29769
31670
    break;
29770
31671
 
29771
31672
  case 1009:
 
31673
 
 
31674
/* Line 1455 of yacc.c  */
29772
31675
#line 6255 "preproc.y"
29773
31676
    { 
29774
 
 yyval.str = yyvsp[0].str;
 
31677
 (yyval.str) = (yyvsp[(1) - (1)].str);
29775
31678
;}
29776
31679
    break;
29777
31680
 
29778
31681
  case 1010:
 
31682
 
 
31683
/* Line 1455 of yacc.c  */
29779
31684
#line 6259 "preproc.y"
29780
31685
    { 
29781
 
 yyval.str = yyvsp[0].str;
 
31686
 (yyval.str) = (yyvsp[(1) - (1)].str);
29782
31687
;}
29783
31688
    break;
29784
31689
 
29785
31690
  case 1011:
 
31691
 
 
31692
/* Line 1455 of yacc.c  */
29786
31693
#line 6267 "preproc.y"
29787
31694
    { 
29788
 
 yyval.str = yyvsp[0].str;
 
31695
 (yyval.str) = (yyvsp[(1) - (1)].str);
29789
31696
;}
29790
31697
    break;
29791
31698
 
29792
31699
  case 1012:
 
31700
 
 
31701
/* Line 1455 of yacc.c  */
29793
31702
#line 6271 "preproc.y"
29794
31703
    { 
29795
 
 yyval.str=EMPTY; ;}
 
31704
 (yyval.str)=EMPTY; ;}
29796
31705
    break;
29797
31706
 
29798
31707
  case 1013:
 
31708
 
 
31709
/* Line 1455 of yacc.c  */
29799
31710
#line 6278 "preproc.y"
29800
31711
    {
29801
 
                yyval.prep.name = yyvsp[-3].str;
29802
 
                yyval.prep.type = yyvsp[-2].str;
29803
 
                yyval.prep.stmt = cat_str(3, make_str("\""), yyvsp[0].str, make_str("\""));
 
31712
                (yyval.prep).name = (yyvsp[(2) - (5)].str);
 
31713
                (yyval.prep).type = (yyvsp[(3) - (5)].str);
 
31714
                (yyval.prep).stmt = cat_str(3, make_str("\""), (yyvsp[(5) - (5)].str), make_str("\""));
29804
31715
        ;}
29805
31716
    break;
29806
31717
 
29807
31718
  case 1014:
 
31719
 
 
31720
/* Line 1455 of yacc.c  */
29808
31721
#line 6284 "preproc.y"
29809
31722
    {
29810
 
                yyval.prep.name = yyvsp[-2].str;
29811
 
                yyval.prep.type = NULL;
29812
 
                yyval.prep.stmt = yyvsp[0].str;
 
31723
                (yyval.prep).name = (yyvsp[(2) - (4)].str);
 
31724
                (yyval.prep).type = NULL;
 
31725
                (yyval.prep).stmt = (yyvsp[(4) - (4)].str);
29813
31726
        ;}
29814
31727
    break;
29815
31728
 
29816
31729
  case 1015:
 
31730
 
 
31731
/* Line 1455 of yacc.c  */
29817
31732
#line 6294 "preproc.y"
29818
31733
    { 
29819
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
31734
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
29820
31735
;}
29821
31736
    break;
29822
31737
 
29823
31738
  case 1016:
 
31739
 
 
31740
/* Line 1455 of yacc.c  */
29824
31741
#line 6298 "preproc.y"
29825
31742
    { 
29826
 
 yyval.str=EMPTY; ;}
 
31743
 (yyval.str)=EMPTY; ;}
29827
31744
    break;
29828
31745
 
29829
31746
  case 1017:
 
31747
 
 
31748
/* Line 1455 of yacc.c  */
29830
31749
#line 6305 "preproc.y"
29831
31750
    { 
29832
 
 yyval.str = yyvsp[0].str;
 
31751
 (yyval.str) = (yyvsp[(1) - (1)].str);
29833
31752
;}
29834
31753
    break;
29835
31754
 
29836
31755
  case 1018:
 
31756
 
 
31757
/* Line 1455 of yacc.c  */
29837
31758
#line 6309 "preproc.y"
29838
31759
    { 
29839
 
 yyval.str = yyvsp[0].str;
 
31760
 (yyval.str) = (yyvsp[(1) - (1)].str);
29840
31761
;}
29841
31762
    break;
29842
31763
 
29843
31764
  case 1019:
 
31765
 
 
31766
/* Line 1455 of yacc.c  */
29844
31767
#line 6313 "preproc.y"
29845
31768
    { 
29846
 
 yyval.str = yyvsp[0].str;
 
31769
 (yyval.str) = (yyvsp[(1) - (1)].str);
29847
31770
;}
29848
31771
    break;
29849
31772
 
29850
31773
  case 1020:
 
31774
 
 
31775
/* Line 1455 of yacc.c  */
29851
31776
#line 6317 "preproc.y"
29852
31777
    { 
29853
 
 yyval.str = yyvsp[0].str;
 
31778
 (yyval.str) = (yyvsp[(1) - (1)].str);
29854
31779
;}
29855
31780
    break;
29856
31781
 
29857
31782
  case 1021:
 
31783
 
 
31784
/* Line 1455 of yacc.c  */
29858
31785
#line 6325 "preproc.y"
29859
 
    { yyval.str = yyvsp[-2].str; ;}
 
31786
    { (yyval.str) = (yyvsp[(2) - (4)].str); ;}
29860
31787
    break;
29861
31788
 
29862
31789
  case 1022:
 
31790
 
 
31791
/* Line 1455 of yacc.c  */
29863
31792
#line 6327 "preproc.y"
29864
31793
    { 
29865
 
 yyval.str = cat_str(7,make_str("create"),yyvsp[-6].str,make_str("table"),yyvsp[-4].str,make_str("as execute"),yyvsp[-1].str,yyvsp[0].str);
 
31794
 (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));
29866
31795
;}
29867
31796
    break;
29868
31797
 
29869
31798
  case 1023:
 
31799
 
 
31800
/* Line 1455 of yacc.c  */
29870
31801
#line 6335 "preproc.y"
29871
31802
    { 
29872
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
31803
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
29873
31804
;}
29874
31805
    break;
29875
31806
 
29876
31807
  case 1024:
 
31808
 
 
31809
/* Line 1455 of yacc.c  */
29877
31810
#line 6339 "preproc.y"
29878
31811
    { 
29879
 
 yyval.str=EMPTY; ;}
 
31812
 (yyval.str)=EMPTY; ;}
29880
31813
    break;
29881
31814
 
29882
31815
  case 1025:
 
31816
 
 
31817
/* Line 1455 of yacc.c  */
29883
31818
#line 6346 "preproc.y"
29884
31819
    { 
29885
 
 yyval.str = cat_str(4,make_str("insert into"),yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
31820
 (yyval.str) = cat_str(4,make_str("insert into"),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
29886
31821
;}
29887
31822
    break;
29888
31823
 
29889
31824
  case 1026:
 
31825
 
 
31826
/* Line 1455 of yacc.c  */
29890
31827
#line 6354 "preproc.y"
29891
31828
    { 
29892
 
 yyval.str = yyvsp[0].str;
 
31829
 (yyval.str) = (yyvsp[(1) - (1)].str);
29893
31830
;}
29894
31831
    break;
29895
31832
 
29896
31833
  case 1027:
 
31834
 
 
31835
/* Line 1455 of yacc.c  */
29897
31836
#line 6358 "preproc.y"
29898
31837
    { 
29899
 
 yyval.str = cat_str(4,make_str("("),yyvsp[-2].str,make_str(")"),yyvsp[0].str);
 
31838
 (yyval.str) = cat_str(4,make_str("("),(yyvsp[(2) - (4)].str),make_str(")"),(yyvsp[(4) - (4)].str));
29900
31839
;}
29901
31840
    break;
29902
31841
 
29903
31842
  case 1028:
 
31843
 
 
31844
/* Line 1455 of yacc.c  */
29904
31845
#line 6362 "preproc.y"
29905
31846
    { 
29906
 
 yyval.str = make_str("default values");
 
31847
 (yyval.str) = make_str("default values");
29907
31848
;}
29908
31849
    break;
29909
31850
 
29910
31851
  case 1029:
 
31852
 
 
31853
/* Line 1455 of yacc.c  */
29911
31854
#line 6370 "preproc.y"
29912
31855
    { 
29913
 
 yyval.str = yyvsp[0].str;
 
31856
 (yyval.str) = (yyvsp[(1) - (1)].str);
29914
31857
;}
29915
31858
    break;
29916
31859
 
29917
31860
  case 1030:
 
31861
 
 
31862
/* Line 1455 of yacc.c  */
29918
31863
#line 6374 "preproc.y"
29919
31864
    { 
29920
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
31865
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
29921
31866
;}
29922
31867
    break;
29923
31868
 
29924
31869
  case 1031:
 
31870
 
 
31871
/* Line 1455 of yacc.c  */
29925
31872
#line 6382 "preproc.y"
29926
31873
    { 
29927
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
31874
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
29928
31875
;}
29929
31876
    break;
29930
31877
 
29931
31878
  case 1032:
 
31879
 
 
31880
/* Line 1455 of yacc.c  */
29932
31881
#line 6390 "preproc.y"
29933
31882
    { 
29934
 
 yyval.str = cat_str(2,make_str("returning"),yyvsp[-1].str);
 
31883
 (yyval.str) = cat_str(2,make_str("returning"),(yyvsp[(2) - (3)].str));
29935
31884
;}
29936
31885
    break;
29937
31886
 
29938
31887
  case 1033:
 
31888
 
 
31889
/* Line 1455 of yacc.c  */
29939
31890
#line 6394 "preproc.y"
29940
31891
    { 
29941
 
 yyval.str=EMPTY; ;}
 
31892
 (yyval.str)=EMPTY; ;}
29942
31893
    break;
29943
31894
 
29944
31895
  case 1034:
 
31896
 
 
31897
/* Line 1455 of yacc.c  */
29945
31898
#line 6401 "preproc.y"
29946
31899
    { 
29947
 
 yyval.str = cat_str(5,make_str("delete from"),yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
31900
 (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));
29948
31901
;}
29949
31902
    break;
29950
31903
 
29951
31904
  case 1035:
 
31905
 
 
31906
/* Line 1455 of yacc.c  */
29952
31907
#line 6409 "preproc.y"
29953
31908
    { 
29954
 
 yyval.str = cat_str(2,make_str("using"),yyvsp[0].str);
 
31909
 (yyval.str) = cat_str(2,make_str("using"),(yyvsp[(2) - (2)].str));
29955
31910
;}
29956
31911
    break;
29957
31912
 
29958
31913
  case 1036:
 
31914
 
 
31915
/* Line 1455 of yacc.c  */
29959
31916
#line 6413 "preproc.y"
29960
31917
    { 
29961
 
 yyval.str=EMPTY; ;}
 
31918
 (yyval.str)=EMPTY; ;}
29962
31919
    break;
29963
31920
 
29964
31921
  case 1037:
 
31922
 
 
31923
/* Line 1455 of yacc.c  */
29965
31924
#line 6420 "preproc.y"
29966
31925
    { 
29967
 
 yyval.str = cat_str(5,make_str("lock"),yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
31926
 (yyval.str) = cat_str(5,make_str("lock"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
29968
31927
;}
29969
31928
    break;
29970
31929
 
29971
31930
  case 1038:
 
31931
 
 
31932
/* Line 1455 of yacc.c  */
29972
31933
#line 6428 "preproc.y"
29973
31934
    { 
29974
 
 yyval.str = cat_str(3,make_str("in"),yyvsp[-1].str,make_str("mode"));
 
31935
 (yyval.str) = cat_str(3,make_str("in"),(yyvsp[(2) - (3)].str),make_str("mode"));
29975
31936
;}
29976
31937
    break;
29977
31938
 
29978
31939
  case 1039:
 
31940
 
 
31941
/* Line 1455 of yacc.c  */
29979
31942
#line 6432 "preproc.y"
29980
31943
    { 
29981
 
 yyval.str=EMPTY; ;}
 
31944
 (yyval.str)=EMPTY; ;}
29982
31945
    break;
29983
31946
 
29984
31947
  case 1040:
 
31948
 
 
31949
/* Line 1455 of yacc.c  */
29985
31950
#line 6439 "preproc.y"
29986
31951
    { 
29987
 
 yyval.str = make_str("access share");
 
31952
 (yyval.str) = make_str("access share");
29988
31953
;}
29989
31954
    break;
29990
31955
 
29991
31956
  case 1041:
 
31957
 
 
31958
/* Line 1455 of yacc.c  */
29992
31959
#line 6443 "preproc.y"
29993
31960
    { 
29994
 
 yyval.str = make_str("row share");
 
31961
 (yyval.str) = make_str("row share");
29995
31962
;}
29996
31963
    break;
29997
31964
 
29998
31965
  case 1042:
 
31966
 
 
31967
/* Line 1455 of yacc.c  */
29999
31968
#line 6447 "preproc.y"
30000
31969
    { 
30001
 
 yyval.str = make_str("row exclusive");
 
31970
 (yyval.str) = make_str("row exclusive");
30002
31971
;}
30003
31972
    break;
30004
31973
 
30005
31974
  case 1043:
 
31975
 
 
31976
/* Line 1455 of yacc.c  */
30006
31977
#line 6451 "preproc.y"
30007
31978
    { 
30008
 
 yyval.str = make_str("share update exclusive");
 
31979
 (yyval.str) = make_str("share update exclusive");
30009
31980
;}
30010
31981
    break;
30011
31982
 
30012
31983
  case 1044:
 
31984
 
 
31985
/* Line 1455 of yacc.c  */
30013
31986
#line 6455 "preproc.y"
30014
31987
    { 
30015
 
 yyval.str = make_str("share");
 
31988
 (yyval.str) = make_str("share");
30016
31989
;}
30017
31990
    break;
30018
31991
 
30019
31992
  case 1045:
 
31993
 
 
31994
/* Line 1455 of yacc.c  */
30020
31995
#line 6459 "preproc.y"
30021
31996
    { 
30022
 
 yyval.str = make_str("share row exclusive");
 
31997
 (yyval.str) = make_str("share row exclusive");
30023
31998
;}
30024
31999
    break;
30025
32000
 
30026
32001
  case 1046:
 
32002
 
 
32003
/* Line 1455 of yacc.c  */
30027
32004
#line 6463 "preproc.y"
30028
32005
    { 
30029
 
 yyval.str = make_str("exclusive");
 
32006
 (yyval.str) = make_str("exclusive");
30030
32007
;}
30031
32008
    break;
30032
32009
 
30033
32010
  case 1047:
 
32011
 
 
32012
/* Line 1455 of yacc.c  */
30034
32013
#line 6467 "preproc.y"
30035
32014
    { 
30036
 
 yyval.str = make_str("access exclusive");
 
32015
 (yyval.str) = make_str("access exclusive");
30037
32016
;}
30038
32017
    break;
30039
32018
 
30040
32019
  case 1048:
 
32020
 
 
32021
/* Line 1455 of yacc.c  */
30041
32022
#line 6475 "preproc.y"
30042
32023
    { 
30043
 
 yyval.str = make_str("nowait");
 
32024
 (yyval.str) = make_str("nowait");
30044
32025
;}
30045
32026
    break;
30046
32027
 
30047
32028
  case 1049:
 
32029
 
 
32030
/* Line 1455 of yacc.c  */
30048
32031
#line 6479 "preproc.y"
30049
32032
    { 
30050
 
 yyval.str=EMPTY; ;}
 
32033
 (yyval.str)=EMPTY; ;}
30051
32034
    break;
30052
32035
 
30053
32036
  case 1050:
 
32037
 
 
32038
/* Line 1455 of yacc.c  */
30054
32039
#line 6486 "preproc.y"
30055
32040
    { 
30056
 
 yyval.str = cat_str(7,make_str("update"),yyvsp[-5].str,make_str("set"),yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
32041
 (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));
30057
32042
;}
30058
32043
    break;
30059
32044
 
30060
32045
  case 1051:
 
32046
 
 
32047
/* Line 1455 of yacc.c  */
30061
32048
#line 6494 "preproc.y"
30062
32049
    { 
30063
 
 yyval.str = yyvsp[0].str;
 
32050
 (yyval.str) = (yyvsp[(1) - (1)].str);
30064
32051
;}
30065
32052
    break;
30066
32053
 
30067
32054
  case 1052:
 
32055
 
 
32056
/* Line 1455 of yacc.c  */
30068
32057
#line 6498 "preproc.y"
30069
32058
    { 
30070
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
32059
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
30071
32060
;}
30072
32061
    break;
30073
32062
 
30074
32063
  case 1053:
 
32064
 
 
32065
/* Line 1455 of yacc.c  */
30075
32066
#line 6506 "preproc.y"
30076
32067
    { 
30077
 
 yyval.str = yyvsp[0].str;
 
32068
 (yyval.str) = (yyvsp[(1) - (1)].str);
30078
32069
;}
30079
32070
    break;
30080
32071
 
30081
32072
  case 1054:
 
32073
 
 
32074
/* Line 1455 of yacc.c  */
30082
32075
#line 6510 "preproc.y"
30083
32076
    { 
30084
 
 yyval.str = yyvsp[0].str;
 
32077
 (yyval.str) = (yyvsp[(1) - (1)].str);
30085
32078
;}
30086
32079
    break;
30087
32080
 
30088
32081
  case 1055:
 
32082
 
 
32083
/* Line 1455 of yacc.c  */
30089
32084
#line 6518 "preproc.y"
30090
32085
    { 
30091
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("="),yyvsp[0].str);
 
32086
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("="),(yyvsp[(3) - (3)].str));
30092
32087
;}
30093
32088
    break;
30094
32089
 
30095
32090
  case 1056:
 
32091
 
 
32092
/* Line 1455 of yacc.c  */
30096
32093
#line 6526 "preproc.y"
30097
32094
    { 
30098
 
 yyval.str = cat_str(4,make_str("("),yyvsp[-3].str,make_str(") ="),yyvsp[0].str);
 
32095
 (yyval.str) = cat_str(4,make_str("("),(yyvsp[(2) - (5)].str),make_str(") ="),(yyvsp[(5) - (5)].str));
30099
32096
;}
30100
32097
    break;
30101
32098
 
30102
32099
  case 1057:
 
32100
 
 
32101
/* Line 1455 of yacc.c  */
30103
32102
#line 6534 "preproc.y"
30104
32103
    { 
30105
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
32104
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
30106
32105
;}
30107
32106
    break;
30108
32107
 
30109
32108
  case 1058:
 
32109
 
 
32110
/* Line 1455 of yacc.c  */
30110
32111
#line 6542 "preproc.y"
30111
32112
    { 
30112
 
 yyval.str = yyvsp[0].str;
 
32113
 (yyval.str) = (yyvsp[(1) - (1)].str);
30113
32114
;}
30114
32115
    break;
30115
32116
 
30116
32117
  case 1059:
 
32118
 
 
32119
/* Line 1455 of yacc.c  */
30117
32120
#line 6546 "preproc.y"
30118
32121
    { 
30119
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
32122
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
30120
32123
;}
30121
32124
    break;
30122
32125
 
30123
32126
  case 1060:
 
32127
 
 
32128
/* Line 1455 of yacc.c  */
30124
32129
#line 6554 "preproc.y"
30125
32130
    {
30126
32131
                struct cursor *ptr, *this;
30128
32133
 
30129
32134
                for (ptr = cur; ptr != NULL; ptr = ptr->next)
30130
32135
                {
30131
 
                        if (strcmp(yyvsp[-5].str, ptr->name) == 0)
30132
 
                                mmerror(PARSE_ERROR, ET_ERROR, "cursor \"%s\" is already defined", yyvsp[-5].str);
 
32136
                        if (strcmp((yyvsp[(2) - (7)].str), ptr->name) == 0)
 
32137
                                mmerror(PARSE_ERROR, ET_ERROR, "cursor \"%s\" is already defined", (yyvsp[(2) - (7)].str));
30133
32138
                }
30134
32139
 
30135
32140
                this = (struct cursor *) mm_alloc(sizeof(struct cursor));
30136
32141
 
30137
32142
                this->next = cur;
30138
 
                this->name = yyvsp[-5].str;
 
32143
                this->name = (yyvsp[(2) - (7)].str);
30139
32144
                this->connection = connection;
30140
32145
                this->opened = false;
30141
 
                this->command =  cat_str(7, make_str("declare"), mm_strdup(yyvsp[-5].str), yyvsp[-4].str, make_str("cursor"), yyvsp[-2].str, make_str("for"), yyvsp[0].str);
 
32146
                this->command =  cat_str(7, make_str("declare"), mm_strdup((yyvsp[(2) - (7)].str)), (yyvsp[(3) - (7)].str), make_str("cursor"), (yyvsp[(5) - (7)].str), make_str("for"), (yyvsp[(7) - (7)].str));
30142
32147
                this->argsinsert = argsinsert;
30143
32148
                this->argsresult = argsresult;
30144
32149
                argsinsert = argsresult = NULL;
30153
32158
                }
30154
32159
 
30155
32160
                if (INFORMIX_MODE)
30156
 
                        yyval.str = cat_str(5, adjust_informix(this->argsinsert), adjust_informix(this->argsresult), make_str("/*"), c1, make_str("*/"));
 
32161
                        (yyval.str) = cat_str(5, adjust_informix(this->argsinsert), adjust_informix(this->argsresult), make_str("/*"), c1, make_str("*/"));
30157
32162
                else
30158
 
                        yyval.str = cat_str(3, make_str("/*"), c1, make_str("*/"));
 
32163
                        (yyval.str) = cat_str(3, make_str("/*"), c1, make_str("*/"));
30159
32164
        ;}
30160
32165
    break;
30161
32166
 
30162
32167
  case 1061:
 
32168
 
 
32169
/* Line 1455 of yacc.c  */
30163
32170
#line 6594 "preproc.y"
30164
32171
    { 
30165
 
 yyval.str=EMPTY; ;}
 
32172
 (yyval.str)=EMPTY; ;}
30166
32173
    break;
30167
32174
 
30168
32175
  case 1062:
 
32176
 
 
32177
/* Line 1455 of yacc.c  */
30169
32178
#line 6597 "preproc.y"
30170
32179
    { 
30171
 
 yyval.str = cat_str(2,yyvsp[-2].str,make_str("no scroll"));
 
32180
 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("no scroll"));
30172
32181
;}
30173
32182
    break;
30174
32183
 
30175
32184
  case 1063:
 
32185
 
 
32186
/* Line 1455 of yacc.c  */
30176
32187
#line 6601 "preproc.y"
30177
32188
    { 
30178
 
 yyval.str = cat_str(2,yyvsp[-1].str,make_str("scroll"));
 
32189
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),make_str("scroll"));
30179
32190
;}
30180
32191
    break;
30181
32192
 
30182
32193
  case 1064:
 
32194
 
 
32195
/* Line 1455 of yacc.c  */
30183
32196
#line 6605 "preproc.y"
30184
32197
    { 
30185
 
 yyval.str = cat_str(2,yyvsp[-1].str,make_str("binary"));
 
32198
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),make_str("binary"));
30186
32199
;}
30187
32200
    break;
30188
32201
 
30189
32202
  case 1065:
 
32203
 
 
32204
/* Line 1455 of yacc.c  */
30190
32205
#line 6609 "preproc.y"
30191
32206
    { 
30192
 
 yyval.str = cat_str(2,yyvsp[-1].str,make_str("insensitive"));
 
32207
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),make_str("insensitive"));
30193
32208
;}
30194
32209
    break;
30195
32210
 
30196
32211
  case 1066:
 
32212
 
 
32213
/* Line 1455 of yacc.c  */
30197
32214
#line 6617 "preproc.y"
30198
32215
    {
30199
32216
                if (compat == ECPG_COMPAT_INFORMIX_SE && autocommit == true)
30200
 
                        yyval.str = make_str("with hold");
 
32217
                        (yyval.str) = make_str("with hold");
30201
32218
                else
30202
 
                        yyval.str = EMPTY;
 
32219
                        (yyval.str) = EMPTY;
30203
32220
        ;}
30204
32221
    break;
30205
32222
 
30206
32223
  case 1067:
 
32224
 
 
32225
/* Line 1455 of yacc.c  */
30207
32226
#line 6624 "preproc.y"
30208
32227
    { 
30209
 
 yyval.str = make_str("with hold");
 
32228
 (yyval.str) = make_str("with hold");
30210
32229
;}
30211
32230
    break;
30212
32231
 
30213
32232
  case 1068:
 
32233
 
 
32234
/* Line 1455 of yacc.c  */
30214
32235
#line 6628 "preproc.y"
30215
32236
    { 
30216
 
 yyval.str = make_str("without hold");
 
32237
 (yyval.str) = make_str("without hold");
30217
32238
;}
30218
32239
    break;
30219
32240
 
30220
32241
  case 1069:
 
32242
 
 
32243
/* Line 1455 of yacc.c  */
30221
32244
#line 6636 "preproc.y"
30222
32245
    { 
30223
 
 yyval.str = yyvsp[0].str;
 
32246
 (yyval.str) = (yyvsp[(1) - (1)].str);
30224
32247
;}
30225
32248
    break;
30226
32249
 
30227
32250
  case 1070:
 
32251
 
 
32252
/* Line 1455 of yacc.c  */
30228
32253
#line 6640 "preproc.y"
30229
32254
    { 
30230
 
 yyval.str = yyvsp[0].str;
 
32255
 (yyval.str) = (yyvsp[(1) - (1)].str);
30231
32256
;}
30232
32257
    break;
30233
32258
 
30234
32259
  case 1071:
 
32260
 
 
32261
/* Line 1455 of yacc.c  */
30235
32262
#line 6648 "preproc.y"
30236
32263
    { 
30237
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
32264
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
30238
32265
;}
30239
32266
    break;
30240
32267
 
30241
32268
  case 1072:
 
32269
 
 
32270
/* Line 1455 of yacc.c  */
30242
32271
#line 6652 "preproc.y"
30243
32272
    { 
30244
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
32273
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
30245
32274
;}
30246
32275
    break;
30247
32276
 
30248
32277
  case 1073:
 
32278
 
 
32279
/* Line 1455 of yacc.c  */
30249
32280
#line 6660 "preproc.y"
30250
32281
    { 
30251
 
 yyval.str = yyvsp[0].str;
 
32282
 (yyval.str) = (yyvsp[(1) - (1)].str);
30252
32283
;}
30253
32284
    break;
30254
32285
 
30255
32286
  case 1074:
 
32287
 
 
32288
/* Line 1455 of yacc.c  */
30256
32289
#line 6664 "preproc.y"
30257
32290
    { 
30258
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
32291
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
30259
32292
;}
30260
32293
    break;
30261
32294
 
30262
32295
  case 1075:
 
32296
 
 
32297
/* Line 1455 of yacc.c  */
30263
32298
#line 6668 "preproc.y"
30264
32299
    { 
30265
 
 yyval.str = cat_str(4,yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
32300
 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
30266
32301
;}
30267
32302
    break;
30268
32303
 
30269
32304
  case 1076:
 
32305
 
 
32306
/* Line 1455 of yacc.c  */
30270
32307
#line 6672 "preproc.y"
30271
32308
    { 
30272
 
 yyval.str = cat_str(4,yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
32309
 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
30273
32310
;}
30274
32311
    break;
30275
32312
 
30276
32313
  case 1077:
 
32314
 
 
32315
/* Line 1455 of yacc.c  */
30277
32316
#line 6676 "preproc.y"
30278
32317
    { 
30279
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
32318
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
30280
32319
;}
30281
32320
    break;
30282
32321
 
30283
32322
  case 1078:
 
32323
 
 
32324
/* Line 1455 of yacc.c  */
30284
32325
#line 6680 "preproc.y"
30285
32326
    { 
30286
 
 yyval.str = cat_str(3,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
32327
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
30287
32328
;}
30288
32329
    break;
30289
32330
 
30290
32331
  case 1079:
 
32332
 
 
32333
/* Line 1455 of yacc.c  */
30291
32334
#line 6684 "preproc.y"
30292
32335
    { 
30293
 
 yyval.str = cat_str(5,yyvsp[-4].str,yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
32336
 (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));
30294
32337
;}
30295
32338
    break;
30296
32339
 
30297
32340
  case 1080:
 
32341
 
 
32342
/* Line 1455 of yacc.c  */
30298
32343
#line 6688 "preproc.y"
30299
32344
    { 
30300
 
 yyval.str = cat_str(5,yyvsp[-4].str,yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
32345
 (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));
30301
32346
;}
30302
32347
    break;
30303
32348
 
30304
32349
  case 1081:
 
32350
 
 
32351
/* Line 1455 of yacc.c  */
30305
32352
#line 6696 "preproc.y"
30306
32353
    { 
30307
 
 yyval.str = yyvsp[0].str;
 
32354
 (yyval.str) = (yyvsp[(1) - (1)].str);
30308
32355
;}
30309
32356
    break;
30310
32357
 
30311
32358
  case 1082:
 
32359
 
 
32360
/* Line 1455 of yacc.c  */
30312
32361
#line 6700 "preproc.y"
30313
32362
    { 
30314
 
 yyval.str = yyvsp[0].str;
 
32363
 (yyval.str) = (yyvsp[(1) - (1)].str);
30315
32364
;}
30316
32365
    break;
30317
32366
 
30318
32367
  case 1083:
 
32368
 
 
32369
/* Line 1455 of yacc.c  */
30319
32370
#line 6708 "preproc.y"
30320
32371
    { 
30321
 
 yyval.str = cat_str(9,make_str("select"),yyvsp[-7].str,yyvsp[-6].str,yyvsp[-5].str,yyvsp[-4].str,yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
32372
 (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));
30322
32373
;}
30323
32374
    break;
30324
32375
 
30325
32376
  case 1084:
 
32377
 
 
32378
/* Line 1455 of yacc.c  */
30326
32379
#line 6712 "preproc.y"
30327
32380
    { 
30328
 
 yyval.str = yyvsp[0].str;
 
32381
 (yyval.str) = (yyvsp[(1) - (1)].str);
30329
32382
;}
30330
32383
    break;
30331
32384
 
30332
32385
  case 1085:
 
32386
 
 
32387
/* Line 1455 of yacc.c  */
30333
32388
#line 6716 "preproc.y"
30334
32389
    { 
30335
 
 yyval.str = cat_str(2,make_str("table"),yyvsp[0].str);
 
32390
 (yyval.str) = cat_str(2,make_str("table"),(yyvsp[(2) - (2)].str));
30336
32391
;}
30337
32392
    break;
30338
32393
 
30339
32394
  case 1086:
 
32395
 
 
32396
/* Line 1455 of yacc.c  */
30340
32397
#line 6720 "preproc.y"
30341
32398
    { 
30342
 
 yyval.str = cat_str(4,yyvsp[-3].str,make_str("union"),yyvsp[-1].str,yyvsp[0].str);
 
32399
 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),make_str("union"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
30343
32400
;}
30344
32401
    break;
30345
32402
 
30346
32403
  case 1087:
 
32404
 
 
32405
/* Line 1455 of yacc.c  */
30347
32406
#line 6724 "preproc.y"
30348
32407
    { 
30349
 
 yyval.str = cat_str(4,yyvsp[-3].str,make_str("intersect"),yyvsp[-1].str,yyvsp[0].str);
 
32408
 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),make_str("intersect"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
30350
32409
;}
30351
32410
    break;
30352
32411
 
30353
32412
  case 1088:
 
32413
 
 
32414
/* Line 1455 of yacc.c  */
30354
32415
#line 6728 "preproc.y"
30355
32416
    { 
30356
 
 yyval.str = cat_str(4,yyvsp[-3].str,make_str("except"),yyvsp[-1].str,yyvsp[0].str);
 
32417
 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),make_str("except"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
30357
32418
;}
30358
32419
    break;
30359
32420
 
30360
32421
  case 1089:
 
32422
 
 
32423
/* Line 1455 of yacc.c  */
30361
32424
#line 6736 "preproc.y"
30362
32425
    { 
30363
 
 yyval.str = cat_str(2,make_str("with"),yyvsp[0].str);
 
32426
 (yyval.str) = cat_str(2,make_str("with"),(yyvsp[(2) - (2)].str));
30364
32427
;}
30365
32428
    break;
30366
32429
 
30367
32430
  case 1090:
 
32431
 
 
32432
/* Line 1455 of yacc.c  */
30368
32433
#line 6740 "preproc.y"
30369
32434
    { 
30370
 
 yyval.str = cat_str(2,make_str("with recursive"),yyvsp[0].str);
 
32435
 (yyval.str) = cat_str(2,make_str("with recursive"),(yyvsp[(3) - (3)].str));
30371
32436
;}
30372
32437
    break;
30373
32438
 
30374
32439
  case 1091:
 
32440
 
 
32441
/* Line 1455 of yacc.c  */
30375
32442
#line 6748 "preproc.y"
30376
32443
    { 
30377
 
 yyval.str = yyvsp[0].str;
 
32444
 (yyval.str) = (yyvsp[(1) - (1)].str);
30378
32445
;}
30379
32446
    break;
30380
32447
 
30381
32448
  case 1092:
 
32449
 
 
32450
/* Line 1455 of yacc.c  */
30382
32451
#line 6752 "preproc.y"
30383
32452
    { 
30384
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
32453
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
30385
32454
;}
30386
32455
    break;
30387
32456
 
30388
32457
  case 1093:
 
32458
 
 
32459
/* Line 1455 of yacc.c  */
30389
32460
#line 6760 "preproc.y"
30390
32461
    { 
30391
 
 yyval.str = cat_str(4,yyvsp[-3].str,yyvsp[-2].str,make_str("as"),yyvsp[0].str);
 
32462
 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),make_str("as"),(yyvsp[(4) - (4)].str));
30392
32463
;}
30393
32464
    break;
30394
32465
 
30395
32466
  case 1094:
 
32467
 
 
32468
/* Line 1455 of yacc.c  */
30396
32469
#line 6768 "preproc.y"
30397
32470
    {
30398
32471
                                                FoundInto = 1;
30399
 
                                                yyval.str= cat2_str(make_str("into"), yyvsp[0].str);
 
32472
                                                (yyval.str)= cat2_str(make_str("into"), (yyvsp[(2) - (2)].str));
30400
32473
                                        ;}
30401
32474
    break;
30402
32475
 
30403
32476
  case 1095:
 
32477
 
 
32478
/* Line 1455 of yacc.c  */
30404
32479
#line 6772 "preproc.y"
30405
 
    { yyval.str = EMPTY; ;}
 
32480
    { (yyval.str) = EMPTY; ;}
30406
32481
    break;
30407
32482
 
30408
32483
  case 1096:
 
32484
 
 
32485
/* Line 1455 of yacc.c  */
30409
32486
#line 6774 "preproc.y"
30410
32487
    { 
30411
 
 yyval.str=EMPTY; ;}
 
32488
 (yyval.str)=EMPTY; ;}
30412
32489
    break;
30413
32490
 
30414
32491
  case 1097:
 
32492
 
 
32493
/* Line 1455 of yacc.c  */
30415
32494
#line 6781 "preproc.y"
30416
32495
    { 
30417
 
 yyval.str = cat_str(3,make_str("temporary"),yyvsp[-1].str,yyvsp[0].str);
 
32496
 (yyval.str) = cat_str(3,make_str("temporary"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
30418
32497
;}
30419
32498
    break;
30420
32499
 
30421
32500
  case 1098:
 
32501
 
 
32502
/* Line 1455 of yacc.c  */
30422
32503
#line 6785 "preproc.y"
30423
32504
    { 
30424
 
 yyval.str = cat_str(3,make_str("temp"),yyvsp[-1].str,yyvsp[0].str);
 
32505
 (yyval.str) = cat_str(3,make_str("temp"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
30425
32506
;}
30426
32507
    break;
30427
32508
 
30428
32509
  case 1099:
 
32510
 
 
32511
/* Line 1455 of yacc.c  */
30429
32512
#line 6789 "preproc.y"
30430
32513
    { 
30431
 
 yyval.str = cat_str(3,make_str("local temporary"),yyvsp[-1].str,yyvsp[0].str);
 
32514
 (yyval.str) = cat_str(3,make_str("local temporary"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
30432
32515
;}
30433
32516
    break;
30434
32517
 
30435
32518
  case 1100:
 
32519
 
 
32520
/* Line 1455 of yacc.c  */
30436
32521
#line 6793 "preproc.y"
30437
32522
    { 
30438
 
 yyval.str = cat_str(3,make_str("local temp"),yyvsp[-1].str,yyvsp[0].str);
 
32523
 (yyval.str) = cat_str(3,make_str("local temp"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
30439
32524
;}
30440
32525
    break;
30441
32526
 
30442
32527
  case 1101:
 
32528
 
 
32529
/* Line 1455 of yacc.c  */
30443
32530
#line 6797 "preproc.y"
30444
32531
    { 
30445
 
 yyval.str = cat_str(3,make_str("global temporary"),yyvsp[-1].str,yyvsp[0].str);
 
32532
 (yyval.str) = cat_str(3,make_str("global temporary"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
30446
32533
;}
30447
32534
    break;
30448
32535
 
30449
32536
  case 1102:
 
32537
 
 
32538
/* Line 1455 of yacc.c  */
30450
32539
#line 6801 "preproc.y"
30451
32540
    { 
30452
 
 yyval.str = cat_str(3,make_str("global temp"),yyvsp[-1].str,yyvsp[0].str);
 
32541
 (yyval.str) = cat_str(3,make_str("global temp"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
30453
32542
;}
30454
32543
    break;
30455
32544
 
30456
32545
  case 1103:
 
32546
 
 
32547
/* Line 1455 of yacc.c  */
30457
32548
#line 6805 "preproc.y"
30458
32549
    { 
30459
 
 yyval.str = cat_str(2,make_str("table"),yyvsp[0].str);
 
32550
 (yyval.str) = cat_str(2,make_str("table"),(yyvsp[(2) - (2)].str));
30460
32551
;}
30461
32552
    break;
30462
32553
 
30463
32554
  case 1104:
 
32555
 
 
32556
/* Line 1455 of yacc.c  */
30464
32557
#line 6809 "preproc.y"
30465
32558
    { 
30466
 
 yyval.str = yyvsp[0].str;
 
32559
 (yyval.str) = (yyvsp[(1) - (1)].str);
30467
32560
;}
30468
32561
    break;
30469
32562
 
30470
32563
  case 1105:
 
32564
 
 
32565
/* Line 1455 of yacc.c  */
30471
32566
#line 6817 "preproc.y"
30472
32567
    { 
30473
 
 yyval.str = make_str("table");
 
32568
 (yyval.str) = make_str("table");
30474
32569
;}
30475
32570
    break;
30476
32571
 
30477
32572
  case 1106:
 
32573
 
 
32574
/* Line 1455 of yacc.c  */
30478
32575
#line 6821 "preproc.y"
30479
32576
    { 
30480
 
 yyval.str=EMPTY; ;}
 
32577
 (yyval.str)=EMPTY; ;}
30481
32578
    break;
30482
32579
 
30483
32580
  case 1107:
 
32581
 
 
32582
/* Line 1455 of yacc.c  */
30484
32583
#line 6828 "preproc.y"
30485
32584
    { 
30486
 
 yyval.str = make_str("all");
 
32585
 (yyval.str) = make_str("all");
30487
32586
;}
30488
32587
    break;
30489
32588
 
30490
32589
  case 1108:
 
32590
 
 
32591
/* Line 1455 of yacc.c  */
30491
32592
#line 6832 "preproc.y"
30492
32593
    { 
30493
 
 yyval.str = make_str("distinct");
 
32594
 (yyval.str) = make_str("distinct");
30494
32595
;}
30495
32596
    break;
30496
32597
 
30497
32598
  case 1109:
 
32599
 
 
32600
/* Line 1455 of yacc.c  */
30498
32601
#line 6836 "preproc.y"
30499
32602
    { 
30500
 
 yyval.str=EMPTY; ;}
 
32603
 (yyval.str)=EMPTY; ;}
30501
32604
    break;
30502
32605
 
30503
32606
  case 1110:
 
32607
 
 
32608
/* Line 1455 of yacc.c  */
30504
32609
#line 6843 "preproc.y"
30505
32610
    { 
30506
 
 yyval.str = make_str("distinct");
 
32611
 (yyval.str) = make_str("distinct");
30507
32612
;}
30508
32613
    break;
30509
32614
 
30510
32615
  case 1111:
 
32616
 
 
32617
/* Line 1455 of yacc.c  */
30511
32618
#line 6847 "preproc.y"
30512
32619
    { 
30513
 
 yyval.str = cat_str(3,make_str("distinct on ("),yyvsp[-1].str,make_str(")"));
 
32620
 (yyval.str) = cat_str(3,make_str("distinct on ("),(yyvsp[(4) - (5)].str),make_str(")"));
30514
32621
;}
30515
32622
    break;
30516
32623
 
30517
32624
  case 1112:
 
32625
 
 
32626
/* Line 1455 of yacc.c  */
30518
32627
#line 6851 "preproc.y"
30519
32628
    { 
30520
 
 yyval.str = make_str("all");
 
32629
 (yyval.str) = make_str("all");
30521
32630
;}
30522
32631
    break;
30523
32632
 
30524
32633
  case 1113:
 
32634
 
 
32635
/* Line 1455 of yacc.c  */
30525
32636
#line 6855 "preproc.y"
30526
32637
    { 
30527
 
 yyval.str=EMPTY; ;}
 
32638
 (yyval.str)=EMPTY; ;}
30528
32639
    break;
30529
32640
 
30530
32641
  case 1114:
 
32642
 
 
32643
/* Line 1455 of yacc.c  */
30531
32644
#line 6862 "preproc.y"
30532
32645
    { 
30533
 
 yyval.str = yyvsp[0].str;
 
32646
 (yyval.str) = (yyvsp[(1) - (1)].str);
30534
32647
;}
30535
32648
    break;
30536
32649
 
30537
32650
  case 1115:
 
32651
 
 
32652
/* Line 1455 of yacc.c  */
30538
32653
#line 6866 "preproc.y"
30539
32654
    { 
30540
 
 yyval.str=EMPTY; ;}
 
32655
 (yyval.str)=EMPTY; ;}
30541
32656
    break;
30542
32657
 
30543
32658
  case 1116:
 
32659
 
 
32660
/* Line 1455 of yacc.c  */
30544
32661
#line 6873 "preproc.y"
30545
32662
    { 
30546
 
 yyval.str = cat_str(2,make_str("order by"),yyvsp[0].str);
 
32663
 (yyval.str) = cat_str(2,make_str("order by"),(yyvsp[(3) - (3)].str));
30547
32664
;}
30548
32665
    break;
30549
32666
 
30550
32667
  case 1117:
 
32668
 
 
32669
/* Line 1455 of yacc.c  */
30551
32670
#line 6881 "preproc.y"
30552
32671
    { 
30553
 
 yyval.str = yyvsp[0].str;
 
32672
 (yyval.str) = (yyvsp[(1) - (1)].str);
30554
32673
;}
30555
32674
    break;
30556
32675
 
30557
32676
  case 1118:
 
32677
 
 
32678
/* Line 1455 of yacc.c  */
30558
32679
#line 6885 "preproc.y"
30559
32680
    { 
30560
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
32681
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
30561
32682
;}
30562
32683
    break;
30563
32684
 
30564
32685
  case 1119:
 
32686
 
 
32687
/* Line 1455 of yacc.c  */
30565
32688
#line 6893 "preproc.y"
30566
32689
    { 
30567
 
 yyval.str = cat_str(4,yyvsp[-3].str,make_str("using"),yyvsp[-1].str,yyvsp[0].str);
 
32690
 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),make_str("using"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
30568
32691
;}
30569
32692
    break;
30570
32693
 
30571
32694
  case 1120:
 
32695
 
 
32696
/* Line 1455 of yacc.c  */
30572
32697
#line 6897 "preproc.y"
30573
32698
    { 
30574
 
 yyval.str = cat_str(3,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
32699
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
30575
32700
;}
30576
32701
    break;
30577
32702
 
30578
32703
  case 1121:
 
32704
 
 
32705
/* Line 1455 of yacc.c  */
30579
32706
#line 6905 "preproc.y"
30580
32707
    { 
30581
 
 yyval.str = cat_str(4,make_str("limit"),yyvsp[-2].str,make_str("offset"),yyvsp[0].str);
 
32708
 (yyval.str) = cat_str(4,make_str("limit"),(yyvsp[(2) - (4)].str),make_str("offset"),(yyvsp[(4) - (4)].str));
30582
32709
;}
30583
32710
    break;
30584
32711
 
30585
32712
  case 1122:
 
32713
 
 
32714
/* Line 1455 of yacc.c  */
30586
32715
#line 6909 "preproc.y"
30587
32716
    { 
30588
 
 yyval.str = cat_str(4,make_str("offset"),yyvsp[-2].str,make_str("limit"),yyvsp[0].str);
 
32717
 (yyval.str) = cat_str(4,make_str("offset"),(yyvsp[(2) - (4)].str),make_str("limit"),(yyvsp[(4) - (4)].str));
30589
32718
;}
30590
32719
    break;
30591
32720
 
30592
32721
  case 1123:
 
32722
 
 
32723
/* Line 1455 of yacc.c  */
30593
32724
#line 6913 "preproc.y"
30594
32725
    { 
30595
 
 yyval.str = cat_str(2,make_str("limit"),yyvsp[0].str);
 
32726
 (yyval.str) = cat_str(2,make_str("limit"),(yyvsp[(2) - (2)].str));
30596
32727
;}
30597
32728
    break;
30598
32729
 
30599
32730
  case 1124:
 
32731
 
 
32732
/* Line 1455 of yacc.c  */
30600
32733
#line 6917 "preproc.y"
30601
32734
    { 
30602
 
 yyval.str = cat_str(2,make_str("offset"),yyvsp[0].str);
 
32735
 (yyval.str) = cat_str(2,make_str("offset"),(yyvsp[(2) - (2)].str));
30603
32736
;}
30604
32737
    break;
30605
32738
 
30606
32739
  case 1125:
 
32740
 
 
32741
/* Line 1455 of yacc.c  */
30607
32742
#line 6921 "preproc.y"
30608
32743
    {
30609
32744
                mmerror(PARSE_ERROR, ET_WARNING, "no longer supported LIMIT #,# syntax passed to server");
30610
 
                yyval.str = cat_str(4, make_str("limit"), yyvsp[-2].str, make_str(","), yyvsp[0].str);
 
32745
                (yyval.str) = cat_str(4, make_str("limit"), (yyvsp[(2) - (4)].str), make_str(","), (yyvsp[(4) - (4)].str));
30611
32746
        ;}
30612
32747
    break;
30613
32748
 
30614
32749
  case 1126:
 
32750
 
 
32751
/* Line 1455 of yacc.c  */
30615
32752
#line 6926 "preproc.y"
30616
32753
    { 
30617
 
 yyval.str = cat_str(3,make_str("offset"),yyvsp[-1].str,yyvsp[0].str);
 
32754
 (yyval.str) = cat_str(3,make_str("offset"),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
30618
32755
;}
30619
32756
    break;
30620
32757
 
30621
32758
  case 1127:
 
32759
 
 
32760
/* Line 1455 of yacc.c  */
30622
32761
#line 6930 "preproc.y"
30623
32762
    { 
30624
 
 yyval.str = cat_str(5,make_str("fetch"),yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,make_str("only"));
 
32763
 (yyval.str) = cat_str(5,make_str("fetch"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),make_str("only"));
30625
32764
;}
30626
32765
    break;
30627
32766
 
30628
32767
  case 1128:
 
32768
 
 
32769
/* Line 1455 of yacc.c  */
30629
32770
#line 6934 "preproc.y"
30630
32771
    { 
30631
 
 yyval.str = cat_str(8,make_str("offset"),yyvsp[-6].str,yyvsp[-5].str,make_str("fetch"),yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,make_str("only"));
 
32772
 (yyval.str) = cat_str(8,make_str("offset"),(yyvsp[(2) - (8)].str),(yyvsp[(3) - (8)].str),make_str("fetch"),(yyvsp[(5) - (8)].str),(yyvsp[(6) - (8)].str),(yyvsp[(7) - (8)].str),make_str("only"));
30632
32773
;}
30633
32774
    break;
30634
32775
 
30635
32776
  case 1129:
 
32777
 
 
32778
/* Line 1455 of yacc.c  */
30636
32779
#line 6942 "preproc.y"
30637
32780
    { 
30638
 
 yyval.str = yyvsp[0].str;
 
32781
 (yyval.str) = (yyvsp[(1) - (1)].str);
30639
32782
;}
30640
32783
    break;
30641
32784
 
30642
32785
  case 1130:
 
32786
 
 
32787
/* Line 1455 of yacc.c  */
30643
32788
#line 6946 "preproc.y"
30644
32789
    { 
30645
 
 yyval.str=EMPTY; ;}
 
32790
 (yyval.str)=EMPTY; ;}
30646
32791
    break;
30647
32792
 
30648
32793
  case 1131:
 
32794
 
 
32795
/* Line 1455 of yacc.c  */
30649
32796
#line 6953 "preproc.y"
30650
32797
    { 
30651
 
 yyval.str = yyvsp[0].str;
 
32798
 (yyval.str) = (yyvsp[(1) - (1)].str);
30652
32799
;}
30653
32800
    break;
30654
32801
 
30655
32802
  case 1132:
 
32803
 
 
32804
/* Line 1455 of yacc.c  */
30656
32805
#line 6957 "preproc.y"
30657
32806
    { 
30658
 
 yyval.str = make_str("all");
 
32807
 (yyval.str) = make_str("all");
30659
32808
;}
30660
32809
    break;
30661
32810
 
30662
32811
  case 1133:
 
32812
 
 
32813
/* Line 1455 of yacc.c  */
30663
32814
#line 6965 "preproc.y"
30664
32815
    { 
30665
 
 yyval.str = yyvsp[0].str;
 
32816
 (yyval.str) = (yyvsp[(1) - (1)].str);
30666
32817
;}
30667
32818
    break;
30668
32819
 
30669
32820
  case 1134:
 
32821
 
 
32822
/* Line 1455 of yacc.c  */
30670
32823
#line 6969 "preproc.y"
30671
32824
    { 
30672
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
32825
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
30673
32826
;}
30674
32827
    break;
30675
32828
 
30676
32829
  case 1135:
 
32830
 
 
32831
/* Line 1455 of yacc.c  */
30677
32832
#line 6973 "preproc.y"
30678
32833
    { 
30679
 
 yyval.str=EMPTY; ;}
 
32834
 (yyval.str)=EMPTY; ;}
30680
32835
    break;
30681
32836
 
30682
32837
  case 1136:
 
32838
 
 
32839
/* Line 1455 of yacc.c  */
30683
32840
#line 6980 "preproc.y"
30684
32841
    { 
30685
 
 yyval.str = yyvsp[0].str;
 
32842
 (yyval.str) = (yyvsp[(1) - (1)].str);
30686
32843
;}
30687
32844
    break;
30688
32845
 
30689
32846
  case 1137:
 
32847
 
 
32848
/* Line 1455 of yacc.c  */
30690
32849
#line 6988 "preproc.y"
30691
32850
    { 
30692
 
 yyval.str = yyvsp[0].str;
 
32851
 (yyval.str) = (yyvsp[(1) - (1)].str);
30693
32852
;}
30694
32853
    break;
30695
32854
 
30696
32855
  case 1138:
 
32856
 
 
32857
/* Line 1455 of yacc.c  */
30697
32858
#line 6996 "preproc.y"
30698
32859
    { 
30699
 
 yyval.str = make_str("row");
 
32860
 (yyval.str) = make_str("row");
30700
32861
;}
30701
32862
    break;
30702
32863
 
30703
32864
  case 1139:
 
32865
 
 
32866
/* Line 1455 of yacc.c  */
30704
32867
#line 7000 "preproc.y"
30705
32868
    { 
30706
 
 yyval.str = make_str("rows");
 
32869
 (yyval.str) = make_str("rows");
30707
32870
;}
30708
32871
    break;
30709
32872
 
30710
32873
  case 1140:
 
32874
 
 
32875
/* Line 1455 of yacc.c  */
30711
32876
#line 7008 "preproc.y"
30712
32877
    { 
30713
 
 yyval.str = make_str("first");
 
32878
 (yyval.str) = make_str("first");
30714
32879
;}
30715
32880
    break;
30716
32881
 
30717
32882
  case 1141:
 
32883
 
 
32884
/* Line 1455 of yacc.c  */
30718
32885
#line 7012 "preproc.y"
30719
32886
    { 
30720
 
 yyval.str = make_str("next");
 
32887
 (yyval.str) = make_str("next");
30721
32888
;}
30722
32889
    break;
30723
32890
 
30724
32891
  case 1142:
 
32892
 
 
32893
/* Line 1455 of yacc.c  */
30725
32894
#line 7020 "preproc.y"
30726
32895
    { 
30727
 
 yyval.str = cat_str(2,make_str("group by"),yyvsp[0].str);
 
32896
 (yyval.str) = cat_str(2,make_str("group by"),(yyvsp[(3) - (3)].str));
30728
32897
;}
30729
32898
    break;
30730
32899
 
30731
32900
  case 1143:
 
32901
 
 
32902
/* Line 1455 of yacc.c  */
30732
32903
#line 7024 "preproc.y"
30733
32904
    { 
30734
 
 yyval.str=EMPTY; ;}
 
32905
 (yyval.str)=EMPTY; ;}
30735
32906
    break;
30736
32907
 
30737
32908
  case 1144:
 
32909
 
 
32910
/* Line 1455 of yacc.c  */
30738
32911
#line 7031 "preproc.y"
30739
32912
    { 
30740
 
 yyval.str = cat_str(2,make_str("having"),yyvsp[0].str);
 
32913
 (yyval.str) = cat_str(2,make_str("having"),(yyvsp[(2) - (2)].str));
30741
32914
;}
30742
32915
    break;
30743
32916
 
30744
32917
  case 1145:
 
32918
 
 
32919
/* Line 1455 of yacc.c  */
30745
32920
#line 7035 "preproc.y"
30746
32921
    { 
30747
 
 yyval.str=EMPTY; ;}
 
32922
 (yyval.str)=EMPTY; ;}
30748
32923
    break;
30749
32924
 
30750
32925
  case 1146:
 
32926
 
 
32927
/* Line 1455 of yacc.c  */
30751
32928
#line 7042 "preproc.y"
30752
32929
    { 
30753
 
 yyval.str = yyvsp[0].str;
 
32930
 (yyval.str) = (yyvsp[(1) - (1)].str);
30754
32931
;}
30755
32932
    break;
30756
32933
 
30757
32934
  case 1147:
 
32935
 
 
32936
/* Line 1455 of yacc.c  */
30758
32937
#line 7046 "preproc.y"
30759
32938
    { 
30760
 
 yyval.str = make_str("for read only");
 
32939
 (yyval.str) = make_str("for read only");
30761
32940
;}
30762
32941
    break;
30763
32942
 
30764
32943
  case 1148:
 
32944
 
 
32945
/* Line 1455 of yacc.c  */
30765
32946
#line 7054 "preproc.y"
30766
32947
    { 
30767
 
 yyval.str = yyvsp[0].str;
 
32948
 (yyval.str) = (yyvsp[(1) - (1)].str);
30768
32949
;}
30769
32950
    break;
30770
32951
 
30771
32952
  case 1149:
 
32953
 
 
32954
/* Line 1455 of yacc.c  */
30772
32955
#line 7058 "preproc.y"
30773
32956
    { 
30774
 
 yyval.str=EMPTY; ;}
 
32957
 (yyval.str)=EMPTY; ;}
30775
32958
    break;
30776
32959
 
30777
32960
  case 1150:
 
32961
 
 
32962
/* Line 1455 of yacc.c  */
30778
32963
#line 7065 "preproc.y"
30779
32964
    { 
30780
 
 yyval.str = yyvsp[0].str;
 
32965
 (yyval.str) = (yyvsp[(1) - (1)].str);
30781
32966
;}
30782
32967
    break;
30783
32968
 
30784
32969
  case 1151:
 
32970
 
 
32971
/* Line 1455 of yacc.c  */
30785
32972
#line 7069 "preproc.y"
30786
32973
    { 
30787
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
32974
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
30788
32975
;}
30789
32976
    break;
30790
32977
 
30791
32978
  case 1152:
 
32979
 
 
32980
/* Line 1455 of yacc.c  */
30792
32981
#line 7077 "preproc.y"
30793
32982
    { 
30794
 
 yyval.str = cat_str(3,make_str("for update"),yyvsp[-1].str,yyvsp[0].str);
 
32983
 (yyval.str) = cat_str(3,make_str("for update"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
30795
32984
;}
30796
32985
    break;
30797
32986
 
30798
32987
  case 1153:
 
32988
 
 
32989
/* Line 1455 of yacc.c  */
30799
32990
#line 7081 "preproc.y"
30800
32991
    { 
30801
 
 yyval.str = cat_str(3,make_str("for share"),yyvsp[-1].str,yyvsp[0].str);
 
32992
 (yyval.str) = cat_str(3,make_str("for share"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
30802
32993
;}
30803
32994
    break;
30804
32995
 
30805
32996
  case 1154:
 
32997
 
 
32998
/* Line 1455 of yacc.c  */
30806
32999
#line 7089 "preproc.y"
30807
33000
    { 
30808
 
 yyval.str = cat_str(2,make_str("of"),yyvsp[0].str);
 
33001
 (yyval.str) = cat_str(2,make_str("of"),(yyvsp[(2) - (2)].str));
30809
33002
;}
30810
33003
    break;
30811
33004
 
30812
33005
  case 1155:
 
33006
 
 
33007
/* Line 1455 of yacc.c  */
30813
33008
#line 7093 "preproc.y"
30814
33009
    { 
30815
 
 yyval.str=EMPTY; ;}
 
33010
 (yyval.str)=EMPTY; ;}
30816
33011
    break;
30817
33012
 
30818
33013
  case 1156:
 
33014
 
 
33015
/* Line 1455 of yacc.c  */
30819
33016
#line 7100 "preproc.y"
30820
33017
    { 
30821
 
 yyval.str = cat_str(2,make_str("values"),yyvsp[0].str);
 
33018
 (yyval.str) = cat_str(2,make_str("values"),(yyvsp[(2) - (2)].str));
30822
33019
;}
30823
33020
    break;
30824
33021
 
30825
33022
  case 1157:
 
33023
 
 
33024
/* Line 1455 of yacc.c  */
30826
33025
#line 7104 "preproc.y"
30827
33026
    { 
30828
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
33027
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
30829
33028
;}
30830
33029
    break;
30831
33030
 
30832
33031
  case 1158:
 
33032
 
 
33033
/* Line 1455 of yacc.c  */
30833
33034
#line 7112 "preproc.y"
30834
33035
    { 
30835
 
 yyval.str = cat_str(2,make_str("from"),yyvsp[0].str);
 
33036
 (yyval.str) = cat_str(2,make_str("from"),(yyvsp[(2) - (2)].str));
30836
33037
;}
30837
33038
    break;
30838
33039
 
30839
33040
  case 1159:
 
33041
 
 
33042
/* Line 1455 of yacc.c  */
30840
33043
#line 7116 "preproc.y"
30841
33044
    { 
30842
 
 yyval.str=EMPTY; ;}
 
33045
 (yyval.str)=EMPTY; ;}
30843
33046
    break;
30844
33047
 
30845
33048
  case 1160:
 
33049
 
 
33050
/* Line 1455 of yacc.c  */
30846
33051
#line 7123 "preproc.y"
30847
33052
    { 
30848
 
 yyval.str = yyvsp[0].str;
 
33053
 (yyval.str) = (yyvsp[(1) - (1)].str);
30849
33054
;}
30850
33055
    break;
30851
33056
 
30852
33057
  case 1161:
 
33058
 
 
33059
/* Line 1455 of yacc.c  */
30853
33060
#line 7127 "preproc.y"
30854
33061
    { 
30855
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
33062
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
30856
33063
;}
30857
33064
    break;
30858
33065
 
30859
33066
  case 1162:
 
33067
 
 
33068
/* Line 1455 of yacc.c  */
30860
33069
#line 7135 "preproc.y"
30861
33070
    { 
30862
 
 yyval.str = yyvsp[0].str;
 
33071
 (yyval.str) = (yyvsp[(1) - (1)].str);
30863
33072
;}
30864
33073
    break;
30865
33074
 
30866
33075
  case 1163:
 
33076
 
 
33077
/* Line 1455 of yacc.c  */
30867
33078
#line 7139 "preproc.y"
30868
33079
    { 
30869
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
33080
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
30870
33081
;}
30871
33082
    break;
30872
33083
 
30873
33084
  case 1164:
 
33085
 
 
33086
/* Line 1455 of yacc.c  */
30874
33087
#line 7143 "preproc.y"
30875
33088
    { 
30876
 
 yyval.str = yyvsp[0].str;
 
33089
 (yyval.str) = (yyvsp[(1) - (1)].str);
30877
33090
;}
30878
33091
    break;
30879
33092
 
30880
33093
  case 1165:
 
33094
 
 
33095
/* Line 1455 of yacc.c  */
30881
33096
#line 7147 "preproc.y"
30882
33097
    { 
30883
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
33098
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
30884
33099
;}
30885
33100
    break;
30886
33101
 
30887
33102
  case 1166:
 
33103
 
 
33104
/* Line 1455 of yacc.c  */
30888
33105
#line 7151 "preproc.y"
30889
33106
    { 
30890
 
 yyval.str = cat_str(4,yyvsp[-4].str,make_str("as ("),yyvsp[-1].str,make_str(")"));
 
33107
 (yyval.str) = cat_str(4,(yyvsp[(1) - (5)].str),make_str("as ("),(yyvsp[(4) - (5)].str),make_str(")"));
30891
33108
;}
30892
33109
    break;
30893
33110
 
30894
33111
  case 1167:
 
33112
 
 
33113
/* Line 1455 of yacc.c  */
30895
33114
#line 7155 "preproc.y"
30896
33115
    { 
30897
 
 yyval.str = cat_str(6,yyvsp[-5].str,make_str("as"),yyvsp[-3].str,make_str("("),yyvsp[-1].str,make_str(")"));
 
33116
 (yyval.str) = cat_str(6,(yyvsp[(1) - (6)].str),make_str("as"),(yyvsp[(3) - (6)].str),make_str("("),(yyvsp[(5) - (6)].str),make_str(")"));
30898
33117
;}
30899
33118
    break;
30900
33119
 
30901
33120
  case 1168:
 
33121
 
 
33122
/* Line 1455 of yacc.c  */
30902
33123
#line 7159 "preproc.y"
30903
33124
    { 
30904
 
 yyval.str = cat_str(5,yyvsp[-4].str,yyvsp[-3].str,make_str("("),yyvsp[-1].str,make_str(")"));
 
33125
 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),(yyvsp[(2) - (5)].str),make_str("("),(yyvsp[(4) - (5)].str),make_str(")"));
30905
33126
;}
30906
33127
    break;
30907
33128
 
30908
33129
  case 1169:
 
33130
 
 
33131
/* Line 1455 of yacc.c  */
30909
33132
#line 7163 "preproc.y"
30910
33133
    { 
30911
33134
                mmerror(PARSE_ERROR, ET_ERROR, "subquery in FROM must have an alias");
30912
33135
 
30913
 
 yyval.str = yyvsp[0].str;
 
33136
 (yyval.str) = (yyvsp[(1) - (1)].str);
30914
33137
;}
30915
33138
    break;
30916
33139
 
30917
33140
  case 1170:
 
33141
 
 
33142
/* Line 1455 of yacc.c  */
30918
33143
#line 7169 "preproc.y"
30919
33144
    { 
30920
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
33145
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
30921
33146
;}
30922
33147
    break;
30923
33148
 
30924
33149
  case 1171:
 
33150
 
 
33151
/* Line 1455 of yacc.c  */
30925
33152
#line 7173 "preproc.y"
30926
33153
    { 
30927
 
 yyval.str = yyvsp[0].str;
 
33154
 (yyval.str) = (yyvsp[(1) - (1)].str);
30928
33155
;}
30929
33156
    break;
30930
33157
 
30931
33158
  case 1172:
 
33159
 
 
33160
/* Line 1455 of yacc.c  */
30932
33161
#line 7177 "preproc.y"
30933
33162
    { 
30934
 
 yyval.str = cat_str(4,make_str("("),yyvsp[-2].str,make_str(")"),yyvsp[0].str);
 
33163
 (yyval.str) = cat_str(4,make_str("("),(yyvsp[(2) - (4)].str),make_str(")"),(yyvsp[(4) - (4)].str));
30935
33164
;}
30936
33165
    break;
30937
33166
 
30938
33167
  case 1173:
 
33168
 
 
33169
/* Line 1455 of yacc.c  */
30939
33170
#line 7185 "preproc.y"
30940
33171
    { 
30941
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
33172
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
30942
33173
;}
30943
33174
    break;
30944
33175
 
30945
33176
  case 1174:
 
33177
 
 
33178
/* Line 1455 of yacc.c  */
30946
33179
#line 7189 "preproc.y"
30947
33180
    { 
30948
 
 yyval.str = cat_str(3,yyvsp[-3].str,make_str("cross join"),yyvsp[0].str);
 
33181
 (yyval.str) = cat_str(3,(yyvsp[(1) - (4)].str),make_str("cross join"),(yyvsp[(4) - (4)].str));
30949
33182
;}
30950
33183
    break;
30951
33184
 
30952
33185
  case 1175:
 
33186
 
 
33187
/* Line 1455 of yacc.c  */
30953
33188
#line 7193 "preproc.y"
30954
33189
    { 
30955
 
 yyval.str = cat_str(5,yyvsp[-4].str,yyvsp[-3].str,make_str("join"),yyvsp[-1].str,yyvsp[0].str);
 
33190
 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),(yyvsp[(2) - (5)].str),make_str("join"),(yyvsp[(4) - (5)].str),(yyvsp[(5) - (5)].str));
30956
33191
;}
30957
33192
    break;
30958
33193
 
30959
33194
  case 1176:
 
33195
 
 
33196
/* Line 1455 of yacc.c  */
30960
33197
#line 7197 "preproc.y"
30961
33198
    { 
30962
 
 yyval.str = cat_str(4,yyvsp[-3].str,make_str("join"),yyvsp[-1].str,yyvsp[0].str);
 
33199
 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),make_str("join"),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
30963
33200
;}
30964
33201
    break;
30965
33202
 
30966
33203
  case 1177:
 
33204
 
 
33205
/* Line 1455 of yacc.c  */
30967
33206
#line 7201 "preproc.y"
30968
33207
    { 
30969
 
 yyval.str = cat_str(5,yyvsp[-4].str,make_str("natural"),yyvsp[-2].str,make_str("join"),yyvsp[0].str);
 
33208
 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),make_str("natural"),(yyvsp[(3) - (5)].str),make_str("join"),(yyvsp[(5) - (5)].str));
30970
33209
;}
30971
33210
    break;
30972
33211
 
30973
33212
  case 1178:
 
33213
 
 
33214
/* Line 1455 of yacc.c  */
30974
33215
#line 7205 "preproc.y"
30975
33216
    { 
30976
 
 yyval.str = cat_str(3,yyvsp[-3].str,make_str("natural join"),yyvsp[0].str);
 
33217
 (yyval.str) = cat_str(3,(yyvsp[(1) - (4)].str),make_str("natural join"),(yyvsp[(4) - (4)].str));
30977
33218
;}
30978
33219
    break;
30979
33220
 
30980
33221
  case 1179:
 
33222
 
 
33223
/* Line 1455 of yacc.c  */
30981
33224
#line 7213 "preproc.y"
30982
33225
    { 
30983
 
 yyval.str = cat_str(5,make_str("as"),yyvsp[-3].str,make_str("("),yyvsp[-1].str,make_str(")"));
 
33226
 (yyval.str) = cat_str(5,make_str("as"),(yyvsp[(2) - (5)].str),make_str("("),(yyvsp[(4) - (5)].str),make_str(")"));
30984
33227
;}
30985
33228
    break;
30986
33229
 
30987
33230
  case 1180:
 
33231
 
 
33232
/* Line 1455 of yacc.c  */
30988
33233
#line 7217 "preproc.y"
30989
33234
    { 
30990
 
 yyval.str = cat_str(2,make_str("as"),yyvsp[0].str);
 
33235
 (yyval.str) = cat_str(2,make_str("as"),(yyvsp[(2) - (2)].str));
30991
33236
;}
30992
33237
    break;
30993
33238
 
30994
33239
  case 1181:
 
33240
 
 
33241
/* Line 1455 of yacc.c  */
30995
33242
#line 7221 "preproc.y"
30996
33243
    { 
30997
 
 yyval.str = cat_str(4,yyvsp[-3].str,make_str("("),yyvsp[-1].str,make_str(")"));
 
33244
 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),make_str("("),(yyvsp[(3) - (4)].str),make_str(")"));
30998
33245
;}
30999
33246
    break;
31000
33247
 
31001
33248
  case 1182:
 
33249
 
 
33250
/* Line 1455 of yacc.c  */
31002
33251
#line 7225 "preproc.y"
31003
33252
    { 
31004
 
 yyval.str = yyvsp[0].str;
 
33253
 (yyval.str) = (yyvsp[(1) - (1)].str);
31005
33254
;}
31006
33255
    break;
31007
33256
 
31008
33257
  case 1183:
 
33258
 
 
33259
/* Line 1455 of yacc.c  */
31009
33260
#line 7233 "preproc.y"
31010
33261
    { 
31011
 
 yyval.str = cat_str(2,make_str("full"),yyvsp[0].str);
 
33262
 (yyval.str) = cat_str(2,make_str("full"),(yyvsp[(2) - (2)].str));
31012
33263
;}
31013
33264
    break;
31014
33265
 
31015
33266
  case 1184:
 
33267
 
 
33268
/* Line 1455 of yacc.c  */
31016
33269
#line 7237 "preproc.y"
31017
33270
    { 
31018
 
 yyval.str = cat_str(2,make_str("left"),yyvsp[0].str);
 
33271
 (yyval.str) = cat_str(2,make_str("left"),(yyvsp[(2) - (2)].str));
31019
33272
;}
31020
33273
    break;
31021
33274
 
31022
33275
  case 1185:
 
33276
 
 
33277
/* Line 1455 of yacc.c  */
31023
33278
#line 7241 "preproc.y"
31024
33279
    { 
31025
 
 yyval.str = cat_str(2,make_str("right"),yyvsp[0].str);
 
33280
 (yyval.str) = cat_str(2,make_str("right"),(yyvsp[(2) - (2)].str));
31026
33281
;}
31027
33282
    break;
31028
33283
 
31029
33284
  case 1186:
 
33285
 
 
33286
/* Line 1455 of yacc.c  */
31030
33287
#line 7245 "preproc.y"
31031
33288
    { 
31032
 
 yyval.str = make_str("inner");
 
33289
 (yyval.str) = make_str("inner");
31033
33290
;}
31034
33291
    break;
31035
33292
 
31036
33293
  case 1187:
 
33294
 
 
33295
/* Line 1455 of yacc.c  */
31037
33296
#line 7253 "preproc.y"
31038
33297
    { 
31039
 
 yyval.str = make_str("outer");
 
33298
 (yyval.str) = make_str("outer");
31040
33299
;}
31041
33300
    break;
31042
33301
 
31043
33302
  case 1188:
 
33303
 
 
33304
/* Line 1455 of yacc.c  */
31044
33305
#line 7257 "preproc.y"
31045
33306
    { 
31046
 
 yyval.str=EMPTY; ;}
 
33307
 (yyval.str)=EMPTY; ;}
31047
33308
    break;
31048
33309
 
31049
33310
  case 1189:
 
33311
 
 
33312
/* Line 1455 of yacc.c  */
31050
33313
#line 7264 "preproc.y"
31051
33314
    { 
31052
 
 yyval.str = cat_str(3,make_str("using ("),yyvsp[-1].str,make_str(")"));
 
33315
 (yyval.str) = cat_str(3,make_str("using ("),(yyvsp[(3) - (4)].str),make_str(")"));
31053
33316
;}
31054
33317
    break;
31055
33318
 
31056
33319
  case 1190:
 
33320
 
 
33321
/* Line 1455 of yacc.c  */
31057
33322
#line 7268 "preproc.y"
31058
33323
    { 
31059
 
 yyval.str = cat_str(2,make_str("on"),yyvsp[0].str);
 
33324
 (yyval.str) = cat_str(2,make_str("on"),(yyvsp[(2) - (2)].str));
31060
33325
;}
31061
33326
    break;
31062
33327
 
31063
33328
  case 1191:
 
33329
 
 
33330
/* Line 1455 of yacc.c  */
31064
33331
#line 7276 "preproc.y"
31065
33332
    { 
31066
 
 yyval.str = yyvsp[0].str;
 
33333
 (yyval.str) = (yyvsp[(1) - (1)].str);
31067
33334
;}
31068
33335
    break;
31069
33336
 
31070
33337
  case 1192:
 
33338
 
 
33339
/* Line 1455 of yacc.c  */
31071
33340
#line 7280 "preproc.y"
31072
33341
    { 
31073
 
 yyval.str = cat_str(2,yyvsp[-1].str,make_str("*"));
 
33342
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),make_str("*"));
31074
33343
;}
31075
33344
    break;
31076
33345
 
31077
33346
  case 1193:
 
33347
 
 
33348
/* Line 1455 of yacc.c  */
31078
33349
#line 7284 "preproc.y"
31079
33350
    { 
31080
 
 yyval.str = cat_str(2,make_str("only"),yyvsp[0].str);
 
33351
 (yyval.str) = cat_str(2,make_str("only"),(yyvsp[(2) - (2)].str));
31081
33352
;}
31082
33353
    break;
31083
33354
 
31084
33355
  case 1194:
 
33356
 
 
33357
/* Line 1455 of yacc.c  */
31085
33358
#line 7288 "preproc.y"
31086
33359
    { 
31087
 
 yyval.str = cat_str(3,make_str("only ("),yyvsp[-1].str,make_str(")"));
 
33360
 (yyval.str) = cat_str(3,make_str("only ("),(yyvsp[(3) - (4)].str),make_str(")"));
31088
33361
;}
31089
33362
    break;
31090
33363
 
31091
33364
  case 1195:
 
33365
 
 
33366
/* Line 1455 of yacc.c  */
31092
33367
#line 7296 "preproc.y"
31093
33368
    { 
31094
 
 yyval.str = yyvsp[0].str;
 
33369
 (yyval.str) = (yyvsp[(1) - (1)].str);
31095
33370
;}
31096
33371
    break;
31097
33372
 
31098
33373
  case 1196:
 
33374
 
 
33375
/* Line 1455 of yacc.c  */
31099
33376
#line 7300 "preproc.y"
31100
33377
    { 
31101
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
33378
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
31102
33379
;}
31103
33380
    break;
31104
33381
 
31105
33382
  case 1197:
 
33383
 
 
33384
/* Line 1455 of yacc.c  */
31106
33385
#line 7308 "preproc.y"
31107
33386
    { 
31108
 
 yyval.str = yyvsp[0].str;
 
33387
 (yyval.str) = (yyvsp[(1) - (1)].str);
31109
33388
;}
31110
33389
    break;
31111
33390
 
31112
33391
  case 1198:
 
33392
 
 
33393
/* Line 1455 of yacc.c  */
31113
33394
#line 7312 "preproc.y"
31114
33395
    { 
31115
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
33396
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
31116
33397
;}
31117
33398
    break;
31118
33399
 
31119
33400
  case 1199:
 
33401
 
 
33402
/* Line 1455 of yacc.c  */
31120
33403
#line 7316 "preproc.y"
31121
33404
    { 
31122
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("as"),yyvsp[0].str);
 
33405
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("as"),(yyvsp[(3) - (3)].str));
31123
33406
;}
31124
33407
    break;
31125
33408
 
31126
33409
  case 1200:
 
33410
 
 
33411
/* Line 1455 of yacc.c  */
31127
33412
#line 7324 "preproc.y"
31128
33413
    { 
31129
 
 yyval.str = yyvsp[0].str;
 
33414
 (yyval.str) = (yyvsp[(1) - (1)].str);
31130
33415
;}
31131
33416
    break;
31132
33417
 
31133
33418
  case 1201:
 
33419
 
 
33420
/* Line 1455 of yacc.c  */
31134
33421
#line 7332 "preproc.y"
31135
33422
    { 
31136
 
 yyval.str = cat_str(2,make_str("where"),yyvsp[0].str);
 
33423
 (yyval.str) = cat_str(2,make_str("where"),(yyvsp[(2) - (2)].str));
31137
33424
;}
31138
33425
    break;
31139
33426
 
31140
33427
  case 1202:
 
33428
 
 
33429
/* Line 1455 of yacc.c  */
31141
33430
#line 7336 "preproc.y"
31142
33431
    { 
31143
 
 yyval.str=EMPTY; ;}
 
33432
 (yyval.str)=EMPTY; ;}
31144
33433
    break;
31145
33434
 
31146
33435
  case 1203:
 
33436
 
 
33437
/* Line 1455 of yacc.c  */
31147
33438
#line 7343 "preproc.y"
31148
33439
    { 
31149
 
 yyval.str = cat_str(2,make_str("where"),yyvsp[0].str);
 
33440
 (yyval.str) = cat_str(2,make_str("where"),(yyvsp[(2) - (2)].str));
31150
33441
;}
31151
33442
    break;
31152
33443
 
31153
33444
  case 1204:
 
33445
 
 
33446
/* Line 1455 of yacc.c  */
31154
33447
#line 7347 "preproc.y"
31155
33448
    { 
31156
 
 yyval.str = cat_str(2,make_str("where current of"),yyvsp[0].str);
 
33449
 (yyval.str) = cat_str(2,make_str("where current of"),(yyvsp[(4) - (4)].str));
31157
33450
;}
31158
33451
    break;
31159
33452
 
31160
33453
  case 1205:
 
33454
 
 
33455
/* Line 1455 of yacc.c  */
31161
33456
#line 7351 "preproc.y"
31162
33457
    { 
31163
 
 yyval.str = cat_str(2,make_str("where current of"),yyvsp[0].str);
 
33458
 (yyval.str) = cat_str(2,make_str("where current of"),(yyvsp[(4) - (4)].str));
31164
33459
;}
31165
33460
    break;
31166
33461
 
31167
33462
  case 1206:
 
33463
 
 
33464
/* Line 1455 of yacc.c  */
31168
33465
#line 7355 "preproc.y"
31169
33466
    { 
31170
 
 yyval.str=EMPTY; ;}
 
33467
 (yyval.str)=EMPTY; ;}
31171
33468
    break;
31172
33469
 
31173
33470
  case 1207:
 
33471
 
 
33472
/* Line 1455 of yacc.c  */
31174
33473
#line 7362 "preproc.y"
31175
33474
    { 
31176
 
 yyval.str = yyvsp[0].str;
 
33475
 (yyval.str) = (yyvsp[(1) - (1)].str);
31177
33476
;}
31178
33477
    break;
31179
33478
 
31180
33479
  case 1208:
 
33480
 
 
33481
/* Line 1455 of yacc.c  */
31181
33482
#line 7366 "preproc.y"
31182
33483
    { 
31183
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
33484
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
31184
33485
;}
31185
33486
    break;
31186
33487
 
31187
33488
  case 1209:
 
33489
 
 
33490
/* Line 1455 of yacc.c  */
31188
33491
#line 7374 "preproc.y"
31189
33492
    { 
31190
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
33493
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
31191
33494
;}
31192
33495
    break;
31193
33496
 
31194
33497
  case 1210:
 
33498
 
 
33499
/* Line 1455 of yacc.c  */
31195
33500
#line 7382 "preproc.y"
31196
 
    {   yyval.str = cat2_str(yyvsp[-1].str, yyvsp[0].index.str); ;}
 
33501
    {   (yyval.str) = cat2_str((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].index).str); ;}
31197
33502
    break;
31198
33503
 
31199
33504
  case 1211:
 
33505
 
 
33506
/* Line 1455 of yacc.c  */
31200
33507
#line 7384 "preproc.y"
31201
 
    {   yyval.str = yyval.str = cat_str(3, make_str("setof"), yyvsp[-1].str, yyvsp[0].index.str); ;}
 
33508
    {   (yyval.str) = (yyval.str) = cat_str(3, make_str("setof"), (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].index).str); ;}
31202
33509
    break;
31203
33510
 
31204
33511
  case 1212:
 
33512
 
 
33513
/* Line 1455 of yacc.c  */
31205
33514
#line 7386 "preproc.y"
31206
33515
    { 
31207
 
 yyval.str = cat_str(4,yyvsp[-4].str,make_str("array ["),yyvsp[-1].str,make_str("]"));
 
33516
 (yyval.str) = cat_str(4,(yyvsp[(1) - (5)].str),make_str("array ["),(yyvsp[(4) - (5)].str),make_str("]"));
31208
33517
;}
31209
33518
    break;
31210
33519
 
31211
33520
  case 1213:
 
33521
 
 
33522
/* Line 1455 of yacc.c  */
31212
33523
#line 7390 "preproc.y"
31213
33524
    { 
31214
 
 yyval.str = cat_str(5,make_str("setof"),yyvsp[-4].str,make_str("array ["),yyvsp[-1].str,make_str("]"));
 
33525
 (yyval.str) = cat_str(5,make_str("setof"),(yyvsp[(2) - (6)].str),make_str("array ["),(yyvsp[(5) - (6)].str),make_str("]"));
31215
33526
;}
31216
33527
    break;
31217
33528
 
31218
33529
  case 1214:
 
33530
 
 
33531
/* Line 1455 of yacc.c  */
31219
33532
#line 7394 "preproc.y"
31220
33533
    { 
31221
 
 yyval.str = cat_str(2,yyvsp[-1].str,make_str("array"));
 
33534
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),make_str("array"));
31222
33535
;}
31223
33536
    break;
31224
33537
 
31225
33538
  case 1215:
 
33539
 
 
33540
/* Line 1455 of yacc.c  */
31226
33541
#line 7398 "preproc.y"
31227
33542
    { 
31228
 
 yyval.str = cat_str(3,make_str("setof"),yyvsp[-1].str,make_str("array"));
 
33543
 (yyval.str) = cat_str(3,make_str("setof"),(yyvsp[(2) - (3)].str),make_str("array"));
31229
33544
;}
31230
33545
    break;
31231
33546
 
31232
33547
  case 1216:
 
33548
 
 
33549
/* Line 1455 of yacc.c  */
31233
33550
#line 7406 "preproc.y"
31234
33551
    {
31235
 
                yyval.index.index1 = yyvsp[-2].index.index1;
31236
 
                yyval.index.index2 = yyvsp[-2].index.index2;
31237
 
                if (strcmp(yyval.index.index1, "-1") == 0)
31238
 
                        yyval.index.index1 = make_str("0");
31239
 
                else if (strcmp(yyvsp[-2].index.index2, "-1") == 0)
31240
 
                        yyval.index.index2 = make_str("0");
31241
 
                yyval.index.str = cat_str(2, yyvsp[-2].index.str, make_str("[]"));
 
33552
                (yyval.index).index1 = (yyvsp[(1) - (3)].index).index1;
 
33553
                (yyval.index).index2 = (yyvsp[(1) - (3)].index).index2;
 
33554
                if (strcmp((yyval.index).index1, "-1") == 0)
 
33555
                        (yyval.index).index1 = make_str("0");
 
33556
                else if (strcmp((yyvsp[(1) - (3)].index).index2, "-1") == 0)
 
33557
                        (yyval.index).index2 = make_str("0");
 
33558
                (yyval.index).str = cat_str(2, (yyvsp[(1) - (3)].index).str, make_str("[]"));
31242
33559
        ;}
31243
33560
    break;
31244
33561
 
31245
33562
  case 1217:
 
33563
 
 
33564
/* Line 1455 of yacc.c  */
31246
33565
#line 7416 "preproc.y"
31247
33566
    {
31248
 
                yyval.index.index1 = yyvsp[-3].index.index1;
31249
 
                yyval.index.index2 = yyvsp[-3].index.index2;
31250
 
                if (strcmp(yyvsp[-3].index.index1, "-1") == 0)
31251
 
                        yyval.index.index1 = strdup(yyvsp[-1].str);
31252
 
                else if (strcmp(yyvsp[-3].index.index2, "-1") == 0)
31253
 
                        yyval.index.index2 = strdup(yyvsp[-1].str);
31254
 
                yyval.index.str = cat_str(4, yyvsp[-3].index.str, make_str("["), yyvsp[-1].str, make_str("]"));
 
33567
                (yyval.index).index1 = (yyvsp[(1) - (4)].index).index1;
 
33568
                (yyval.index).index2 = (yyvsp[(1) - (4)].index).index2;
 
33569
                if (strcmp((yyvsp[(1) - (4)].index).index1, "-1") == 0)
 
33570
                        (yyval.index).index1 = strdup((yyvsp[(3) - (4)].str));
 
33571
                else if (strcmp((yyvsp[(1) - (4)].index).index2, "-1") == 0)
 
33572
                        (yyval.index).index2 = strdup((yyvsp[(3) - (4)].str));
 
33573
                (yyval.index).str = cat_str(4, (yyvsp[(1) - (4)].index).str, make_str("["), (yyvsp[(3) - (4)].str), make_str("]"));
31255
33574
        ;}
31256
33575
    break;
31257
33576
 
31258
33577
  case 1218:
 
33578
 
 
33579
/* Line 1455 of yacc.c  */
31259
33580
#line 7426 "preproc.y"
31260
33581
    {
31261
 
                yyval.index.index1 = make_str("-1");
31262
 
                yyval.index.index2 = make_str("-1");
31263
 
                yyval.index.str= EMPTY;
 
33582
                (yyval.index).index1 = make_str("-1");
 
33583
                (yyval.index).index2 = make_str("-1");
 
33584
                (yyval.index).str= EMPTY;
31264
33585
        ;}
31265
33586
    break;
31266
33587
 
31267
33588
  case 1219:
 
33589
 
 
33590
/* Line 1455 of yacc.c  */
31268
33591
#line 7436 "preproc.y"
31269
33592
    { 
31270
 
 yyval.str = yyvsp[0].str;
 
33593
 (yyval.str) = (yyvsp[(1) - (1)].str);
31271
33594
;}
31272
33595
    break;
31273
33596
 
31274
33597
  case 1220:
 
33598
 
 
33599
/* Line 1455 of yacc.c  */
31275
33600
#line 7440 "preproc.y"
31276
33601
    { 
31277
 
 yyval.str = yyvsp[0].str;
 
33602
 (yyval.str) = (yyvsp[(1) - (1)].str);
31278
33603
;}
31279
33604
    break;
31280
33605
 
31281
33606
  case 1221:
 
33607
 
 
33608
/* Line 1455 of yacc.c  */
31282
33609
#line 7444 "preproc.y"
31283
33610
    { 
31284
 
 yyval.str = yyvsp[0].str;
 
33611
 (yyval.str) = (yyvsp[(1) - (1)].str);
31285
33612
;}
31286
33613
    break;
31287
33614
 
31288
33615
  case 1222:
 
33616
 
 
33617
/* Line 1455 of yacc.c  */
31289
33618
#line 7448 "preproc.y"
31290
33619
    { 
31291
 
 yyval.str = yyvsp[0].str;
 
33620
 (yyval.str) = (yyvsp[(1) - (1)].str);
31292
33621
;}
31293
33622
    break;
31294
33623
 
31295
33624
  case 1223:
 
33625
 
 
33626
/* Line 1455 of yacc.c  */
31296
33627
#line 7452 "preproc.y"
31297
33628
    { 
31298
 
 yyval.str = yyvsp[0].str;
 
33629
 (yyval.str) = (yyvsp[(1) - (1)].str);
31299
33630
;}
31300
33631
    break;
31301
33632
 
31302
33633
  case 1224:
 
33634
 
 
33635
/* Line 1455 of yacc.c  */
31303
33636
#line 7456 "preproc.y"
31304
33637
    { 
31305
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
33638
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
31306
33639
;}
31307
33640
    break;
31308
33641
 
31309
33642
  case 1225:
 
33643
 
 
33644
/* Line 1455 of yacc.c  */
31310
33645
#line 7460 "preproc.y"
31311
33646
    { 
31312
 
 yyval.str = cat_str(5,yyvsp[-4].str,make_str("("),yyvsp[-2].str,make_str(")"),yyvsp[0].str);
 
33647
 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),make_str("("),(yyvsp[(3) - (5)].str),make_str(")"),(yyvsp[(5) - (5)].str));
31313
33648
;}
31314
33649
    break;
31315
33650
 
31316
33651
  case 1226:
 
33652
 
 
33653
/* Line 1455 of yacc.c  */
31317
33654
#line 7468 "preproc.y"
31318
33655
    { 
31319
 
 yyval.str = yyvsp[0].str;
 
33656
 (yyval.str) = (yyvsp[(1) - (1)].str);
31320
33657
;}
31321
33658
    break;
31322
33659
 
31323
33660
  case 1227:
 
33661
 
 
33662
/* Line 1455 of yacc.c  */
31324
33663
#line 7472 "preproc.y"
31325
33664
    { 
31326
 
 yyval.str = yyvsp[0].str;
 
33665
 (yyval.str) = (yyvsp[(1) - (1)].str);
31327
33666
;}
31328
33667
    break;
31329
33668
 
31330
33669
  case 1228:
 
33670
 
 
33671
/* Line 1455 of yacc.c  */
31331
33672
#line 7476 "preproc.y"
31332
33673
    { 
31333
 
 yyval.str = yyvsp[0].str;
 
33674
 (yyval.str) = (yyvsp[(1) - (1)].str);
31334
33675
;}
31335
33676
    break;
31336
33677
 
31337
33678
  case 1229:
 
33679
 
 
33680
/* Line 1455 of yacc.c  */
31338
33681
#line 7480 "preproc.y"
31339
33682
    { 
31340
 
 yyval.str = yyvsp[0].str;
 
33683
 (yyval.str) = (yyvsp[(1) - (1)].str);
31341
33684
;}
31342
33685
    break;
31343
33686
 
31344
33687
  case 1230:
 
33688
 
 
33689
/* Line 1455 of yacc.c  */
31345
33690
#line 7488 "preproc.y"
31346
33691
    { 
31347
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
33692
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
31348
33693
;}
31349
33694
    break;
31350
33695
 
31351
33696
  case 1231:
 
33697
 
 
33698
/* Line 1455 of yacc.c  */
31352
33699
#line 7492 "preproc.y"
31353
33700
    { 
31354
 
 yyval.str = cat_str(3,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
33701
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
31355
33702
;}
31356
33703
    break;
31357
33704
 
31358
33705
  case 1232:
 
33706
 
 
33707
/* Line 1455 of yacc.c  */
31359
33708
#line 7500 "preproc.y"
31360
33709
    { 
31361
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
33710
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
31362
33711
;}
31363
33712
    break;
31364
33713
 
31365
33714
  case 1233:
 
33715
 
 
33716
/* Line 1455 of yacc.c  */
31366
33717
#line 7504 "preproc.y"
31367
33718
    { 
31368
 
 yyval.str=EMPTY; ;}
 
33719
 (yyval.str)=EMPTY; ;}
31369
33720
    break;
31370
33721
 
31371
33722
  case 1234:
 
33723
 
 
33724
/* Line 1455 of yacc.c  */
31372
33725
#line 7511 "preproc.y"
31373
33726
    { 
31374
 
 yyval.str = make_str("int");
 
33727
 (yyval.str) = make_str("int");
31375
33728
;}
31376
33729
    break;
31377
33730
 
31378
33731
  case 1235:
 
33732
 
 
33733
/* Line 1455 of yacc.c  */
31379
33734
#line 7515 "preproc.y"
31380
33735
    { 
31381
 
 yyval.str = make_str("integer");
 
33736
 (yyval.str) = make_str("integer");
31382
33737
;}
31383
33738
    break;
31384
33739
 
31385
33740
  case 1236:
 
33741
 
 
33742
/* Line 1455 of yacc.c  */
31386
33743
#line 7519 "preproc.y"
31387
33744
    { 
31388
 
 yyval.str = make_str("smallint");
 
33745
 (yyval.str) = make_str("smallint");
31389
33746
;}
31390
33747
    break;
31391
33748
 
31392
33749
  case 1237:
 
33750
 
 
33751
/* Line 1455 of yacc.c  */
31393
33752
#line 7523 "preproc.y"
31394
33753
    { 
31395
 
 yyval.str = make_str("bigint");
 
33754
 (yyval.str) = make_str("bigint");
31396
33755
;}
31397
33756
    break;
31398
33757
 
31399
33758
  case 1238:
 
33759
 
 
33760
/* Line 1455 of yacc.c  */
31400
33761
#line 7527 "preproc.y"
31401
33762
    { 
31402
 
 yyval.str = make_str("real");
 
33763
 (yyval.str) = make_str("real");
31403
33764
;}
31404
33765
    break;
31405
33766
 
31406
33767
  case 1239:
 
33768
 
 
33769
/* Line 1455 of yacc.c  */
31407
33770
#line 7531 "preproc.y"
31408
33771
    { 
31409
 
 yyval.str = cat_str(2,make_str("float"),yyvsp[0].str);
 
33772
 (yyval.str) = cat_str(2,make_str("float"),(yyvsp[(2) - (2)].str));
31410
33773
;}
31411
33774
    break;
31412
33775
 
31413
33776
  case 1240:
 
33777
 
 
33778
/* Line 1455 of yacc.c  */
31414
33779
#line 7535 "preproc.y"
31415
33780
    { 
31416
 
 yyval.str = make_str("double precision");
 
33781
 (yyval.str) = make_str("double precision");
31417
33782
;}
31418
33783
    break;
31419
33784
 
31420
33785
  case 1241:
 
33786
 
 
33787
/* Line 1455 of yacc.c  */
31421
33788
#line 7539 "preproc.y"
31422
33789
    { 
31423
 
 yyval.str = cat_str(2,make_str("decimal"),yyvsp[0].str);
 
33790
 (yyval.str) = cat_str(2,make_str("decimal"),(yyvsp[(2) - (2)].str));
31424
33791
;}
31425
33792
    break;
31426
33793
 
31427
33794
  case 1242:
 
33795
 
 
33796
/* Line 1455 of yacc.c  */
31428
33797
#line 7543 "preproc.y"
31429
33798
    { 
31430
 
 yyval.str = cat_str(2,make_str("dec"),yyvsp[0].str);
 
33799
 (yyval.str) = cat_str(2,make_str("dec"),(yyvsp[(2) - (2)].str));
31431
33800
;}
31432
33801
    break;
31433
33802
 
31434
33803
  case 1243:
 
33804
 
 
33805
/* Line 1455 of yacc.c  */
31435
33806
#line 7547 "preproc.y"
31436
33807
    { 
31437
 
 yyval.str = cat_str(2,make_str("numeric"),yyvsp[0].str);
 
33808
 (yyval.str) = cat_str(2,make_str("numeric"),(yyvsp[(2) - (2)].str));
31438
33809
;}
31439
33810
    break;
31440
33811
 
31441
33812
  case 1244:
 
33813
 
 
33814
/* Line 1455 of yacc.c  */
31442
33815
#line 7551 "preproc.y"
31443
33816
    { 
31444
 
 yyval.str = make_str("boolean");
 
33817
 (yyval.str) = make_str("boolean");
31445
33818
;}
31446
33819
    break;
31447
33820
 
31448
33821
  case 1245:
 
33822
 
 
33823
/* Line 1455 of yacc.c  */
31449
33824
#line 7559 "preproc.y"
31450
33825
    { 
31451
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
33826
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
31452
33827
;}
31453
33828
    break;
31454
33829
 
31455
33830
  case 1246:
 
33831
 
 
33832
/* Line 1455 of yacc.c  */
31456
33833
#line 7563 "preproc.y"
31457
33834
    { 
31458
 
 yyval.str=EMPTY; ;}
 
33835
 (yyval.str)=EMPTY; ;}
31459
33836
    break;
31460
33837
 
31461
33838
  case 1247:
 
33839
 
 
33840
/* Line 1455 of yacc.c  */
31462
33841
#line 7570 "preproc.y"
31463
33842
    { 
31464
 
 yyval.str = yyvsp[0].str;
 
33843
 (yyval.str) = (yyvsp[(1) - (1)].str);
31465
33844
;}
31466
33845
    break;
31467
33846
 
31468
33847
  case 1248:
 
33848
 
 
33849
/* Line 1455 of yacc.c  */
31469
33850
#line 7574 "preproc.y"
31470
33851
    { 
31471
 
 yyval.str = yyvsp[0].str;
 
33852
 (yyval.str) = (yyvsp[(1) - (1)].str);
31472
33853
;}
31473
33854
    break;
31474
33855
 
31475
33856
  case 1249:
 
33857
 
 
33858
/* Line 1455 of yacc.c  */
31476
33859
#line 7582 "preproc.y"
31477
33860
    { 
31478
 
 yyval.str = yyvsp[0].str;
 
33861
 (yyval.str) = (yyvsp[(1) - (1)].str);
31479
33862
;}
31480
33863
    break;
31481
33864
 
31482
33865
  case 1250:
 
33866
 
 
33867
/* Line 1455 of yacc.c  */
31483
33868
#line 7586 "preproc.y"
31484
33869
    { 
31485
 
 yyval.str = yyvsp[0].str;
 
33870
 (yyval.str) = (yyvsp[(1) - (1)].str);
31486
33871
;}
31487
33872
    break;
31488
33873
 
31489
33874
  case 1251:
 
33875
 
 
33876
/* Line 1455 of yacc.c  */
31490
33877
#line 7594 "preproc.y"
31491
33878
    { 
31492
 
 yyval.str = cat_str(5,make_str("bit"),yyvsp[-3].str,make_str("("),yyvsp[-1].str,make_str(")"));
 
33879
 (yyval.str) = cat_str(5,make_str("bit"),(yyvsp[(2) - (5)].str),make_str("("),(yyvsp[(4) - (5)].str),make_str(")"));
31493
33880
;}
31494
33881
    break;
31495
33882
 
31496
33883
  case 1252:
 
33884
 
 
33885
/* Line 1455 of yacc.c  */
31497
33886
#line 7602 "preproc.y"
31498
33887
    { 
31499
 
 yyval.str = cat_str(2,make_str("bit"),yyvsp[0].str);
 
33888
 (yyval.str) = cat_str(2,make_str("bit"),(yyvsp[(2) - (2)].str));
31500
33889
;}
31501
33890
    break;
31502
33891
 
31503
33892
  case 1253:
 
33893
 
 
33894
/* Line 1455 of yacc.c  */
31504
33895
#line 7610 "preproc.y"
31505
33896
    { 
31506
 
 yyval.str = yyvsp[0].str;
 
33897
 (yyval.str) = (yyvsp[(1) - (1)].str);
31507
33898
;}
31508
33899
    break;
31509
33900
 
31510
33901
  case 1254:
 
33902
 
 
33903
/* Line 1455 of yacc.c  */
31511
33904
#line 7614 "preproc.y"
31512
33905
    { 
31513
 
 yyval.str = yyvsp[0].str;
 
33906
 (yyval.str) = (yyvsp[(1) - (1)].str);
31514
33907
;}
31515
33908
    break;
31516
33909
 
31517
33910
  case 1255:
 
33911
 
 
33912
/* Line 1455 of yacc.c  */
31518
33913
#line 7622 "preproc.y"
31519
33914
    { 
31520
 
 yyval.str = yyvsp[0].str;
 
33915
 (yyval.str) = (yyvsp[(1) - (1)].str);
31521
33916
;}
31522
33917
    break;
31523
33918
 
31524
33919
  case 1256:
 
33920
 
 
33921
/* Line 1455 of yacc.c  */
31525
33922
#line 7626 "preproc.y"
31526
33923
    { 
31527
 
 yyval.str = yyvsp[0].str;
 
33924
 (yyval.str) = (yyvsp[(1) - (1)].str);
31528
33925
;}
31529
33926
    break;
31530
33927
 
31531
33928
  case 1257:
 
33929
 
 
33930
/* Line 1455 of yacc.c  */
31532
33931
#line 7634 "preproc.y"
31533
33932
    { 
31534
 
 yyval.str = cat_str(5,yyvsp[-4].str,make_str("("),yyvsp[-2].str,make_str(")"),yyvsp[0].str);
 
33933
 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),make_str("("),(yyvsp[(3) - (5)].str),make_str(")"),(yyvsp[(5) - (5)].str));
31535
33934
;}
31536
33935
    break;
31537
33936
 
31538
33937
  case 1258:
 
33938
 
 
33939
/* Line 1455 of yacc.c  */
31539
33940
#line 7642 "preproc.y"
31540
33941
    { 
31541
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
33942
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
31542
33943
;}
31543
33944
    break;
31544
33945
 
31545
33946
  case 1259:
 
33947
 
 
33948
/* Line 1455 of yacc.c  */
31546
33949
#line 7650 "preproc.y"
31547
33950
    { 
31548
 
 yyval.str = cat_str(2,make_str("character"),yyvsp[0].str);
 
33951
 (yyval.str) = cat_str(2,make_str("character"),(yyvsp[(2) - (2)].str));
31549
33952
;}
31550
33953
    break;
31551
33954
 
31552
33955
  case 1260:
 
33956
 
 
33957
/* Line 1455 of yacc.c  */
31553
33958
#line 7654 "preproc.y"
31554
33959
    { 
31555
 
 yyval.str = cat_str(2,make_str("char"),yyvsp[0].str);
 
33960
 (yyval.str) = cat_str(2,make_str("char"),(yyvsp[(2) - (2)].str));
31556
33961
;}
31557
33962
    break;
31558
33963
 
31559
33964
  case 1261:
 
33965
 
 
33966
/* Line 1455 of yacc.c  */
31560
33967
#line 7658 "preproc.y"
31561
33968
    { 
31562
 
 yyval.str = make_str("varchar");
 
33969
 (yyval.str) = make_str("varchar");
31563
33970
;}
31564
33971
    break;
31565
33972
 
31566
33973
  case 1262:
 
33974
 
 
33975
/* Line 1455 of yacc.c  */
31567
33976
#line 7662 "preproc.y"
31568
33977
    { 
31569
 
 yyval.str = cat_str(2,make_str("national character"),yyvsp[0].str);
 
33978
 (yyval.str) = cat_str(2,make_str("national character"),(yyvsp[(3) - (3)].str));
31570
33979
;}
31571
33980
    break;
31572
33981
 
31573
33982
  case 1263:
 
33983
 
 
33984
/* Line 1455 of yacc.c  */
31574
33985
#line 7666 "preproc.y"
31575
33986
    { 
31576
 
 yyval.str = cat_str(2,make_str("national char"),yyvsp[0].str);
 
33987
 (yyval.str) = cat_str(2,make_str("national char"),(yyvsp[(3) - (3)].str));
31577
33988
;}
31578
33989
    break;
31579
33990
 
31580
33991
  case 1264:
 
33992
 
 
33993
/* Line 1455 of yacc.c  */
31581
33994
#line 7670 "preproc.y"
31582
33995
    { 
31583
 
 yyval.str = cat_str(2,make_str("nchar"),yyvsp[0].str);
 
33996
 (yyval.str) = cat_str(2,make_str("nchar"),(yyvsp[(2) - (2)].str));
31584
33997
;}
31585
33998
    break;
31586
33999
 
31587
34000
  case 1265:
 
34001
 
 
34002
/* Line 1455 of yacc.c  */
31588
34003
#line 7678 "preproc.y"
31589
34004
    { 
31590
 
 yyval.str = make_str("varying");
 
34005
 (yyval.str) = make_str("varying");
31591
34006
;}
31592
34007
    break;
31593
34008
 
31594
34009
  case 1266:
 
34010
 
 
34011
/* Line 1455 of yacc.c  */
31595
34012
#line 7682 "preproc.y"
31596
34013
    { 
31597
 
 yyval.str=EMPTY; ;}
 
34014
 (yyval.str)=EMPTY; ;}
31598
34015
    break;
31599
34016
 
31600
34017
  case 1267:
 
34018
 
 
34019
/* Line 1455 of yacc.c  */
31601
34020
#line 7689 "preproc.y"
31602
34021
    { 
31603
 
 yyval.str = cat_str(2,make_str("character set"),yyvsp[0].str);
 
34022
 (yyval.str) = cat_str(2,make_str("character set"),(yyvsp[(3) - (3)].str));
31604
34023
;}
31605
34024
    break;
31606
34025
 
31607
34026
  case 1268:
 
34027
 
 
34028
/* Line 1455 of yacc.c  */
31608
34029
#line 7693 "preproc.y"
31609
34030
    { 
31610
 
 yyval.str=EMPTY; ;}
 
34031
 (yyval.str)=EMPTY; ;}
31611
34032
    break;
31612
34033
 
31613
34034
  case 1269:
 
34035
 
 
34036
/* Line 1455 of yacc.c  */
31614
34037
#line 7700 "preproc.y"
31615
34038
    { 
31616
 
 yyval.str = cat_str(4,make_str("timestamp ("),yyvsp[-2].str,make_str(")"),yyvsp[0].str);
 
34039
 (yyval.str) = cat_str(4,make_str("timestamp ("),(yyvsp[(3) - (5)].str),make_str(")"),(yyvsp[(5) - (5)].str));
31617
34040
;}
31618
34041
    break;
31619
34042
 
31620
34043
  case 1270:
 
34044
 
 
34045
/* Line 1455 of yacc.c  */
31621
34046
#line 7704 "preproc.y"
31622
34047
    { 
31623
 
 yyval.str = cat_str(2,make_str("timestamp"),yyvsp[0].str);
 
34048
 (yyval.str) = cat_str(2,make_str("timestamp"),(yyvsp[(2) - (2)].str));
31624
34049
;}
31625
34050
    break;
31626
34051
 
31627
34052
  case 1271:
 
34053
 
 
34054
/* Line 1455 of yacc.c  */
31628
34055
#line 7708 "preproc.y"
31629
34056
    { 
31630
 
 yyval.str = cat_str(4,make_str("time ("),yyvsp[-2].str,make_str(")"),yyvsp[0].str);
 
34057
 (yyval.str) = cat_str(4,make_str("time ("),(yyvsp[(3) - (5)].str),make_str(")"),(yyvsp[(5) - (5)].str));
31631
34058
;}
31632
34059
    break;
31633
34060
 
31634
34061
  case 1272:
 
34062
 
 
34063
/* Line 1455 of yacc.c  */
31635
34064
#line 7712 "preproc.y"
31636
34065
    { 
31637
 
 yyval.str = cat_str(2,make_str("time"),yyvsp[0].str);
 
34066
 (yyval.str) = cat_str(2,make_str("time"),(yyvsp[(2) - (2)].str));
31638
34067
;}
31639
34068
    break;
31640
34069
 
31641
34070
  case 1273:
 
34071
 
 
34072
/* Line 1455 of yacc.c  */
31642
34073
#line 7720 "preproc.y"
31643
34074
    { 
31644
 
 yyval.str = make_str("interval");
 
34075
 (yyval.str) = make_str("interval");
31645
34076
;}
31646
34077
    break;
31647
34078
 
31648
34079
  case 1274:
 
34080
 
 
34081
/* Line 1455 of yacc.c  */
31649
34082
#line 7728 "preproc.y"
31650
34083
    { 
31651
 
 yyval.str = make_str("with time zone");
 
34084
 (yyval.str) = make_str("with time zone");
31652
34085
;}
31653
34086
    break;
31654
34087
 
31655
34088
  case 1275:
 
34089
 
 
34090
/* Line 1455 of yacc.c  */
31656
34091
#line 7732 "preproc.y"
31657
34092
    { 
31658
 
 yyval.str = make_str("without time zone");
 
34093
 (yyval.str) = make_str("without time zone");
31659
34094
;}
31660
34095
    break;
31661
34096
 
31662
34097
  case 1276:
 
34098
 
 
34099
/* Line 1455 of yacc.c  */
31663
34100
#line 7736 "preproc.y"
31664
34101
    { 
31665
 
 yyval.str=EMPTY; ;}
 
34102
 (yyval.str)=EMPTY; ;}
31666
34103
    break;
31667
34104
 
31668
34105
  case 1277:
 
34106
 
 
34107
/* Line 1455 of yacc.c  */
31669
34108
#line 7743 "preproc.y"
31670
34109
    { 
31671
 
 yyval.str = make_str("year");
 
34110
 (yyval.str) = make_str("year");
31672
34111
;}
31673
34112
    break;
31674
34113
 
31675
34114
  case 1278:
 
34115
 
 
34116
/* Line 1455 of yacc.c  */
31676
34117
#line 7747 "preproc.y"
31677
34118
    { 
31678
 
 yyval.str = make_str("month");
 
34119
 (yyval.str) = make_str("month");
31679
34120
;}
31680
34121
    break;
31681
34122
 
31682
34123
  case 1279:
 
34124
 
 
34125
/* Line 1455 of yacc.c  */
31683
34126
#line 7751 "preproc.y"
31684
34127
    { 
31685
 
 yyval.str = make_str("day");
 
34128
 (yyval.str) = make_str("day");
31686
34129
;}
31687
34130
    break;
31688
34131
 
31689
34132
  case 1280:
 
34133
 
 
34134
/* Line 1455 of yacc.c  */
31690
34135
#line 7755 "preproc.y"
31691
34136
    { 
31692
 
 yyval.str = make_str("hour");
 
34137
 (yyval.str) = make_str("hour");
31693
34138
;}
31694
34139
    break;
31695
34140
 
31696
34141
  case 1281:
 
34142
 
 
34143
/* Line 1455 of yacc.c  */
31697
34144
#line 7759 "preproc.y"
31698
34145
    { 
31699
 
 yyval.str = make_str("minute");
 
34146
 (yyval.str) = make_str("minute");
31700
34147
;}
31701
34148
    break;
31702
34149
 
31703
34150
  case 1282:
 
34151
 
 
34152
/* Line 1455 of yacc.c  */
31704
34153
#line 7763 "preproc.y"
31705
34154
    { 
31706
 
 yyval.str = yyvsp[0].str;
 
34155
 (yyval.str) = (yyvsp[(1) - (1)].str);
31707
34156
;}
31708
34157
    break;
31709
34158
 
31710
34159
  case 1283:
 
34160
 
 
34161
/* Line 1455 of yacc.c  */
31711
34162
#line 7767 "preproc.y"
31712
34163
    { 
31713
 
 yyval.str = make_str("year to month");
 
34164
 (yyval.str) = make_str("year to month");
31714
34165
;}
31715
34166
    break;
31716
34167
 
31717
34168
  case 1284:
 
34169
 
 
34170
/* Line 1455 of yacc.c  */
31718
34171
#line 7771 "preproc.y"
31719
34172
    { 
31720
 
 yyval.str = make_str("day to hour");
 
34173
 (yyval.str) = make_str("day to hour");
31721
34174
;}
31722
34175
    break;
31723
34176
 
31724
34177
  case 1285:
 
34178
 
 
34179
/* Line 1455 of yacc.c  */
31725
34180
#line 7775 "preproc.y"
31726
34181
    { 
31727
 
 yyval.str = make_str("day to minute");
 
34182
 (yyval.str) = make_str("day to minute");
31728
34183
;}
31729
34184
    break;
31730
34185
 
31731
34186
  case 1286:
 
34187
 
 
34188
/* Line 1455 of yacc.c  */
31732
34189
#line 7779 "preproc.y"
31733
34190
    { 
31734
 
 yyval.str = cat_str(2,make_str("day to"),yyvsp[0].str);
 
34191
 (yyval.str) = cat_str(2,make_str("day to"),(yyvsp[(3) - (3)].str));
31735
34192
;}
31736
34193
    break;
31737
34194
 
31738
34195
  case 1287:
 
34196
 
 
34197
/* Line 1455 of yacc.c  */
31739
34198
#line 7783 "preproc.y"
31740
34199
    { 
31741
 
 yyval.str = make_str("hour to minute");
 
34200
 (yyval.str) = make_str("hour to minute");
31742
34201
;}
31743
34202
    break;
31744
34203
 
31745
34204
  case 1288:
 
34205
 
 
34206
/* Line 1455 of yacc.c  */
31746
34207
#line 7787 "preproc.y"
31747
34208
    { 
31748
 
 yyval.str = cat_str(2,make_str("hour to"),yyvsp[0].str);
 
34209
 (yyval.str) = cat_str(2,make_str("hour to"),(yyvsp[(3) - (3)].str));
31749
34210
;}
31750
34211
    break;
31751
34212
 
31752
34213
  case 1289:
 
34214
 
 
34215
/* Line 1455 of yacc.c  */
31753
34216
#line 7791 "preproc.y"
31754
34217
    { 
31755
 
 yyval.str = cat_str(2,make_str("minute to"),yyvsp[0].str);
 
34218
 (yyval.str) = cat_str(2,make_str("minute to"),(yyvsp[(3) - (3)].str));
31756
34219
;}
31757
34220
    break;
31758
34221
 
31759
34222
  case 1290:
 
34223
 
 
34224
/* Line 1455 of yacc.c  */
31760
34225
#line 7795 "preproc.y"
31761
34226
    { 
31762
 
 yyval.str=EMPTY; ;}
 
34227
 (yyval.str)=EMPTY; ;}
31763
34228
    break;
31764
34229
 
31765
34230
  case 1291:
 
34231
 
 
34232
/* Line 1455 of yacc.c  */
31766
34233
#line 7802 "preproc.y"
31767
34234
    { 
31768
 
 yyval.str = make_str("second");
 
34235
 (yyval.str) = make_str("second");
31769
34236
;}
31770
34237
    break;
31771
34238
 
31772
34239
  case 1292:
 
34240
 
 
34241
/* Line 1455 of yacc.c  */
31773
34242
#line 7806 "preproc.y"
31774
34243
    { 
31775
 
 yyval.str = cat_str(3,make_str("second ("),yyvsp[-1].str,make_str(")"));
 
34244
 (yyval.str) = cat_str(3,make_str("second ("),(yyvsp[(3) - (4)].str),make_str(")"));
31776
34245
;}
31777
34246
    break;
31778
34247
 
31779
34248
  case 1293:
 
34249
 
 
34250
/* Line 1455 of yacc.c  */
31780
34251
#line 7814 "preproc.y"
31781
34252
    { 
31782
 
 yyval.str = yyvsp[0].str;
 
34253
 (yyval.str) = (yyvsp[(1) - (1)].str);
31783
34254
;}
31784
34255
    break;
31785
34256
 
31786
34257
  case 1294:
 
34258
 
 
34259
/* Line 1455 of yacc.c  */
31787
34260
#line 7818 "preproc.y"
31788
34261
    { 
31789
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("::"),yyvsp[0].str);
 
34262
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("::"),(yyvsp[(3) - (3)].str));
31790
34263
;}
31791
34264
    break;
31792
34265
 
31793
34266
  case 1295:
 
34267
 
 
34268
/* Line 1455 of yacc.c  */
31794
34269
#line 7822 "preproc.y"
31795
34270
    { 
31796
 
 yyval.str = cat_str(3,yyvsp[-4].str,make_str("at time zone"),yyvsp[0].str);
 
34271
 (yyval.str) = cat_str(3,(yyvsp[(1) - (5)].str),make_str("at time zone"),(yyvsp[(5) - (5)].str));
31797
34272
;}
31798
34273
    break;
31799
34274
 
31800
34275
  case 1296:
 
34276
 
 
34277
/* Line 1455 of yacc.c  */
31801
34278
#line 7826 "preproc.y"
31802
34279
    { 
31803
 
 yyval.str = cat_str(2,make_str("+"),yyvsp[0].str);
 
34280
 (yyval.str) = cat_str(2,make_str("+"),(yyvsp[(2) - (2)].str));
31804
34281
;}
31805
34282
    break;
31806
34283
 
31807
34284
  case 1297:
 
34285
 
 
34286
/* Line 1455 of yacc.c  */
31808
34287
#line 7830 "preproc.y"
31809
34288
    { 
31810
 
 yyval.str = cat_str(2,make_str("-"),yyvsp[0].str);
 
34289
 (yyval.str) = cat_str(2,make_str("-"),(yyvsp[(2) - (2)].str));
31811
34290
;}
31812
34291
    break;
31813
34292
 
31814
34293
  case 1298:
 
34294
 
 
34295
/* Line 1455 of yacc.c  */
31815
34296
#line 7834 "preproc.y"
31816
34297
    { 
31817
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("+"),yyvsp[0].str);
 
34298
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("+"),(yyvsp[(3) - (3)].str));
31818
34299
;}
31819
34300
    break;
31820
34301
 
31821
34302
  case 1299:
 
34303
 
 
34304
/* Line 1455 of yacc.c  */
31822
34305
#line 7838 "preproc.y"
31823
34306
    { 
31824
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("-"),yyvsp[0].str);
 
34307
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("-"),(yyvsp[(3) - (3)].str));
31825
34308
;}
31826
34309
    break;
31827
34310
 
31828
34311
  case 1300:
 
34312
 
 
34313
/* Line 1455 of yacc.c  */
31829
34314
#line 7842 "preproc.y"
31830
34315
    { 
31831
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("*"),yyvsp[0].str);
 
34316
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("*"),(yyvsp[(3) - (3)].str));
31832
34317
;}
31833
34318
    break;
31834
34319
 
31835
34320
  case 1301:
 
34321
 
 
34322
/* Line 1455 of yacc.c  */
31836
34323
#line 7846 "preproc.y"
31837
34324
    { 
31838
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("/"),yyvsp[0].str);
 
34325
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("/"),(yyvsp[(3) - (3)].str));
31839
34326
;}
31840
34327
    break;
31841
34328
 
31842
34329
  case 1302:
 
34330
 
 
34331
/* Line 1455 of yacc.c  */
31843
34332
#line 7850 "preproc.y"
31844
34333
    { 
31845
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("%"),yyvsp[0].str);
 
34334
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("%"),(yyvsp[(3) - (3)].str));
31846
34335
;}
31847
34336
    break;
31848
34337
 
31849
34338
  case 1303:
 
34339
 
 
34340
/* Line 1455 of yacc.c  */
31850
34341
#line 7854 "preproc.y"
31851
34342
    { 
31852
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("^"),yyvsp[0].str);
 
34343
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("^"),(yyvsp[(3) - (3)].str));
31853
34344
;}
31854
34345
    break;
31855
34346
 
31856
34347
  case 1304:
 
34348
 
 
34349
/* Line 1455 of yacc.c  */
31857
34350
#line 7858 "preproc.y"
31858
34351
    { 
31859
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("<"),yyvsp[0].str);
 
34352
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("<"),(yyvsp[(3) - (3)].str));
31860
34353
;}
31861
34354
    break;
31862
34355
 
31863
34356
  case 1305:
 
34357
 
 
34358
/* Line 1455 of yacc.c  */
31864
34359
#line 7862 "preproc.y"
31865
34360
    { 
31866
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(">"),yyvsp[0].str);
 
34361
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(">"),(yyvsp[(3) - (3)].str));
31867
34362
;}
31868
34363
    break;
31869
34364
 
31870
34365
  case 1306:
 
34366
 
 
34367
/* Line 1455 of yacc.c  */
31871
34368
#line 7866 "preproc.y"
31872
34369
    { 
31873
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("="),yyvsp[0].str);
 
34370
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("="),(yyvsp[(3) - (3)].str));
31874
34371
;}
31875
34372
    break;
31876
34373
 
31877
34374
  case 1307:
 
34375
 
 
34376
/* Line 1455 of yacc.c  */
31878
34377
#line 7870 "preproc.y"
31879
34378
    { 
31880
 
 yyval.str = cat_str(3,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
34379
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
31881
34380
;}
31882
34381
    break;
31883
34382
 
31884
34383
  case 1308:
 
34384
 
 
34385
/* Line 1455 of yacc.c  */
31885
34386
#line 7874 "preproc.y"
31886
34387
    { 
31887
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
34388
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
31888
34389
;}
31889
34390
    break;
31890
34391
 
31891
34392
  case 1309:
 
34393
 
 
34394
/* Line 1455 of yacc.c  */
31892
34395
#line 7878 "preproc.y"
31893
34396
    { 
31894
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
34397
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
31895
34398
;}
31896
34399
    break;
31897
34400
 
31898
34401
  case 1310:
 
34402
 
 
34403
/* Line 1455 of yacc.c  */
31899
34404
#line 7882 "preproc.y"
31900
34405
    { 
31901
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("and"),yyvsp[0].str);
 
34406
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("and"),(yyvsp[(3) - (3)].str));
31902
34407
;}
31903
34408
    break;
31904
34409
 
31905
34410
  case 1311:
 
34411
 
 
34412
/* Line 1455 of yacc.c  */
31906
34413
#line 7886 "preproc.y"
31907
34414
    { 
31908
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("or"),yyvsp[0].str);
 
34415
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("or"),(yyvsp[(3) - (3)].str));
31909
34416
;}
31910
34417
    break;
31911
34418
 
31912
34419
  case 1312:
 
34420
 
 
34421
/* Line 1455 of yacc.c  */
31913
34422
#line 7890 "preproc.y"
31914
34423
    { 
31915
 
 yyval.str = cat_str(2,make_str("not"),yyvsp[0].str);
 
34424
 (yyval.str) = cat_str(2,make_str("not"),(yyvsp[(2) - (2)].str));
31916
34425
;}
31917
34426
    break;
31918
34427
 
31919
34428
  case 1313:
 
34429
 
 
34430
/* Line 1455 of yacc.c  */
31920
34431
#line 7894 "preproc.y"
31921
34432
    { 
31922
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("like"),yyvsp[0].str);
 
34433
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("like"),(yyvsp[(3) - (3)].str));
31923
34434
;}
31924
34435
    break;
31925
34436
 
31926
34437
  case 1314:
 
34438
 
 
34439
/* Line 1455 of yacc.c  */
31927
34440
#line 7898 "preproc.y"
31928
34441
    { 
31929
 
 yyval.str = cat_str(5,yyvsp[-4].str,make_str("like"),yyvsp[-2].str,make_str("escape"),yyvsp[0].str);
 
34442
 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),make_str("like"),(yyvsp[(3) - (5)].str),make_str("escape"),(yyvsp[(5) - (5)].str));
31930
34443
;}
31931
34444
    break;
31932
34445
 
31933
34446
  case 1315:
 
34447
 
 
34448
/* Line 1455 of yacc.c  */
31934
34449
#line 7902 "preproc.y"
31935
34450
    { 
31936
 
 yyval.str = cat_str(3,yyvsp[-3].str,make_str("not like"),yyvsp[0].str);
 
34451
 (yyval.str) = cat_str(3,(yyvsp[(1) - (4)].str),make_str("not like"),(yyvsp[(4) - (4)].str));
31937
34452
;}
31938
34453
    break;
31939
34454
 
31940
34455
  case 1316:
 
34456
 
 
34457
/* Line 1455 of yacc.c  */
31941
34458
#line 7906 "preproc.y"
31942
34459
    { 
31943
 
 yyval.str = cat_str(5,yyvsp[-5].str,make_str("not like"),yyvsp[-2].str,make_str("escape"),yyvsp[0].str);
 
34460
 (yyval.str) = cat_str(5,(yyvsp[(1) - (6)].str),make_str("not like"),(yyvsp[(4) - (6)].str),make_str("escape"),(yyvsp[(6) - (6)].str));
31944
34461
;}
31945
34462
    break;
31946
34463
 
31947
34464
  case 1317:
 
34465
 
 
34466
/* Line 1455 of yacc.c  */
31948
34467
#line 7910 "preproc.y"
31949
34468
    { 
31950
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("ilike"),yyvsp[0].str);
 
34469
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("ilike"),(yyvsp[(3) - (3)].str));
31951
34470
;}
31952
34471
    break;
31953
34472
 
31954
34473
  case 1318:
 
34474
 
 
34475
/* Line 1455 of yacc.c  */
31955
34476
#line 7914 "preproc.y"
31956
34477
    { 
31957
 
 yyval.str = cat_str(5,yyvsp[-4].str,make_str("ilike"),yyvsp[-2].str,make_str("escape"),yyvsp[0].str);
 
34478
 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),make_str("ilike"),(yyvsp[(3) - (5)].str),make_str("escape"),(yyvsp[(5) - (5)].str));
31958
34479
;}
31959
34480
    break;
31960
34481
 
31961
34482
  case 1319:
 
34483
 
 
34484
/* Line 1455 of yacc.c  */
31962
34485
#line 7918 "preproc.y"
31963
34486
    { 
31964
 
 yyval.str = cat_str(3,yyvsp[-3].str,make_str("not ilike"),yyvsp[0].str);
 
34487
 (yyval.str) = cat_str(3,(yyvsp[(1) - (4)].str),make_str("not ilike"),(yyvsp[(4) - (4)].str));
31965
34488
;}
31966
34489
    break;
31967
34490
 
31968
34491
  case 1320:
 
34492
 
 
34493
/* Line 1455 of yacc.c  */
31969
34494
#line 7922 "preproc.y"
31970
34495
    { 
31971
 
 yyval.str = cat_str(5,yyvsp[-5].str,make_str("not ilike"),yyvsp[-2].str,make_str("escape"),yyvsp[0].str);
 
34496
 (yyval.str) = cat_str(5,(yyvsp[(1) - (6)].str),make_str("not ilike"),(yyvsp[(4) - (6)].str),make_str("escape"),(yyvsp[(6) - (6)].str));
31972
34497
;}
31973
34498
    break;
31974
34499
 
31975
34500
  case 1321:
 
34501
 
 
34502
/* Line 1455 of yacc.c  */
31976
34503
#line 7926 "preproc.y"
31977
34504
    { 
31978
 
 yyval.str = cat_str(3,yyvsp[-3].str,make_str("similar to"),yyvsp[0].str);
 
34505
 (yyval.str) = cat_str(3,(yyvsp[(1) - (4)].str),make_str("similar to"),(yyvsp[(4) - (4)].str));
31979
34506
;}
31980
34507
    break;
31981
34508
 
31982
34509
  case 1322:
 
34510
 
 
34511
/* Line 1455 of yacc.c  */
31983
34512
#line 7930 "preproc.y"
31984
34513
    { 
31985
 
 yyval.str = cat_str(5,yyvsp[-5].str,make_str("similar to"),yyvsp[-2].str,make_str("escape"),yyvsp[0].str);
 
34514
 (yyval.str) = cat_str(5,(yyvsp[(1) - (6)].str),make_str("similar to"),(yyvsp[(4) - (6)].str),make_str("escape"),(yyvsp[(6) - (6)].str));
31986
34515
;}
31987
34516
    break;
31988
34517
 
31989
34518
  case 1323:
 
34519
 
 
34520
/* Line 1455 of yacc.c  */
31990
34521
#line 7934 "preproc.y"
31991
34522
    { 
31992
 
 yyval.str = cat_str(3,yyvsp[-4].str,make_str("not similar to"),yyvsp[0].str);
 
34523
 (yyval.str) = cat_str(3,(yyvsp[(1) - (5)].str),make_str("not similar to"),(yyvsp[(5) - (5)].str));
31993
34524
;}
31994
34525
    break;
31995
34526
 
31996
34527
  case 1324:
 
34528
 
 
34529
/* Line 1455 of yacc.c  */
31997
34530
#line 7938 "preproc.y"
31998
34531
    { 
31999
 
 yyval.str = cat_str(5,yyvsp[-6].str,make_str("not similar to"),yyvsp[-2].str,make_str("escape"),yyvsp[0].str);
 
34532
 (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));
32000
34533
;}
32001
34534
    break;
32002
34535
 
32003
34536
  case 1325:
 
34537
 
 
34538
/* Line 1455 of yacc.c  */
32004
34539
#line 7942 "preproc.y"
32005
34540
    { 
32006
 
 yyval.str = cat_str(2,yyvsp[-2].str,make_str("is null"));
 
34541
 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("is null"));
32007
34542
;}
32008
34543
    break;
32009
34544
 
32010
34545
  case 1326:
 
34546
 
 
34547
/* Line 1455 of yacc.c  */
32011
34548
#line 7946 "preproc.y"
32012
34549
    { 
32013
 
 yyval.str = cat_str(2,yyvsp[-1].str,make_str("isnull"));
 
34550
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),make_str("isnull"));
32014
34551
;}
32015
34552
    break;
32016
34553
 
32017
34554
  case 1327:
 
34555
 
 
34556
/* Line 1455 of yacc.c  */
32018
34557
#line 7950 "preproc.y"
32019
34558
    { 
32020
 
 yyval.str = cat_str(2,yyvsp[-3].str,make_str("is not null"));
 
34559
 (yyval.str) = cat_str(2,(yyvsp[(1) - (4)].str),make_str("is not null"));
32021
34560
;}
32022
34561
    break;
32023
34562
 
32024
34563
  case 1328:
 
34564
 
 
34565
/* Line 1455 of yacc.c  */
32025
34566
#line 7954 "preproc.y"
32026
34567
    { 
32027
 
 yyval.str = cat_str(2,yyvsp[-1].str,make_str("notnull"));
 
34568
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),make_str("notnull"));
32028
34569
;}
32029
34570
    break;
32030
34571
 
32031
34572
  case 1329:
 
34573
 
 
34574
/* Line 1455 of yacc.c  */
32032
34575
#line 7958 "preproc.y"
32033
34576
    { 
32034
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("overlaps"),yyvsp[0].str);
 
34577
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("overlaps"),(yyvsp[(3) - (3)].str));
32035
34578
;}
32036
34579
    break;
32037
34580
 
32038
34581
  case 1330:
 
34582
 
 
34583
/* Line 1455 of yacc.c  */
32039
34584
#line 7962 "preproc.y"
32040
34585
    { 
32041
 
 yyval.str = cat_str(2,yyvsp[-2].str,make_str("is true"));
 
34586
 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("is true"));
32042
34587
;}
32043
34588
    break;
32044
34589
 
32045
34590
  case 1331:
 
34591
 
 
34592
/* Line 1455 of yacc.c  */
32046
34593
#line 7966 "preproc.y"
32047
34594
    { 
32048
 
 yyval.str = cat_str(2,yyvsp[-3].str,make_str("is not true"));
 
34595
 (yyval.str) = cat_str(2,(yyvsp[(1) - (4)].str),make_str("is not true"));
32049
34596
;}
32050
34597
    break;
32051
34598
 
32052
34599
  case 1332:
 
34600
 
 
34601
/* Line 1455 of yacc.c  */
32053
34602
#line 7970 "preproc.y"
32054
34603
    { 
32055
 
 yyval.str = cat_str(2,yyvsp[-2].str,make_str("is false"));
 
34604
 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("is false"));
32056
34605
;}
32057
34606
    break;
32058
34607
 
32059
34608
  case 1333:
 
34609
 
 
34610
/* Line 1455 of yacc.c  */
32060
34611
#line 7974 "preproc.y"
32061
34612
    { 
32062
 
 yyval.str = cat_str(2,yyvsp[-3].str,make_str("is not false"));
 
34613
 (yyval.str) = cat_str(2,(yyvsp[(1) - (4)].str),make_str("is not false"));
32063
34614
;}
32064
34615
    break;
32065
34616
 
32066
34617
  case 1334:
 
34618
 
 
34619
/* Line 1455 of yacc.c  */
32067
34620
#line 7978 "preproc.y"
32068
34621
    { 
32069
 
 yyval.str = cat_str(2,yyvsp[-2].str,make_str("is unknown"));
 
34622
 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("is unknown"));
32070
34623
;}
32071
34624
    break;
32072
34625
 
32073
34626
  case 1335:
 
34627
 
 
34628
/* Line 1455 of yacc.c  */
32074
34629
#line 7982 "preproc.y"
32075
34630
    { 
32076
 
 yyval.str = cat_str(2,yyvsp[-3].str,make_str("is not unknown"));
 
34631
 (yyval.str) = cat_str(2,(yyvsp[(1) - (4)].str),make_str("is not unknown"));
32077
34632
;}
32078
34633
    break;
32079
34634
 
32080
34635
  case 1336:
 
34636
 
 
34637
/* Line 1455 of yacc.c  */
32081
34638
#line 7986 "preproc.y"
32082
34639
    { 
32083
 
 yyval.str = cat_str(3,yyvsp[-4].str,make_str("is distinct from"),yyvsp[0].str);
 
34640
 (yyval.str) = cat_str(3,(yyvsp[(1) - (5)].str),make_str("is distinct from"),(yyvsp[(5) - (5)].str));
32084
34641
;}
32085
34642
    break;
32086
34643
 
32087
34644
  case 1337:
 
34645
 
 
34646
/* Line 1455 of yacc.c  */
32088
34647
#line 7990 "preproc.y"
32089
34648
    { 
32090
 
 yyval.str = cat_str(3,yyvsp[-5].str,make_str("is not distinct from"),yyvsp[0].str);
 
34649
 (yyval.str) = cat_str(3,(yyvsp[(1) - (6)].str),make_str("is not distinct from"),(yyvsp[(6) - (6)].str));
32091
34650
;}
32092
34651
    break;
32093
34652
 
32094
34653
  case 1338:
 
34654
 
 
34655
/* Line 1455 of yacc.c  */
32095
34656
#line 7994 "preproc.y"
32096
34657
    { 
32097
 
 yyval.str = cat_str(4,yyvsp[-5].str,make_str("is of ("),yyvsp[-1].str,make_str(")"));
 
34658
 (yyval.str) = cat_str(4,(yyvsp[(1) - (6)].str),make_str("is of ("),(yyvsp[(5) - (6)].str),make_str(")"));
32098
34659
;}
32099
34660
    break;
32100
34661
 
32101
34662
  case 1339:
 
34663
 
 
34664
/* Line 1455 of yacc.c  */
32102
34665
#line 7998 "preproc.y"
32103
34666
    { 
32104
 
 yyval.str = cat_str(4,yyvsp[-6].str,make_str("is not of ("),yyvsp[-1].str,make_str(")"));
 
34667
 (yyval.str) = cat_str(4,(yyvsp[(1) - (7)].str),make_str("is not of ("),(yyvsp[(6) - (7)].str),make_str(")"));
32105
34668
;}
32106
34669
    break;
32107
34670
 
32108
34671
  case 1340:
 
34672
 
 
34673
/* Line 1455 of yacc.c  */
32109
34674
#line 8002 "preproc.y"
32110
34675
    { 
32111
 
 yyval.str = cat_str(6,yyvsp[-5].str,make_str("between"),yyvsp[-3].str,yyvsp[-2].str,make_str("and"),yyvsp[0].str);
 
34676
 (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));
32112
34677
;}
32113
34678
    break;
32114
34679
 
32115
34680
  case 1341:
 
34681
 
 
34682
/* Line 1455 of yacc.c  */
32116
34683
#line 8006 "preproc.y"
32117
34684
    { 
32118
 
 yyval.str = cat_str(6,yyvsp[-6].str,make_str("not between"),yyvsp[-3].str,yyvsp[-2].str,make_str("and"),yyvsp[0].str);
 
34685
 (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));
32119
34686
;}
32120
34687
    break;
32121
34688
 
32122
34689
  case 1342:
 
34690
 
 
34691
/* Line 1455 of yacc.c  */
32123
34692
#line 8010 "preproc.y"
32124
34693
    { 
32125
 
 yyval.str = cat_str(5,yyvsp[-5].str,make_str("between symmetric"),yyvsp[-2].str,make_str("and"),yyvsp[0].str);
 
34694
 (yyval.str) = cat_str(5,(yyvsp[(1) - (6)].str),make_str("between symmetric"),(yyvsp[(4) - (6)].str),make_str("and"),(yyvsp[(6) - (6)].str));
32126
34695
;}
32127
34696
    break;
32128
34697
 
32129
34698
  case 1343:
 
34699
 
 
34700
/* Line 1455 of yacc.c  */
32130
34701
#line 8014 "preproc.y"
32131
34702
    { 
32132
 
 yyval.str = cat_str(5,yyvsp[-6].str,make_str("not between symmetric"),yyvsp[-2].str,make_str("and"),yyvsp[0].str);
 
34703
 (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));
32133
34704
;}
32134
34705
    break;
32135
34706
 
32136
34707
  case 1344:
 
34708
 
 
34709
/* Line 1455 of yacc.c  */
32137
34710
#line 8018 "preproc.y"
32138
34711
    { 
32139
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("in"),yyvsp[0].str);
 
34712
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("in"),(yyvsp[(3) - (3)].str));
32140
34713
;}
32141
34714
    break;
32142
34715
 
32143
34716
  case 1345:
 
34717
 
 
34718
/* Line 1455 of yacc.c  */
32144
34719
#line 8022 "preproc.y"
32145
34720
    { 
32146
 
 yyval.str = cat_str(3,yyvsp[-3].str,make_str("not in"),yyvsp[0].str);
 
34721
 (yyval.str) = cat_str(3,(yyvsp[(1) - (4)].str),make_str("not in"),(yyvsp[(4) - (4)].str));
32147
34722
;}
32148
34723
    break;
32149
34724
 
32150
34725
  case 1346:
 
34726
 
 
34727
/* Line 1455 of yacc.c  */
32151
34728
#line 8026 "preproc.y"
32152
34729
    { 
32153
 
 yyval.str = cat_str(4,yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
34730
 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
32154
34731
;}
32155
34732
    break;
32156
34733
 
32157
34734
  case 1347:
 
34735
 
 
34736
/* Line 1455 of yacc.c  */
32158
34737
#line 8030 "preproc.y"
32159
34738
    { 
32160
 
 yyval.str = cat_str(6,yyvsp[-5].str,yyvsp[-4].str,yyvsp[-3].str,make_str("("),yyvsp[-1].str,make_str(")"));
 
34739
 (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(")"));
32161
34740
;}
32162
34741
    break;
32163
34742
 
32164
34743
  case 1348:
 
34744
 
 
34745
/* Line 1455 of yacc.c  */
32165
34746
#line 8034 "preproc.y"
32166
34747
    { 
32167
34748
mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
32168
 
 yyval.str = cat_str(2,make_str("unique"),yyvsp[0].str);
 
34749
 (yyval.str) = cat_str(2,make_str("unique"),(yyvsp[(2) - (2)].str));
32169
34750
;}
32170
34751
    break;
32171
34752
 
32172
34753
  case 1349:
 
34754
 
 
34755
/* Line 1455 of yacc.c  */
32173
34756
#line 8039 "preproc.y"
32174
34757
    { 
32175
 
 yyval.str = cat_str(2,yyvsp[-2].str,make_str("is document"));
 
34758
 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("is document"));
32176
34759
;}
32177
34760
    break;
32178
34761
 
32179
34762
  case 1350:
 
34763
 
 
34764
/* Line 1455 of yacc.c  */
32180
34765
#line 8043 "preproc.y"
32181
34766
    { 
32182
 
 yyval.str = cat_str(2,yyvsp[-3].str,make_str("is not document"));
 
34767
 (yyval.str) = cat_str(2,(yyvsp[(1) - (4)].str),make_str("is not document"));
32183
34768
;}
32184
34769
    break;
32185
34770
 
32186
34771
  case 1351:
 
34772
 
 
34773
/* Line 1455 of yacc.c  */
32187
34774
#line 8051 "preproc.y"
32188
34775
    { 
32189
 
 yyval.str = yyvsp[0].str;
 
34776
 (yyval.str) = (yyvsp[(1) - (1)].str);
32190
34777
;}
32191
34778
    break;
32192
34779
 
32193
34780
  case 1352:
 
34781
 
 
34782
/* Line 1455 of yacc.c  */
32194
34783
#line 8055 "preproc.y"
32195
34784
    { 
32196
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("::"),yyvsp[0].str);
 
34785
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("::"),(yyvsp[(3) - (3)].str));
32197
34786
;}
32198
34787
    break;
32199
34788
 
32200
34789
  case 1353:
 
34790
 
 
34791
/* Line 1455 of yacc.c  */
32201
34792
#line 8059 "preproc.y"
32202
34793
    { 
32203
 
 yyval.str = cat_str(2,make_str("+"),yyvsp[0].str);
 
34794
 (yyval.str) = cat_str(2,make_str("+"),(yyvsp[(2) - (2)].str));
32204
34795
;}
32205
34796
    break;
32206
34797
 
32207
34798
  case 1354:
 
34799
 
 
34800
/* Line 1455 of yacc.c  */
32208
34801
#line 8063 "preproc.y"
32209
34802
    { 
32210
 
 yyval.str = cat_str(2,make_str("-"),yyvsp[0].str);
 
34803
 (yyval.str) = cat_str(2,make_str("-"),(yyvsp[(2) - (2)].str));
32211
34804
;}
32212
34805
    break;
32213
34806
 
32214
34807
  case 1355:
 
34808
 
 
34809
/* Line 1455 of yacc.c  */
32215
34810
#line 8067 "preproc.y"
32216
34811
    { 
32217
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("+"),yyvsp[0].str);
 
34812
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("+"),(yyvsp[(3) - (3)].str));
32218
34813
;}
32219
34814
    break;
32220
34815
 
32221
34816
  case 1356:
 
34817
 
 
34818
/* Line 1455 of yacc.c  */
32222
34819
#line 8071 "preproc.y"
32223
34820
    { 
32224
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("-"),yyvsp[0].str);
 
34821
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("-"),(yyvsp[(3) - (3)].str));
32225
34822
;}
32226
34823
    break;
32227
34824
 
32228
34825
  case 1357:
 
34826
 
 
34827
/* Line 1455 of yacc.c  */
32229
34828
#line 8075 "preproc.y"
32230
34829
    { 
32231
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("*"),yyvsp[0].str);
 
34830
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("*"),(yyvsp[(3) - (3)].str));
32232
34831
;}
32233
34832
    break;
32234
34833
 
32235
34834
  case 1358:
 
34835
 
 
34836
/* Line 1455 of yacc.c  */
32236
34837
#line 8079 "preproc.y"
32237
34838
    { 
32238
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("/"),yyvsp[0].str);
 
34839
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("/"),(yyvsp[(3) - (3)].str));
32239
34840
;}
32240
34841
    break;
32241
34842
 
32242
34843
  case 1359:
 
34844
 
 
34845
/* Line 1455 of yacc.c  */
32243
34846
#line 8083 "preproc.y"
32244
34847
    { 
32245
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("%"),yyvsp[0].str);
 
34848
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("%"),(yyvsp[(3) - (3)].str));
32246
34849
;}
32247
34850
    break;
32248
34851
 
32249
34852
  case 1360:
 
34853
 
 
34854
/* Line 1455 of yacc.c  */
32250
34855
#line 8087 "preproc.y"
32251
34856
    { 
32252
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("^"),yyvsp[0].str);
 
34857
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("^"),(yyvsp[(3) - (3)].str));
32253
34858
;}
32254
34859
    break;
32255
34860
 
32256
34861
  case 1361:
 
34862
 
 
34863
/* Line 1455 of yacc.c  */
32257
34864
#line 8091 "preproc.y"
32258
34865
    { 
32259
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("<"),yyvsp[0].str);
 
34866
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("<"),(yyvsp[(3) - (3)].str));
32260
34867
;}
32261
34868
    break;
32262
34869
 
32263
34870
  case 1362:
 
34871
 
 
34872
/* Line 1455 of yacc.c  */
32264
34873
#line 8095 "preproc.y"
32265
34874
    { 
32266
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(">"),yyvsp[0].str);
 
34875
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(">"),(yyvsp[(3) - (3)].str));
32267
34876
;}
32268
34877
    break;
32269
34878
 
32270
34879
  case 1363:
 
34880
 
 
34881
/* Line 1455 of yacc.c  */
32271
34882
#line 8099 "preproc.y"
32272
34883
    { 
32273
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("="),yyvsp[0].str);
 
34884
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("="),(yyvsp[(3) - (3)].str));
32274
34885
;}
32275
34886
    break;
32276
34887
 
32277
34888
  case 1364:
 
34889
 
 
34890
/* Line 1455 of yacc.c  */
32278
34891
#line 8103 "preproc.y"
32279
34892
    { 
32280
 
 yyval.str = cat_str(3,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
34893
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
32281
34894
;}
32282
34895
    break;
32283
34896
 
32284
34897
  case 1365:
 
34898
 
 
34899
/* Line 1455 of yacc.c  */
32285
34900
#line 8107 "preproc.y"
32286
34901
    { 
32287
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
34902
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
32288
34903
;}
32289
34904
    break;
32290
34905
 
32291
34906
  case 1366:
 
34907
 
 
34908
/* Line 1455 of yacc.c  */
32292
34909
#line 8111 "preproc.y"
32293
34910
    { 
32294
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
34911
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
32295
34912
;}
32296
34913
    break;
32297
34914
 
32298
34915
  case 1367:
 
34916
 
 
34917
/* Line 1455 of yacc.c  */
32299
34918
#line 8115 "preproc.y"
32300
34919
    { 
32301
 
 yyval.str = cat_str(3,yyvsp[-4].str,make_str("is distinct from"),yyvsp[0].str);
 
34920
 (yyval.str) = cat_str(3,(yyvsp[(1) - (5)].str),make_str("is distinct from"),(yyvsp[(5) - (5)].str));
32302
34921
;}
32303
34922
    break;
32304
34923
 
32305
34924
  case 1368:
 
34925
 
 
34926
/* Line 1455 of yacc.c  */
32306
34927
#line 8119 "preproc.y"
32307
34928
    { 
32308
 
 yyval.str = cat_str(3,yyvsp[-5].str,make_str("is not distinct from"),yyvsp[0].str);
 
34929
 (yyval.str) = cat_str(3,(yyvsp[(1) - (6)].str),make_str("is not distinct from"),(yyvsp[(6) - (6)].str));
32309
34930
;}
32310
34931
    break;
32311
34932
 
32312
34933
  case 1369:
 
34934
 
 
34935
/* Line 1455 of yacc.c  */
32313
34936
#line 8123 "preproc.y"
32314
34937
    { 
32315
 
 yyval.str = cat_str(4,yyvsp[-5].str,make_str("is of ("),yyvsp[-1].str,make_str(")"));
 
34938
 (yyval.str) = cat_str(4,(yyvsp[(1) - (6)].str),make_str("is of ("),(yyvsp[(5) - (6)].str),make_str(")"));
32316
34939
;}
32317
34940
    break;
32318
34941
 
32319
34942
  case 1370:
 
34943
 
 
34944
/* Line 1455 of yacc.c  */
32320
34945
#line 8127 "preproc.y"
32321
34946
    { 
32322
 
 yyval.str = cat_str(4,yyvsp[-6].str,make_str("is not of ("),yyvsp[-1].str,make_str(")"));
 
34947
 (yyval.str) = cat_str(4,(yyvsp[(1) - (7)].str),make_str("is not of ("),(yyvsp[(6) - (7)].str),make_str(")"));
32323
34948
;}
32324
34949
    break;
32325
34950
 
32326
34951
  case 1371:
 
34952
 
 
34953
/* Line 1455 of yacc.c  */
32327
34954
#line 8131 "preproc.y"
32328
34955
    { 
32329
 
 yyval.str = cat_str(2,yyvsp[-2].str,make_str("is document"));
 
34956
 (yyval.str) = cat_str(2,(yyvsp[(1) - (3)].str),make_str("is document"));
32330
34957
;}
32331
34958
    break;
32332
34959
 
32333
34960
  case 1372:
 
34961
 
 
34962
/* Line 1455 of yacc.c  */
32334
34963
#line 8135 "preproc.y"
32335
34964
    { 
32336
 
 yyval.str = cat_str(2,yyvsp[-3].str,make_str("is not document"));
 
34965
 (yyval.str) = cat_str(2,(yyvsp[(1) - (4)].str),make_str("is not document"));
32337
34966
;}
32338
34967
    break;
32339
34968
 
32340
34969
  case 1373:
 
34970
 
 
34971
/* Line 1455 of yacc.c  */
32341
34972
#line 8143 "preproc.y"
32342
34973
    { 
32343
 
 yyval.str = yyvsp[0].str;
 
34974
 (yyval.str) = (yyvsp[(1) - (1)].str);
32344
34975
;}
32345
34976
    break;
32346
34977
 
32347
34978
  case 1374:
 
34979
 
 
34980
/* Line 1455 of yacc.c  */
32348
34981
#line 8147 "preproc.y"
32349
34982
    { 
32350
 
 yyval.str = yyvsp[0].str;
 
34983
 (yyval.str) = (yyvsp[(1) - (1)].str);
32351
34984
;}
32352
34985
    break;
32353
34986
 
32354
34987
  case 1375:
 
34988
 
 
34989
/* Line 1455 of yacc.c  */
32355
34990
#line 8151 "preproc.y"
32356
34991
    { 
32357
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
34992
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
32358
34993
;}
32359
34994
    break;
32360
34995
 
32361
34996
  case 1376:
 
34997
 
 
34998
/* Line 1455 of yacc.c  */
32362
34999
#line 8155 "preproc.y"
32363
35000
    { 
32364
 
 yyval.str = cat_str(4,make_str("("),yyvsp[-2].str,make_str(")"),yyvsp[0].str);
 
35001
 (yyval.str) = cat_str(4,make_str("("),(yyvsp[(2) - (4)].str),make_str(")"),(yyvsp[(4) - (4)].str));
32365
35002
;}
32366
35003
    break;
32367
35004
 
32368
35005
  case 1377:
 
35006
 
 
35007
/* Line 1455 of yacc.c  */
32369
35008
#line 8159 "preproc.y"
32370
35009
    { 
32371
 
 yyval.str = yyvsp[0].str;
 
35010
 (yyval.str) = (yyvsp[(1) - (1)].str);
32372
35011
;}
32373
35012
    break;
32374
35013
 
32375
35014
  case 1378:
 
35015
 
 
35016
/* Line 1455 of yacc.c  */
32376
35017
#line 8163 "preproc.y"
32377
35018
    { 
32378
 
 yyval.str = yyvsp[0].str;
 
35019
 (yyval.str) = (yyvsp[(1) - (1)].str);
32379
35020
;}
32380
35021
    break;
32381
35022
 
32382
35023
  case 1379:
 
35024
 
 
35025
/* Line 1455 of yacc.c  */
32383
35026
#line 8167 "preproc.y"
32384
35027
    { 
32385
 
 yyval.str = yyvsp[0].str;
 
35028
 (yyval.str) = (yyvsp[(1) - (1)].str);
32386
35029
;}
32387
35030
    break;
32388
35031
 
32389
35032
  case 1380:
 
35033
 
 
35034
/* Line 1455 of yacc.c  */
32390
35035
#line 8171 "preproc.y"
32391
35036
    { 
32392
 
 yyval.str = cat_str(2,make_str("exists"),yyvsp[0].str);
 
35037
 (yyval.str) = cat_str(2,make_str("exists"),(yyvsp[(2) - (2)].str));
32393
35038
;}
32394
35039
    break;
32395
35040
 
32396
35041
  case 1381:
 
35042
 
 
35043
/* Line 1455 of yacc.c  */
32397
35044
#line 8175 "preproc.y"
32398
35045
    { 
32399
 
 yyval.str = cat_str(2,make_str("array"),yyvsp[0].str);
 
35046
 (yyval.str) = cat_str(2,make_str("array"),(yyvsp[(2) - (2)].str));
32400
35047
;}
32401
35048
    break;
32402
35049
 
32403
35050
  case 1382:
 
35051
 
 
35052
/* Line 1455 of yacc.c  */
32404
35053
#line 8179 "preproc.y"
32405
35054
    { 
32406
 
 yyval.str = cat_str(2,make_str("array"),yyvsp[0].str);
 
35055
 (yyval.str) = cat_str(2,make_str("array"),(yyvsp[(2) - (2)].str));
32407
35056
;}
32408
35057
    break;
32409
35058
 
32410
35059
  case 1383:
 
35060
 
 
35061
/* Line 1455 of yacc.c  */
32411
35062
#line 8183 "preproc.y"
32412
35063
    { 
32413
 
 yyval.str = yyvsp[0].str;
 
35064
 (yyval.str) = (yyvsp[(1) - (1)].str);
32414
35065
;}
32415
35066
    break;
32416
35067
 
32417
35068
  case 1384:
 
35069
 
 
35070
/* Line 1455 of yacc.c  */
32418
35071
#line 8191 "preproc.y"
32419
35072
    { 
32420
 
 yyval.str = cat_str(3,yyvsp[-3].str,make_str("( )"),yyvsp[0].str);
 
35073
 (yyval.str) = cat_str(3,(yyvsp[(1) - (4)].str),make_str("( )"),(yyvsp[(4) - (4)].str));
32421
35074
;}
32422
35075
    break;
32423
35076
 
32424
35077
  case 1385:
 
35078
 
 
35079
/* Line 1455 of yacc.c  */
32425
35080
#line 8195 "preproc.y"
32426
35081
    { 
32427
 
 yyval.str = cat_str(5,yyvsp[-4].str,make_str("("),yyvsp[-2].str,make_str(")"),yyvsp[0].str);
 
35082
 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),make_str("("),(yyvsp[(3) - (5)].str),make_str(")"),(yyvsp[(5) - (5)].str));
32428
35083
;}
32429
35084
    break;
32430
35085
 
32431
35086
  case 1386:
 
35087
 
 
35088
/* Line 1455 of yacc.c  */
32432
35089
#line 8199 "preproc.y"
32433
35090
    { 
32434
 
 yyval.str = cat_str(5,yyvsp[-5].str,make_str("( variadic"),yyvsp[-2].str,make_str(")"),yyvsp[0].str);
 
35091
 (yyval.str) = cat_str(5,(yyvsp[(1) - (6)].str),make_str("( variadic"),(yyvsp[(4) - (6)].str),make_str(")"),(yyvsp[(6) - (6)].str));
32435
35092
;}
32436
35093
    break;
32437
35094
 
32438
35095
  case 1387:
 
35096
 
 
35097
/* Line 1455 of yacc.c  */
32439
35098
#line 8203 "preproc.y"
32440
35099
    { 
32441
 
 yyval.str = cat_str(7,yyvsp[-7].str,make_str("("),yyvsp[-5].str,make_str(", variadic"),yyvsp[-2].str,make_str(")"),yyvsp[0].str);
 
35100
 (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));
32442
35101
;}
32443
35102
    break;
32444
35103
 
32445
35104
  case 1388:
 
35105
 
 
35106
/* Line 1455 of yacc.c  */
32446
35107
#line 8207 "preproc.y"
32447
35108
    { 
32448
 
 yyval.str = cat_str(5,yyvsp[-5].str,make_str("( all"),yyvsp[-2].str,make_str(")"),yyvsp[0].str);
 
35109
 (yyval.str) = cat_str(5,(yyvsp[(1) - (6)].str),make_str("( all"),(yyvsp[(4) - (6)].str),make_str(")"),(yyvsp[(6) - (6)].str));
32449
35110
;}
32450
35111
    break;
32451
35112
 
32452
35113
  case 1389:
 
35114
 
 
35115
/* Line 1455 of yacc.c  */
32453
35116
#line 8211 "preproc.y"
32454
35117
    { 
32455
 
 yyval.str = cat_str(5,yyvsp[-5].str,make_str("( distinct"),yyvsp[-2].str,make_str(")"),yyvsp[0].str);
 
35118
 (yyval.str) = cat_str(5,(yyvsp[(1) - (6)].str),make_str("( distinct"),(yyvsp[(4) - (6)].str),make_str(")"),(yyvsp[(6) - (6)].str));
32456
35119
;}
32457
35120
    break;
32458
35121
 
32459
35122
  case 1390:
 
35123
 
 
35124
/* Line 1455 of yacc.c  */
32460
35125
#line 8215 "preproc.y"
32461
35126
    { 
32462
 
 yyval.str = cat_str(3,yyvsp[-4].str,make_str("( * )"),yyvsp[0].str);
 
35127
 (yyval.str) = cat_str(3,(yyvsp[(1) - (5)].str),make_str("( * )"),(yyvsp[(5) - (5)].str));
32463
35128
;}
32464
35129
    break;
32465
35130
 
32466
35131
  case 1391:
 
35132
 
 
35133
/* Line 1455 of yacc.c  */
32467
35134
#line 8219 "preproc.y"
32468
35135
    { 
32469
 
 yyval.str = make_str("current_date");
 
35136
 (yyval.str) = make_str("current_date");
32470
35137
;}
32471
35138
    break;
32472
35139
 
32473
35140
  case 1392:
 
35141
 
 
35142
/* Line 1455 of yacc.c  */
32474
35143
#line 8223 "preproc.y"
32475
35144
    { 
32476
 
 yyval.str = make_str("current_time");
 
35145
 (yyval.str) = make_str("current_time");
32477
35146
;}
32478
35147
    break;
32479
35148
 
32480
35149
  case 1393:
 
35150
 
 
35151
/* Line 1455 of yacc.c  */
32481
35152
#line 8227 "preproc.y"
32482
35153
    { 
32483
 
 yyval.str = cat_str(3,make_str("current_time ("),yyvsp[-1].str,make_str(")"));
 
35154
 (yyval.str) = cat_str(3,make_str("current_time ("),(yyvsp[(3) - (4)].str),make_str(")"));
32484
35155
;}
32485
35156
    break;
32486
35157
 
32487
35158
  case 1394:
 
35159
 
 
35160
/* Line 1455 of yacc.c  */
32488
35161
#line 8231 "preproc.y"
32489
35162
    { 
32490
 
 yyval.str = make_str("current_timestamp");
 
35163
 (yyval.str) = make_str("current_timestamp");
32491
35164
;}
32492
35165
    break;
32493
35166
 
32494
35167
  case 1395:
 
35168
 
 
35169
/* Line 1455 of yacc.c  */
32495
35170
#line 8235 "preproc.y"
32496
35171
    { 
32497
 
 yyval.str = cat_str(3,make_str("current_timestamp ("),yyvsp[-1].str,make_str(")"));
 
35172
 (yyval.str) = cat_str(3,make_str("current_timestamp ("),(yyvsp[(3) - (4)].str),make_str(")"));
32498
35173
;}
32499
35174
    break;
32500
35175
 
32501
35176
  case 1396:
 
35177
 
 
35178
/* Line 1455 of yacc.c  */
32502
35179
#line 8239 "preproc.y"
32503
35180
    { 
32504
 
 yyval.str = make_str("localtime");
 
35181
 (yyval.str) = make_str("localtime");
32505
35182
;}
32506
35183
    break;
32507
35184
 
32508
35185
  case 1397:
 
35186
 
 
35187
/* Line 1455 of yacc.c  */
32509
35188
#line 8243 "preproc.y"
32510
35189
    { 
32511
 
 yyval.str = cat_str(3,make_str("localtime ("),yyvsp[-1].str,make_str(")"));
 
35190
 (yyval.str) = cat_str(3,make_str("localtime ("),(yyvsp[(3) - (4)].str),make_str(")"));
32512
35191
;}
32513
35192
    break;
32514
35193
 
32515
35194
  case 1398:
 
35195
 
 
35196
/* Line 1455 of yacc.c  */
32516
35197
#line 8247 "preproc.y"
32517
35198
    { 
32518
 
 yyval.str = make_str("localtimestamp");
 
35199
 (yyval.str) = make_str("localtimestamp");
32519
35200
;}
32520
35201
    break;
32521
35202
 
32522
35203
  case 1399:
 
35204
 
 
35205
/* Line 1455 of yacc.c  */
32523
35206
#line 8251 "preproc.y"
32524
35207
    { 
32525
 
 yyval.str = cat_str(3,make_str("localtimestamp ("),yyvsp[-1].str,make_str(")"));
 
35208
 (yyval.str) = cat_str(3,make_str("localtimestamp ("),(yyvsp[(3) - (4)].str),make_str(")"));
32526
35209
;}
32527
35210
    break;
32528
35211
 
32529
35212
  case 1400:
 
35213
 
 
35214
/* Line 1455 of yacc.c  */
32530
35215
#line 8255 "preproc.y"
32531
35216
    { 
32532
 
 yyval.str = make_str("current_role");
 
35217
 (yyval.str) = make_str("current_role");
32533
35218
;}
32534
35219
    break;
32535
35220
 
32536
35221
  case 1401:
 
35222
 
 
35223
/* Line 1455 of yacc.c  */
32537
35224
#line 8259 "preproc.y"
32538
35225
    { 
32539
 
 yyval.str = make_str("current_user");
 
35226
 (yyval.str) = make_str("current_user");
32540
35227
;}
32541
35228
    break;
32542
35229
 
32543
35230
  case 1402:
 
35231
 
 
35232
/* Line 1455 of yacc.c  */
32544
35233
#line 8263 "preproc.y"
32545
35234
    { 
32546
 
 yyval.str = make_str("session_user");
 
35235
 (yyval.str) = make_str("session_user");
32547
35236
;}
32548
35237
    break;
32549
35238
 
32550
35239
  case 1403:
 
35240
 
 
35241
/* Line 1455 of yacc.c  */
32551
35242
#line 8267 "preproc.y"
32552
35243
    { 
32553
 
 yyval.str = make_str("user");
 
35244
 (yyval.str) = make_str("user");
32554
35245
;}
32555
35246
    break;
32556
35247
 
32557
35248
  case 1404:
 
35249
 
 
35250
/* Line 1455 of yacc.c  */
32558
35251
#line 8271 "preproc.y"
32559
35252
    { 
32560
 
 yyval.str = make_str("current_catalog");
 
35253
 (yyval.str) = make_str("current_catalog");
32561
35254
;}
32562
35255
    break;
32563
35256
 
32564
35257
  case 1405:
 
35258
 
 
35259
/* Line 1455 of yacc.c  */
32565
35260
#line 8275 "preproc.y"
32566
35261
    { 
32567
 
 yyval.str = make_str("current_schema");
 
35262
 (yyval.str) = make_str("current_schema");
32568
35263
;}
32569
35264
    break;
32570
35265
 
32571
35266
  case 1406:
 
35267
 
 
35268
/* Line 1455 of yacc.c  */
32572
35269
#line 8279 "preproc.y"
32573
35270
    { 
32574
 
 yyval.str = cat_str(5,make_str("cast ("),yyvsp[-3].str,make_str("as"),yyvsp[-1].str,make_str(")"));
 
35271
 (yyval.str) = cat_str(5,make_str("cast ("),(yyvsp[(3) - (6)].str),make_str("as"),(yyvsp[(5) - (6)].str),make_str(")"));
32575
35272
;}
32576
35273
    break;
32577
35274
 
32578
35275
  case 1407:
 
35276
 
 
35277
/* Line 1455 of yacc.c  */
32579
35278
#line 8283 "preproc.y"
32580
35279
    { 
32581
 
 yyval.str = cat_str(3,make_str("extract ("),yyvsp[-1].str,make_str(")"));
 
35280
 (yyval.str) = cat_str(3,make_str("extract ("),(yyvsp[(3) - (4)].str),make_str(")"));
32582
35281
;}
32583
35282
    break;
32584
35283
 
32585
35284
  case 1408:
 
35285
 
 
35286
/* Line 1455 of yacc.c  */
32586
35287
#line 8287 "preproc.y"
32587
35288
    { 
32588
 
 yyval.str = cat_str(3,make_str("overlay ("),yyvsp[-1].str,make_str(")"));
 
35289
 (yyval.str) = cat_str(3,make_str("overlay ("),(yyvsp[(3) - (4)].str),make_str(")"));
32589
35290
;}
32590
35291
    break;
32591
35292
 
32592
35293
  case 1409:
 
35294
 
 
35295
/* Line 1455 of yacc.c  */
32593
35296
#line 8291 "preproc.y"
32594
35297
    { 
32595
 
 yyval.str = cat_str(3,make_str("position ("),yyvsp[-1].str,make_str(")"));
 
35298
 (yyval.str) = cat_str(3,make_str("position ("),(yyvsp[(3) - (4)].str),make_str(")"));
32596
35299
;}
32597
35300
    break;
32598
35301
 
32599
35302
  case 1410:
 
35303
 
 
35304
/* Line 1455 of yacc.c  */
32600
35305
#line 8295 "preproc.y"
32601
35306
    { 
32602
 
 yyval.str = cat_str(3,make_str("substring ("),yyvsp[-1].str,make_str(")"));
 
35307
 (yyval.str) = cat_str(3,make_str("substring ("),(yyvsp[(3) - (4)].str),make_str(")"));
32603
35308
;}
32604
35309
    break;
32605
35310
 
32606
35311
  case 1411:
 
35312
 
 
35313
/* Line 1455 of yacc.c  */
32607
35314
#line 8299 "preproc.y"
32608
35315
    { 
32609
 
 yyval.str = cat_str(5,make_str("treat ("),yyvsp[-3].str,make_str("as"),yyvsp[-1].str,make_str(")"));
 
35316
 (yyval.str) = cat_str(5,make_str("treat ("),(yyvsp[(3) - (6)].str),make_str("as"),(yyvsp[(5) - (6)].str),make_str(")"));
32610
35317
;}
32611
35318
    break;
32612
35319
 
32613
35320
  case 1412:
 
35321
 
 
35322
/* Line 1455 of yacc.c  */
32614
35323
#line 8303 "preproc.y"
32615
35324
    { 
32616
 
 yyval.str = cat_str(3,make_str("trim ( both"),yyvsp[-1].str,make_str(")"));
 
35325
 (yyval.str) = cat_str(3,make_str("trim ( both"),(yyvsp[(4) - (5)].str),make_str(")"));
32617
35326
;}
32618
35327
    break;
32619
35328
 
32620
35329
  case 1413:
 
35330
 
 
35331
/* Line 1455 of yacc.c  */
32621
35332
#line 8307 "preproc.y"
32622
35333
    { 
32623
 
 yyval.str = cat_str(3,make_str("trim ( leading"),yyvsp[-1].str,make_str(")"));
 
35334
 (yyval.str) = cat_str(3,make_str("trim ( leading"),(yyvsp[(4) - (5)].str),make_str(")"));
32624
35335
;}
32625
35336
    break;
32626
35337
 
32627
35338
  case 1414:
 
35339
 
 
35340
/* Line 1455 of yacc.c  */
32628
35341
#line 8311 "preproc.y"
32629
35342
    { 
32630
 
 yyval.str = cat_str(3,make_str("trim ( trailing"),yyvsp[-1].str,make_str(")"));
 
35343
 (yyval.str) = cat_str(3,make_str("trim ( trailing"),(yyvsp[(4) - (5)].str),make_str(")"));
32631
35344
;}
32632
35345
    break;
32633
35346
 
32634
35347
  case 1415:
 
35348
 
 
35349
/* Line 1455 of yacc.c  */
32635
35350
#line 8315 "preproc.y"
32636
35351
    { 
32637
 
 yyval.str = cat_str(3,make_str("trim ("),yyvsp[-1].str,make_str(")"));
 
35352
 (yyval.str) = cat_str(3,make_str("trim ("),(yyvsp[(3) - (4)].str),make_str(")"));
32638
35353
;}
32639
35354
    break;
32640
35355
 
32641
35356
  case 1416:
 
35357
 
 
35358
/* Line 1455 of yacc.c  */
32642
35359
#line 8319 "preproc.y"
32643
35360
    { 
32644
 
 yyval.str = cat_str(5,make_str("nullif ("),yyvsp[-3].str,make_str(","),yyvsp[-1].str,make_str(")"));
 
35361
 (yyval.str) = cat_str(5,make_str("nullif ("),(yyvsp[(3) - (6)].str),make_str(","),(yyvsp[(5) - (6)].str),make_str(")"));
32645
35362
;}
32646
35363
    break;
32647
35364
 
32648
35365
  case 1417:
 
35366
 
 
35367
/* Line 1455 of yacc.c  */
32649
35368
#line 8323 "preproc.y"
32650
35369
    { 
32651
 
 yyval.str = cat_str(3,make_str("coalesce ("),yyvsp[-1].str,make_str(")"));
 
35370
 (yyval.str) = cat_str(3,make_str("coalesce ("),(yyvsp[(3) - (4)].str),make_str(")"));
32652
35371
;}
32653
35372
    break;
32654
35373
 
32655
35374
  case 1418:
 
35375
 
 
35376
/* Line 1455 of yacc.c  */
32656
35377
#line 8327 "preproc.y"
32657
35378
    { 
32658
 
 yyval.str = cat_str(3,make_str("greatest ("),yyvsp[-1].str,make_str(")"));
 
35379
 (yyval.str) = cat_str(3,make_str("greatest ("),(yyvsp[(3) - (4)].str),make_str(")"));
32659
35380
;}
32660
35381
    break;
32661
35382
 
32662
35383
  case 1419:
 
35384
 
 
35385
/* Line 1455 of yacc.c  */
32663
35386
#line 8331 "preproc.y"
32664
35387
    { 
32665
 
 yyval.str = cat_str(3,make_str("least ("),yyvsp[-1].str,make_str(")"));
 
35388
 (yyval.str) = cat_str(3,make_str("least ("),(yyvsp[(3) - (4)].str),make_str(")"));
32666
35389
;}
32667
35390
    break;
32668
35391
 
32669
35392
  case 1420:
 
35393
 
 
35394
/* Line 1455 of yacc.c  */
32670
35395
#line 8335 "preproc.y"
32671
35396
    { 
32672
 
 yyval.str = cat_str(3,make_str("xmlconcat ("),yyvsp[-1].str,make_str(")"));
 
35397
 (yyval.str) = cat_str(3,make_str("xmlconcat ("),(yyvsp[(3) - (4)].str),make_str(")"));
32673
35398
;}
32674
35399
    break;
32675
35400
 
32676
35401
  case 1421:
 
35402
 
 
35403
/* Line 1455 of yacc.c  */
32677
35404
#line 8339 "preproc.y"
32678
35405
    { 
32679
 
 yyval.str = cat_str(3,make_str("xmlelement ( name"),yyvsp[-1].str,make_str(")"));
 
35406
 (yyval.str) = cat_str(3,make_str("xmlelement ( name"),(yyvsp[(4) - (5)].str),make_str(")"));
32680
35407
;}
32681
35408
    break;
32682
35409
 
32683
35410
  case 1422:
 
35411
 
 
35412
/* Line 1455 of yacc.c  */
32684
35413
#line 8343 "preproc.y"
32685
35414
    { 
32686
 
 yyval.str = cat_str(5,make_str("xmlelement ( name"),yyvsp[-3].str,make_str(","),yyvsp[-1].str,make_str(")"));
 
35415
 (yyval.str) = cat_str(5,make_str("xmlelement ( name"),(yyvsp[(4) - (7)].str),make_str(","),(yyvsp[(6) - (7)].str),make_str(")"));
32687
35416
;}
32688
35417
    break;
32689
35418
 
32690
35419
  case 1423:
 
35420
 
 
35421
/* Line 1455 of yacc.c  */
32691
35422
#line 8347 "preproc.y"
32692
35423
    { 
32693
 
 yyval.str = cat_str(5,make_str("xmlelement ( name"),yyvsp[-3].str,make_str(","),yyvsp[-1].str,make_str(")"));
 
35424
 (yyval.str) = cat_str(5,make_str("xmlelement ( name"),(yyvsp[(4) - (7)].str),make_str(","),(yyvsp[(6) - (7)].str),make_str(")"));
32694
35425
;}
32695
35426
    break;
32696
35427
 
32697
35428
  case 1424:
 
35429
 
 
35430
/* Line 1455 of yacc.c  */
32698
35431
#line 8351 "preproc.y"
32699
35432
    { 
32700
 
 yyval.str = cat_str(7,make_str("xmlelement ( name"),yyvsp[-5].str,make_str(","),yyvsp[-3].str,make_str(","),yyvsp[-1].str,make_str(")"));
 
35433
 (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(")"));
32701
35434
;}
32702
35435
    break;
32703
35436
 
32704
35437
  case 1425:
 
35438
 
 
35439
/* Line 1455 of yacc.c  */
32705
35440
#line 8355 "preproc.y"
32706
35441
    { 
32707
 
 yyval.str = cat_str(3,make_str("xmlforest ("),yyvsp[-1].str,make_str(")"));
 
35442
 (yyval.str) = cat_str(3,make_str("xmlforest ("),(yyvsp[(3) - (4)].str),make_str(")"));
32708
35443
;}
32709
35444
    break;
32710
35445
 
32711
35446
  case 1426:
 
35447
 
 
35448
/* Line 1455 of yacc.c  */
32712
35449
#line 8359 "preproc.y"
32713
35450
    { 
32714
 
 yyval.str = cat_str(5,make_str("xmlparse ("),yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,make_str(")"));
 
35451
 (yyval.str) = cat_str(5,make_str("xmlparse ("),(yyvsp[(3) - (6)].str),(yyvsp[(4) - (6)].str),(yyvsp[(5) - (6)].str),make_str(")"));
32715
35452
;}
32716
35453
    break;
32717
35454
 
32718
35455
  case 1427:
 
35456
 
 
35457
/* Line 1455 of yacc.c  */
32719
35458
#line 8363 "preproc.y"
32720
35459
    { 
32721
 
 yyval.str = cat_str(3,make_str("xmlpi ( name"),yyvsp[-1].str,make_str(")"));
 
35460
 (yyval.str) = cat_str(3,make_str("xmlpi ( name"),(yyvsp[(4) - (5)].str),make_str(")"));
32722
35461
;}
32723
35462
    break;
32724
35463
 
32725
35464
  case 1428:
 
35465
 
 
35466
/* Line 1455 of yacc.c  */
32726
35467
#line 8367 "preproc.y"
32727
35468
    { 
32728
 
 yyval.str = cat_str(5,make_str("xmlpi ( name"),yyvsp[-3].str,make_str(","),yyvsp[-1].str,make_str(")"));
 
35469
 (yyval.str) = cat_str(5,make_str("xmlpi ( name"),(yyvsp[(4) - (7)].str),make_str(","),(yyvsp[(6) - (7)].str),make_str(")"));
32729
35470
;}
32730
35471
    break;
32731
35472
 
32732
35473
  case 1429:
 
35474
 
 
35475
/* Line 1455 of yacc.c  */
32733
35476
#line 8371 "preproc.y"
32734
35477
    { 
32735
 
 yyval.str = cat_str(6,make_str("xmlroot ("),yyvsp[-4].str,make_str(","),yyvsp[-2].str,yyvsp[-1].str,make_str(")"));
 
35478
 (yyval.str) = cat_str(6,make_str("xmlroot ("),(yyvsp[(3) - (7)].str),make_str(","),(yyvsp[(5) - (7)].str),(yyvsp[(6) - (7)].str),make_str(")"));
32736
35479
;}
32737
35480
    break;
32738
35481
 
32739
35482
  case 1430:
 
35483
 
 
35484
/* Line 1455 of yacc.c  */
32740
35485
#line 8375 "preproc.y"
32741
35486
    { 
32742
 
 yyval.str = cat_str(6,make_str("xmlserialize ("),yyvsp[-4].str,yyvsp[-3].str,make_str("as"),yyvsp[-1].str,make_str(")"));
 
35487
 (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(")"));
32743
35488
;}
32744
35489
    break;
32745
35490
 
32746
35491
  case 1431:
 
35492
 
 
35493
/* Line 1455 of yacc.c  */
32747
35494
#line 8383 "preproc.y"
32748
35495
    { 
32749
 
 yyval.str = cat_str(2,make_str("version"),yyvsp[0].str);
 
35496
 (yyval.str) = cat_str(2,make_str("version"),(yyvsp[(2) - (2)].str));
32750
35497
;}
32751
35498
    break;
32752
35499
 
32753
35500
  case 1432:
 
35501
 
 
35502
/* Line 1455 of yacc.c  */
32754
35503
#line 8387 "preproc.y"
32755
35504
    { 
32756
 
 yyval.str = make_str("version no value");
 
35505
 (yyval.str) = make_str("version no value");
32757
35506
;}
32758
35507
    break;
32759
35508
 
32760
35509
  case 1433:
 
35510
 
 
35511
/* Line 1455 of yacc.c  */
32761
35512
#line 8395 "preproc.y"
32762
35513
    { 
32763
 
 yyval.str = make_str(", standalone yes");
 
35514
 (yyval.str) = make_str(", standalone yes");
32764
35515
;}
32765
35516
    break;
32766
35517
 
32767
35518
  case 1434:
 
35519
 
 
35520
/* Line 1455 of yacc.c  */
32768
35521
#line 8399 "preproc.y"
32769
35522
    { 
32770
 
 yyval.str = make_str(", standalone no");
 
35523
 (yyval.str) = make_str(", standalone no");
32771
35524
;}
32772
35525
    break;
32773
35526
 
32774
35527
  case 1435:
 
35528
 
 
35529
/* Line 1455 of yacc.c  */
32775
35530
#line 8403 "preproc.y"
32776
35531
    { 
32777
 
 yyval.str = make_str(", standalone no value");
 
35532
 (yyval.str) = make_str(", standalone no value");
32778
35533
;}
32779
35534
    break;
32780
35535
 
32781
35536
  case 1436:
 
35537
 
 
35538
/* Line 1455 of yacc.c  */
32782
35539
#line 8407 "preproc.y"
32783
35540
    { 
32784
 
 yyval.str=EMPTY; ;}
 
35541
 (yyval.str)=EMPTY; ;}
32785
35542
    break;
32786
35543
 
32787
35544
  case 1437:
 
35545
 
 
35546
/* Line 1455 of yacc.c  */
32788
35547
#line 8414 "preproc.y"
32789
35548
    { 
32790
 
 yyval.str = cat_str(3,make_str("xmlattributes ("),yyvsp[-1].str,make_str(")"));
 
35549
 (yyval.str) = cat_str(3,make_str("xmlattributes ("),(yyvsp[(3) - (4)].str),make_str(")"));
32791
35550
;}
32792
35551
    break;
32793
35552
 
32794
35553
  case 1438:
 
35554
 
 
35555
/* Line 1455 of yacc.c  */
32795
35556
#line 8422 "preproc.y"
32796
35557
    { 
32797
 
 yyval.str = yyvsp[0].str;
 
35558
 (yyval.str) = (yyvsp[(1) - (1)].str);
32798
35559
;}
32799
35560
    break;
32800
35561
 
32801
35562
  case 1439:
 
35563
 
 
35564
/* Line 1455 of yacc.c  */
32802
35565
#line 8426 "preproc.y"
32803
35566
    { 
32804
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
35567
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
32805
35568
;}
32806
35569
    break;
32807
35570
 
32808
35571
  case 1440:
 
35572
 
 
35573
/* Line 1455 of yacc.c  */
32809
35574
#line 8434 "preproc.y"
32810
35575
    { 
32811
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("as"),yyvsp[0].str);
 
35576
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("as"),(yyvsp[(3) - (3)].str));
32812
35577
;}
32813
35578
    break;
32814
35579
 
32815
35580
  case 1441:
 
35581
 
 
35582
/* Line 1455 of yacc.c  */
32816
35583
#line 8438 "preproc.y"
32817
35584
    { 
32818
 
 yyval.str = yyvsp[0].str;
 
35585
 (yyval.str) = (yyvsp[(1) - (1)].str);
32819
35586
;}
32820
35587
    break;
32821
35588
 
32822
35589
  case 1442:
 
35590
 
 
35591
/* Line 1455 of yacc.c  */
32823
35592
#line 8446 "preproc.y"
32824
35593
    { 
32825
 
 yyval.str = make_str("document");
 
35594
 (yyval.str) = make_str("document");
32826
35595
;}
32827
35596
    break;
32828
35597
 
32829
35598
  case 1443:
 
35599
 
 
35600
/* Line 1455 of yacc.c  */
32830
35601
#line 8450 "preproc.y"
32831
35602
    { 
32832
 
 yyval.str = make_str("content");
 
35603
 (yyval.str) = make_str("content");
32833
35604
;}
32834
35605
    break;
32835
35606
 
32836
35607
  case 1444:
 
35608
 
 
35609
/* Line 1455 of yacc.c  */
32837
35610
#line 8458 "preproc.y"
32838
35611
    { 
32839
 
 yyval.str = make_str("preserve whitespace");
 
35612
 (yyval.str) = make_str("preserve whitespace");
32840
35613
;}
32841
35614
    break;
32842
35615
 
32843
35616
  case 1445:
 
35617
 
 
35618
/* Line 1455 of yacc.c  */
32844
35619
#line 8462 "preproc.y"
32845
35620
    { 
32846
 
 yyval.str = make_str("strip whitespace");
 
35621
 (yyval.str) = make_str("strip whitespace");
32847
35622
;}
32848
35623
    break;
32849
35624
 
32850
35625
  case 1446:
 
35626
 
 
35627
/* Line 1455 of yacc.c  */
32851
35628
#line 8466 "preproc.y"
32852
35629
    { 
32853
 
 yyval.str=EMPTY; ;}
 
35630
 (yyval.str)=EMPTY; ;}
32854
35631
    break;
32855
35632
 
32856
35633
  case 1447:
 
35634
 
 
35635
/* Line 1455 of yacc.c  */
32857
35636
#line 8473 "preproc.y"
32858
35637
    { 
32859
 
 yyval.str = cat_str(2,make_str("window"),yyvsp[0].str);
 
35638
 (yyval.str) = cat_str(2,make_str("window"),(yyvsp[(2) - (2)].str));
32860
35639
;}
32861
35640
    break;
32862
35641
 
32863
35642
  case 1448:
 
35643
 
 
35644
/* Line 1455 of yacc.c  */
32864
35645
#line 8477 "preproc.y"
32865
35646
    { 
32866
 
 yyval.str=EMPTY; ;}
 
35647
 (yyval.str)=EMPTY; ;}
32867
35648
    break;
32868
35649
 
32869
35650
  case 1449:
 
35651
 
 
35652
/* Line 1455 of yacc.c  */
32870
35653
#line 8484 "preproc.y"
32871
35654
    { 
32872
 
 yyval.str = yyvsp[0].str;
 
35655
 (yyval.str) = (yyvsp[(1) - (1)].str);
32873
35656
;}
32874
35657
    break;
32875
35658
 
32876
35659
  case 1450:
 
35660
 
 
35661
/* Line 1455 of yacc.c  */
32877
35662
#line 8488 "preproc.y"
32878
35663
    { 
32879
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
35664
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
32880
35665
;}
32881
35666
    break;
32882
35667
 
32883
35668
  case 1451:
 
35669
 
 
35670
/* Line 1455 of yacc.c  */
32884
35671
#line 8496 "preproc.y"
32885
35672
    { 
32886
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("as"),yyvsp[0].str);
 
35673
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("as"),(yyvsp[(3) - (3)].str));
32887
35674
;}
32888
35675
    break;
32889
35676
 
32890
35677
  case 1452:
 
35678
 
 
35679
/* Line 1455 of yacc.c  */
32891
35680
#line 8504 "preproc.y"
32892
35681
    { 
32893
 
 yyval.str = cat_str(2,make_str("over"),yyvsp[0].str);
 
35682
 (yyval.str) = cat_str(2,make_str("over"),(yyvsp[(2) - (2)].str));
32894
35683
;}
32895
35684
    break;
32896
35685
 
32897
35686
  case 1453:
 
35687
 
 
35688
/* Line 1455 of yacc.c  */
32898
35689
#line 8508 "preproc.y"
32899
35690
    { 
32900
 
 yyval.str = cat_str(2,make_str("over"),yyvsp[0].str);
 
35691
 (yyval.str) = cat_str(2,make_str("over"),(yyvsp[(2) - (2)].str));
32901
35692
;}
32902
35693
    break;
32903
35694
 
32904
35695
  case 1454:
 
35696
 
 
35697
/* Line 1455 of yacc.c  */
32905
35698
#line 8512 "preproc.y"
32906
35699
    { 
32907
 
 yyval.str=EMPTY; ;}
 
35700
 (yyval.str)=EMPTY; ;}
32908
35701
    break;
32909
35702
 
32910
35703
  case 1455:
 
35704
 
 
35705
/* Line 1455 of yacc.c  */
32911
35706
#line 8519 "preproc.y"
32912
35707
    { 
32913
 
 yyval.str = cat_str(6,make_str("("),yyvsp[-4].str,yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,make_str(")"));
 
35708
 (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(")"));
32914
35709
;}
32915
35710
    break;
32916
35711
 
32917
35712
  case 1456:
 
35713
 
 
35714
/* Line 1455 of yacc.c  */
32918
35715
#line 8527 "preproc.y"
32919
35716
    { 
32920
 
 yyval.str = yyvsp[0].str;
 
35717
 (yyval.str) = (yyvsp[(1) - (1)].str);
32921
35718
;}
32922
35719
    break;
32923
35720
 
32924
35721
  case 1457:
 
35722
 
 
35723
/* Line 1455 of yacc.c  */
32925
35724
#line 8531 "preproc.y"
32926
35725
    { 
32927
 
 yyval.str=EMPTY; ;}
 
35726
 (yyval.str)=EMPTY; ;}
32928
35727
    break;
32929
35728
 
32930
35729
  case 1458:
 
35730
 
 
35731
/* Line 1455 of yacc.c  */
32931
35732
#line 8538 "preproc.y"
32932
35733
    { 
32933
 
 yyval.str = cat_str(2,make_str("partition by"),yyvsp[0].str);
 
35734
 (yyval.str) = cat_str(2,make_str("partition by"),(yyvsp[(3) - (3)].str));
32934
35735
;}
32935
35736
    break;
32936
35737
 
32937
35738
  case 1459:
 
35739
 
 
35740
/* Line 1455 of yacc.c  */
32938
35741
#line 8542 "preproc.y"
32939
35742
    { 
32940
 
 yyval.str=EMPTY; ;}
 
35743
 (yyval.str)=EMPTY; ;}
32941
35744
    break;
32942
35745
 
32943
35746
  case 1460:
 
35747
 
 
35748
/* Line 1455 of yacc.c  */
32944
35749
#line 8549 "preproc.y"
32945
35750
    { 
32946
 
 yyval.str = cat_str(2,make_str("range"),yyvsp[0].str);
 
35751
 (yyval.str) = cat_str(2,make_str("range"),(yyvsp[(2) - (2)].str));
32947
35752
;}
32948
35753
    break;
32949
35754
 
32950
35755
  case 1461:
 
35756
 
 
35757
/* Line 1455 of yacc.c  */
32951
35758
#line 8553 "preproc.y"
32952
35759
    { 
32953
 
 yyval.str = cat_str(2,make_str("rows"),yyvsp[0].str);
 
35760
 (yyval.str) = cat_str(2,make_str("rows"),(yyvsp[(2) - (2)].str));
32954
35761
;}
32955
35762
    break;
32956
35763
 
32957
35764
  case 1462:
 
35765
 
 
35766
/* Line 1455 of yacc.c  */
32958
35767
#line 8557 "preproc.y"
32959
35768
    { 
32960
 
 yyval.str=EMPTY; ;}
 
35769
 (yyval.str)=EMPTY; ;}
32961
35770
    break;
32962
35771
 
32963
35772
  case 1463:
 
35773
 
 
35774
/* Line 1455 of yacc.c  */
32964
35775
#line 8564 "preproc.y"
32965
35776
    { 
32966
35777
mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
32967
 
 yyval.str = yyvsp[0].str;
 
35778
 (yyval.str) = (yyvsp[(1) - (1)].str);
32968
35779
;}
32969
35780
    break;
32970
35781
 
32971
35782
  case 1464:
 
35783
 
 
35784
/* Line 1455 of yacc.c  */
32972
35785
#line 8569 "preproc.y"
32973
35786
    { 
32974
35787
mmerror(PARSE_ERROR, ET_WARNING, "unsupported feature will be passed to server");
32975
 
 yyval.str = cat_str(4,make_str("between"),yyvsp[-2].str,make_str("and"),yyvsp[0].str);
 
35788
 (yyval.str) = cat_str(4,make_str("between"),(yyvsp[(2) - (4)].str),make_str("and"),(yyvsp[(4) - (4)].str));
32976
35789
;}
32977
35790
    break;
32978
35791
 
32979
35792
  case 1465:
 
35793
 
 
35794
/* Line 1455 of yacc.c  */
32980
35795
#line 8578 "preproc.y"
32981
35796
    { 
32982
 
 yyval.str = make_str("unbounded preceding");
 
35797
 (yyval.str) = make_str("unbounded preceding");
32983
35798
;}
32984
35799
    break;
32985
35800
 
32986
35801
  case 1466:
 
35802
 
 
35803
/* Line 1455 of yacc.c  */
32987
35804
#line 8582 "preproc.y"
32988
35805
    { 
32989
 
 yyval.str = make_str("unbounded following");
 
35806
 (yyval.str) = make_str("unbounded following");
32990
35807
;}
32991
35808
    break;
32992
35809
 
32993
35810
  case 1467:
 
35811
 
 
35812
/* Line 1455 of yacc.c  */
32994
35813
#line 8586 "preproc.y"
32995
35814
    { 
32996
 
 yyval.str = make_str("current row");
 
35815
 (yyval.str) = make_str("current row");
32997
35816
;}
32998
35817
    break;
32999
35818
 
33000
35819
  case 1468:
 
35820
 
 
35821
/* Line 1455 of yacc.c  */
33001
35822
#line 8594 "preproc.y"
33002
35823
    { 
33003
 
 yyval.str = cat_str(3,make_str("row ("),yyvsp[-1].str,make_str(")"));
 
35824
 (yyval.str) = cat_str(3,make_str("row ("),(yyvsp[(3) - (4)].str),make_str(")"));
33004
35825
;}
33005
35826
    break;
33006
35827
 
33007
35828
  case 1469:
 
35829
 
 
35830
/* Line 1455 of yacc.c  */
33008
35831
#line 8598 "preproc.y"
33009
35832
    { 
33010
 
 yyval.str = make_str("row ( )");
 
35833
 (yyval.str) = make_str("row ( )");
33011
35834
;}
33012
35835
    break;
33013
35836
 
33014
35837
  case 1470:
 
35838
 
 
35839
/* Line 1455 of yacc.c  */
33015
35840
#line 8602 "preproc.y"
33016
35841
    { 
33017
 
 yyval.str = cat_str(5,make_str("("),yyvsp[-3].str,make_str(","),yyvsp[-1].str,make_str(")"));
 
35842
 (yyval.str) = cat_str(5,make_str("("),(yyvsp[(2) - (5)].str),make_str(","),(yyvsp[(4) - (5)].str),make_str(")"));
33018
35843
;}
33019
35844
    break;
33020
35845
 
33021
35846
  case 1471:
 
35847
 
 
35848
/* Line 1455 of yacc.c  */
33022
35849
#line 8610 "preproc.y"
33023
35850
    { 
33024
 
 yyval.str = make_str("any");
 
35851
 (yyval.str) = make_str("any");
33025
35852
;}
33026
35853
    break;
33027
35854
 
33028
35855
  case 1472:
 
35856
 
 
35857
/* Line 1455 of yacc.c  */
33029
35858
#line 8614 "preproc.y"
33030
35859
    { 
33031
 
 yyval.str = make_str("some");
 
35860
 (yyval.str) = make_str("some");
33032
35861
;}
33033
35862
    break;
33034
35863
 
33035
35864
  case 1473:
 
35865
 
 
35866
/* Line 1455 of yacc.c  */
33036
35867
#line 8618 "preproc.y"
33037
35868
    { 
33038
 
 yyval.str = make_str("all");
 
35869
 (yyval.str) = make_str("all");
33039
35870
;}
33040
35871
    break;
33041
35872
 
33042
35873
  case 1474:
 
35874
 
 
35875
/* Line 1455 of yacc.c  */
33043
35876
#line 8626 "preproc.y"
33044
35877
    { 
33045
 
 yyval.str = yyvsp[0].str;
 
35878
 (yyval.str) = (yyvsp[(1) - (1)].str);
33046
35879
;}
33047
35880
    break;
33048
35881
 
33049
35882
  case 1475:
 
35883
 
 
35884
/* Line 1455 of yacc.c  */
33050
35885
#line 8630 "preproc.y"
33051
35886
    { 
33052
 
 yyval.str = yyvsp[0].str;
 
35887
 (yyval.str) = (yyvsp[(1) - (1)].str);
33053
35888
;}
33054
35889
    break;
33055
35890
 
33056
35891
  case 1476:
 
35892
 
 
35893
/* Line 1455 of yacc.c  */
33057
35894
#line 8638 "preproc.y"
33058
35895
    { 
33059
 
 yyval.str = make_str("+");
 
35896
 (yyval.str) = make_str("+");
33060
35897
;}
33061
35898
    break;
33062
35899
 
33063
35900
  case 1477:
 
35901
 
 
35902
/* Line 1455 of yacc.c  */
33064
35903
#line 8642 "preproc.y"
33065
35904
    { 
33066
 
 yyval.str = make_str("-");
 
35905
 (yyval.str) = make_str("-");
33067
35906
;}
33068
35907
    break;
33069
35908
 
33070
35909
  case 1478:
 
35910
 
 
35911
/* Line 1455 of yacc.c  */
33071
35912
#line 8646 "preproc.y"
33072
35913
    { 
33073
 
 yyval.str = make_str("*");
 
35914
 (yyval.str) = make_str("*");
33074
35915
;}
33075
35916
    break;
33076
35917
 
33077
35918
  case 1479:
 
35919
 
 
35920
/* Line 1455 of yacc.c  */
33078
35921
#line 8650 "preproc.y"
33079
35922
    { 
33080
 
 yyval.str = make_str("/");
 
35923
 (yyval.str) = make_str("/");
33081
35924
;}
33082
35925
    break;
33083
35926
 
33084
35927
  case 1480:
 
35928
 
 
35929
/* Line 1455 of yacc.c  */
33085
35930
#line 8654 "preproc.y"
33086
35931
    { 
33087
 
 yyval.str = make_str("%");
 
35932
 (yyval.str) = make_str("%");
33088
35933
;}
33089
35934
    break;
33090
35935
 
33091
35936
  case 1481:
 
35937
 
 
35938
/* Line 1455 of yacc.c  */
33092
35939
#line 8658 "preproc.y"
33093
35940
    { 
33094
 
 yyval.str = make_str("^");
 
35941
 (yyval.str) = make_str("^");
33095
35942
;}
33096
35943
    break;
33097
35944
 
33098
35945
  case 1482:
 
35946
 
 
35947
/* Line 1455 of yacc.c  */
33099
35948
#line 8662 "preproc.y"
33100
35949
    { 
33101
 
 yyval.str = make_str("<");
 
35950
 (yyval.str) = make_str("<");
33102
35951
;}
33103
35952
    break;
33104
35953
 
33105
35954
  case 1483:
 
35955
 
 
35956
/* Line 1455 of yacc.c  */
33106
35957
#line 8666 "preproc.y"
33107
35958
    { 
33108
 
 yyval.str = make_str(">");
 
35959
 (yyval.str) = make_str(">");
33109
35960
;}
33110
35961
    break;
33111
35962
 
33112
35963
  case 1484:
 
35964
 
 
35965
/* Line 1455 of yacc.c  */
33113
35966
#line 8670 "preproc.y"
33114
35967
    { 
33115
 
 yyval.str = make_str("=");
 
35968
 (yyval.str) = make_str("=");
33116
35969
;}
33117
35970
    break;
33118
35971
 
33119
35972
  case 1485:
 
35973
 
 
35974
/* Line 1455 of yacc.c  */
33120
35975
#line 8678 "preproc.y"
33121
35976
    { 
33122
 
 yyval.str = yyvsp[0].str;
 
35977
 (yyval.str) = (yyvsp[(1) - (1)].str);
33123
35978
;}
33124
35979
    break;
33125
35980
 
33126
35981
  case 1486:
 
35982
 
 
35983
/* Line 1455 of yacc.c  */
33127
35984
#line 8682 "preproc.y"
33128
35985
    { 
33129
 
 yyval.str = cat_str(3,make_str("operator ("),yyvsp[-1].str,make_str(")"));
 
35986
 (yyval.str) = cat_str(3,make_str("operator ("),(yyvsp[(3) - (4)].str),make_str(")"));
33130
35987
;}
33131
35988
    break;
33132
35989
 
33133
35990
  case 1487:
 
35991
 
 
35992
/* Line 1455 of yacc.c  */
33134
35993
#line 8690 "preproc.y"
33135
35994
    { 
33136
 
 yyval.str = yyvsp[0].str;
 
35995
 (yyval.str) = (yyvsp[(1) - (1)].str);
33137
35996
;}
33138
35997
    break;
33139
35998
 
33140
35999
  case 1488:
 
36000
 
 
36001
/* Line 1455 of yacc.c  */
33141
36002
#line 8694 "preproc.y"
33142
36003
    { 
33143
 
 yyval.str = cat_str(3,make_str("operator ("),yyvsp[-1].str,make_str(")"));
 
36004
 (yyval.str) = cat_str(3,make_str("operator ("),(yyvsp[(3) - (4)].str),make_str(")"));
33144
36005
;}
33145
36006
    break;
33146
36007
 
33147
36008
  case 1489:
 
36009
 
 
36010
/* Line 1455 of yacc.c  */
33148
36011
#line 8702 "preproc.y"
33149
36012
    { 
33150
 
 yyval.str = yyvsp[0].str;
 
36013
 (yyval.str) = (yyvsp[(1) - (1)].str);
33151
36014
;}
33152
36015
    break;
33153
36016
 
33154
36017
  case 1490:
 
36018
 
 
36019
/* Line 1455 of yacc.c  */
33155
36020
#line 8706 "preproc.y"
33156
36021
    { 
33157
 
 yyval.str = cat_str(3,make_str("operator ("),yyvsp[-1].str,make_str(")"));
 
36022
 (yyval.str) = cat_str(3,make_str("operator ("),(yyvsp[(3) - (4)].str),make_str(")"));
33158
36023
;}
33159
36024
    break;
33160
36025
 
33161
36026
  case 1491:
 
36027
 
 
36028
/* Line 1455 of yacc.c  */
33162
36029
#line 8710 "preproc.y"
33163
36030
    { 
33164
 
 yyval.str = make_str("like");
 
36031
 (yyval.str) = make_str("like");
33165
36032
;}
33166
36033
    break;
33167
36034
 
33168
36035
  case 1492:
 
36036
 
 
36037
/* Line 1455 of yacc.c  */
33169
36038
#line 8714 "preproc.y"
33170
36039
    { 
33171
 
 yyval.str = make_str("not like");
 
36040
 (yyval.str) = make_str("not like");
33172
36041
;}
33173
36042
    break;
33174
36043
 
33175
36044
  case 1493:
 
36045
 
 
36046
/* Line 1455 of yacc.c  */
33176
36047
#line 8718 "preproc.y"
33177
36048
    { 
33178
 
 yyval.str = make_str("ilike");
 
36049
 (yyval.str) = make_str("ilike");
33179
36050
;}
33180
36051
    break;
33181
36052
 
33182
36053
  case 1494:
 
36054
 
 
36055
/* Line 1455 of yacc.c  */
33183
36056
#line 8722 "preproc.y"
33184
36057
    { 
33185
 
 yyval.str = make_str("not ilike");
 
36058
 (yyval.str) = make_str("not ilike");
33186
36059
;}
33187
36060
    break;
33188
36061
 
33189
36062
  case 1495:
 
36063
 
 
36064
/* Line 1455 of yacc.c  */
33190
36065
#line 8730 "preproc.y"
33191
36066
    { 
33192
 
 yyval.str = yyvsp[0].str;
 
36067
 (yyval.str) = (yyvsp[(1) - (1)].str);
33193
36068
;}
33194
36069
    break;
33195
36070
 
33196
36071
  case 1496:
 
36072
 
 
36073
/* Line 1455 of yacc.c  */
33197
36074
#line 8734 "preproc.y"
33198
36075
    { 
33199
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
36076
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
33200
36077
;}
33201
36078
    break;
33202
36079
 
33203
36080
  case 1497:
 
36081
 
 
36082
/* Line 1455 of yacc.c  */
33204
36083
#line 8742 "preproc.y"
33205
36084
    { 
33206
 
 yyval.str = yyvsp[0].str;
 
36085
 (yyval.str) = (yyvsp[(1) - (1)].str);
33207
36086
;}
33208
36087
    break;
33209
36088
 
33210
36089
  case 1498:
 
36090
 
 
36091
/* Line 1455 of yacc.c  */
33211
36092
#line 8746 "preproc.y"
33212
36093
    { 
33213
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
36094
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
33214
36095
;}
33215
36096
    break;
33216
36097
 
33217
36098
  case 1499:
 
36099
 
 
36100
/* Line 1455 of yacc.c  */
33218
36101
#line 8754 "preproc.y"
33219
36102
    { 
33220
 
 yyval.str = cat_str(3,make_str("["),yyvsp[-1].str,make_str("]"));
 
36103
 (yyval.str) = cat_str(3,make_str("["),(yyvsp[(2) - (3)].str),make_str("]"));
33221
36104
;}
33222
36105
    break;
33223
36106
 
33224
36107
  case 1500:
 
36108
 
 
36109
/* Line 1455 of yacc.c  */
33225
36110
#line 8758 "preproc.y"
33226
36111
    { 
33227
 
 yyval.str = cat_str(3,make_str("["),yyvsp[-1].str,make_str("]"));
 
36112
 (yyval.str) = cat_str(3,make_str("["),(yyvsp[(2) - (3)].str),make_str("]"));
33228
36113
;}
33229
36114
    break;
33230
36115
 
33231
36116
  case 1501:
 
36117
 
 
36118
/* Line 1455 of yacc.c  */
33232
36119
#line 8762 "preproc.y"
33233
36120
    { 
33234
 
 yyval.str = make_str("[ ]");
 
36121
 (yyval.str) = make_str("[ ]");
33235
36122
;}
33236
36123
    break;
33237
36124
 
33238
36125
  case 1502:
 
36126
 
 
36127
/* Line 1455 of yacc.c  */
33239
36128
#line 8770 "preproc.y"
33240
36129
    { 
33241
 
 yyval.str = yyvsp[0].str;
 
36130
 (yyval.str) = (yyvsp[(1) - (1)].str);
33242
36131
;}
33243
36132
    break;
33244
36133
 
33245
36134
  case 1503:
 
36135
 
 
36136
/* Line 1455 of yacc.c  */
33246
36137
#line 8774 "preproc.y"
33247
36138
    { 
33248
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
36139
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
33249
36140
;}
33250
36141
    break;
33251
36142
 
33252
36143
  case 1504:
 
36144
 
 
36145
/* Line 1455 of yacc.c  */
33253
36146
#line 8782 "preproc.y"
33254
36147
    { 
33255
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("from"),yyvsp[0].str);
 
36148
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("from"),(yyvsp[(3) - (3)].str));
33256
36149
;}
33257
36150
    break;
33258
36151
 
33259
36152
  case 1505:
 
36153
 
 
36154
/* Line 1455 of yacc.c  */
33260
36155
#line 8786 "preproc.y"
33261
36156
    { 
33262
 
 yyval.str=EMPTY; ;}
 
36157
 (yyval.str)=EMPTY; ;}
33263
36158
    break;
33264
36159
 
33265
36160
  case 1506:
 
36161
 
 
36162
/* Line 1455 of yacc.c  */
33266
36163
#line 8793 "preproc.y"
33267
36164
    { 
33268
 
 yyval.str = yyvsp[0].str;
 
36165
 (yyval.str) = (yyvsp[(1) - (1)].str);
33269
36166
;}
33270
36167
    break;
33271
36168
 
33272
36169
  case 1507:
 
36170
 
 
36171
/* Line 1455 of yacc.c  */
33273
36172
#line 8797 "preproc.y"
33274
36173
    { 
33275
 
 yyval.str = make_str("year");
 
36174
 (yyval.str) = make_str("year");
33276
36175
;}
33277
36176
    break;
33278
36177
 
33279
36178
  case 1508:
 
36179
 
 
36180
/* Line 1455 of yacc.c  */
33280
36181
#line 8801 "preproc.y"
33281
36182
    { 
33282
 
 yyval.str = make_str("month");
 
36183
 (yyval.str) = make_str("month");
33283
36184
;}
33284
36185
    break;
33285
36186
 
33286
36187
  case 1509:
 
36188
 
 
36189
/* Line 1455 of yacc.c  */
33287
36190
#line 8805 "preproc.y"
33288
36191
    { 
33289
 
 yyval.str = make_str("day");
 
36192
 (yyval.str) = make_str("day");
33290
36193
;}
33291
36194
    break;
33292
36195
 
33293
36196
  case 1510:
 
36197
 
 
36198
/* Line 1455 of yacc.c  */
33294
36199
#line 8809 "preproc.y"
33295
36200
    { 
33296
 
 yyval.str = make_str("hour");
 
36201
 (yyval.str) = make_str("hour");
33297
36202
;}
33298
36203
    break;
33299
36204
 
33300
36205
  case 1511:
 
36206
 
 
36207
/* Line 1455 of yacc.c  */
33301
36208
#line 8813 "preproc.y"
33302
36209
    { 
33303
 
 yyval.str = make_str("minute");
 
36210
 (yyval.str) = make_str("minute");
33304
36211
;}
33305
36212
    break;
33306
36213
 
33307
36214
  case 1512:
 
36215
 
 
36216
/* Line 1455 of yacc.c  */
33308
36217
#line 8817 "preproc.y"
33309
36218
    { 
33310
 
 yyval.str = make_str("second");
 
36219
 (yyval.str) = make_str("second");
33311
36220
;}
33312
36221
    break;
33313
36222
 
33314
36223
  case 1513:
 
36224
 
 
36225
/* Line 1455 of yacc.c  */
33315
36226
#line 8821 "preproc.y"
33316
36227
    { 
33317
 
 yyval.str = yyvsp[0].str;
 
36228
 (yyval.str) = (yyvsp[(1) - (1)].str);
33318
36229
;}
33319
36230
    break;
33320
36231
 
33321
36232
  case 1514:
 
36233
 
 
36234
/* Line 1455 of yacc.c  */
33322
36235
#line 8829 "preproc.y"
33323
36236
    { 
33324
 
 yyval.str = cat_str(4,yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
36237
 (yyval.str) = cat_str(4,(yyvsp[(1) - (4)].str),(yyvsp[(2) - (4)].str),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
33325
36238
;}
33326
36239
    break;
33327
36240
 
33328
36241
  case 1515:
 
36242
 
 
36243
/* Line 1455 of yacc.c  */
33329
36244
#line 8833 "preproc.y"
33330
36245
    { 
33331
 
 yyval.str = cat_str(3,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
36246
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
33332
36247
;}
33333
36248
    break;
33334
36249
 
33335
36250
  case 1516:
 
36251
 
 
36252
/* Line 1455 of yacc.c  */
33336
36253
#line 8841 "preproc.y"
33337
36254
    { 
33338
 
 yyval.str = cat_str(2,make_str("placing"),yyvsp[0].str);
 
36255
 (yyval.str) = cat_str(2,make_str("placing"),(yyvsp[(2) - (2)].str));
33339
36256
;}
33340
36257
    break;
33341
36258
 
33342
36259
  case 1517:
 
36260
 
 
36261
/* Line 1455 of yacc.c  */
33343
36262
#line 8849 "preproc.y"
33344
36263
    { 
33345
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("in"),yyvsp[0].str);
 
36264
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("in"),(yyvsp[(3) - (3)].str));
33346
36265
;}
33347
36266
    break;
33348
36267
 
33349
36268
  case 1518:
 
36269
 
 
36270
/* Line 1455 of yacc.c  */
33350
36271
#line 8853 "preproc.y"
33351
36272
    { 
33352
 
 yyval.str=EMPTY; ;}
 
36273
 (yyval.str)=EMPTY; ;}
33353
36274
    break;
33354
36275
 
33355
36276
  case 1519:
 
36277
 
 
36278
/* Line 1455 of yacc.c  */
33356
36279
#line 8860 "preproc.y"
33357
36280
    { 
33358
 
 yyval.str = cat_str(3,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
36281
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
33359
36282
;}
33360
36283
    break;
33361
36284
 
33362
36285
  case 1520:
 
36286
 
 
36287
/* Line 1455 of yacc.c  */
33363
36288
#line 8864 "preproc.y"
33364
36289
    { 
33365
 
 yyval.str = cat_str(3,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
36290
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
33366
36291
;}
33367
36292
    break;
33368
36293
 
33369
36294
  case 1521:
 
36295
 
 
36296
/* Line 1455 of yacc.c  */
33370
36297
#line 8868 "preproc.y"
33371
36298
    { 
33372
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
36299
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
33373
36300
;}
33374
36301
    break;
33375
36302
 
33376
36303
  case 1522:
 
36304
 
 
36305
/* Line 1455 of yacc.c  */
33377
36306
#line 8872 "preproc.y"
33378
36307
    { 
33379
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
36308
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
33380
36309
;}
33381
36310
    break;
33382
36311
 
33383
36312
  case 1523:
 
36313
 
 
36314
/* Line 1455 of yacc.c  */
33384
36315
#line 8876 "preproc.y"
33385
36316
    { 
33386
 
 yyval.str = yyvsp[0].str;
 
36317
 (yyval.str) = (yyvsp[(1) - (1)].str);
33387
36318
;}
33388
36319
    break;
33389
36320
 
33390
36321
  case 1524:
 
36322
 
 
36323
/* Line 1455 of yacc.c  */
33391
36324
#line 8880 "preproc.y"
33392
36325
    { 
33393
 
 yyval.str=EMPTY; ;}
 
36326
 (yyval.str)=EMPTY; ;}
33394
36327
    break;
33395
36328
 
33396
36329
  case 1525:
 
36330
 
 
36331
/* Line 1455 of yacc.c  */
33397
36332
#line 8887 "preproc.y"
33398
36333
    { 
33399
 
 yyval.str = cat_str(2,make_str("from"),yyvsp[0].str);
 
36334
 (yyval.str) = cat_str(2,make_str("from"),(yyvsp[(2) - (2)].str));
33400
36335
;}
33401
36336
    break;
33402
36337
 
33403
36338
  case 1526:
 
36339
 
 
36340
/* Line 1455 of yacc.c  */
33404
36341
#line 8895 "preproc.y"
33405
36342
    { 
33406
 
 yyval.str = cat_str(2,make_str("for"),yyvsp[0].str);
 
36343
 (yyval.str) = cat_str(2,make_str("for"),(yyvsp[(2) - (2)].str));
33407
36344
;}
33408
36345
    break;
33409
36346
 
33410
36347
  case 1527:
 
36348
 
 
36349
/* Line 1455 of yacc.c  */
33411
36350
#line 8903 "preproc.y"
33412
36351
    { 
33413
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("from"),yyvsp[0].str);
 
36352
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("from"),(yyvsp[(3) - (3)].str));
33414
36353
;}
33415
36354
    break;
33416
36355
 
33417
36356
  case 1528:
 
36357
 
 
36358
/* Line 1455 of yacc.c  */
33418
36359
#line 8907 "preproc.y"
33419
36360
    { 
33420
 
 yyval.str = cat_str(2,make_str("from"),yyvsp[0].str);
 
36361
 (yyval.str) = cat_str(2,make_str("from"),(yyvsp[(2) - (2)].str));
33421
36362
;}
33422
36363
    break;
33423
36364
 
33424
36365
  case 1529:
 
36366
 
 
36367
/* Line 1455 of yacc.c  */
33425
36368
#line 8911 "preproc.y"
33426
36369
    { 
33427
 
 yyval.str = yyvsp[0].str;
 
36370
 (yyval.str) = (yyvsp[(1) - (1)].str);
33428
36371
;}
33429
36372
    break;
33430
36373
 
33431
36374
  case 1530:
 
36375
 
 
36376
/* Line 1455 of yacc.c  */
33432
36377
#line 8919 "preproc.y"
33433
36378
    { 
33434
 
 yyval.str = yyvsp[0].str;
 
36379
 (yyval.str) = (yyvsp[(1) - (1)].str);
33435
36380
;}
33436
36381
    break;
33437
36382
 
33438
36383
  case 1531:
 
36384
 
 
36385
/* Line 1455 of yacc.c  */
33439
36386
#line 8923 "preproc.y"
33440
36387
    { 
33441
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
36388
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
33442
36389
;}
33443
36390
    break;
33444
36391
 
33445
36392
  case 1532:
 
36393
 
 
36394
/* Line 1455 of yacc.c  */
33446
36395
#line 8931 "preproc.y"
33447
36396
    { 
33448
 
 yyval.str = cat_str(5,make_str("case"),yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str,make_str("end"));
 
36397
 (yyval.str) = cat_str(5,make_str("case"),(yyvsp[(2) - (5)].str),(yyvsp[(3) - (5)].str),(yyvsp[(4) - (5)].str),make_str("end"));
33449
36398
;}
33450
36399
    break;
33451
36400
 
33452
36401
  case 1533:
 
36402
 
 
36403
/* Line 1455 of yacc.c  */
33453
36404
#line 8939 "preproc.y"
33454
36405
    { 
33455
 
 yyval.str = yyvsp[0].str;
 
36406
 (yyval.str) = (yyvsp[(1) - (1)].str);
33456
36407
;}
33457
36408
    break;
33458
36409
 
33459
36410
  case 1534:
 
36411
 
 
36412
/* Line 1455 of yacc.c  */
33460
36413
#line 8943 "preproc.y"
33461
36414
    { 
33462
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
36415
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
33463
36416
;}
33464
36417
    break;
33465
36418
 
33466
36419
  case 1535:
 
36420
 
 
36421
/* Line 1455 of yacc.c  */
33467
36422
#line 8951 "preproc.y"
33468
36423
    { 
33469
 
 yyval.str = cat_str(4,make_str("when"),yyvsp[-2].str,make_str("then"),yyvsp[0].str);
 
36424
 (yyval.str) = cat_str(4,make_str("when"),(yyvsp[(2) - (4)].str),make_str("then"),(yyvsp[(4) - (4)].str));
33470
36425
;}
33471
36426
    break;
33472
36427
 
33473
36428
  case 1536:
 
36429
 
 
36430
/* Line 1455 of yacc.c  */
33474
36431
#line 8959 "preproc.y"
33475
36432
    { 
33476
 
 yyval.str = cat_str(2,make_str("else"),yyvsp[0].str);
 
36433
 (yyval.str) = cat_str(2,make_str("else"),(yyvsp[(2) - (2)].str));
33477
36434
;}
33478
36435
    break;
33479
36436
 
33480
36437
  case 1537:
 
36438
 
 
36439
/* Line 1455 of yacc.c  */
33481
36440
#line 8963 "preproc.y"
33482
36441
    { 
33483
 
 yyval.str=EMPTY; ;}
 
36442
 (yyval.str)=EMPTY; ;}
33484
36443
    break;
33485
36444
 
33486
36445
  case 1538:
 
36446
 
 
36447
/* Line 1455 of yacc.c  */
33487
36448
#line 8970 "preproc.y"
33488
36449
    { 
33489
 
 yyval.str = yyvsp[0].str;
 
36450
 (yyval.str) = (yyvsp[(1) - (1)].str);
33490
36451
;}
33491
36452
    break;
33492
36453
 
33493
36454
  case 1539:
 
36455
 
 
36456
/* Line 1455 of yacc.c  */
33494
36457
#line 8974 "preproc.y"
33495
36458
    { 
33496
 
 yyval.str=EMPTY; ;}
 
36459
 (yyval.str)=EMPTY; ;}
33497
36460
    break;
33498
36461
 
33499
36462
  case 1540:
 
36463
 
 
36464
/* Line 1455 of yacc.c  */
33500
36465
#line 8981 "preproc.y"
33501
36466
    { 
33502
 
 yyval.str = yyvsp[0].str;
 
36467
 (yyval.str) = (yyvsp[(1) - (1)].str);
33503
36468
;}
33504
36469
    break;
33505
36470
 
33506
36471
  case 1541:
 
36472
 
 
36473
/* Line 1455 of yacc.c  */
33507
36474
#line 8985 "preproc.y"
33508
36475
    { 
33509
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
36476
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
33510
36477
;}
33511
36478
    break;
33512
36479
 
33513
36480
  case 1542:
 
36481
 
 
36482
/* Line 1455 of yacc.c  */
33514
36483
#line 8993 "preproc.y"
33515
36484
    { 
33516
 
 yyval.str = cat_str(2,make_str("."),yyvsp[0].str);
 
36485
 (yyval.str) = cat_str(2,make_str("."),(yyvsp[(2) - (2)].str));
33517
36486
;}
33518
36487
    break;
33519
36488
 
33520
36489
  case 1543:
 
36490
 
 
36491
/* Line 1455 of yacc.c  */
33521
36492
#line 8997 "preproc.y"
33522
36493
    { 
33523
 
 yyval.str = make_str(". *");
 
36494
 (yyval.str) = make_str(". *");
33524
36495
;}
33525
36496
    break;
33526
36497
 
33527
36498
  case 1544:
 
36499
 
 
36500
/* Line 1455 of yacc.c  */
33528
36501
#line 9001 "preproc.y"
33529
36502
    { 
33530
 
 yyval.str = cat_str(3,make_str("["),yyvsp[-1].str,make_str("]"));
 
36503
 (yyval.str) = cat_str(3,make_str("["),(yyvsp[(2) - (3)].str),make_str("]"));
33531
36504
;}
33532
36505
    break;
33533
36506
 
33534
36507
  case 1545:
 
36508
 
 
36509
/* Line 1455 of yacc.c  */
33535
36510
#line 9005 "preproc.y"
33536
36511
    { 
33537
 
 yyval.str = cat_str(5,make_str("["),yyvsp[-3].str,make_str(":"),yyvsp[-1].str,make_str("]"));
 
36512
 (yyval.str) = cat_str(5,make_str("["),(yyvsp[(2) - (5)].str),make_str(":"),(yyvsp[(4) - (5)].str),make_str("]"));
33538
36513
;}
33539
36514
    break;
33540
36515
 
33541
36516
  case 1546:
 
36517
 
 
36518
/* Line 1455 of yacc.c  */
33542
36519
#line 9013 "preproc.y"
33543
36520
    { 
33544
 
 yyval.str = yyvsp[0].str;
 
36521
 (yyval.str) = (yyvsp[(1) - (1)].str);
33545
36522
;}
33546
36523
    break;
33547
36524
 
33548
36525
  case 1547:
 
36526
 
 
36527
/* Line 1455 of yacc.c  */
33549
36528
#line 9017 "preproc.y"
33550
36529
    { 
33551
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
36530
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
33552
36531
;}
33553
36532
    break;
33554
36533
 
33555
36534
  case 1548:
 
36535
 
 
36536
/* Line 1455 of yacc.c  */
33556
36537
#line 9025 "preproc.y"
33557
36538
    { 
33558
 
 yyval.str=EMPTY; ;}
 
36539
 (yyval.str)=EMPTY; ;}
33559
36540
    break;
33560
36541
 
33561
36542
  case 1549:
 
36543
 
 
36544
/* Line 1455 of yacc.c  */
33562
36545
#line 9028 "preproc.y"
33563
36546
    { 
33564
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
36547
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
33565
36548
;}
33566
36549
    break;
33567
36550
 
33568
36551
  case 1550:
 
36552
 
 
36553
/* Line 1455 of yacc.c  */
33569
36554
#line 9036 "preproc.y"
33570
36555
    { 
33571
 
 yyval.str = make_str("asymmetric");
 
36556
 (yyval.str) = make_str("asymmetric");
33572
36557
;}
33573
36558
    break;
33574
36559
 
33575
36560
  case 1551:
 
36561
 
 
36562
/* Line 1455 of yacc.c  */
33576
36563
#line 9040 "preproc.y"
33577
36564
    { 
33578
 
 yyval.str=EMPTY; ;}
 
36565
 (yyval.str)=EMPTY; ;}
33579
36566
    break;
33580
36567
 
33581
36568
  case 1552:
 
36569
 
 
36570
/* Line 1455 of yacc.c  */
33582
36571
#line 9047 "preproc.y"
33583
36572
    { 
33584
 
 yyval.str = yyvsp[0].str;
 
36573
 (yyval.str) = (yyvsp[(1) - (1)].str);
33585
36574
;}
33586
36575
    break;
33587
36576
 
33588
36577
  case 1553:
 
36578
 
 
36579
/* Line 1455 of yacc.c  */
33589
36580
#line 9051 "preproc.y"
33590
36581
    { 
33591
 
 yyval.str = make_str("default");
 
36582
 (yyval.str) = make_str("default");
33592
36583
;}
33593
36584
    break;
33594
36585
 
33595
36586
  case 1554:
 
36587
 
 
36588
/* Line 1455 of yacc.c  */
33596
36589
#line 9059 "preproc.y"
33597
36590
    { 
33598
 
 yyval.str = yyvsp[0].str;
 
36591
 (yyval.str) = (yyvsp[(1) - (1)].str);
33599
36592
;}
33600
36593
    break;
33601
36594
 
33602
36595
  case 1555:
 
36596
 
 
36597
/* Line 1455 of yacc.c  */
33603
36598
#line 9063 "preproc.y"
33604
36599
    { 
33605
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
36600
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
33606
36601
;}
33607
36602
    break;
33608
36603
 
33609
36604
  case 1556:
 
36605
 
 
36606
/* Line 1455 of yacc.c  */
33610
36607
#line 9071 "preproc.y"
33611
36608
    { 
33612
 
 yyval.str = cat_str(3,make_str("("),yyvsp[-1].str,make_str(")"));
 
36609
 (yyval.str) = cat_str(3,make_str("("),(yyvsp[(2) - (3)].str),make_str(")"));
33613
36610
;}
33614
36611
    break;
33615
36612
 
33616
36613
  case 1557:
 
36614
 
 
36615
/* Line 1455 of yacc.c  */
33617
36616
#line 9079 "preproc.y"
33618
36617
    { 
33619
 
 yyval.str = yyvsp[0].str;
 
36618
 (yyval.str) = (yyvsp[(1) - (1)].str);
33620
36619
;}
33621
36620
    break;
33622
36621
 
33623
36622
  case 1558:
 
36623
 
 
36624
/* Line 1455 of yacc.c  */
33624
36625
#line 9083 "preproc.y"
33625
36626
    { 
33626
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
36627
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
33627
36628
;}
33628
36629
    break;
33629
36630
 
33630
36631
  case 1559:
 
36632
 
 
36633
/* Line 1455 of yacc.c  */
33631
36634
#line 9091 "preproc.y"
33632
36635
    { 
33633
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str("as"),yyvsp[0].str);
 
36636
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str("as"),(yyvsp[(3) - (3)].str));
33634
36637
;}
33635
36638
    break;
33636
36639
 
33637
36640
  case 1560:
 
36641
 
 
36642
/* Line 1455 of yacc.c  */
33638
36643
#line 9095 "preproc.y"
33639
36644
    { 
33640
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
36645
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
33641
36646
;}
33642
36647
    break;
33643
36648
 
33644
36649
  case 1561:
 
36650
 
 
36651
/* Line 1455 of yacc.c  */
33645
36652
#line 9099 "preproc.y"
33646
36653
    { 
33647
 
 yyval.str = yyvsp[0].str;
 
36654
 (yyval.str) = (yyvsp[(1) - (1)].str);
33648
36655
;}
33649
36656
    break;
33650
36657
 
33651
36658
  case 1562:
 
36659
 
 
36660
/* Line 1455 of yacc.c  */
33652
36661
#line 9103 "preproc.y"
33653
36662
    { 
33654
 
 yyval.str = make_str("*");
 
36663
 (yyval.str) = make_str("*");
33655
36664
;}
33656
36665
    break;
33657
36666
 
33658
36667
  case 1563:
 
36668
 
 
36669
/* Line 1455 of yacc.c  */
33659
36670
#line 9111 "preproc.y"
33660
36671
    { 
33661
 
 yyval.str = yyvsp[0].str;
 
36672
 (yyval.str) = (yyvsp[(1) - (1)].str);
33662
36673
;}
33663
36674
    break;
33664
36675
 
33665
36676
  case 1564:
 
36677
 
 
36678
/* Line 1455 of yacc.c  */
33666
36679
#line 9115 "preproc.y"
33667
36680
    { 
33668
 
 yyval.str = yyvsp[0].str;
 
36681
 (yyval.str) = (yyvsp[(1) - (1)].str);
33669
36682
;}
33670
36683
    break;
33671
36684
 
33672
36685
  case 1565:
 
36686
 
 
36687
/* Line 1455 of yacc.c  */
33673
36688
#line 9123 "preproc.y"
33674
36689
    { 
33675
 
 yyval.str = yyvsp[0].str;
 
36690
 (yyval.str) = (yyvsp[(1) - (1)].str);
33676
36691
;}
33677
36692
    break;
33678
36693
 
33679
36694
  case 1566:
 
36695
 
 
36696
/* Line 1455 of yacc.c  */
33680
36697
#line 9127 "preproc.y"
33681
36698
    { 
33682
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
36699
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
33683
36700
;}
33684
36701
    break;
33685
36702
 
33686
36703
  case 1567:
 
36704
 
 
36705
/* Line 1455 of yacc.c  */
33687
36706
#line 9135 "preproc.y"
33688
36707
    { 
33689
 
 yyval.str = yyvsp[0].str;
 
36708
 (yyval.str) = (yyvsp[(1) - (1)].str);
33690
36709
;}
33691
36710
    break;
33692
36711
 
33693
36712
  case 1568:
 
36713
 
 
36714
/* Line 1455 of yacc.c  */
33694
36715
#line 9139 "preproc.y"
33695
36716
    { 
33696
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
36717
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
33697
36718
;}
33698
36719
    break;
33699
36720
 
33700
36721
  case 1569:
 
36722
 
 
36723
/* Line 1455 of yacc.c  */
33701
36724
#line 9147 "preproc.y"
33702
36725
    { 
33703
 
 yyval.str = yyvsp[0].str;
 
36726
 (yyval.str) = (yyvsp[(1) - (1)].str);
33704
36727
;}
33705
36728
    break;
33706
36729
 
33707
36730
  case 1570:
 
36731
 
 
36732
/* Line 1455 of yacc.c  */
33708
36733
#line 9151 "preproc.y"
33709
36734
    { 
33710
 
 yyval.str = cat_str(3,yyvsp[-2].str,make_str(","),yyvsp[0].str);
 
36735
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),make_str(","),(yyvsp[(3) - (3)].str));
33711
36736
;}
33712
36737
    break;
33713
36738
 
33714
36739
  case 1571:
 
36740
 
 
36741
/* Line 1455 of yacc.c  */
33715
36742
#line 9159 "preproc.y"
33716
36743
    { 
33717
 
 yyval.str = yyvsp[0].str;
 
36744
 (yyval.str) = (yyvsp[(1) - (1)].str);
33718
36745
;}
33719
36746
    break;
33720
36747
 
33721
36748
  case 1572:
 
36749
 
 
36750
/* Line 1455 of yacc.c  */
33722
36751
#line 9167 "preproc.y"
33723
36752
    { 
33724
 
 yyval.str = yyvsp[0].str;
 
36753
 (yyval.str) = (yyvsp[(1) - (1)].str);
33725
36754
;}
33726
36755
    break;
33727
36756
 
33728
36757
  case 1573:
 
36758
 
 
36759
/* Line 1455 of yacc.c  */
33729
36760
#line 9175 "preproc.y"
33730
36761
    { 
33731
 
 yyval.str = yyvsp[0].str;
 
36762
 (yyval.str) = (yyvsp[(1) - (1)].str);
33732
36763
;}
33733
36764
    break;
33734
36765
 
33735
36766
  case 1574:
 
36767
 
 
36768
/* Line 1455 of yacc.c  */
33736
36769
#line 9183 "preproc.y"
33737
36770
    { 
33738
 
 yyval.str = yyvsp[0].str;
 
36771
 (yyval.str) = (yyvsp[(1) - (1)].str);
33739
36772
;}
33740
36773
    break;
33741
36774
 
33742
36775
  case 1575:
 
36776
 
 
36777
/* Line 1455 of yacc.c  */
33743
36778
#line 9191 "preproc.y"
33744
36779
    { 
33745
 
 yyval.str = yyvsp[0].str;
 
36780
 (yyval.str) = (yyvsp[(1) - (1)].str);
33746
36781
;}
33747
36782
    break;
33748
36783
 
33749
36784
  case 1576:
 
36785
 
 
36786
/* Line 1455 of yacc.c  */
33750
36787
#line 9199 "preproc.y"
33751
36788
    { 
33752
 
 yyval.str = yyvsp[0].str;
 
36789
 (yyval.str) = (yyvsp[(1) - (1)].str);
33753
36790
;}
33754
36791
    break;
33755
36792
 
33756
36793
  case 1577:
 
36794
 
 
36795
/* Line 1455 of yacc.c  */
33757
36796
#line 9207 "preproc.y"
33758
36797
    { 
33759
 
 yyval.str = yyvsp[0].str;
 
36798
 (yyval.str) = (yyvsp[(1) - (1)].str);
33760
36799
;}
33761
36800
    break;
33762
36801
 
33763
36802
  case 1578:
 
36803
 
 
36804
/* Line 1455 of yacc.c  */
33764
36805
#line 9211 "preproc.y"
33765
36806
    { 
33766
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
36807
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
33767
36808
;}
33768
36809
    break;
33769
36810
 
33770
36811
  case 1579:
 
36812
 
 
36813
/* Line 1455 of yacc.c  */
33771
36814
#line 9219 "preproc.y"
33772
36815
    { 
33773
 
 yyval.str = yyvsp[0].str;
 
36816
 (yyval.str) = (yyvsp[(1) - (1)].str);
33774
36817
;}
33775
36818
    break;
33776
36819
 
33777
36820
  case 1580:
 
36821
 
 
36822
/* Line 1455 of yacc.c  */
33778
36823
#line 9223 "preproc.y"
33779
36824
    { 
33780
 
 yyval.str = yyvsp[0].str;
 
36825
 (yyval.str) = (yyvsp[(1) - (1)].str);
33781
36826
;}
33782
36827
    break;
33783
36828
 
33784
36829
  case 1581:
 
36830
 
 
36831
/* Line 1455 of yacc.c  */
33785
36832
#line 9227 "preproc.y"
33786
36833
    { 
33787
 
 yyval.str = yyvsp[0].str;
 
36834
 (yyval.str) = (yyvsp[(1) - (1)].str);
33788
36835
;}
33789
36836
    break;
33790
36837
 
33791
36838
  case 1582:
 
36839
 
 
36840
/* Line 1455 of yacc.c  */
33792
36841
#line 9231 "preproc.y"
33793
36842
    { 
33794
 
 yyval.str = yyvsp[0].str;
 
36843
 (yyval.str) = (yyvsp[(1) - (1)].str);
33795
36844
;}
33796
36845
    break;
33797
36846
 
33798
36847
  case 1583:
 
36848
 
 
36849
/* Line 1455 of yacc.c  */
33799
36850
#line 9235 "preproc.y"
33800
36851
    { 
33801
 
 yyval.str = make_str("xconst");
 
36852
 (yyval.str) = make_str("xconst");
33802
36853
;}
33803
36854
    break;
33804
36855
 
33805
36856
  case 1584:
 
36857
 
 
36858
/* Line 1455 of yacc.c  */
33806
36859
#line 9239 "preproc.y"
33807
36860
    { 
33808
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
36861
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
33809
36862
;}
33810
36863
    break;
33811
36864
 
33812
36865
  case 1585:
 
36866
 
 
36867
/* Line 1455 of yacc.c  */
33813
36868
#line 9243 "preproc.y"
33814
36869
    { 
33815
 
 yyval.str = cat_str(5,yyvsp[-4].str,make_str("("),yyvsp[-2].str,make_str(")"),yyvsp[0].str);
 
36870
 (yyval.str) = cat_str(5,(yyvsp[(1) - (5)].str),make_str("("),(yyvsp[(3) - (5)].str),make_str(")"),(yyvsp[(5) - (5)].str));
33816
36871
;}
33817
36872
    break;
33818
36873
 
33819
36874
  case 1586:
 
36875
 
 
36876
/* Line 1455 of yacc.c  */
33820
36877
#line 9247 "preproc.y"
33821
36878
    { 
33822
 
 yyval.str = cat_str(2,yyvsp[-1].str,yyvsp[0].str);
 
36879
 (yyval.str) = cat_str(2,(yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
33823
36880
;}
33824
36881
    break;
33825
36882
 
33826
36883
  case 1587:
 
36884
 
 
36885
/* Line 1455 of yacc.c  */
33827
36886
#line 9251 "preproc.y"
33828
36887
    { 
33829
 
 yyval.str = cat_str(3,yyvsp[-2].str,yyvsp[-1].str,yyvsp[0].str);
 
36888
 (yyval.str) = cat_str(3,(yyvsp[(1) - (3)].str),(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
33830
36889
;}
33831
36890
    break;
33832
36891
 
33833
36892
  case 1588:
 
36893
 
 
36894
/* Line 1455 of yacc.c  */
33834
36895
#line 9255 "preproc.y"
33835
36896
    { 
33836
 
 yyval.str = cat_str(6,yyvsp[-5].str,make_str("("),yyvsp[-3].str,make_str(")"),yyvsp[-1].str,yyvsp[0].str);
 
36897
 (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));
33837
36898
;}
33838
36899
    break;
33839
36900
 
33840
36901
  case 1589:
 
36902
 
 
36903
/* Line 1455 of yacc.c  */
33841
36904
#line 9259 "preproc.y"
33842
36905
    { 
33843
 
 yyval.str = make_str("true");
 
36906
 (yyval.str) = make_str("true");
33844
36907
;}
33845
36908
    break;
33846
36909
 
33847
36910
  case 1590:
 
36911
 
 
36912
/* Line 1455 of yacc.c  */
33848
36913
#line 9263 "preproc.y"
33849
36914
    { 
33850
 
 yyval.str = make_str("false");
 
36915
 (yyval.str) = make_str("false");
33851
36916
;}
33852
36917
    break;
33853
36918
 
33854
36919
  case 1591:
 
36920
 
 
36921
/* Line 1455 of yacc.c  */
33855
36922
#line 9267 "preproc.y"
33856
36923
    { 
33857
 
 yyval.str = make_str("null");
 
36924
 (yyval.str) = make_str("null");
33858
36925
;}
33859
36926
    break;
33860
36927
 
33861
36928
  case 1592:
 
36929
 
 
36930
/* Line 1455 of yacc.c  */
33862
36931
#line 9270 "preproc.y"
33863
 
    { yyval.str = yyvsp[0].str; ;}
 
36932
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
33864
36933
    break;
33865
36934
 
33866
36935
  case 1593:
 
36936
 
 
36937
/* Line 1455 of yacc.c  */
33867
36938
#line 9271 "preproc.y"
33868
 
    { yyval.str = yyvsp[0].str; ;}
 
36939
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
33869
36940
    break;
33870
36941
 
33871
36942
  case 1594:
 
36943
 
 
36944
/* Line 1455 of yacc.c  */
33872
36945
#line 9277 "preproc.y"
33873
 
    { yyval.str = make_name(); ;}
 
36946
    { (yyval.str) = make_name(); ;}
33874
36947
    break;
33875
36948
 
33876
36949
  case 1595:
 
36950
 
 
36951
/* Line 1455 of yacc.c  */
33877
36952
#line 9283 "preproc.y"
33878
36953
    { 
33879
 
 yyval.str = yyvsp[0].str;
 
36954
 (yyval.str) = (yyvsp[(1) - (1)].str);
33880
36955
;}
33881
36956
    break;
33882
36957
 
33883
36958
  case 1596:
 
36959
 
 
36960
/* Line 1455 of yacc.c  */
33884
36961
#line 9291 "preproc.y"
33885
36962
    { 
33886
 
 yyval.str = yyvsp[0].str;
 
36963
 (yyval.str) = (yyvsp[(1) - (1)].str);
33887
36964
;}
33888
36965
    break;
33889
36966
 
33890
36967
  case 1597:
 
36968
 
 
36969
/* Line 1455 of yacc.c  */
33891
36970
#line 9294 "preproc.y"
33892
 
    { yyval.str = yyvsp[0].str; ;}
 
36971
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
33893
36972
    break;
33894
36973
 
33895
36974
  case 1598:
 
36975
 
 
36976
/* Line 1455 of yacc.c  */
33896
36977
#line 9296 "preproc.y"
33897
36978
    { 
33898
 
 yyval.str = cat_str(2,make_str("+"),yyvsp[0].str);
 
36979
 (yyval.str) = cat_str(2,make_str("+"),(yyvsp[(2) - (2)].str));
33899
36980
;}
33900
36981
    break;
33901
36982
 
33902
36983
  case 1599:
 
36984
 
 
36985
/* Line 1455 of yacc.c  */
33903
36986
#line 9300 "preproc.y"
33904
36987
    { 
33905
 
 yyval.str = cat_str(2,make_str("-"),yyvsp[0].str);
 
36988
 (yyval.str) = cat_str(2,make_str("-"),(yyvsp[(2) - (2)].str));
33906
36989
;}
33907
36990
    break;
33908
36991
 
33909
36992
  case 1600:
 
36993
 
 
36994
/* Line 1455 of yacc.c  */
33910
36995
#line 9308 "preproc.y"
33911
36996
    { 
33912
 
 yyval.str = make_str("abort");
 
36997
 (yyval.str) = make_str("abort");
33913
36998
;}
33914
36999
    break;
33915
37000
 
33916
37001
  case 1601:
 
37002
 
 
37003
/* Line 1455 of yacc.c  */
33917
37004
#line 9312 "preproc.y"
33918
37005
    { 
33919
 
 yyval.str = make_str("absolute");
 
37006
 (yyval.str) = make_str("absolute");
33920
37007
;}
33921
37008
    break;
33922
37009
 
33923
37010
  case 1602:
 
37011
 
 
37012
/* Line 1455 of yacc.c  */
33924
37013
#line 9316 "preproc.y"
33925
37014
    { 
33926
 
 yyval.str = make_str("access");
 
37015
 (yyval.str) = make_str("access");
33927
37016
;}
33928
37017
    break;
33929
37018
 
33930
37019
  case 1603:
 
37020
 
 
37021
/* Line 1455 of yacc.c  */
33931
37022
#line 9320 "preproc.y"
33932
37023
    { 
33933
 
 yyval.str = make_str("action");
 
37024
 (yyval.str) = make_str("action");
33934
37025
;}
33935
37026
    break;
33936
37027
 
33937
37028
  case 1604:
 
37029
 
 
37030
/* Line 1455 of yacc.c  */
33938
37031
#line 9324 "preproc.y"
33939
37032
    { 
33940
 
 yyval.str = make_str("add");
 
37033
 (yyval.str) = make_str("add");
33941
37034
;}
33942
37035
    break;
33943
37036
 
33944
37037
  case 1605:
 
37038
 
 
37039
/* Line 1455 of yacc.c  */
33945
37040
#line 9328 "preproc.y"
33946
37041
    { 
33947
 
 yyval.str = make_str("admin");
 
37042
 (yyval.str) = make_str("admin");
33948
37043
;}
33949
37044
    break;
33950
37045
 
33951
37046
  case 1606:
 
37047
 
 
37048
/* Line 1455 of yacc.c  */
33952
37049
#line 9332 "preproc.y"
33953
37050
    { 
33954
 
 yyval.str = make_str("after");
 
37051
 (yyval.str) = make_str("after");
33955
37052
;}
33956
37053
    break;
33957
37054
 
33958
37055
  case 1607:
 
37056
 
 
37057
/* Line 1455 of yacc.c  */
33959
37058
#line 9336 "preproc.y"
33960
37059
    { 
33961
 
 yyval.str = make_str("aggregate");
 
37060
 (yyval.str) = make_str("aggregate");
33962
37061
;}
33963
37062
    break;
33964
37063
 
33965
37064
  case 1608:
 
37065
 
 
37066
/* Line 1455 of yacc.c  */
33966
37067
#line 9340 "preproc.y"
33967
37068
    { 
33968
 
 yyval.str = make_str("also");
 
37069
 (yyval.str) = make_str("also");
33969
37070
;}
33970
37071
    break;
33971
37072
 
33972
37073
  case 1609:
 
37074
 
 
37075
/* Line 1455 of yacc.c  */
33973
37076
#line 9344 "preproc.y"
33974
37077
    { 
33975
 
 yyval.str = make_str("alter");
 
37078
 (yyval.str) = make_str("alter");
33976
37079
;}
33977
37080
    break;
33978
37081
 
33979
37082
  case 1610:
 
37083
 
 
37084
/* Line 1455 of yacc.c  */
33980
37085
#line 9348 "preproc.y"
33981
37086
    { 
33982
 
 yyval.str = make_str("always");
 
37087
 (yyval.str) = make_str("always");
33983
37088
;}
33984
37089
    break;
33985
37090
 
33986
37091
  case 1611:
 
37092
 
 
37093
/* Line 1455 of yacc.c  */
33987
37094
#line 9352 "preproc.y"
33988
37095
    { 
33989
 
 yyval.str = make_str("assertion");
 
37096
 (yyval.str) = make_str("assertion");
33990
37097
;}
33991
37098
    break;
33992
37099
 
33993
37100
  case 1612:
 
37101
 
 
37102
/* Line 1455 of yacc.c  */
33994
37103
#line 9356 "preproc.y"
33995
37104
    { 
33996
 
 yyval.str = make_str("assignment");
 
37105
 (yyval.str) = make_str("assignment");
33997
37106
;}
33998
37107
    break;
33999
37108
 
34000
37109
  case 1613:
 
37110
 
 
37111
/* Line 1455 of yacc.c  */
34001
37112
#line 9360 "preproc.y"
34002
37113
    { 
34003
 
 yyval.str = make_str("at");
 
37114
 (yyval.str) = make_str("at");
34004
37115
;}
34005
37116
    break;
34006
37117
 
34007
37118
  case 1614:
 
37119
 
 
37120
/* Line 1455 of yacc.c  */
34008
37121
#line 9364 "preproc.y"
34009
37122
    { 
34010
 
 yyval.str = make_str("backward");
 
37123
 (yyval.str) = make_str("backward");
34011
37124
;}
34012
37125
    break;
34013
37126
 
34014
37127
  case 1615:
 
37128
 
 
37129
/* Line 1455 of yacc.c  */
34015
37130
#line 9368 "preproc.y"
34016
37131
    { 
34017
 
 yyval.str = make_str("before");
 
37132
 (yyval.str) = make_str("before");
34018
37133
;}
34019
37134
    break;
34020
37135
 
34021
37136
  case 1616:
 
37137
 
 
37138
/* Line 1455 of yacc.c  */
34022
37139
#line 9372 "preproc.y"
34023
37140
    { 
34024
 
 yyval.str = make_str("begin");
 
37141
 (yyval.str) = make_str("begin");
34025
37142
;}
34026
37143
    break;
34027
37144
 
34028
37145
  case 1617:
 
37146
 
 
37147
/* Line 1455 of yacc.c  */
34029
37148
#line 9376 "preproc.y"
34030
37149
    { 
34031
 
 yyval.str = make_str("by");
 
37150
 (yyval.str) = make_str("by");
34032
37151
;}
34033
37152
    break;
34034
37153
 
34035
37154
  case 1618:
 
37155
 
 
37156
/* Line 1455 of yacc.c  */
34036
37157
#line 9380 "preproc.y"
34037
37158
    { 
34038
 
 yyval.str = make_str("cache");
 
37159
 (yyval.str) = make_str("cache");
34039
37160
;}
34040
37161
    break;
34041
37162
 
34042
37163
  case 1619:
 
37164
 
 
37165
/* Line 1455 of yacc.c  */
34043
37166
#line 9384 "preproc.y"
34044
37167
    { 
34045
 
 yyval.str = make_str("called");
 
37168
 (yyval.str) = make_str("called");
34046
37169
;}
34047
37170
    break;
34048
37171
 
34049
37172
  case 1620:
 
37173
 
 
37174
/* Line 1455 of yacc.c  */
34050
37175
#line 9388 "preproc.y"
34051
37176
    { 
34052
 
 yyval.str = make_str("cascade");
 
37177
 (yyval.str) = make_str("cascade");
34053
37178
;}
34054
37179
    break;
34055
37180
 
34056
37181
  case 1621:
 
37182
 
 
37183
/* Line 1455 of yacc.c  */
34057
37184
#line 9392 "preproc.y"
34058
37185
    { 
34059
 
 yyval.str = make_str("cascaded");
 
37186
 (yyval.str) = make_str("cascaded");
34060
37187
;}
34061
37188
    break;
34062
37189
 
34063
37190
  case 1622:
 
37191
 
 
37192
/* Line 1455 of yacc.c  */
34064
37193
#line 9396 "preproc.y"
34065
37194
    { 
34066
 
 yyval.str = make_str("catalog");
 
37195
 (yyval.str) = make_str("catalog");
34067
37196
;}
34068
37197
    break;
34069
37198
 
34070
37199
  case 1623:
 
37200
 
 
37201
/* Line 1455 of yacc.c  */
34071
37202
#line 9400 "preproc.y"
34072
37203
    { 
34073
 
 yyval.str = make_str("chain");
 
37204
 (yyval.str) = make_str("chain");
34074
37205
;}
34075
37206
    break;
34076
37207
 
34077
37208
  case 1624:
 
37209
 
 
37210
/* Line 1455 of yacc.c  */
34078
37211
#line 9404 "preproc.y"
34079
37212
    { 
34080
 
 yyval.str = make_str("characteristics");
 
37213
 (yyval.str) = make_str("characteristics");
34081
37214
;}
34082
37215
    break;
34083
37216
 
34084
37217
  case 1625:
 
37218
 
 
37219
/* Line 1455 of yacc.c  */
34085
37220
#line 9408 "preproc.y"
34086
37221
    { 
34087
 
 yyval.str = make_str("checkpoint");
 
37222
 (yyval.str) = make_str("checkpoint");
34088
37223
;}
34089
37224
    break;
34090
37225
 
34091
37226
  case 1626:
 
37227
 
 
37228
/* Line 1455 of yacc.c  */
34092
37229
#line 9412 "preproc.y"
34093
37230
    { 
34094
 
 yyval.str = make_str("class");
 
37231
 (yyval.str) = make_str("class");
34095
37232
;}
34096
37233
    break;
34097
37234
 
34098
37235
  case 1627:
 
37236
 
 
37237
/* Line 1455 of yacc.c  */
34099
37238
#line 9416 "preproc.y"
34100
37239
    { 
34101
 
 yyval.str = make_str("close");
 
37240
 (yyval.str) = make_str("close");
34102
37241
;}
34103
37242
    break;
34104
37243
 
34105
37244
  case 1628:
 
37245
 
 
37246
/* Line 1455 of yacc.c  */
34106
37247
#line 9420 "preproc.y"
34107
37248
    { 
34108
 
 yyval.str = make_str("cluster");
 
37249
 (yyval.str) = make_str("cluster");
34109
37250
;}
34110
37251
    break;
34111
37252
 
34112
37253
  case 1629:
 
37254
 
 
37255
/* Line 1455 of yacc.c  */
34113
37256
#line 9424 "preproc.y"
34114
37257
    { 
34115
 
 yyval.str = make_str("comment");
 
37258
 (yyval.str) = make_str("comment");
34116
37259
;}
34117
37260
    break;
34118
37261
 
34119
37262
  case 1630:
 
37263
 
 
37264
/* Line 1455 of yacc.c  */
34120
37265
#line 9428 "preproc.y"
34121
37266
    { 
34122
 
 yyval.str = make_str("commit");
 
37267
 (yyval.str) = make_str("commit");
34123
37268
;}
34124
37269
    break;
34125
37270
 
34126
37271
  case 1631:
 
37272
 
 
37273
/* Line 1455 of yacc.c  */
34127
37274
#line 9432 "preproc.y"
34128
37275
    { 
34129
 
 yyval.str = make_str("committed");
 
37276
 (yyval.str) = make_str("committed");
34130
37277
;}
34131
37278
    break;
34132
37279
 
34133
37280
  case 1632:
 
37281
 
 
37282
/* Line 1455 of yacc.c  */
34134
37283
#line 9436 "preproc.y"
34135
37284
    { 
34136
 
 yyval.str = make_str("concurrently");
 
37285
 (yyval.str) = make_str("concurrently");
34137
37286
;}
34138
37287
    break;
34139
37288
 
34140
37289
  case 1633:
 
37290
 
 
37291
/* Line 1455 of yacc.c  */
34141
37292
#line 9440 "preproc.y"
34142
37293
    { 
34143
 
 yyval.str = make_str("configuration");
 
37294
 (yyval.str) = make_str("configuration");
34144
37295
;}
34145
37296
    break;
34146
37297
 
34147
37298
  case 1634:
 
37299
 
 
37300
/* Line 1455 of yacc.c  */
34148
37301
#line 9444 "preproc.y"
34149
37302
    { 
34150
 
 yyval.str = make_str("constraints");
 
37303
 (yyval.str) = make_str("constraints");
34151
37304
;}
34152
37305
    break;
34153
37306
 
34154
37307
  case 1635:
 
37308
 
 
37309
/* Line 1455 of yacc.c  */
34155
37310
#line 9448 "preproc.y"
34156
37311
    { 
34157
 
 yyval.str = make_str("content");
 
37312
 (yyval.str) = make_str("content");
34158
37313
;}
34159
37314
    break;
34160
37315
 
34161
37316
  case 1636:
 
37317
 
 
37318
/* Line 1455 of yacc.c  */
34162
37319
#line 9452 "preproc.y"
34163
37320
    { 
34164
 
 yyval.str = make_str("continue");
 
37321
 (yyval.str) = make_str("continue");
34165
37322
;}
34166
37323
    break;
34167
37324
 
34168
37325
  case 1637:
 
37326
 
 
37327
/* Line 1455 of yacc.c  */
34169
37328
#line 9456 "preproc.y"
34170
37329
    { 
34171
 
 yyval.str = make_str("conversion");
 
37330
 (yyval.str) = make_str("conversion");
34172
37331
;}
34173
37332
    break;
34174
37333
 
34175
37334
  case 1638:
 
37335
 
 
37336
/* Line 1455 of yacc.c  */
34176
37337
#line 9460 "preproc.y"
34177
37338
    { 
34178
 
 yyval.str = make_str("copy");
 
37339
 (yyval.str) = make_str("copy");
34179
37340
;}
34180
37341
    break;
34181
37342
 
34182
37343
  case 1639:
 
37344
 
 
37345
/* Line 1455 of yacc.c  */
34183
37346
#line 9464 "preproc.y"
34184
37347
    { 
34185
 
 yyval.str = make_str("cost");
 
37348
 (yyval.str) = make_str("cost");
34186
37349
;}
34187
37350
    break;
34188
37351
 
34189
37352
  case 1640:
 
37353
 
 
37354
/* Line 1455 of yacc.c  */
34190
37355
#line 9468 "preproc.y"
34191
37356
    { 
34192
 
 yyval.str = make_str("createdb");
 
37357
 (yyval.str) = make_str("createdb");
34193
37358
;}
34194
37359
    break;
34195
37360
 
34196
37361
  case 1641:
 
37362
 
 
37363
/* Line 1455 of yacc.c  */
34197
37364
#line 9472 "preproc.y"
34198
37365
    { 
34199
 
 yyval.str = make_str("createrole");
 
37366
 (yyval.str) = make_str("createrole");
34200
37367
;}
34201
37368
    break;
34202
37369
 
34203
37370
  case 1642:
 
37371
 
 
37372
/* Line 1455 of yacc.c  */
34204
37373
#line 9476 "preproc.y"
34205
37374
    { 
34206
 
 yyval.str = make_str("createuser");
 
37375
 (yyval.str) = make_str("createuser");
34207
37376
;}
34208
37377
    break;
34209
37378
 
34210
37379
  case 1643:
 
37380
 
 
37381
/* Line 1455 of yacc.c  */
34211
37382
#line 9480 "preproc.y"
34212
37383
    { 
34213
 
 yyval.str = make_str("csv");
 
37384
 (yyval.str) = make_str("csv");
34214
37385
;}
34215
37386
    break;
34216
37387
 
34217
37388
  case 1644:
 
37389
 
 
37390
/* Line 1455 of yacc.c  */
34218
37391
#line 9484 "preproc.y"
34219
37392
    { 
34220
 
 yyval.str = make_str("cursor");
 
37393
 (yyval.str) = make_str("cursor");
34221
37394
;}
34222
37395
    break;
34223
37396
 
34224
37397
  case 1645:
 
37398
 
 
37399
/* Line 1455 of yacc.c  */
34225
37400
#line 9488 "preproc.y"
34226
37401
    { 
34227
 
 yyval.str = make_str("cycle");
 
37402
 (yyval.str) = make_str("cycle");
34228
37403
;}
34229
37404
    break;
34230
37405
 
34231
37406
  case 1646:
 
37407
 
 
37408
/* Line 1455 of yacc.c  */
34232
37409
#line 9492 "preproc.y"
34233
37410
    { 
34234
 
 yyval.str = make_str("data");
 
37411
 (yyval.str) = make_str("data");
34235
37412
;}
34236
37413
    break;
34237
37414
 
34238
37415
  case 1647:
 
37416
 
 
37417
/* Line 1455 of yacc.c  */
34239
37418
#line 9496 "preproc.y"
34240
37419
    { 
34241
 
 yyval.str = make_str("database");
 
37420
 (yyval.str) = make_str("database");
34242
37421
;}
34243
37422
    break;
34244
37423
 
34245
37424
  case 1648:
 
37425
 
 
37426
/* Line 1455 of yacc.c  */
34246
37427
#line 9500 "preproc.y"
34247
37428
    { 
34248
 
 yyval.str = make_str("deallocate");
 
37429
 (yyval.str) = make_str("deallocate");
34249
37430
;}
34250
37431
    break;
34251
37432
 
34252
37433
  case 1649:
 
37434
 
 
37435
/* Line 1455 of yacc.c  */
34253
37436
#line 9504 "preproc.y"
34254
37437
    { 
34255
 
 yyval.str = make_str("declare");
 
37438
 (yyval.str) = make_str("declare");
34256
37439
;}
34257
37440
    break;
34258
37441
 
34259
37442
  case 1650:
 
37443
 
 
37444
/* Line 1455 of yacc.c  */
34260
37445
#line 9508 "preproc.y"
34261
37446
    { 
34262
 
 yyval.str = make_str("defaults");
 
37447
 (yyval.str) = make_str("defaults");
34263
37448
;}
34264
37449
    break;
34265
37450
 
34266
37451
  case 1651:
 
37452
 
 
37453
/* Line 1455 of yacc.c  */
34267
37454
#line 9512 "preproc.y"
34268
37455
    { 
34269
 
 yyval.str = make_str("deferred");
 
37456
 (yyval.str) = make_str("deferred");
34270
37457
;}
34271
37458
    break;
34272
37459
 
34273
37460
  case 1652:
 
37461
 
 
37462
/* Line 1455 of yacc.c  */
34274
37463
#line 9516 "preproc.y"
34275
37464
    { 
34276
 
 yyval.str = make_str("definer");
 
37465
 (yyval.str) = make_str("definer");
34277
37466
;}
34278
37467
    break;
34279
37468
 
34280
37469
  case 1653:
 
37470
 
 
37471
/* Line 1455 of yacc.c  */
34281
37472
#line 9520 "preproc.y"
34282
37473
    { 
34283
 
 yyval.str = make_str("delete");
 
37474
 (yyval.str) = make_str("delete");
34284
37475
;}
34285
37476
    break;
34286
37477
 
34287
37478
  case 1654:
 
37479
 
 
37480
/* Line 1455 of yacc.c  */
34288
37481
#line 9524 "preproc.y"
34289
37482
    { 
34290
 
 yyval.str = make_str("delimiter");
 
37483
 (yyval.str) = make_str("delimiter");
34291
37484
;}
34292
37485
    break;
34293
37486
 
34294
37487
  case 1655:
 
37488
 
 
37489
/* Line 1455 of yacc.c  */
34295
37490
#line 9528 "preproc.y"
34296
37491
    { 
34297
 
 yyval.str = make_str("delimiters");
 
37492
 (yyval.str) = make_str("delimiters");
34298
37493
;}
34299
37494
    break;
34300
37495
 
34301
37496
  case 1656:
 
37497
 
 
37498
/* Line 1455 of yacc.c  */
34302
37499
#line 9532 "preproc.y"
34303
37500
    { 
34304
 
 yyval.str = make_str("dictionary");
 
37501
 (yyval.str) = make_str("dictionary");
34305
37502
;}
34306
37503
    break;
34307
37504
 
34308
37505
  case 1657:
 
37506
 
 
37507
/* Line 1455 of yacc.c  */
34309
37508
#line 9536 "preproc.y"
34310
37509
    { 
34311
 
 yyval.str = make_str("disable");
 
37510
 (yyval.str) = make_str("disable");
34312
37511
;}
34313
37512
    break;
34314
37513
 
34315
37514
  case 1658:
 
37515
 
 
37516
/* Line 1455 of yacc.c  */
34316
37517
#line 9540 "preproc.y"
34317
37518
    { 
34318
 
 yyval.str = make_str("discard");
 
37519
 (yyval.str) = make_str("discard");
34319
37520
;}
34320
37521
    break;
34321
37522
 
34322
37523
  case 1659:
 
37524
 
 
37525
/* Line 1455 of yacc.c  */
34323
37526
#line 9544 "preproc.y"
34324
37527
    { 
34325
 
 yyval.str = make_str("document");
 
37528
 (yyval.str) = make_str("document");
34326
37529
;}
34327
37530
    break;
34328
37531
 
34329
37532
  case 1660:
 
37533
 
 
37534
/* Line 1455 of yacc.c  */
34330
37535
#line 9548 "preproc.y"
34331
37536
    { 
34332
 
 yyval.str = make_str("domain");
 
37537
 (yyval.str) = make_str("domain");
34333
37538
;}
34334
37539
    break;
34335
37540
 
34336
37541
  case 1661:
 
37542
 
 
37543
/* Line 1455 of yacc.c  */
34337
37544
#line 9552 "preproc.y"
34338
37545
    { 
34339
 
 yyval.str = make_str("double");
 
37546
 (yyval.str) = make_str("double");
34340
37547
;}
34341
37548
    break;
34342
37549
 
34343
37550
  case 1662:
 
37551
 
 
37552
/* Line 1455 of yacc.c  */
34344
37553
#line 9556 "preproc.y"
34345
37554
    { 
34346
 
 yyval.str = make_str("drop");
 
37555
 (yyval.str) = make_str("drop");
34347
37556
;}
34348
37557
    break;
34349
37558
 
34350
37559
  case 1663:
 
37560
 
 
37561
/* Line 1455 of yacc.c  */
34351
37562
#line 9560 "preproc.y"
34352
37563
    { 
34353
 
 yyval.str = make_str("each");
 
37564
 (yyval.str) = make_str("each");
34354
37565
;}
34355
37566
    break;
34356
37567
 
34357
37568
  case 1664:
 
37569
 
 
37570
/* Line 1455 of yacc.c  */
34358
37571
#line 9564 "preproc.y"
34359
37572
    { 
34360
 
 yyval.str = make_str("enable");
 
37573
 (yyval.str) = make_str("enable");
34361
37574
;}
34362
37575
    break;
34363
37576
 
34364
37577
  case 1665:
 
37578
 
 
37579
/* Line 1455 of yacc.c  */
34365
37580
#line 9568 "preproc.y"
34366
37581
    { 
34367
 
 yyval.str = make_str("encoding");
 
37582
 (yyval.str) = make_str("encoding");
34368
37583
;}
34369
37584
    break;
34370
37585
 
34371
37586
  case 1666:
 
37587
 
 
37588
/* Line 1455 of yacc.c  */
34372
37589
#line 9572 "preproc.y"
34373
37590
    { 
34374
 
 yyval.str = make_str("encrypted");
 
37591
 (yyval.str) = make_str("encrypted");
34375
37592
;}
34376
37593
    break;
34377
37594
 
34378
37595
  case 1667:
 
37596
 
 
37597
/* Line 1455 of yacc.c  */
34379
37598
#line 9576 "preproc.y"
34380
37599
    { 
34381
 
 yyval.str = make_str("enum");
 
37600
 (yyval.str) = make_str("enum");
34382
37601
;}
34383
37602
    break;
34384
37603
 
34385
37604
  case 1668:
 
37605
 
 
37606
/* Line 1455 of yacc.c  */
34386
37607
#line 9580 "preproc.y"
34387
37608
    { 
34388
 
 yyval.str = make_str("escape");
 
37609
 (yyval.str) = make_str("escape");
34389
37610
;}
34390
37611
    break;
34391
37612
 
34392
37613
  case 1669:
 
37614
 
 
37615
/* Line 1455 of yacc.c  */
34393
37616
#line 9584 "preproc.y"
34394
37617
    { 
34395
 
 yyval.str = make_str("excluding");
 
37618
 (yyval.str) = make_str("excluding");
34396
37619
;}
34397
37620
    break;
34398
37621
 
34399
37622
  case 1670:
 
37623
 
 
37624
/* Line 1455 of yacc.c  */
34400
37625
#line 9588 "preproc.y"
34401
37626
    { 
34402
 
 yyval.str = make_str("exclusive");
 
37627
 (yyval.str) = make_str("exclusive");
34403
37628
;}
34404
37629
    break;
34405
37630
 
34406
37631
  case 1671:
 
37632
 
 
37633
/* Line 1455 of yacc.c  */
34407
37634
#line 9592 "preproc.y"
34408
37635
    { 
34409
 
 yyval.str = make_str("execute");
 
37636
 (yyval.str) = make_str("execute");
34410
37637
;}
34411
37638
    break;
34412
37639
 
34413
37640
  case 1672:
 
37641
 
 
37642
/* Line 1455 of yacc.c  */
34414
37643
#line 9596 "preproc.y"
34415
37644
    { 
34416
 
 yyval.str = make_str("explain");
 
37645
 (yyval.str) = make_str("explain");
34417
37646
;}
34418
37647
    break;
34419
37648
 
34420
37649
  case 1673:
 
37650
 
 
37651
/* Line 1455 of yacc.c  */
34421
37652
#line 9600 "preproc.y"
34422
37653
    { 
34423
 
 yyval.str = make_str("external");
 
37654
 (yyval.str) = make_str("external");
34424
37655
;}
34425
37656
    break;
34426
37657
 
34427
37658
  case 1674:
 
37659
 
 
37660
/* Line 1455 of yacc.c  */
34428
37661
#line 9604 "preproc.y"
34429
37662
    { 
34430
 
 yyval.str = make_str("family");
 
37663
 (yyval.str) = make_str("family");
34431
37664
;}
34432
37665
    break;
34433
37666
 
34434
37667
  case 1675:
 
37668
 
 
37669
/* Line 1455 of yacc.c  */
34435
37670
#line 9608 "preproc.y"
34436
37671
    { 
34437
 
 yyval.str = make_str("first");
 
37672
 (yyval.str) = make_str("first");
34438
37673
;}
34439
37674
    break;
34440
37675
 
34441
37676
  case 1676:
 
37677
 
 
37678
/* Line 1455 of yacc.c  */
34442
37679
#line 9612 "preproc.y"
34443
37680
    { 
34444
 
 yyval.str = make_str("following");
 
37681
 (yyval.str) = make_str("following");
34445
37682
;}
34446
37683
    break;
34447
37684
 
34448
37685
  case 1677:
 
37686
 
 
37687
/* Line 1455 of yacc.c  */
34449
37688
#line 9616 "preproc.y"
34450
37689
    { 
34451
 
 yyval.str = make_str("force");
 
37690
 (yyval.str) = make_str("force");
34452
37691
;}
34453
37692
    break;
34454
37693
 
34455
37694
  case 1678:
 
37695
 
 
37696
/* Line 1455 of yacc.c  */
34456
37697
#line 9620 "preproc.y"
34457
37698
    { 
34458
 
 yyval.str = make_str("forward");
 
37699
 (yyval.str) = make_str("forward");
34459
37700
;}
34460
37701
    break;
34461
37702
 
34462
37703
  case 1679:
 
37704
 
 
37705
/* Line 1455 of yacc.c  */
34463
37706
#line 9624 "preproc.y"
34464
37707
    { 
34465
 
 yyval.str = make_str("function");
 
37708
 (yyval.str) = make_str("function");
34466
37709
;}
34467
37710
    break;
34468
37711
 
34469
37712
  case 1680:
 
37713
 
 
37714
/* Line 1455 of yacc.c  */
34470
37715
#line 9628 "preproc.y"
34471
37716
    { 
34472
 
 yyval.str = make_str("global");
 
37717
 (yyval.str) = make_str("global");
34473
37718
;}
34474
37719
    break;
34475
37720
 
34476
37721
  case 1681:
 
37722
 
 
37723
/* Line 1455 of yacc.c  */
34477
37724
#line 9632 "preproc.y"
34478
37725
    { 
34479
 
 yyval.str = make_str("granted");
 
37726
 (yyval.str) = make_str("granted");
34480
37727
;}
34481
37728
    break;
34482
37729
 
34483
37730
  case 1682:
 
37731
 
 
37732
/* Line 1455 of yacc.c  */
34484
37733
#line 9636 "preproc.y"
34485
37734
    { 
34486
 
 yyval.str = make_str("handler");
 
37735
 (yyval.str) = make_str("handler");
34487
37736
;}
34488
37737
    break;
34489
37738
 
34490
37739
  case 1683:
 
37740
 
 
37741
/* Line 1455 of yacc.c  */
34491
37742
#line 9640 "preproc.y"
34492
37743
    { 
34493
 
 yyval.str = make_str("header");
 
37744
 (yyval.str) = make_str("header");
34494
37745
;}
34495
37746
    break;
34496
37747
 
34497
37748
  case 1684:
 
37749
 
 
37750
/* Line 1455 of yacc.c  */
34498
37751
#line 9644 "preproc.y"
34499
37752
    { 
34500
 
 yyval.str = make_str("hold");
 
37753
 (yyval.str) = make_str("hold");
34501
37754
;}
34502
37755
    break;
34503
37756
 
34504
37757
  case 1685:
 
37758
 
 
37759
/* Line 1455 of yacc.c  */
34505
37760
#line 9648 "preproc.y"
34506
37761
    { 
34507
 
 yyval.str = make_str("identity");
 
37762
 (yyval.str) = make_str("identity");
34508
37763
;}
34509
37764
    break;
34510
37765
 
34511
37766
  case 1686:
 
37767
 
 
37768
/* Line 1455 of yacc.c  */
34512
37769
#line 9652 "preproc.y"
34513
37770
    { 
34514
 
 yyval.str = make_str("if");
 
37771
 (yyval.str) = make_str("if");
34515
37772
;}
34516
37773
    break;
34517
37774
 
34518
37775
  case 1687:
 
37776
 
 
37777
/* Line 1455 of yacc.c  */
34519
37778
#line 9656 "preproc.y"
34520
37779
    { 
34521
 
 yyval.str = make_str("immediate");
 
37780
 (yyval.str) = make_str("immediate");
34522
37781
;}
34523
37782
    break;
34524
37783
 
34525
37784
  case 1688:
 
37785
 
 
37786
/* Line 1455 of yacc.c  */
34526
37787
#line 9660 "preproc.y"
34527
37788
    { 
34528
 
 yyval.str = make_str("immutable");
 
37789
 (yyval.str) = make_str("immutable");
34529
37790
;}
34530
37791
    break;
34531
37792
 
34532
37793
  case 1689:
 
37794
 
 
37795
/* Line 1455 of yacc.c  */
34533
37796
#line 9664 "preproc.y"
34534
37797
    { 
34535
 
 yyval.str = make_str("implicit");
 
37798
 (yyval.str) = make_str("implicit");
34536
37799
;}
34537
37800
    break;
34538
37801
 
34539
37802
  case 1690:
 
37803
 
 
37804
/* Line 1455 of yacc.c  */
34540
37805
#line 9668 "preproc.y"
34541
37806
    { 
34542
 
 yyval.str = make_str("including");
 
37807
 (yyval.str) = make_str("including");
34543
37808
;}
34544
37809
    break;
34545
37810
 
34546
37811
  case 1691:
 
37812
 
 
37813
/* Line 1455 of yacc.c  */
34547
37814
#line 9672 "preproc.y"
34548
37815
    { 
34549
 
 yyval.str = make_str("increment");
 
37816
 (yyval.str) = make_str("increment");
34550
37817
;}
34551
37818
    break;
34552
37819
 
34553
37820
  case 1692:
 
37821
 
 
37822
/* Line 1455 of yacc.c  */
34554
37823
#line 9676 "preproc.y"
34555
37824
    { 
34556
 
 yyval.str = make_str("index");
 
37825
 (yyval.str) = make_str("index");
34557
37826
;}
34558
37827
    break;
34559
37828
 
34560
37829
  case 1693:
 
37830
 
 
37831
/* Line 1455 of yacc.c  */
34561
37832
#line 9680 "preproc.y"
34562
37833
    { 
34563
 
 yyval.str = make_str("indexes");
 
37834
 (yyval.str) = make_str("indexes");
34564
37835
;}
34565
37836
    break;
34566
37837
 
34567
37838
  case 1694:
 
37839
 
 
37840
/* Line 1455 of yacc.c  */
34568
37841
#line 9684 "preproc.y"
34569
37842
    { 
34570
 
 yyval.str = make_str("inherit");
 
37843
 (yyval.str) = make_str("inherit");
34571
37844
;}
34572
37845
    break;
34573
37846
 
34574
37847
  case 1695:
 
37848
 
 
37849
/* Line 1455 of yacc.c  */
34575
37850
#line 9688 "preproc.y"
34576
37851
    { 
34577
 
 yyval.str = make_str("inherits");
 
37852
 (yyval.str) = make_str("inherits");
34578
37853
;}
34579
37854
    break;
34580
37855
 
34581
37856
  case 1696:
 
37857
 
 
37858
/* Line 1455 of yacc.c  */
34582
37859
#line 9692 "preproc.y"
34583
37860
    { 
34584
 
 yyval.str = make_str("insensitive");
 
37861
 (yyval.str) = make_str("insensitive");
34585
37862
;}
34586
37863
    break;
34587
37864
 
34588
37865
  case 1697:
 
37866
 
 
37867
/* Line 1455 of yacc.c  */
34589
37868
#line 9696 "preproc.y"
34590
37869
    { 
34591
 
 yyval.str = make_str("insert");
 
37870
 (yyval.str) = make_str("insert");
34592
37871
;}
34593
37872
    break;
34594
37873
 
34595
37874
  case 1698:
 
37875
 
 
37876
/* Line 1455 of yacc.c  */
34596
37877
#line 9700 "preproc.y"
34597
37878
    { 
34598
 
 yyval.str = make_str("instead");
 
37879
 (yyval.str) = make_str("instead");
34599
37880
;}
34600
37881
    break;
34601
37882
 
34602
37883
  case 1699:
 
37884
 
 
37885
/* Line 1455 of yacc.c  */
34603
37886
#line 9704 "preproc.y"
34604
37887
    { 
34605
 
 yyval.str = make_str("invoker");
 
37888
 (yyval.str) = make_str("invoker");
34606
37889
;}
34607
37890
    break;
34608
37891
 
34609
37892
  case 1700:
 
37893
 
 
37894
/* Line 1455 of yacc.c  */
34610
37895
#line 9708 "preproc.y"
34611
37896
    { 
34612
 
 yyval.str = make_str("isolation");
 
37897
 (yyval.str) = make_str("isolation");
34613
37898
;}
34614
37899
    break;
34615
37900
 
34616
37901
  case 1701:
 
37902
 
 
37903
/* Line 1455 of yacc.c  */
34617
37904
#line 9712 "preproc.y"
34618
37905
    { 
34619
 
 yyval.str = make_str("key");
 
37906
 (yyval.str) = make_str("key");
34620
37907
;}
34621
37908
    break;
34622
37909
 
34623
37910
  case 1702:
 
37911
 
 
37912
/* Line 1455 of yacc.c  */
34624
37913
#line 9716 "preproc.y"
34625
37914
    { 
34626
 
 yyval.str = make_str("lancompiler");
 
37915
 (yyval.str) = make_str("lancompiler");
34627
37916
;}
34628
37917
    break;
34629
37918
 
34630
37919
  case 1703:
 
37920
 
 
37921
/* Line 1455 of yacc.c  */
34631
37922
#line 9720 "preproc.y"
34632
37923
    { 
34633
 
 yyval.str = make_str("language");
 
37924
 (yyval.str) = make_str("language");
34634
37925
;}
34635
37926
    break;
34636
37927
 
34637
37928
  case 1704:
 
37929
 
 
37930
/* Line 1455 of yacc.c  */
34638
37931
#line 9724 "preproc.y"
34639
37932
    { 
34640
 
 yyval.str = make_str("large");
 
37933
 (yyval.str) = make_str("large");
34641
37934
;}
34642
37935
    break;
34643
37936
 
34644
37937
  case 1705:
 
37938
 
 
37939
/* Line 1455 of yacc.c  */
34645
37940
#line 9728 "preproc.y"
34646
37941
    { 
34647
 
 yyval.str = make_str("last");
 
37942
 (yyval.str) = make_str("last");
34648
37943
;}
34649
37944
    break;
34650
37945
 
34651
37946
  case 1706:
 
37947
 
 
37948
/* Line 1455 of yacc.c  */
34652
37949
#line 9732 "preproc.y"
34653
37950
    { 
34654
 
 yyval.str = make_str("lc_collate");
 
37951
 (yyval.str) = make_str("lc_collate");
34655
37952
;}
34656
37953
    break;
34657
37954
 
34658
37955
  case 1707:
 
37956
 
 
37957
/* Line 1455 of yacc.c  */
34659
37958
#line 9736 "preproc.y"
34660
37959
    { 
34661
 
 yyval.str = make_str("lc_ctype");
 
37960
 (yyval.str) = make_str("lc_ctype");
34662
37961
;}
34663
37962
    break;
34664
37963
 
34665
37964
  case 1708:
 
37965
 
 
37966
/* Line 1455 of yacc.c  */
34666
37967
#line 9740 "preproc.y"
34667
37968
    { 
34668
 
 yyval.str = make_str("level");
 
37969
 (yyval.str) = make_str("level");
34669
37970
;}
34670
37971
    break;
34671
37972
 
34672
37973
  case 1709:
 
37974
 
 
37975
/* Line 1455 of yacc.c  */
34673
37976
#line 9744 "preproc.y"
34674
37977
    { 
34675
 
 yyval.str = make_str("listen");
 
37978
 (yyval.str) = make_str("listen");
34676
37979
;}
34677
37980
    break;
34678
37981
 
34679
37982
  case 1710:
 
37983
 
 
37984
/* Line 1455 of yacc.c  */
34680
37985
#line 9748 "preproc.y"
34681
37986
    { 
34682
 
 yyval.str = make_str("load");
 
37987
 (yyval.str) = make_str("load");
34683
37988
;}
34684
37989
    break;
34685
37990
 
34686
37991
  case 1711:
 
37992
 
 
37993
/* Line 1455 of yacc.c  */
34687
37994
#line 9752 "preproc.y"
34688
37995
    { 
34689
 
 yyval.str = make_str("local");
 
37996
 (yyval.str) = make_str("local");
34690
37997
;}
34691
37998
    break;
34692
37999
 
34693
38000
  case 1712:
 
38001
 
 
38002
/* Line 1455 of yacc.c  */
34694
38003
#line 9756 "preproc.y"
34695
38004
    { 
34696
 
 yyval.str = make_str("location");
 
38005
 (yyval.str) = make_str("location");
34697
38006
;}
34698
38007
    break;
34699
38008
 
34700
38009
  case 1713:
 
38010
 
 
38011
/* Line 1455 of yacc.c  */
34701
38012
#line 9760 "preproc.y"
34702
38013
    { 
34703
 
 yyval.str = make_str("lock");
 
38014
 (yyval.str) = make_str("lock");
34704
38015
;}
34705
38016
    break;
34706
38017
 
34707
38018
  case 1714:
 
38019
 
 
38020
/* Line 1455 of yacc.c  */
34708
38021
#line 9764 "preproc.y"
34709
38022
    { 
34710
 
 yyval.str = make_str("login");
 
38023
 (yyval.str) = make_str("login");
34711
38024
;}
34712
38025
    break;
34713
38026
 
34714
38027
  case 1715:
 
38028
 
 
38029
/* Line 1455 of yacc.c  */
34715
38030
#line 9768 "preproc.y"
34716
38031
    { 
34717
 
 yyval.str = make_str("mapping");
 
38032
 (yyval.str) = make_str("mapping");
34718
38033
;}
34719
38034
    break;
34720
38035
 
34721
38036
  case 1716:
 
38037
 
 
38038
/* Line 1455 of yacc.c  */
34722
38039
#line 9772 "preproc.y"
34723
38040
    { 
34724
 
 yyval.str = make_str("match");
 
38041
 (yyval.str) = make_str("match");
34725
38042
;}
34726
38043
    break;
34727
38044
 
34728
38045
  case 1717:
 
38046
 
 
38047
/* Line 1455 of yacc.c  */
34729
38048
#line 9776 "preproc.y"
34730
38049
    { 
34731
 
 yyval.str = make_str("maxvalue");
 
38050
 (yyval.str) = make_str("maxvalue");
34732
38051
;}
34733
38052
    break;
34734
38053
 
34735
38054
  case 1718:
 
38055
 
 
38056
/* Line 1455 of yacc.c  */
34736
38057
#line 9780 "preproc.y"
34737
38058
    { 
34738
 
 yyval.str = make_str("minvalue");
 
38059
 (yyval.str) = make_str("minvalue");
34739
38060
;}
34740
38061
    break;
34741
38062
 
34742
38063
  case 1719:
 
38064
 
 
38065
/* Line 1455 of yacc.c  */
34743
38066
#line 9784 "preproc.y"
34744
38067
    { 
34745
 
 yyval.str = make_str("mode");
 
38068
 (yyval.str) = make_str("mode");
34746
38069
;}
34747
38070
    break;
34748
38071
 
34749
38072
  case 1720:
 
38073
 
 
38074
/* Line 1455 of yacc.c  */
34750
38075
#line 9788 "preproc.y"
34751
38076
    { 
34752
 
 yyval.str = make_str("move");
 
38077
 (yyval.str) = make_str("move");
34753
38078
;}
34754
38079
    break;
34755
38080
 
34756
38081
  case 1721:
 
38082
 
 
38083
/* Line 1455 of yacc.c  */
34757
38084
#line 9792 "preproc.y"
34758
38085
    { 
34759
 
 yyval.str = make_str("name");
 
38086
 (yyval.str) = make_str("name");
34760
38087
;}
34761
38088
    break;
34762
38089
 
34763
38090
  case 1722:
 
38091
 
 
38092
/* Line 1455 of yacc.c  */
34764
38093
#line 9796 "preproc.y"
34765
38094
    { 
34766
 
 yyval.str = make_str("names");
 
38095
 (yyval.str) = make_str("names");
34767
38096
;}
34768
38097
    break;
34769
38098
 
34770
38099
  case 1723:
 
38100
 
 
38101
/* Line 1455 of yacc.c  */
34771
38102
#line 9800 "preproc.y"
34772
38103
    { 
34773
 
 yyval.str = make_str("next");
 
38104
 (yyval.str) = make_str("next");
34774
38105
;}
34775
38106
    break;
34776
38107
 
34777
38108
  case 1724:
 
38109
 
 
38110
/* Line 1455 of yacc.c  */
34778
38111
#line 9804 "preproc.y"
34779
38112
    { 
34780
 
 yyval.str = make_str("no");
 
38113
 (yyval.str) = make_str("no");
34781
38114
;}
34782
38115
    break;
34783
38116
 
34784
38117
  case 1725:
 
38118
 
 
38119
/* Line 1455 of yacc.c  */
34785
38120
#line 9808 "preproc.y"
34786
38121
    { 
34787
 
 yyval.str = make_str("nocreatedb");
 
38122
 (yyval.str) = make_str("nocreatedb");
34788
38123
;}
34789
38124
    break;
34790
38125
 
34791
38126
  case 1726:
 
38127
 
 
38128
/* Line 1455 of yacc.c  */
34792
38129
#line 9812 "preproc.y"
34793
38130
    { 
34794
 
 yyval.str = make_str("nocreaterole");
 
38131
 (yyval.str) = make_str("nocreaterole");
34795
38132
;}
34796
38133
    break;
34797
38134
 
34798
38135
  case 1727:
 
38136
 
 
38137
/* Line 1455 of yacc.c  */
34799
38138
#line 9816 "preproc.y"
34800
38139
    { 
34801
 
 yyval.str = make_str("nocreateuser");
 
38140
 (yyval.str) = make_str("nocreateuser");
34802
38141
;}
34803
38142
    break;
34804
38143
 
34805
38144
  case 1728:
 
38145
 
 
38146
/* Line 1455 of yacc.c  */
34806
38147
#line 9820 "preproc.y"
34807
38148
    { 
34808
 
 yyval.str = make_str("noinherit");
 
38149
 (yyval.str) = make_str("noinherit");
34809
38150
;}
34810
38151
    break;
34811
38152
 
34812
38153
  case 1729:
 
38154
 
 
38155
/* Line 1455 of yacc.c  */
34813
38156
#line 9824 "preproc.y"
34814
38157
    { 
34815
 
 yyval.str = make_str("nologin");
 
38158
 (yyval.str) = make_str("nologin");
34816
38159
;}
34817
38160
    break;
34818
38161
 
34819
38162
  case 1730:
 
38163
 
 
38164
/* Line 1455 of yacc.c  */
34820
38165
#line 9828 "preproc.y"
34821
38166
    { 
34822
 
 yyval.str = make_str("nosuperuser");
 
38167
 (yyval.str) = make_str("nosuperuser");
34823
38168
;}
34824
38169
    break;
34825
38170
 
34826
38171
  case 1731:
 
38172
 
 
38173
/* Line 1455 of yacc.c  */
34827
38174
#line 9832 "preproc.y"
34828
38175
    { 
34829
 
 yyval.str = make_str("nothing");
 
38176
 (yyval.str) = make_str("nothing");
34830
38177
;}
34831
38178
    break;
34832
38179
 
34833
38180
  case 1732:
 
38181
 
 
38182
/* Line 1455 of yacc.c  */
34834
38183
#line 9836 "preproc.y"
34835
38184
    { 
34836
 
 yyval.str = make_str("notify");
 
38185
 (yyval.str) = make_str("notify");
34837
38186
;}
34838
38187
    break;
34839
38188
 
34840
38189
  case 1733:
 
38190
 
 
38191
/* Line 1455 of yacc.c  */
34841
38192
#line 9840 "preproc.y"
34842
38193
    { 
34843
 
 yyval.str = make_str("nowait");
 
38194
 (yyval.str) = make_str("nowait");
34844
38195
;}
34845
38196
    break;
34846
38197
 
34847
38198
  case 1734:
 
38199
 
 
38200
/* Line 1455 of yacc.c  */
34848
38201
#line 9844 "preproc.y"
34849
38202
    { 
34850
 
 yyval.str = make_str("nulls");
 
38203
 (yyval.str) = make_str("nulls");
34851
38204
;}
34852
38205
    break;
34853
38206
 
34854
38207
  case 1735:
 
38208
 
 
38209
/* Line 1455 of yacc.c  */
34855
38210
#line 9848 "preproc.y"
34856
38211
    { 
34857
 
 yyval.str = make_str("object");
 
38212
 (yyval.str) = make_str("object");
34858
38213
;}
34859
38214
    break;
34860
38215
 
34861
38216
  case 1736:
 
38217
 
 
38218
/* Line 1455 of yacc.c  */
34862
38219
#line 9852 "preproc.y"
34863
38220
    { 
34864
 
 yyval.str = make_str("of");
 
38221
 (yyval.str) = make_str("of");
34865
38222
;}
34866
38223
    break;
34867
38224
 
34868
38225
  case 1737:
 
38226
 
 
38227
/* Line 1455 of yacc.c  */
34869
38228
#line 9856 "preproc.y"
34870
38229
    { 
34871
 
 yyval.str = make_str("oids");
 
38230
 (yyval.str) = make_str("oids");
34872
38231
;}
34873
38232
    break;
34874
38233
 
34875
38234
  case 1738:
 
38235
 
 
38236
/* Line 1455 of yacc.c  */
34876
38237
#line 9860 "preproc.y"
34877
38238
    { 
34878
 
 yyval.str = make_str("operator");
 
38239
 (yyval.str) = make_str("operator");
34879
38240
;}
34880
38241
    break;
34881
38242
 
34882
38243
  case 1739:
 
38244
 
 
38245
/* Line 1455 of yacc.c  */
34883
38246
#line 9864 "preproc.y"
34884
38247
    { 
34885
 
 yyval.str = make_str("option");
 
38248
 (yyval.str) = make_str("option");
34886
38249
;}
34887
38250
    break;
34888
38251
 
34889
38252
  case 1740:
 
38253
 
 
38254
/* Line 1455 of yacc.c  */
34890
38255
#line 9868 "preproc.y"
34891
38256
    { 
34892
 
 yyval.str = make_str("options");
 
38257
 (yyval.str) = make_str("options");
34893
38258
;}
34894
38259
    break;
34895
38260
 
34896
38261
  case 1741:
 
38262
 
 
38263
/* Line 1455 of yacc.c  */
34897
38264
#line 9872 "preproc.y"
34898
38265
    { 
34899
 
 yyval.str = make_str("owned");
 
38266
 (yyval.str) = make_str("owned");
34900
38267
;}
34901
38268
    break;
34902
38269
 
34903
38270
  case 1742:
 
38271
 
 
38272
/* Line 1455 of yacc.c  */
34904
38273
#line 9876 "preproc.y"
34905
38274
    { 
34906
 
 yyval.str = make_str("owner");
 
38275
 (yyval.str) = make_str("owner");
34907
38276
;}
34908
38277
    break;
34909
38278
 
34910
38279
  case 1743:
 
38280
 
 
38281
/* Line 1455 of yacc.c  */
34911
38282
#line 9880 "preproc.y"
34912
38283
    { 
34913
 
 yyval.str = make_str("parser");
 
38284
 (yyval.str) = make_str("parser");
34914
38285
;}
34915
38286
    break;
34916
38287
 
34917
38288
  case 1744:
 
38289
 
 
38290
/* Line 1455 of yacc.c  */
34918
38291
#line 9884 "preproc.y"
34919
38292
    { 
34920
 
 yyval.str = make_str("partial");
 
38293
 (yyval.str) = make_str("partial");
34921
38294
;}
34922
38295
    break;
34923
38296
 
34924
38297
  case 1745:
 
38298
 
 
38299
/* Line 1455 of yacc.c  */
34925
38300
#line 9888 "preproc.y"
34926
38301
    { 
34927
 
 yyval.str = make_str("partition");
 
38302
 (yyval.str) = make_str("partition");
34928
38303
;}
34929
38304
    break;
34930
38305
 
34931
38306
  case 1746:
 
38307
 
 
38308
/* Line 1455 of yacc.c  */
34932
38309
#line 9892 "preproc.y"
34933
38310
    { 
34934
 
 yyval.str = make_str("password");
 
38311
 (yyval.str) = make_str("password");
34935
38312
;}
34936
38313
    break;
34937
38314
 
34938
38315
  case 1747:
 
38316
 
 
38317
/* Line 1455 of yacc.c  */
34939
38318
#line 9896 "preproc.y"
34940
38319
    { 
34941
 
 yyval.str = make_str("plans");
 
38320
 (yyval.str) = make_str("plans");
34942
38321
;}
34943
38322
    break;
34944
38323
 
34945
38324
  case 1748:
 
38325
 
 
38326
/* Line 1455 of yacc.c  */
34946
38327
#line 9900 "preproc.y"
34947
38328
    { 
34948
 
 yyval.str = make_str("preceding");
 
38329
 (yyval.str) = make_str("preceding");
34949
38330
;}
34950
38331
    break;
34951
38332
 
34952
38333
  case 1749:
 
38334
 
 
38335
/* Line 1455 of yacc.c  */
34953
38336
#line 9904 "preproc.y"
34954
38337
    { 
34955
 
 yyval.str = make_str("prepare");
 
38338
 (yyval.str) = make_str("prepare");
34956
38339
;}
34957
38340
    break;
34958
38341
 
34959
38342
  case 1750:
 
38343
 
 
38344
/* Line 1455 of yacc.c  */
34960
38345
#line 9908 "preproc.y"
34961
38346
    { 
34962
 
 yyval.str = make_str("prepared");
 
38347
 (yyval.str) = make_str("prepared");
34963
38348
;}
34964
38349
    break;
34965
38350
 
34966
38351
  case 1751:
 
38352
 
 
38353
/* Line 1455 of yacc.c  */
34967
38354
#line 9912 "preproc.y"
34968
38355
    { 
34969
 
 yyval.str = make_str("preserve");
 
38356
 (yyval.str) = make_str("preserve");
34970
38357
;}
34971
38358
    break;
34972
38359
 
34973
38360
  case 1752:
 
38361
 
 
38362
/* Line 1455 of yacc.c  */
34974
38363
#line 9916 "preproc.y"
34975
38364
    { 
34976
 
 yyval.str = make_str("prior");
 
38365
 (yyval.str) = make_str("prior");
34977
38366
;}
34978
38367
    break;
34979
38368
 
34980
38369
  case 1753:
 
38370
 
 
38371
/* Line 1455 of yacc.c  */
34981
38372
#line 9920 "preproc.y"
34982
38373
    { 
34983
 
 yyval.str = make_str("privileges");
 
38374
 (yyval.str) = make_str("privileges");
34984
38375
;}
34985
38376
    break;
34986
38377
 
34987
38378
  case 1754:
 
38379
 
 
38380
/* Line 1455 of yacc.c  */
34988
38381
#line 9924 "preproc.y"
34989
38382
    { 
34990
 
 yyval.str = make_str("procedural");
 
38383
 (yyval.str) = make_str("procedural");
34991
38384
;}
34992
38385
    break;
34993
38386
 
34994
38387
  case 1755:
 
38388
 
 
38389
/* Line 1455 of yacc.c  */
34995
38390
#line 9928 "preproc.y"
34996
38391
    { 
34997
 
 yyval.str = make_str("procedure");
 
38392
 (yyval.str) = make_str("procedure");
34998
38393
;}
34999
38394
    break;
35000
38395
 
35001
38396
  case 1756:
 
38397
 
 
38398
/* Line 1455 of yacc.c  */
35002
38399
#line 9932 "preproc.y"
35003
38400
    { 
35004
 
 yyval.str = make_str("quote");
 
38401
 (yyval.str) = make_str("quote");
35005
38402
;}
35006
38403
    break;
35007
38404
 
35008
38405
  case 1757:
 
38406
 
 
38407
/* Line 1455 of yacc.c  */
35009
38408
#line 9936 "preproc.y"
35010
38409
    { 
35011
 
 yyval.str = make_str("range");
 
38410
 (yyval.str) = make_str("range");
35012
38411
;}
35013
38412
    break;
35014
38413
 
35015
38414
  case 1758:
 
38415
 
 
38416
/* Line 1455 of yacc.c  */
35016
38417
#line 9940 "preproc.y"
35017
38418
    { 
35018
 
 yyval.str = make_str("read");
 
38419
 (yyval.str) = make_str("read");
35019
38420
;}
35020
38421
    break;
35021
38422
 
35022
38423
  case 1759:
 
38424
 
 
38425
/* Line 1455 of yacc.c  */
35023
38426
#line 9944 "preproc.y"
35024
38427
    { 
35025
 
 yyval.str = make_str("reassign");
 
38428
 (yyval.str) = make_str("reassign");
35026
38429
;}
35027
38430
    break;
35028
38431
 
35029
38432
  case 1760:
 
38433
 
 
38434
/* Line 1455 of yacc.c  */
35030
38435
#line 9948 "preproc.y"
35031
38436
    { 
35032
 
 yyval.str = make_str("recheck");
 
38437
 (yyval.str) = make_str("recheck");
35033
38438
;}
35034
38439
    break;
35035
38440
 
35036
38441
  case 1761:
 
38442
 
 
38443
/* Line 1455 of yacc.c  */
35037
38444
#line 9952 "preproc.y"
35038
38445
    { 
35039
 
 yyval.str = make_str("recursive");
 
38446
 (yyval.str) = make_str("recursive");
35040
38447
;}
35041
38448
    break;
35042
38449
 
35043
38450
  case 1762:
 
38451
 
 
38452
/* Line 1455 of yacc.c  */
35044
38453
#line 9956 "preproc.y"
35045
38454
    { 
35046
 
 yyval.str = make_str("reindex");
 
38455
 (yyval.str) = make_str("reindex");
35047
38456
;}
35048
38457
    break;
35049
38458
 
35050
38459
  case 1763:
 
38460
 
 
38461
/* Line 1455 of yacc.c  */
35051
38462
#line 9960 "preproc.y"
35052
38463
    { 
35053
 
 yyval.str = make_str("relative");
 
38464
 (yyval.str) = make_str("relative");
35054
38465
;}
35055
38466
    break;
35056
38467
 
35057
38468
  case 1764:
 
38469
 
 
38470
/* Line 1455 of yacc.c  */
35058
38471
#line 9964 "preproc.y"
35059
38472
    { 
35060
 
 yyval.str = make_str("release");
 
38473
 (yyval.str) = make_str("release");
35061
38474
;}
35062
38475
    break;
35063
38476
 
35064
38477
  case 1765:
 
38478
 
 
38479
/* Line 1455 of yacc.c  */
35065
38480
#line 9968 "preproc.y"
35066
38481
    { 
35067
 
 yyval.str = make_str("rename");
 
38482
 (yyval.str) = make_str("rename");
35068
38483
;}
35069
38484
    break;
35070
38485
 
35071
38486
  case 1766:
 
38487
 
 
38488
/* Line 1455 of yacc.c  */
35072
38489
#line 9972 "preproc.y"
35073
38490
    { 
35074
 
 yyval.str = make_str("repeatable");
 
38491
 (yyval.str) = make_str("repeatable");
35075
38492
;}
35076
38493
    break;
35077
38494
 
35078
38495
  case 1767:
 
38496
 
 
38497
/* Line 1455 of yacc.c  */
35079
38498
#line 9976 "preproc.y"
35080
38499
    { 
35081
 
 yyval.str = make_str("replace");
 
38500
 (yyval.str) = make_str("replace");
35082
38501
;}
35083
38502
    break;
35084
38503
 
35085
38504
  case 1768:
 
38505
 
 
38506
/* Line 1455 of yacc.c  */
35086
38507
#line 9980 "preproc.y"
35087
38508
    { 
35088
 
 yyval.str = make_str("replica");
 
38509
 (yyval.str) = make_str("replica");
35089
38510
;}
35090
38511
    break;
35091
38512
 
35092
38513
  case 1769:
 
38514
 
 
38515
/* Line 1455 of yacc.c  */
35093
38516
#line 9984 "preproc.y"
35094
38517
    { 
35095
 
 yyval.str = make_str("reset");
 
38518
 (yyval.str) = make_str("reset");
35096
38519
;}
35097
38520
    break;
35098
38521
 
35099
38522
  case 1770:
 
38523
 
 
38524
/* Line 1455 of yacc.c  */
35100
38525
#line 9988 "preproc.y"
35101
38526
    { 
35102
 
 yyval.str = make_str("restart");
 
38527
 (yyval.str) = make_str("restart");
35103
38528
;}
35104
38529
    break;
35105
38530
 
35106
38531
  case 1771:
 
38532
 
 
38533
/* Line 1455 of yacc.c  */
35107
38534
#line 9992 "preproc.y"
35108
38535
    { 
35109
 
 yyval.str = make_str("restrict");
 
38536
 (yyval.str) = make_str("restrict");
35110
38537
;}
35111
38538
    break;
35112
38539
 
35113
38540
  case 1772:
 
38541
 
 
38542
/* Line 1455 of yacc.c  */
35114
38543
#line 9996 "preproc.y"
35115
38544
    { 
35116
 
 yyval.str = make_str("returns");
 
38545
 (yyval.str) = make_str("returns");
35117
38546
;}
35118
38547
    break;
35119
38548
 
35120
38549
  case 1773:
 
38550
 
 
38551
/* Line 1455 of yacc.c  */
35121
38552
#line 10000 "preproc.y"
35122
38553
    { 
35123
 
 yyval.str = make_str("revoke");
 
38554
 (yyval.str) = make_str("revoke");
35124
38555
;}
35125
38556
    break;
35126
38557
 
35127
38558
  case 1774:
 
38559
 
 
38560
/* Line 1455 of yacc.c  */
35128
38561
#line 10004 "preproc.y"
35129
38562
    { 
35130
 
 yyval.str = make_str("role");
 
38563
 (yyval.str) = make_str("role");
35131
38564
;}
35132
38565
    break;
35133
38566
 
35134
38567
  case 1775:
 
38568
 
 
38569
/* Line 1455 of yacc.c  */
35135
38570
#line 10008 "preproc.y"
35136
38571
    { 
35137
 
 yyval.str = make_str("rollback");
 
38572
 (yyval.str) = make_str("rollback");
35138
38573
;}
35139
38574
    break;
35140
38575
 
35141
38576
  case 1776:
 
38577
 
 
38578
/* Line 1455 of yacc.c  */
35142
38579
#line 10012 "preproc.y"
35143
38580
    { 
35144
 
 yyval.str = make_str("rows");
 
38581
 (yyval.str) = make_str("rows");
35145
38582
;}
35146
38583
    break;
35147
38584
 
35148
38585
  case 1777:
 
38586
 
 
38587
/* Line 1455 of yacc.c  */
35149
38588
#line 10016 "preproc.y"
35150
38589
    { 
35151
 
 yyval.str = make_str("rule");
 
38590
 (yyval.str) = make_str("rule");
35152
38591
;}
35153
38592
    break;
35154
38593
 
35155
38594
  case 1778:
 
38595
 
 
38596
/* Line 1455 of yacc.c  */
35156
38597
#line 10020 "preproc.y"
35157
38598
    { 
35158
 
 yyval.str = make_str("savepoint");
 
38599
 (yyval.str) = make_str("savepoint");
35159
38600
;}
35160
38601
    break;
35161
38602
 
35162
38603
  case 1779:
 
38604
 
 
38605
/* Line 1455 of yacc.c  */
35163
38606
#line 10024 "preproc.y"
35164
38607
    { 
35165
 
 yyval.str = make_str("schema");
 
38608
 (yyval.str) = make_str("schema");
35166
38609
;}
35167
38610
    break;
35168
38611
 
35169
38612
  case 1780:
 
38613
 
 
38614
/* Line 1455 of yacc.c  */
35170
38615
#line 10028 "preproc.y"
35171
38616
    { 
35172
 
 yyval.str = make_str("scroll");
 
38617
 (yyval.str) = make_str("scroll");
35173
38618
;}
35174
38619
    break;
35175
38620
 
35176
38621
  case 1781:
 
38622
 
 
38623
/* Line 1455 of yacc.c  */
35177
38624
#line 10032 "preproc.y"
35178
38625
    { 
35179
 
 yyval.str = make_str("search");
 
38626
 (yyval.str) = make_str("search");
35180
38627
;}
35181
38628
    break;
35182
38629
 
35183
38630
  case 1782:
 
38631
 
 
38632
/* Line 1455 of yacc.c  */
35184
38633
#line 10036 "preproc.y"
35185
38634
    { 
35186
 
 yyval.str = make_str("security");
 
38635
 (yyval.str) = make_str("security");
35187
38636
;}
35188
38637
    break;
35189
38638
 
35190
38639
  case 1783:
 
38640
 
 
38641
/* Line 1455 of yacc.c  */
35191
38642
#line 10040 "preproc.y"
35192
38643
    { 
35193
 
 yyval.str = make_str("sequence");
 
38644
 (yyval.str) = make_str("sequence");
35194
38645
;}
35195
38646
    break;
35196
38647
 
35197
38648
  case 1784:
 
38649
 
 
38650
/* Line 1455 of yacc.c  */
35198
38651
#line 10044 "preproc.y"
35199
38652
    { 
35200
 
 yyval.str = make_str("serializable");
 
38653
 (yyval.str) = make_str("serializable");
35201
38654
;}
35202
38655
    break;
35203
38656
 
35204
38657
  case 1785:
 
38658
 
 
38659
/* Line 1455 of yacc.c  */
35205
38660
#line 10048 "preproc.y"
35206
38661
    { 
35207
 
 yyval.str = make_str("server");
 
38662
 (yyval.str) = make_str("server");
35208
38663
;}
35209
38664
    break;
35210
38665
 
35211
38666
  case 1786:
 
38667
 
 
38668
/* Line 1455 of yacc.c  */
35212
38669
#line 10052 "preproc.y"
35213
38670
    { 
35214
 
 yyval.str = make_str("session");
 
38671
 (yyval.str) = make_str("session");
35215
38672
;}
35216
38673
    break;
35217
38674
 
35218
38675
  case 1787:
 
38676
 
 
38677
/* Line 1455 of yacc.c  */
35219
38678
#line 10056 "preproc.y"
35220
38679
    { 
35221
 
 yyval.str = make_str("set");
 
38680
 (yyval.str) = make_str("set");
35222
38681
;}
35223
38682
    break;
35224
38683
 
35225
38684
  case 1788:
 
38685
 
 
38686
/* Line 1455 of yacc.c  */
35226
38687
#line 10060 "preproc.y"
35227
38688
    { 
35228
 
 yyval.str = make_str("share");
 
38689
 (yyval.str) = make_str("share");
35229
38690
;}
35230
38691
    break;
35231
38692
 
35232
38693
  case 1789:
 
38694
 
 
38695
/* Line 1455 of yacc.c  */
35233
38696
#line 10064 "preproc.y"
35234
38697
    { 
35235
 
 yyval.str = make_str("show");
 
38698
 (yyval.str) = make_str("show");
35236
38699
;}
35237
38700
    break;
35238
38701
 
35239
38702
  case 1790:
 
38703
 
 
38704
/* Line 1455 of yacc.c  */
35240
38705
#line 10068 "preproc.y"
35241
38706
    { 
35242
 
 yyval.str = make_str("simple");
 
38707
 (yyval.str) = make_str("simple");
35243
38708
;}
35244
38709
    break;
35245
38710
 
35246
38711
  case 1791:
 
38712
 
 
38713
/* Line 1455 of yacc.c  */
35247
38714
#line 10072 "preproc.y"
35248
38715
    { 
35249
 
 yyval.str = make_str("stable");
 
38716
 (yyval.str) = make_str("stable");
35250
38717
;}
35251
38718
    break;
35252
38719
 
35253
38720
  case 1792:
 
38721
 
 
38722
/* Line 1455 of yacc.c  */
35254
38723
#line 10076 "preproc.y"
35255
38724
    { 
35256
 
 yyval.str = make_str("standalone");
 
38725
 (yyval.str) = make_str("standalone");
35257
38726
;}
35258
38727
    break;
35259
38728
 
35260
38729
  case 1793:
 
38730
 
 
38731
/* Line 1455 of yacc.c  */
35261
38732
#line 10080 "preproc.y"
35262
38733
    { 
35263
 
 yyval.str = make_str("start");
 
38734
 (yyval.str) = make_str("start");
35264
38735
;}
35265
38736
    break;
35266
38737
 
35267
38738
  case 1794:
 
38739
 
 
38740
/* Line 1455 of yacc.c  */
35268
38741
#line 10084 "preproc.y"
35269
38742
    { 
35270
 
 yyval.str = make_str("statement");
 
38743
 (yyval.str) = make_str("statement");
35271
38744
;}
35272
38745
    break;
35273
38746
 
35274
38747
  case 1795:
 
38748
 
 
38749
/* Line 1455 of yacc.c  */
35275
38750
#line 10088 "preproc.y"
35276
38751
    { 
35277
 
 yyval.str = make_str("statistics");
 
38752
 (yyval.str) = make_str("statistics");
35278
38753
;}
35279
38754
    break;
35280
38755
 
35281
38756
  case 1796:
 
38757
 
 
38758
/* Line 1455 of yacc.c  */
35282
38759
#line 10092 "preproc.y"
35283
38760
    { 
35284
 
 yyval.str = make_str("stdin");
 
38761
 (yyval.str) = make_str("stdin");
35285
38762
;}
35286
38763
    break;
35287
38764
 
35288
38765
  case 1797:
 
38766
 
 
38767
/* Line 1455 of yacc.c  */
35289
38768
#line 10096 "preproc.y"
35290
38769
    { 
35291
 
 yyval.str = make_str("stdout");
 
38770
 (yyval.str) = make_str("stdout");
35292
38771
;}
35293
38772
    break;
35294
38773
 
35295
38774
  case 1798:
 
38775
 
 
38776
/* Line 1455 of yacc.c  */
35296
38777
#line 10100 "preproc.y"
35297
38778
    { 
35298
 
 yyval.str = make_str("storage");
 
38779
 (yyval.str) = make_str("storage");
35299
38780
;}
35300
38781
    break;
35301
38782
 
35302
38783
  case 1799:
 
38784
 
 
38785
/* Line 1455 of yacc.c  */
35303
38786
#line 10104 "preproc.y"
35304
38787
    { 
35305
 
 yyval.str = make_str("strict");
 
38788
 (yyval.str) = make_str("strict");
35306
38789
;}
35307
38790
    break;
35308
38791
 
35309
38792
  case 1800:
 
38793
 
 
38794
/* Line 1455 of yacc.c  */
35310
38795
#line 10108 "preproc.y"
35311
38796
    { 
35312
 
 yyval.str = make_str("strip");
 
38797
 (yyval.str) = make_str("strip");
35313
38798
;}
35314
38799
    break;
35315
38800
 
35316
38801
  case 1801:
 
38802
 
 
38803
/* Line 1455 of yacc.c  */
35317
38804
#line 10112 "preproc.y"
35318
38805
    { 
35319
 
 yyval.str = make_str("superuser");
 
38806
 (yyval.str) = make_str("superuser");
35320
38807
;}
35321
38808
    break;
35322
38809
 
35323
38810
  case 1802:
 
38811
 
 
38812
/* Line 1455 of yacc.c  */
35324
38813
#line 10116 "preproc.y"
35325
38814
    { 
35326
 
 yyval.str = make_str("sysid");
 
38815
 (yyval.str) = make_str("sysid");
35327
38816
;}
35328
38817
    break;
35329
38818
 
35330
38819
  case 1803:
 
38820
 
 
38821
/* Line 1455 of yacc.c  */
35331
38822
#line 10120 "preproc.y"
35332
38823
    { 
35333
 
 yyval.str = make_str("system");
 
38824
 (yyval.str) = make_str("system");
35334
38825
;}
35335
38826
    break;
35336
38827
 
35337
38828
  case 1804:
 
38829
 
 
38830
/* Line 1455 of yacc.c  */
35338
38831
#line 10124 "preproc.y"
35339
38832
    { 
35340
 
 yyval.str = make_str("tablespace");
 
38833
 (yyval.str) = make_str("tablespace");
35341
38834
;}
35342
38835
    break;
35343
38836
 
35344
38837
  case 1805:
 
38838
 
 
38839
/* Line 1455 of yacc.c  */
35345
38840
#line 10128 "preproc.y"
35346
38841
    { 
35347
 
 yyval.str = make_str("temp");
 
38842
 (yyval.str) = make_str("temp");
35348
38843
;}
35349
38844
    break;
35350
38845
 
35351
38846
  case 1806:
 
38847
 
 
38848
/* Line 1455 of yacc.c  */
35352
38849
#line 10132 "preproc.y"
35353
38850
    { 
35354
 
 yyval.str = make_str("template");
 
38851
 (yyval.str) = make_str("template");
35355
38852
;}
35356
38853
    break;
35357
38854
 
35358
38855
  case 1807:
 
38856
 
 
38857
/* Line 1455 of yacc.c  */
35359
38858
#line 10136 "preproc.y"
35360
38859
    { 
35361
 
 yyval.str = make_str("temporary");
 
38860
 (yyval.str) = make_str("temporary");
35362
38861
;}
35363
38862
    break;
35364
38863
 
35365
38864
  case 1808:
 
38865
 
 
38866
/* Line 1455 of yacc.c  */
35366
38867
#line 10140 "preproc.y"
35367
38868
    { 
35368
 
 yyval.str = make_str("text");
 
38869
 (yyval.str) = make_str("text");
35369
38870
;}
35370
38871
    break;
35371
38872
 
35372
38873
  case 1809:
 
38874
 
 
38875
/* Line 1455 of yacc.c  */
35373
38876
#line 10144 "preproc.y"
35374
38877
    { 
35375
 
 yyval.str = make_str("transaction");
 
38878
 (yyval.str) = make_str("transaction");
35376
38879
;}
35377
38880
    break;
35378
38881
 
35379
38882
  case 1810:
 
38883
 
 
38884
/* Line 1455 of yacc.c  */
35380
38885
#line 10148 "preproc.y"
35381
38886
    { 
35382
 
 yyval.str = make_str("trigger");
 
38887
 (yyval.str) = make_str("trigger");
35383
38888
;}
35384
38889
    break;
35385
38890
 
35386
38891
  case 1811:
 
38892
 
 
38893
/* Line 1455 of yacc.c  */
35387
38894
#line 10152 "preproc.y"
35388
38895
    { 
35389
 
 yyval.str = make_str("truncate");
 
38896
 (yyval.str) = make_str("truncate");
35390
38897
;}
35391
38898
    break;
35392
38899
 
35393
38900
  case 1812:
 
38901
 
 
38902
/* Line 1455 of yacc.c  */
35394
38903
#line 10156 "preproc.y"
35395
38904
    { 
35396
 
 yyval.str = make_str("trusted");
 
38905
 (yyval.str) = make_str("trusted");
35397
38906
;}
35398
38907
    break;
35399
38908
 
35400
38909
  case 1813:
 
38910
 
 
38911
/* Line 1455 of yacc.c  */
35401
38912
#line 10160 "preproc.y"
35402
38913
    { 
35403
 
 yyval.str = make_str("type");
 
38914
 (yyval.str) = make_str("type");
35404
38915
;}
35405
38916
    break;
35406
38917
 
35407
38918
  case 1814:
 
38919
 
 
38920
/* Line 1455 of yacc.c  */
35408
38921
#line 10164 "preproc.y"
35409
38922
    { 
35410
 
 yyval.str = make_str("unbounded");
 
38923
 (yyval.str) = make_str("unbounded");
35411
38924
;}
35412
38925
    break;
35413
38926
 
35414
38927
  case 1815:
 
38928
 
 
38929
/* Line 1455 of yacc.c  */
35415
38930
#line 10168 "preproc.y"
35416
38931
    { 
35417
 
 yyval.str = make_str("uncommitted");
 
38932
 (yyval.str) = make_str("uncommitted");
35418
38933
;}
35419
38934
    break;
35420
38935
 
35421
38936
  case 1816:
 
38937
 
 
38938
/* Line 1455 of yacc.c  */
35422
38939
#line 10172 "preproc.y"
35423
38940
    { 
35424
 
 yyval.str = make_str("unencrypted");
 
38941
 (yyval.str) = make_str("unencrypted");
35425
38942
;}
35426
38943
    break;
35427
38944
 
35428
38945
  case 1817:
 
38946
 
 
38947
/* Line 1455 of yacc.c  */
35429
38948
#line 10176 "preproc.y"
35430
38949
    { 
35431
 
 yyval.str = make_str("unknown");
 
38950
 (yyval.str) = make_str("unknown");
35432
38951
;}
35433
38952
    break;
35434
38953
 
35435
38954
  case 1818:
 
38955
 
 
38956
/* Line 1455 of yacc.c  */
35436
38957
#line 10180 "preproc.y"
35437
38958
    { 
35438
 
 yyval.str = make_str("unlisten");
 
38959
 (yyval.str) = make_str("unlisten");
35439
38960
;}
35440
38961
    break;
35441
38962
 
35442
38963
  case 1819:
 
38964
 
 
38965
/* Line 1455 of yacc.c  */
35443
38966
#line 10184 "preproc.y"
35444
38967
    { 
35445
 
 yyval.str = make_str("until");
 
38968
 (yyval.str) = make_str("until");
35446
38969
;}
35447
38970
    break;
35448
38971
 
35449
38972
  case 1820:
 
38973
 
 
38974
/* Line 1455 of yacc.c  */
35450
38975
#line 10188 "preproc.y"
35451
38976
    { 
35452
 
 yyval.str = make_str("update");
 
38977
 (yyval.str) = make_str("update");
35453
38978
;}
35454
38979
    break;
35455
38980
 
35456
38981
  case 1821:
 
38982
 
 
38983
/* Line 1455 of yacc.c  */
35457
38984
#line 10192 "preproc.y"
35458
38985
    { 
35459
 
 yyval.str = make_str("vacuum");
 
38986
 (yyval.str) = make_str("vacuum");
35460
38987
;}
35461
38988
    break;
35462
38989
 
35463
38990
  case 1822:
 
38991
 
 
38992
/* Line 1455 of yacc.c  */
35464
38993
#line 10196 "preproc.y"
35465
38994
    { 
35466
 
 yyval.str = make_str("valid");
 
38995
 (yyval.str) = make_str("valid");
35467
38996
;}
35468
38997
    break;
35469
38998
 
35470
38999
  case 1823:
 
39000
 
 
39001
/* Line 1455 of yacc.c  */
35471
39002
#line 10200 "preproc.y"
35472
39003
    { 
35473
 
 yyval.str = make_str("validator");
 
39004
 (yyval.str) = make_str("validator");
35474
39005
;}
35475
39006
    break;
35476
39007
 
35477
39008
  case 1824:
 
39009
 
 
39010
/* Line 1455 of yacc.c  */
35478
39011
#line 10204 "preproc.y"
35479
39012
    { 
35480
 
 yyval.str = make_str("value");
 
39013
 (yyval.str) = make_str("value");
35481
39014
;}
35482
39015
    break;
35483
39016
 
35484
39017
  case 1825:
 
39018
 
 
39019
/* Line 1455 of yacc.c  */
35485
39020
#line 10208 "preproc.y"
35486
39021
    { 
35487
 
 yyval.str = make_str("varying");
 
39022
 (yyval.str) = make_str("varying");
35488
39023
;}
35489
39024
    break;
35490
39025
 
35491
39026
  case 1826:
 
39027
 
 
39028
/* Line 1455 of yacc.c  */
35492
39029
#line 10212 "preproc.y"
35493
39030
    { 
35494
 
 yyval.str = make_str("version");
 
39031
 (yyval.str) = make_str("version");
35495
39032
;}
35496
39033
    break;
35497
39034
 
35498
39035
  case 1827:
 
39036
 
 
39037
/* Line 1455 of yacc.c  */
35499
39038
#line 10216 "preproc.y"
35500
39039
    { 
35501
 
 yyval.str = make_str("view");
 
39040
 (yyval.str) = make_str("view");
35502
39041
;}
35503
39042
    break;
35504
39043
 
35505
39044
  case 1828:
 
39045
 
 
39046
/* Line 1455 of yacc.c  */
35506
39047
#line 10220 "preproc.y"
35507
39048
    { 
35508
 
 yyval.str = make_str("volatile");
 
39049
 (yyval.str) = make_str("volatile");
35509
39050
;}
35510
39051
    break;
35511
39052
 
35512
39053
  case 1829:
 
39054
 
 
39055
/* Line 1455 of yacc.c  */
35513
39056
#line 10224 "preproc.y"
35514
39057
    { 
35515
 
 yyval.str = make_str("whitespace");
 
39058
 (yyval.str) = make_str("whitespace");
35516
39059
;}
35517
39060
    break;
35518
39061
 
35519
39062
  case 1830:
 
39063
 
 
39064
/* Line 1455 of yacc.c  */
35520
39065
#line 10228 "preproc.y"
35521
39066
    { 
35522
 
 yyval.str = make_str("without");
 
39067
 (yyval.str) = make_str("without");
35523
39068
;}
35524
39069
    break;
35525
39070
 
35526
39071
  case 1831:
 
39072
 
 
39073
/* Line 1455 of yacc.c  */
35527
39074
#line 10232 "preproc.y"
35528
39075
    { 
35529
 
 yyval.str = make_str("work");
 
39076
 (yyval.str) = make_str("work");
35530
39077
;}
35531
39078
    break;
35532
39079
 
35533
39080
  case 1832:
 
39081
 
 
39082
/* Line 1455 of yacc.c  */
35534
39083
#line 10236 "preproc.y"
35535
39084
    { 
35536
 
 yyval.str = make_str("wrapper");
 
39085
 (yyval.str) = make_str("wrapper");
35537
39086
;}
35538
39087
    break;
35539
39088
 
35540
39089
  case 1833:
 
39090
 
 
39091
/* Line 1455 of yacc.c  */
35541
39092
#line 10240 "preproc.y"
35542
39093
    { 
35543
 
 yyval.str = make_str("write");
 
39094
 (yyval.str) = make_str("write");
35544
39095
;}
35545
39096
    break;
35546
39097
 
35547
39098
  case 1834:
 
39099
 
 
39100
/* Line 1455 of yacc.c  */
35548
39101
#line 10244 "preproc.y"
35549
39102
    { 
35550
 
 yyval.str = make_str("xml");
 
39103
 (yyval.str) = make_str("xml");
35551
39104
;}
35552
39105
    break;
35553
39106
 
35554
39107
  case 1835:
 
39108
 
 
39109
/* Line 1455 of yacc.c  */
35555
39110
#line 10248 "preproc.y"
35556
39111
    { 
35557
 
 yyval.str = make_str("yes");
 
39112
 (yyval.str) = make_str("yes");
35558
39113
;}
35559
39114
    break;
35560
39115
 
35561
39116
  case 1836:
 
39117
 
 
39118
/* Line 1455 of yacc.c  */
35562
39119
#line 10252 "preproc.y"
35563
39120
    { 
35564
 
 yyval.str = make_str("zone");
 
39121
 (yyval.str) = make_str("zone");
35565
39122
;}
35566
39123
    break;
35567
39124
 
35568
39125
  case 1837:
 
39126
 
 
39127
/* Line 1455 of yacc.c  */
35569
39128
#line 10260 "preproc.y"
35570
39129
    { 
35571
 
 yyval.str = make_str("bigint");
 
39130
 (yyval.str) = make_str("bigint");
35572
39131
;}
35573
39132
    break;
35574
39133
 
35575
39134
  case 1838:
 
39135
 
 
39136
/* Line 1455 of yacc.c  */
35576
39137
#line 10264 "preproc.y"
35577
39138
    { 
35578
 
 yyval.str = make_str("bit");
 
39139
 (yyval.str) = make_str("bit");
35579
39140
;}
35580
39141
    break;
35581
39142
 
35582
39143
  case 1839:
 
39144
 
 
39145
/* Line 1455 of yacc.c  */
35583
39146
#line 10268 "preproc.y"
35584
39147
    { 
35585
 
 yyval.str = make_str("boolean");
 
39148
 (yyval.str) = make_str("boolean");
35586
39149
;}
35587
39150
    break;
35588
39151
 
35589
39152
  case 1840:
 
39153
 
 
39154
/* Line 1455 of yacc.c  */
35590
39155
#line 10272 "preproc.y"
35591
39156
    { 
35592
 
 yyval.str = make_str("character");
 
39157
 (yyval.str) = make_str("character");
35593
39158
;}
35594
39159
    break;
35595
39160
 
35596
39161
  case 1841:
 
39162
 
 
39163
/* Line 1455 of yacc.c  */
35597
39164
#line 10276 "preproc.y"
35598
39165
    { 
35599
 
 yyval.str = make_str("coalesce");
 
39166
 (yyval.str) = make_str("coalesce");
35600
39167
;}
35601
39168
    break;
35602
39169
 
35603
39170
  case 1842:
 
39171
 
 
39172
/* Line 1455 of yacc.c  */
35604
39173
#line 10280 "preproc.y"
35605
39174
    { 
35606
 
 yyval.str = make_str("dec");
 
39175
 (yyval.str) = make_str("dec");
35607
39176
;}
35608
39177
    break;
35609
39178
 
35610
39179
  case 1843:
 
39180
 
 
39181
/* Line 1455 of yacc.c  */
35611
39182
#line 10284 "preproc.y"
35612
39183
    { 
35613
 
 yyval.str = make_str("decimal");
 
39184
 (yyval.str) = make_str("decimal");
35614
39185
;}
35615
39186
    break;
35616
39187
 
35617
39188
  case 1844:
 
39189
 
 
39190
/* Line 1455 of yacc.c  */
35618
39191
#line 10288 "preproc.y"
35619
39192
    { 
35620
 
 yyval.str = make_str("exists");
 
39193
 (yyval.str) = make_str("exists");
35621
39194
;}
35622
39195
    break;
35623
39196
 
35624
39197
  case 1845:
 
39198
 
 
39199
/* Line 1455 of yacc.c  */
35625
39200
#line 10292 "preproc.y"
35626
39201
    { 
35627
 
 yyval.str = make_str("extract");
 
39202
 (yyval.str) = make_str("extract");
35628
39203
;}
35629
39204
    break;
35630
39205
 
35631
39206
  case 1846:
 
39207
 
 
39208
/* Line 1455 of yacc.c  */
35632
39209
#line 10296 "preproc.y"
35633
39210
    { 
35634
 
 yyval.str = make_str("float");
 
39211
 (yyval.str) = make_str("float");
35635
39212
;}
35636
39213
    break;
35637
39214
 
35638
39215
  case 1847:
 
39216
 
 
39217
/* Line 1455 of yacc.c  */
35639
39218
#line 10300 "preproc.y"
35640
39219
    { 
35641
 
 yyval.str = make_str("greatest");
 
39220
 (yyval.str) = make_str("greatest");
35642
39221
;}
35643
39222
    break;
35644
39223
 
35645
39224
  case 1848:
 
39225
 
 
39226
/* Line 1455 of yacc.c  */
35646
39227
#line 10304 "preproc.y"
35647
39228
    { 
35648
 
 yyval.str = make_str("inout");
 
39229
 (yyval.str) = make_str("inout");
35649
39230
;}
35650
39231
    break;
35651
39232
 
35652
39233
  case 1849:
 
39234
 
 
39235
/* Line 1455 of yacc.c  */
35653
39236
#line 10308 "preproc.y"
35654
39237
    { 
35655
 
 yyval.str = make_str("integer");
 
39238
 (yyval.str) = make_str("integer");
35656
39239
;}
35657
39240
    break;
35658
39241
 
35659
39242
  case 1850:
 
39243
 
 
39244
/* Line 1455 of yacc.c  */
35660
39245
#line 10312 "preproc.y"
35661
39246
    { 
35662
 
 yyval.str = make_str("interval");
 
39247
 (yyval.str) = make_str("interval");
35663
39248
;}
35664
39249
    break;
35665
39250
 
35666
39251
  case 1851:
 
39252
 
 
39253
/* Line 1455 of yacc.c  */
35667
39254
#line 10316 "preproc.y"
35668
39255
    { 
35669
 
 yyval.str = make_str("least");
 
39256
 (yyval.str) = make_str("least");
35670
39257
;}
35671
39258
    break;
35672
39259
 
35673
39260
  case 1852:
 
39261
 
 
39262
/* Line 1455 of yacc.c  */
35674
39263
#line 10320 "preproc.y"
35675
39264
    { 
35676
 
 yyval.str = make_str("national");
 
39265
 (yyval.str) = make_str("national");
35677
39266
;}
35678
39267
    break;
35679
39268
 
35680
39269
  case 1853:
 
39270
 
 
39271
/* Line 1455 of yacc.c  */
35681
39272
#line 10324 "preproc.y"
35682
39273
    { 
35683
 
 yyval.str = make_str("nchar");
 
39274
 (yyval.str) = make_str("nchar");
35684
39275
;}
35685
39276
    break;
35686
39277
 
35687
39278
  case 1854:
 
39279
 
 
39280
/* Line 1455 of yacc.c  */
35688
39281
#line 10328 "preproc.y"
35689
39282
    { 
35690
 
 yyval.str = make_str("none");
 
39283
 (yyval.str) = make_str("none");
35691
39284
;}
35692
39285
    break;
35693
39286
 
35694
39287
  case 1855:
 
39288
 
 
39289
/* Line 1455 of yacc.c  */
35695
39290
#line 10332 "preproc.y"
35696
39291
    { 
35697
 
 yyval.str = make_str("nullif");
 
39292
 (yyval.str) = make_str("nullif");
35698
39293
;}
35699
39294
    break;
35700
39295
 
35701
39296
  case 1856:
 
39297
 
 
39298
/* Line 1455 of yacc.c  */
35702
39299
#line 10336 "preproc.y"
35703
39300
    { 
35704
 
 yyval.str = make_str("numeric");
 
39301
 (yyval.str) = make_str("numeric");
35705
39302
;}
35706
39303
    break;
35707
39304
 
35708
39305
  case 1857:
 
39306
 
 
39307
/* Line 1455 of yacc.c  */
35709
39308
#line 10340 "preproc.y"
35710
39309
    { 
35711
 
 yyval.str = make_str("out");
 
39310
 (yyval.str) = make_str("out");
35712
39311
;}
35713
39312
    break;
35714
39313
 
35715
39314
  case 1858:
 
39315
 
 
39316
/* Line 1455 of yacc.c  */
35716
39317
#line 10344 "preproc.y"
35717
39318
    { 
35718
 
 yyval.str = make_str("overlay");
 
39319
 (yyval.str) = make_str("overlay");
35719
39320
;}
35720
39321
    break;
35721
39322
 
35722
39323
  case 1859:
 
39324
 
 
39325
/* Line 1455 of yacc.c  */
35723
39326
#line 10348 "preproc.y"
35724
39327
    { 
35725
 
 yyval.str = make_str("position");
 
39328
 (yyval.str) = make_str("position");
35726
39329
;}
35727
39330
    break;
35728
39331
 
35729
39332
  case 1860:
 
39333
 
 
39334
/* Line 1455 of yacc.c  */
35730
39335
#line 10352 "preproc.y"
35731
39336
    { 
35732
 
 yyval.str = make_str("precision");
 
39337
 (yyval.str) = make_str("precision");
35733
39338
;}
35734
39339
    break;
35735
39340
 
35736
39341
  case 1861:
 
39342
 
 
39343
/* Line 1455 of yacc.c  */
35737
39344
#line 10356 "preproc.y"
35738
39345
    { 
35739
 
 yyval.str = make_str("real");
 
39346
 (yyval.str) = make_str("real");
35740
39347
;}
35741
39348
    break;
35742
39349
 
35743
39350
  case 1862:
 
39351
 
 
39352
/* Line 1455 of yacc.c  */
35744
39353
#line 10360 "preproc.y"
35745
39354
    { 
35746
 
 yyval.str = make_str("row");
 
39355
 (yyval.str) = make_str("row");
35747
39356
;}
35748
39357
    break;
35749
39358
 
35750
39359
  case 1863:
 
39360
 
 
39361
/* Line 1455 of yacc.c  */
35751
39362
#line 10364 "preproc.y"
35752
39363
    { 
35753
 
 yyval.str = make_str("setof");
 
39364
 (yyval.str) = make_str("setof");
35754
39365
;}
35755
39366
    break;
35756
39367
 
35757
39368
  case 1864:
 
39369
 
 
39370
/* Line 1455 of yacc.c  */
35758
39371
#line 10368 "preproc.y"
35759
39372
    { 
35760
 
 yyval.str = make_str("smallint");
 
39373
 (yyval.str) = make_str("smallint");
35761
39374
;}
35762
39375
    break;
35763
39376
 
35764
39377
  case 1865:
 
39378
 
 
39379
/* Line 1455 of yacc.c  */
35765
39380
#line 10372 "preproc.y"
35766
39381
    { 
35767
 
 yyval.str = make_str("substring");
 
39382
 (yyval.str) = make_str("substring");
35768
39383
;}
35769
39384
    break;
35770
39385
 
35771
39386
  case 1866:
 
39387
 
 
39388
/* Line 1455 of yacc.c  */
35772
39389
#line 10376 "preproc.y"
35773
39390
    { 
35774
 
 yyval.str = make_str("time");
 
39391
 (yyval.str) = make_str("time");
35775
39392
;}
35776
39393
    break;
35777
39394
 
35778
39395
  case 1867:
 
39396
 
 
39397
/* Line 1455 of yacc.c  */
35779
39398
#line 10380 "preproc.y"
35780
39399
    { 
35781
 
 yyval.str = make_str("timestamp");
 
39400
 (yyval.str) = make_str("timestamp");
35782
39401
;}
35783
39402
    break;
35784
39403
 
35785
39404
  case 1868:
 
39405
 
 
39406
/* Line 1455 of yacc.c  */
35786
39407
#line 10384 "preproc.y"
35787
39408
    { 
35788
 
 yyval.str = make_str("treat");
 
39409
 (yyval.str) = make_str("treat");
35789
39410
;}
35790
39411
    break;
35791
39412
 
35792
39413
  case 1869:
 
39414
 
 
39415
/* Line 1455 of yacc.c  */
35793
39416
#line 10388 "preproc.y"
35794
39417
    { 
35795
 
 yyval.str = make_str("trim");
 
39418
 (yyval.str) = make_str("trim");
35796
39419
;}
35797
39420
    break;
35798
39421
 
35799
39422
  case 1870:
 
39423
 
 
39424
/* Line 1455 of yacc.c  */
35800
39425
#line 10392 "preproc.y"
35801
39426
    { 
35802
 
 yyval.str = make_str("varchar");
 
39427
 (yyval.str) = make_str("varchar");
35803
39428
;}
35804
39429
    break;
35805
39430
 
35806
39431
  case 1871:
 
39432
 
 
39433
/* Line 1455 of yacc.c  */
35807
39434
#line 10396 "preproc.y"
35808
39435
    { 
35809
 
 yyval.str = make_str("xmlattributes");
 
39436
 (yyval.str) = make_str("xmlattributes");
35810
39437
;}
35811
39438
    break;
35812
39439
 
35813
39440
  case 1872:
 
39441
 
 
39442
/* Line 1455 of yacc.c  */
35814
39443
#line 10400 "preproc.y"
35815
39444
    { 
35816
 
 yyval.str = make_str("xmlconcat");
 
39445
 (yyval.str) = make_str("xmlconcat");
35817
39446
;}
35818
39447
    break;
35819
39448
 
35820
39449
  case 1873:
 
39450
 
 
39451
/* Line 1455 of yacc.c  */
35821
39452
#line 10404 "preproc.y"
35822
39453
    { 
35823
 
 yyval.str = make_str("xmlelement");
 
39454
 (yyval.str) = make_str("xmlelement");
35824
39455
;}
35825
39456
    break;
35826
39457
 
35827
39458
  case 1874:
 
39459
 
 
39460
/* Line 1455 of yacc.c  */
35828
39461
#line 10408 "preproc.y"
35829
39462
    { 
35830
 
 yyval.str = make_str("xmlforest");
 
39463
 (yyval.str) = make_str("xmlforest");
35831
39464
;}
35832
39465
    break;
35833
39466
 
35834
39467
  case 1875:
 
39468
 
 
39469
/* Line 1455 of yacc.c  */
35835
39470
#line 10412 "preproc.y"
35836
39471
    { 
35837
 
 yyval.str = make_str("xmlparse");
 
39472
 (yyval.str) = make_str("xmlparse");
35838
39473
;}
35839
39474
    break;
35840
39475
 
35841
39476
  case 1876:
 
39477
 
 
39478
/* Line 1455 of yacc.c  */
35842
39479
#line 10416 "preproc.y"
35843
39480
    { 
35844
 
 yyval.str = make_str("xmlpi");
 
39481
 (yyval.str) = make_str("xmlpi");
35845
39482
;}
35846
39483
    break;
35847
39484
 
35848
39485
  case 1877:
 
39486
 
 
39487
/* Line 1455 of yacc.c  */
35849
39488
#line 10420 "preproc.y"
35850
39489
    { 
35851
 
 yyval.str = make_str("xmlroot");
 
39490
 (yyval.str) = make_str("xmlroot");
35852
39491
;}
35853
39492
    break;
35854
39493
 
35855
39494
  case 1878:
 
39495
 
 
39496
/* Line 1455 of yacc.c  */
35856
39497
#line 10424 "preproc.y"
35857
39498
    { 
35858
 
 yyval.str = make_str("xmlserialize");
 
39499
 (yyval.str) = make_str("xmlserialize");
35859
39500
;}
35860
39501
    break;
35861
39502
 
35862
39503
  case 1879:
 
39504
 
 
39505
/* Line 1455 of yacc.c  */
35863
39506
#line 10432 "preproc.y"
35864
39507
    { 
35865
 
 yyval.str = make_str("authorization");
 
39508
 (yyval.str) = make_str("authorization");
35866
39509
;}
35867
39510
    break;
35868
39511
 
35869
39512
  case 1880:
 
39513
 
 
39514
/* Line 1455 of yacc.c  */
35870
39515
#line 10436 "preproc.y"
35871
39516
    { 
35872
 
 yyval.str = make_str("between");
 
39517
 (yyval.str) = make_str("between");
35873
39518
;}
35874
39519
    break;
35875
39520
 
35876
39521
  case 1881:
 
39522
 
 
39523
/* Line 1455 of yacc.c  */
35877
39524
#line 10440 "preproc.y"
35878
39525
    { 
35879
 
 yyval.str = make_str("binary");
 
39526
 (yyval.str) = make_str("binary");
35880
39527
;}
35881
39528
    break;
35882
39529
 
35883
39530
  case 1882:
 
39531
 
 
39532
/* Line 1455 of yacc.c  */
35884
39533
#line 10444 "preproc.y"
35885
39534
    { 
35886
 
 yyval.str = make_str("cross");
 
39535
 (yyval.str) = make_str("cross");
35887
39536
;}
35888
39537
    break;
35889
39538
 
35890
39539
  case 1883:
 
39540
 
 
39541
/* Line 1455 of yacc.c  */
35891
39542
#line 10448 "preproc.y"
35892
39543
    { 
35893
 
 yyval.str = make_str("current_schema");
 
39544
 (yyval.str) = make_str("current_schema");
35894
39545
;}
35895
39546
    break;
35896
39547
 
35897
39548
  case 1884:
 
39549
 
 
39550
/* Line 1455 of yacc.c  */
35898
39551
#line 10452 "preproc.y"
35899
39552
    { 
35900
 
 yyval.str = make_str("freeze");
 
39553
 (yyval.str) = make_str("freeze");
35901
39554
;}
35902
39555
    break;
35903
39556
 
35904
39557
  case 1885:
 
39558
 
 
39559
/* Line 1455 of yacc.c  */
35905
39560
#line 10456 "preproc.y"
35906
39561
    { 
35907
 
 yyval.str = make_str("full");
 
39562
 (yyval.str) = make_str("full");
35908
39563
;}
35909
39564
    break;
35910
39565
 
35911
39566
  case 1886:
 
39567
 
 
39568
/* Line 1455 of yacc.c  */
35912
39569
#line 10460 "preproc.y"
35913
39570
    { 
35914
 
 yyval.str = make_str("ilike");
 
39571
 (yyval.str) = make_str("ilike");
35915
39572
;}
35916
39573
    break;
35917
39574
 
35918
39575
  case 1887:
 
39576
 
 
39577
/* Line 1455 of yacc.c  */
35919
39578
#line 10464 "preproc.y"
35920
39579
    { 
35921
 
 yyval.str = make_str("inner");
 
39580
 (yyval.str) = make_str("inner");
35922
39581
;}
35923
39582
    break;
35924
39583
 
35925
39584
  case 1888:
 
39585
 
 
39586
/* Line 1455 of yacc.c  */
35926
39587
#line 10468 "preproc.y"
35927
39588
    { 
35928
 
 yyval.str = make_str("is");
 
39589
 (yyval.str) = make_str("is");
35929
39590
;}
35930
39591
    break;
35931
39592
 
35932
39593
  case 1889:
 
39594
 
 
39595
/* Line 1455 of yacc.c  */
35933
39596
#line 10472 "preproc.y"
35934
39597
    { 
35935
 
 yyval.str = make_str("isnull");
 
39598
 (yyval.str) = make_str("isnull");
35936
39599
;}
35937
39600
    break;
35938
39601
 
35939
39602
  case 1890:
 
39603
 
 
39604
/* Line 1455 of yacc.c  */
35940
39605
#line 10476 "preproc.y"
35941
39606
    { 
35942
 
 yyval.str = make_str("join");
 
39607
 (yyval.str) = make_str("join");
35943
39608
;}
35944
39609
    break;
35945
39610
 
35946
39611
  case 1891:
 
39612
 
 
39613
/* Line 1455 of yacc.c  */
35947
39614
#line 10480 "preproc.y"
35948
39615
    { 
35949
 
 yyval.str = make_str("left");
 
39616
 (yyval.str) = make_str("left");
35950
39617
;}
35951
39618
    break;
35952
39619
 
35953
39620
  case 1892:
 
39621
 
 
39622
/* Line 1455 of yacc.c  */
35954
39623
#line 10484 "preproc.y"
35955
39624
    { 
35956
 
 yyval.str = make_str("like");
 
39625
 (yyval.str) = make_str("like");
35957
39626
;}
35958
39627
    break;
35959
39628
 
35960
39629
  case 1893:
 
39630
 
 
39631
/* Line 1455 of yacc.c  */
35961
39632
#line 10488 "preproc.y"
35962
39633
    { 
35963
 
 yyval.str = make_str("natural");
 
39634
 (yyval.str) = make_str("natural");
35964
39635
;}
35965
39636
    break;
35966
39637
 
35967
39638
  case 1894:
 
39639
 
 
39640
/* Line 1455 of yacc.c  */
35968
39641
#line 10492 "preproc.y"
35969
39642
    { 
35970
 
 yyval.str = make_str("notnull");
 
39643
 (yyval.str) = make_str("notnull");
35971
39644
;}
35972
39645
    break;
35973
39646
 
35974
39647
  case 1895:
 
39648
 
 
39649
/* Line 1455 of yacc.c  */
35975
39650
#line 10496 "preproc.y"
35976
39651
    { 
35977
 
 yyval.str = make_str("outer");
 
39652
 (yyval.str) = make_str("outer");
35978
39653
;}
35979
39654
    break;
35980
39655
 
35981
39656
  case 1896:
 
39657
 
 
39658
/* Line 1455 of yacc.c  */
35982
39659
#line 10500 "preproc.y"
35983
39660
    { 
35984
 
 yyval.str = make_str("over");
 
39661
 (yyval.str) = make_str("over");
35985
39662
;}
35986
39663
    break;
35987
39664
 
35988
39665
  case 1897:
 
39666
 
 
39667
/* Line 1455 of yacc.c  */
35989
39668
#line 10504 "preproc.y"
35990
39669
    { 
35991
 
 yyval.str = make_str("overlaps");
 
39670
 (yyval.str) = make_str("overlaps");
35992
39671
;}
35993
39672
    break;
35994
39673
 
35995
39674
  case 1898:
 
39675
 
 
39676
/* Line 1455 of yacc.c  */
35996
39677
#line 10508 "preproc.y"
35997
39678
    { 
35998
 
 yyval.str = make_str("right");
 
39679
 (yyval.str) = make_str("right");
35999
39680
;}
36000
39681
    break;
36001
39682
 
36002
39683
  case 1899:
 
39684
 
 
39685
/* Line 1455 of yacc.c  */
36003
39686
#line 10512 "preproc.y"
36004
39687
    { 
36005
 
 yyval.str = make_str("similar");
 
39688
 (yyval.str) = make_str("similar");
36006
39689
;}
36007
39690
    break;
36008
39691
 
36009
39692
  case 1900:
 
39693
 
 
39694
/* Line 1455 of yacc.c  */
36010
39695
#line 10516 "preproc.y"
36011
39696
    { 
36012
 
 yyval.str = make_str("verbose");
 
39697
 (yyval.str) = make_str("verbose");
36013
39698
;}
36014
39699
    break;
36015
39700
 
36016
39701
  case 1901:
 
39702
 
 
39703
/* Line 1455 of yacc.c  */
36017
39704
#line 10524 "preproc.y"
36018
39705
    { 
36019
 
 yyval.str = make_str("all");
 
39706
 (yyval.str) = make_str("all");
36020
39707
;}
36021
39708
    break;
36022
39709
 
36023
39710
  case 1902:
 
39711
 
 
39712
/* Line 1455 of yacc.c  */
36024
39713
#line 10528 "preproc.y"
36025
39714
    { 
36026
 
 yyval.str = make_str("analyse");
 
39715
 (yyval.str) = make_str("analyse");
36027
39716
;}
36028
39717
    break;
36029
39718
 
36030
39719
  case 1903:
 
39720
 
 
39721
/* Line 1455 of yacc.c  */
36031
39722
#line 10532 "preproc.y"
36032
39723
    { 
36033
 
 yyval.str = make_str("analyze");
 
39724
 (yyval.str) = make_str("analyze");
36034
39725
;}
36035
39726
    break;
36036
39727
 
36037
39728
  case 1904:
 
39729
 
 
39730
/* Line 1455 of yacc.c  */
36038
39731
#line 10536 "preproc.y"
36039
39732
    { 
36040
 
 yyval.str = make_str("and");
 
39733
 (yyval.str) = make_str("and");
36041
39734
;}
36042
39735
    break;
36043
39736
 
36044
39737
  case 1905:
 
39738
 
 
39739
/* Line 1455 of yacc.c  */
36045
39740
#line 10540 "preproc.y"
36046
39741
    { 
36047
 
 yyval.str = make_str("any");
 
39742
 (yyval.str) = make_str("any");
36048
39743
;}
36049
39744
    break;
36050
39745
 
36051
39746
  case 1906:
 
39747
 
 
39748
/* Line 1455 of yacc.c  */
36052
39749
#line 10544 "preproc.y"
36053
39750
    { 
36054
 
 yyval.str = make_str("array");
 
39751
 (yyval.str) = make_str("array");
36055
39752
;}
36056
39753
    break;
36057
39754
 
36058
39755
  case 1907:
 
39756
 
 
39757
/* Line 1455 of yacc.c  */
36059
39758
#line 10548 "preproc.y"
36060
39759
    { 
36061
 
 yyval.str = make_str("as");
 
39760
 (yyval.str) = make_str("as");
36062
39761
;}
36063
39762
    break;
36064
39763
 
36065
39764
  case 1908:
 
39765
 
 
39766
/* Line 1455 of yacc.c  */
36066
39767
#line 10552 "preproc.y"
36067
39768
    { 
36068
 
 yyval.str = make_str("asc");
 
39769
 (yyval.str) = make_str("asc");
36069
39770
;}
36070
39771
    break;
36071
39772
 
36072
39773
  case 1909:
 
39774
 
 
39775
/* Line 1455 of yacc.c  */
36073
39776
#line 10556 "preproc.y"
36074
39777
    { 
36075
 
 yyval.str = make_str("asymmetric");
 
39778
 (yyval.str) = make_str("asymmetric");
36076
39779
;}
36077
39780
    break;
36078
39781
 
36079
39782
  case 1910:
 
39783
 
 
39784
/* Line 1455 of yacc.c  */
36080
39785
#line 10560 "preproc.y"
36081
39786
    { 
36082
 
 yyval.str = make_str("both");
 
39787
 (yyval.str) = make_str("both");
36083
39788
;}
36084
39789
    break;
36085
39790
 
36086
39791
  case 1911:
 
39792
 
 
39793
/* Line 1455 of yacc.c  */
36087
39794
#line 10564 "preproc.y"
36088
39795
    { 
36089
 
 yyval.str = make_str("case");
 
39796
 (yyval.str) = make_str("case");
36090
39797
;}
36091
39798
    break;
36092
39799
 
36093
39800
  case 1912:
 
39801
 
 
39802
/* Line 1455 of yacc.c  */
36094
39803
#line 10568 "preproc.y"
36095
39804
    { 
36096
 
 yyval.str = make_str("cast");
 
39805
 (yyval.str) = make_str("cast");
36097
39806
;}
36098
39807
    break;
36099
39808
 
36100
39809
  case 1913:
 
39810
 
 
39811
/* Line 1455 of yacc.c  */
36101
39812
#line 10572 "preproc.y"
36102
39813
    { 
36103
 
 yyval.str = make_str("check");
 
39814
 (yyval.str) = make_str("check");
36104
39815
;}
36105
39816
    break;
36106
39817
 
36107
39818
  case 1914:
 
39819
 
 
39820
/* Line 1455 of yacc.c  */
36108
39821
#line 10576 "preproc.y"
36109
39822
    { 
36110
 
 yyval.str = make_str("collate");
 
39823
 (yyval.str) = make_str("collate");
36111
39824
;}
36112
39825
    break;
36113
39826
 
36114
39827
  case 1915:
 
39828
 
 
39829
/* Line 1455 of yacc.c  */
36115
39830
#line 10580 "preproc.y"
36116
39831
    { 
36117
 
 yyval.str = make_str("column");
 
39832
 (yyval.str) = make_str("column");
36118
39833
;}
36119
39834
    break;
36120
39835
 
36121
39836
  case 1916:
 
39837
 
 
39838
/* Line 1455 of yacc.c  */
36122
39839
#line 10584 "preproc.y"
36123
39840
    { 
36124
 
 yyval.str = make_str("constraint");
 
39841
 (yyval.str) = make_str("constraint");
36125
39842
;}
36126
39843
    break;
36127
39844
 
36128
39845
  case 1917:
 
39846
 
 
39847
/* Line 1455 of yacc.c  */
36129
39848
#line 10588 "preproc.y"
36130
39849
    { 
36131
 
 yyval.str = make_str("create");
 
39850
 (yyval.str) = make_str("create");
36132
39851
;}
36133
39852
    break;
36134
39853
 
36135
39854
  case 1918:
 
39855
 
 
39856
/* Line 1455 of yacc.c  */
36136
39857
#line 10592 "preproc.y"
36137
39858
    { 
36138
 
 yyval.str = make_str("current_catalog");
 
39859
 (yyval.str) = make_str("current_catalog");
36139
39860
;}
36140
39861
    break;
36141
39862
 
36142
39863
  case 1919:
 
39864
 
 
39865
/* Line 1455 of yacc.c  */
36143
39866
#line 10596 "preproc.y"
36144
39867
    { 
36145
 
 yyval.str = make_str("current_date");
 
39868
 (yyval.str) = make_str("current_date");
36146
39869
;}
36147
39870
    break;
36148
39871
 
36149
39872
  case 1920:
 
39873
 
 
39874
/* Line 1455 of yacc.c  */
36150
39875
#line 10600 "preproc.y"
36151
39876
    { 
36152
 
 yyval.str = make_str("current_role");
 
39877
 (yyval.str) = make_str("current_role");
36153
39878
;}
36154
39879
    break;
36155
39880
 
36156
39881
  case 1921:
 
39882
 
 
39883
/* Line 1455 of yacc.c  */
36157
39884
#line 10604 "preproc.y"
36158
39885
    { 
36159
 
 yyval.str = make_str("current_time");
 
39886
 (yyval.str) = make_str("current_time");
36160
39887
;}
36161
39888
    break;
36162
39889
 
36163
39890
  case 1922:
 
39891
 
 
39892
/* Line 1455 of yacc.c  */
36164
39893
#line 10608 "preproc.y"
36165
39894
    { 
36166
 
 yyval.str = make_str("current_timestamp");
 
39895
 (yyval.str) = make_str("current_timestamp");
36167
39896
;}
36168
39897
    break;
36169
39898
 
36170
39899
  case 1923:
 
39900
 
 
39901
/* Line 1455 of yacc.c  */
36171
39902
#line 10612 "preproc.y"
36172
39903
    { 
36173
 
 yyval.str = make_str("current_user");
 
39904
 (yyval.str) = make_str("current_user");
36174
39905
;}
36175
39906
    break;
36176
39907
 
36177
39908
  case 1924:
 
39909
 
 
39910
/* Line 1455 of yacc.c  */
36178
39911
#line 10616 "preproc.y"
36179
39912
    { 
36180
 
 yyval.str = make_str("default");
 
39913
 (yyval.str) = make_str("default");
36181
39914
;}
36182
39915
    break;
36183
39916
 
36184
39917
  case 1925:
 
39918
 
 
39919
/* Line 1455 of yacc.c  */
36185
39920
#line 10620 "preproc.y"
36186
39921
    { 
36187
 
 yyval.str = make_str("deferrable");
 
39922
 (yyval.str) = make_str("deferrable");
36188
39923
;}
36189
39924
    break;
36190
39925
 
36191
39926
  case 1926:
 
39927
 
 
39928
/* Line 1455 of yacc.c  */
36192
39929
#line 10624 "preproc.y"
36193
39930
    { 
36194
 
 yyval.str = make_str("desc");
 
39931
 (yyval.str) = make_str("desc");
36195
39932
;}
36196
39933
    break;
36197
39934
 
36198
39935
  case 1927:
 
39936
 
 
39937
/* Line 1455 of yacc.c  */
36199
39938
#line 10628 "preproc.y"
36200
39939
    { 
36201
 
 yyval.str = make_str("distinct");
 
39940
 (yyval.str) = make_str("distinct");
36202
39941
;}
36203
39942
    break;
36204
39943
 
36205
39944
  case 1928:
 
39945
 
 
39946
/* Line 1455 of yacc.c  */
36206
39947
#line 10632 "preproc.y"
36207
39948
    { 
36208
 
 yyval.str = make_str("do");
 
39949
 (yyval.str) = make_str("do");
36209
39950
;}
36210
39951
    break;
36211
39952
 
36212
39953
  case 1929:
 
39954
 
 
39955
/* Line 1455 of yacc.c  */
36213
39956
#line 10636 "preproc.y"
36214
39957
    { 
36215
 
 yyval.str = make_str("else");
 
39958
 (yyval.str) = make_str("else");
36216
39959
;}
36217
39960
    break;
36218
39961
 
36219
39962
  case 1930:
 
39963
 
 
39964
/* Line 1455 of yacc.c  */
36220
39965
#line 10640 "preproc.y"
36221
39966
    { 
36222
 
 yyval.str = make_str("end");
 
39967
 (yyval.str) = make_str("end");
36223
39968
;}
36224
39969
    break;
36225
39970
 
36226
39971
  case 1931:
 
39972
 
 
39973
/* Line 1455 of yacc.c  */
36227
39974
#line 10644 "preproc.y"
36228
39975
    { 
36229
 
 yyval.str = make_str("except");
 
39976
 (yyval.str) = make_str("except");
36230
39977
;}
36231
39978
    break;
36232
39979
 
36233
39980
  case 1932:
 
39981
 
 
39982
/* Line 1455 of yacc.c  */
36234
39983
#line 10648 "preproc.y"
36235
39984
    { 
36236
 
 yyval.str = make_str("false");
 
39985
 (yyval.str) = make_str("false");
36237
39986
;}
36238
39987
    break;
36239
39988
 
36240
39989
  case 1933:
 
39990
 
 
39991
/* Line 1455 of yacc.c  */
36241
39992
#line 10652 "preproc.y"
36242
39993
    { 
36243
 
 yyval.str = make_str("fetch");
 
39994
 (yyval.str) = make_str("fetch");
36244
39995
;}
36245
39996
    break;
36246
39997
 
36247
39998
  case 1934:
 
39999
 
 
40000
/* Line 1455 of yacc.c  */
36248
40001
#line 10656 "preproc.y"
36249
40002
    { 
36250
 
 yyval.str = make_str("for");
 
40003
 (yyval.str) = make_str("for");
36251
40004
;}
36252
40005
    break;
36253
40006
 
36254
40007
  case 1935:
 
40008
 
 
40009
/* Line 1455 of yacc.c  */
36255
40010
#line 10660 "preproc.y"
36256
40011
    { 
36257
 
 yyval.str = make_str("foreign");
 
40012
 (yyval.str) = make_str("foreign");
36258
40013
;}
36259
40014
    break;
36260
40015
 
36261
40016
  case 1936:
 
40017
 
 
40018
/* Line 1455 of yacc.c  */
36262
40019
#line 10664 "preproc.y"
36263
40020
    { 
36264
 
 yyval.str = make_str("from");
 
40021
 (yyval.str) = make_str("from");
36265
40022
;}
36266
40023
    break;
36267
40024
 
36268
40025
  case 1937:
 
40026
 
 
40027
/* Line 1455 of yacc.c  */
36269
40028
#line 10668 "preproc.y"
36270
40029
    { 
36271
 
 yyval.str = make_str("grant");
 
40030
 (yyval.str) = make_str("grant");
36272
40031
;}
36273
40032
    break;
36274
40033
 
36275
40034
  case 1938:
 
40035
 
 
40036
/* Line 1455 of yacc.c  */
36276
40037
#line 10672 "preproc.y"
36277
40038
    { 
36278
 
 yyval.str = make_str("group");
 
40039
 (yyval.str) = make_str("group");
36279
40040
;}
36280
40041
    break;
36281
40042
 
36282
40043
  case 1939:
 
40044
 
 
40045
/* Line 1455 of yacc.c  */
36283
40046
#line 10676 "preproc.y"
36284
40047
    { 
36285
 
 yyval.str = make_str("having");
 
40048
 (yyval.str) = make_str("having");
36286
40049
;}
36287
40050
    break;
36288
40051
 
36289
40052
  case 1940:
 
40053
 
 
40054
/* Line 1455 of yacc.c  */
36290
40055
#line 10680 "preproc.y"
36291
40056
    { 
36292
 
 yyval.str = make_str("in");
 
40057
 (yyval.str) = make_str("in");
36293
40058
;}
36294
40059
    break;
36295
40060
 
36296
40061
  case 1941:
 
40062
 
 
40063
/* Line 1455 of yacc.c  */
36297
40064
#line 10684 "preproc.y"
36298
40065
    { 
36299
 
 yyval.str = make_str("initially");
 
40066
 (yyval.str) = make_str("initially");
36300
40067
;}
36301
40068
    break;
36302
40069
 
36303
40070
  case 1942:
 
40071
 
 
40072
/* Line 1455 of yacc.c  */
36304
40073
#line 10688 "preproc.y"
36305
40074
    { 
36306
 
 yyval.str = make_str("intersect");
 
40075
 (yyval.str) = make_str("intersect");
36307
40076
;}
36308
40077
    break;
36309
40078
 
36310
40079
  case 1943:
 
40080
 
 
40081
/* Line 1455 of yacc.c  */
36311
40082
#line 10692 "preproc.y"
36312
40083
    { 
36313
 
 yyval.str = make_str("into");
 
40084
 (yyval.str) = make_str("into");
36314
40085
;}
36315
40086
    break;
36316
40087
 
36317
40088
  case 1944:
 
40089
 
 
40090
/* Line 1455 of yacc.c  */
36318
40091
#line 10696 "preproc.y"
36319
40092
    { 
36320
 
 yyval.str = make_str("leading");
 
40093
 (yyval.str) = make_str("leading");
36321
40094
;}
36322
40095
    break;
36323
40096
 
36324
40097
  case 1945:
 
40098
 
 
40099
/* Line 1455 of yacc.c  */
36325
40100
#line 10700 "preproc.y"
36326
40101
    { 
36327
 
 yyval.str = make_str("limit");
 
40102
 (yyval.str) = make_str("limit");
36328
40103
;}
36329
40104
    break;
36330
40105
 
36331
40106
  case 1946:
 
40107
 
 
40108
/* Line 1455 of yacc.c  */
36332
40109
#line 10704 "preproc.y"
36333
40110
    { 
36334
 
 yyval.str = make_str("localtime");
 
40111
 (yyval.str) = make_str("localtime");
36335
40112
;}
36336
40113
    break;
36337
40114
 
36338
40115
  case 1947:
 
40116
 
 
40117
/* Line 1455 of yacc.c  */
36339
40118
#line 10708 "preproc.y"
36340
40119
    { 
36341
 
 yyval.str = make_str("localtimestamp");
 
40120
 (yyval.str) = make_str("localtimestamp");
36342
40121
;}
36343
40122
    break;
36344
40123
 
36345
40124
  case 1948:
 
40125
 
 
40126
/* Line 1455 of yacc.c  */
36346
40127
#line 10712 "preproc.y"
36347
40128
    { 
36348
 
 yyval.str = make_str("new");
 
40129
 (yyval.str) = make_str("new");
36349
40130
;}
36350
40131
    break;
36351
40132
 
36352
40133
  case 1949:
 
40134
 
 
40135
/* Line 1455 of yacc.c  */
36353
40136
#line 10716 "preproc.y"
36354
40137
    { 
36355
 
 yyval.str = make_str("not");
 
40138
 (yyval.str) = make_str("not");
36356
40139
;}
36357
40140
    break;
36358
40141
 
36359
40142
  case 1950:
 
40143
 
 
40144
/* Line 1455 of yacc.c  */
36360
40145
#line 10720 "preproc.y"
36361
40146
    { 
36362
 
 yyval.str = make_str("null");
 
40147
 (yyval.str) = make_str("null");
36363
40148
;}
36364
40149
    break;
36365
40150
 
36366
40151
  case 1951:
 
40152
 
 
40153
/* Line 1455 of yacc.c  */
36367
40154
#line 10724 "preproc.y"
36368
40155
    { 
36369
 
 yyval.str = make_str("off");
 
40156
 (yyval.str) = make_str("off");
36370
40157
;}
36371
40158
    break;
36372
40159
 
36373
40160
  case 1952:
 
40161
 
 
40162
/* Line 1455 of yacc.c  */
36374
40163
#line 10728 "preproc.y"
36375
40164
    { 
36376
 
 yyval.str = make_str("offset");
 
40165
 (yyval.str) = make_str("offset");
36377
40166
;}
36378
40167
    break;
36379
40168
 
36380
40169
  case 1953:
 
40170
 
 
40171
/* Line 1455 of yacc.c  */
36381
40172
#line 10732 "preproc.y"
36382
40173
    { 
36383
 
 yyval.str = make_str("old");
 
40174
 (yyval.str) = make_str("old");
36384
40175
;}
36385
40176
    break;
36386
40177
 
36387
40178
  case 1954:
 
40179
 
 
40180
/* Line 1455 of yacc.c  */
36388
40181
#line 10736 "preproc.y"
36389
40182
    { 
36390
 
 yyval.str = make_str("on");
 
40183
 (yyval.str) = make_str("on");
36391
40184
;}
36392
40185
    break;
36393
40186
 
36394
40187
  case 1955:
 
40188
 
 
40189
/* Line 1455 of yacc.c  */
36395
40190
#line 10740 "preproc.y"
36396
40191
    { 
36397
 
 yyval.str = make_str("only");
 
40192
 (yyval.str) = make_str("only");
36398
40193
;}
36399
40194
    break;
36400
40195
 
36401
40196
  case 1956:
 
40197
 
 
40198
/* Line 1455 of yacc.c  */
36402
40199
#line 10744 "preproc.y"
36403
40200
    { 
36404
 
 yyval.str = make_str("or");
 
40201
 (yyval.str) = make_str("or");
36405
40202
;}
36406
40203
    break;
36407
40204
 
36408
40205
  case 1957:
 
40206
 
 
40207
/* Line 1455 of yacc.c  */
36409
40208
#line 10748 "preproc.y"
36410
40209
    { 
36411
 
 yyval.str = make_str("order");
 
40210
 (yyval.str) = make_str("order");
36412
40211
;}
36413
40212
    break;
36414
40213
 
36415
40214
  case 1958:
 
40215
 
 
40216
/* Line 1455 of yacc.c  */
36416
40217
#line 10752 "preproc.y"
36417
40218
    { 
36418
 
 yyval.str = make_str("placing");
 
40219
 (yyval.str) = make_str("placing");
36419
40220
;}
36420
40221
    break;
36421
40222
 
36422
40223
  case 1959:
 
40224
 
 
40225
/* Line 1455 of yacc.c  */
36423
40226
#line 10756 "preproc.y"
36424
40227
    { 
36425
 
 yyval.str = make_str("primary");
 
40228
 (yyval.str) = make_str("primary");
36426
40229
;}
36427
40230
    break;
36428
40231
 
36429
40232
  case 1960:
 
40233
 
 
40234
/* Line 1455 of yacc.c  */
36430
40235
#line 10760 "preproc.y"
36431
40236
    { 
36432
 
 yyval.str = make_str("references");
 
40237
 (yyval.str) = make_str("references");
36433
40238
;}
36434
40239
    break;
36435
40240
 
36436
40241
  case 1961:
 
40242
 
 
40243
/* Line 1455 of yacc.c  */
36437
40244
#line 10764 "preproc.y"
36438
40245
    { 
36439
 
 yyval.str = make_str("returning");
 
40246
 (yyval.str) = make_str("returning");
36440
40247
;}
36441
40248
    break;
36442
40249
 
36443
40250
  case 1962:
 
40251
 
 
40252
/* Line 1455 of yacc.c  */
36444
40253
#line 10768 "preproc.y"
36445
40254
    { 
36446
 
 yyval.str = make_str("select");
 
40255
 (yyval.str) = make_str("select");
36447
40256
;}
36448
40257
    break;
36449
40258
 
36450
40259
  case 1963:
 
40260
 
 
40261
/* Line 1455 of yacc.c  */
36451
40262
#line 10772 "preproc.y"
36452
40263
    { 
36453
 
 yyval.str = make_str("session_user");
 
40264
 (yyval.str) = make_str("session_user");
36454
40265
;}
36455
40266
    break;
36456
40267
 
36457
40268
  case 1964:
 
40269
 
 
40270
/* Line 1455 of yacc.c  */
36458
40271
#line 10776 "preproc.y"
36459
40272
    { 
36460
 
 yyval.str = make_str("some");
 
40273
 (yyval.str) = make_str("some");
36461
40274
;}
36462
40275
    break;
36463
40276
 
36464
40277
  case 1965:
 
40278
 
 
40279
/* Line 1455 of yacc.c  */
36465
40280
#line 10780 "preproc.y"
36466
40281
    { 
36467
 
 yyval.str = make_str("symmetric");
 
40282
 (yyval.str) = make_str("symmetric");
36468
40283
;}
36469
40284
    break;
36470
40285
 
36471
40286
  case 1966:
 
40287
 
 
40288
/* Line 1455 of yacc.c  */
36472
40289
#line 10784 "preproc.y"
36473
40290
    { 
36474
 
 yyval.str = make_str("table");
 
40291
 (yyval.str) = make_str("table");
36475
40292
;}
36476
40293
    break;
36477
40294
 
36478
40295
  case 1967:
 
40296
 
 
40297
/* Line 1455 of yacc.c  */
36479
40298
#line 10788 "preproc.y"
36480
40299
    { 
36481
 
 yyval.str = make_str("then");
 
40300
 (yyval.str) = make_str("then");
36482
40301
;}
36483
40302
    break;
36484
40303
 
36485
40304
  case 1968:
 
40305
 
 
40306
/* Line 1455 of yacc.c  */
36486
40307
#line 10792 "preproc.y"
36487
40308
    { 
36488
 
 yyval.str = make_str("trailing");
 
40309
 (yyval.str) = make_str("trailing");
36489
40310
;}
36490
40311
    break;
36491
40312
 
36492
40313
  case 1969:
 
40314
 
 
40315
/* Line 1455 of yacc.c  */
36493
40316
#line 10796 "preproc.y"
36494
40317
    { 
36495
 
 yyval.str = make_str("true");
 
40318
 (yyval.str) = make_str("true");
36496
40319
;}
36497
40320
    break;
36498
40321
 
36499
40322
  case 1970:
 
40323
 
 
40324
/* Line 1455 of yacc.c  */
36500
40325
#line 10800 "preproc.y"
36501
40326
    { 
36502
 
 yyval.str = make_str("unique");
 
40327
 (yyval.str) = make_str("unique");
36503
40328
;}
36504
40329
    break;
36505
40330
 
36506
40331
  case 1971:
 
40332
 
 
40333
/* Line 1455 of yacc.c  */
36507
40334
#line 10804 "preproc.y"
36508
40335
    { 
36509
 
 yyval.str = make_str("user");
 
40336
 (yyval.str) = make_str("user");
36510
40337
;}
36511
40338
    break;
36512
40339
 
36513
40340
  case 1972:
 
40341
 
 
40342
/* Line 1455 of yacc.c  */
36514
40343
#line 10808 "preproc.y"
36515
40344
    { 
36516
 
 yyval.str = make_str("using");
 
40345
 (yyval.str) = make_str("using");
36517
40346
;}
36518
40347
    break;
36519
40348
 
36520
40349
  case 1973:
 
40350
 
 
40351
/* Line 1455 of yacc.c  */
36521
40352
#line 10812 "preproc.y"
36522
40353
    { 
36523
 
 yyval.str = make_str("variadic");
 
40354
 (yyval.str) = make_str("variadic");
36524
40355
;}
36525
40356
    break;
36526
40357
 
36527
40358
  case 1974:
 
40359
 
 
40360
/* Line 1455 of yacc.c  */
36528
40361
#line 10816 "preproc.y"
36529
40362
    { 
36530
 
 yyval.str = make_str("when");
 
40363
 (yyval.str) = make_str("when");
36531
40364
;}
36532
40365
    break;
36533
40366
 
36534
40367
  case 1975:
 
40368
 
 
40369
/* Line 1455 of yacc.c  */
36535
40370
#line 10820 "preproc.y"
36536
40371
    { 
36537
 
 yyval.str = make_str("where");
 
40372
 (yyval.str) = make_str("where");
36538
40373
;}
36539
40374
    break;
36540
40375
 
36541
40376
  case 1976:
 
40377
 
 
40378
/* Line 1455 of yacc.c  */
36542
40379
#line 10824 "preproc.y"
36543
40380
    { 
36544
 
 yyval.str = make_str("window");
 
40381
 (yyval.str) = make_str("window");
36545
40382
;}
36546
40383
    break;
36547
40384
 
36548
40385
  case 1977:
 
40386
 
 
40387
/* Line 1455 of yacc.c  */
36549
40388
#line 10828 "preproc.y"
36550
40389
    { 
36551
 
 yyval.str = make_str("with");
 
40390
 (yyval.str) = make_str("with");
36552
40391
;}
36553
40392
    break;
36554
40393
 
36555
40394
  case 1978:
 
40395
 
 
40396
/* Line 1455 of yacc.c  */
36556
40397
#line 10836 "preproc.y"
36557
40398
    { 
36558
40399
                if (!QueryIsRule)
36559
40400
                        mmerror(PARSE_ERROR, ET_ERROR, "OLD used in query that is not in a rule");
36560
40401
 
36561
 
 yyval.str = make_str("old");
 
40402
 (yyval.str) = make_str("old");
36562
40403
;}
36563
40404
    break;
36564
40405
 
36565
40406
  case 1979:
 
40407
 
 
40408
/* Line 1455 of yacc.c  */
36566
40409
#line 10843 "preproc.y"
36567
40410
    { 
36568
40411
                if (!QueryIsRule)
36569
40412
                        mmerror(PARSE_ERROR, ET_ERROR, "NEW used in query that is not in a rule");
36570
40413
 
36571
 
 yyval.str = make_str("new");
 
40414
 (yyval.str) = make_str("new");
36572
40415
;}
36573
40416
    break;
36574
40417
 
36575
40418
  case 1982:
 
40419
 
 
40420
/* Line 1455 of yacc.c  */
36576
40421
#line 10859 "preproc.y"
36577
40422
    { connection = NULL; ;}
36578
40423
    break;
36579
40424
 
36580
40425
  case 1984:
 
40426
 
 
40427
/* Line 1455 of yacc.c  */
36581
40428
#line 10862 "preproc.y"
36582
40429
    {
36583
 
                        fprintf(yyout, "%s", yyvsp[0].str);
36584
 
                        free(yyvsp[0].str);
 
40430
                        fprintf(yyout, "%s", (yyvsp[(2) - (2)].str));
 
40431
                        free((yyvsp[(2) - (2)].str));
36585
40432
                        output_line_number();
36586
40433
                ;}
36587
40434
    break;
36588
40435
 
36589
40436
  case 1986:
 
40437
 
 
40438
/* Line 1455 of yacc.c  */
36590
40439
#line 10868 "preproc.y"
36591
 
    { fprintf(yyout, "%s", yyvsp[0].str); free(yyvsp[0].str); ;}
 
40440
    { fprintf(yyout, "%s", (yyvsp[(1) - (1)].str)); free((yyvsp[(1) - (1)].str)); ;}
36592
40441
    break;
36593
40442
 
36594
40443
  case 1987:
 
40444
 
 
40445
/* Line 1455 of yacc.c  */
36595
40446
#line 10869 "preproc.y"
36596
 
    { fprintf(yyout, "%s", yyvsp[0].str); free(yyvsp[0].str); ;}
 
40447
    { fprintf(yyout, "%s", (yyvsp[(1) - (1)].str)); free((yyvsp[(1) - (1)].str)); ;}
36597
40448
    break;
36598
40449
 
36599
40450
  case 1988:
 
40451
 
 
40452
/* Line 1455 of yacc.c  */
36600
40453
#line 10870 "preproc.y"
36601
40454
    { braces_open++; fputs("{", yyout); ;}
36602
40455
    break;
36603
40456
 
36604
40457
  case 1989:
 
40458
 
 
40459
/* Line 1455 of yacc.c  */
36605
40460
#line 10871 "preproc.y"
36606
40461
    { remove_typedefs(braces_open); remove_variables(braces_open--); fputs("}", yyout); ;}
36607
40462
    break;
36608
40463
 
36609
40464
  case 1990:
 
40465
 
 
40466
/* Line 1455 of yacc.c  */
36610
40467
#line 10874 "preproc.y"
36611
40468
    {FoundInto = 0;;}
36612
40469
    break;
36613
40470
 
36614
40471
  case 1991:
 
40472
 
 
40473
/* Line 1455 of yacc.c  */
36615
40474
#line 10875 "preproc.y"
36616
40475
    {
36617
40476
                        if (FoundInto == 1)
36618
40477
                                mmerror(PARSE_ERROR, ET_ERROR, "CREATE TABLE AS cannot specify INTO");
36619
40478
 
36620
 
                        yyval.str = cat_str(6, make_str("create"), yyvsp[-6].str, make_str("table"), yyvsp[-4].str, make_str("as"), yyvsp[-1].str);
 
40479
                        (yyval.str) = cat_str(6, make_str("create"), (yyvsp[(2) - (8)].str), make_str("table"), (yyvsp[(4) - (8)].str), make_str("as"), (yyvsp[(7) - (8)].str));
36621
40480
                ;}
36622
40481
    break;
36623
40482
 
36624
40483
  case 1992:
 
40484
 
 
40485
/* Line 1455 of yacc.c  */
36625
40486
#line 10884 "preproc.y"
36626
40487
    {QueryIsRule = 1;;}
36627
40488
    break;
36628
40489
 
36629
40490
  case 1993:
 
40491
 
 
40492
/* Line 1455 of yacc.c  */
36630
40493
#line 10887 "preproc.y"
36631
40494
    {
36632
40495
                        QueryIsRule=0;
36633
 
                        yyval.str = cat_str(12, make_str("create"), yyvsp[-12].str, make_str("rule"), yyvsp[-10].str, make_str("as on"), yyvsp[-6].str, make_str("to"), yyvsp[-4].str, yyvsp[-3].str, make_str("do"), yyvsp[-1].str, yyvsp[0].str);
 
40496
                        (yyval.str) = cat_str(12, make_str("create"), (yyvsp[(2) - (14)].str), make_str("rule"), (yyvsp[(4) - (14)].str), make_str("as on"), (yyvsp[(8) - (14)].str), make_str("to"), (yyvsp[(10) - (14)].str), (yyvsp[(11) - (14)].str), make_str("do"), (yyvsp[(13) - (14)].str), (yyvsp[(14) - (14)].str));
36634
40497
                ;}
36635
40498
    break;
36636
40499
 
36637
40500
  case 1994:
 
40501
 
 
40502
/* Line 1455 of yacc.c  */
36638
40503
#line 10894 "preproc.y"
36639
40504
    {
36640
 
                        connection = yyvsp[0].str;
 
40505
                        connection = (yyvsp[(2) - (2)].str);
36641
40506
                        /*
36642
40507
                         *      Do we have a variable as connection target?
36643
40508
                         *      Remove the variable from the variable
36649
40514
    break;
36650
40515
 
36651
40516
  case 1995:
 
40517
 
 
40518
/* Line 1455 of yacc.c  */
36652
40519
#line 10910 "preproc.y"
36653
 
    { yyval.str = cat_str(5, yyvsp[-2].str, make_str(","), yyvsp[0].str, make_str(","), yyvsp[-1].str); ;}
 
40520
    { (yyval.str) = cat_str(5, (yyvsp[(3) - (5)].str), make_str(","), (yyvsp[(5) - (5)].str), make_str(","), (yyvsp[(4) - (5)].str)); ;}
36654
40521
    break;
36655
40522
 
36656
40523
  case 1996:
 
40524
 
 
40525
/* Line 1455 of yacc.c  */
36657
40526
#line 10912 "preproc.y"
36658
 
    { yyval.str = make_str("NULL, NULL, NULL, \"DEFAULT\""); ;}
 
40527
    { (yyval.str) = make_str("NULL, NULL, NULL, \"DEFAULT\""); ;}
36659
40528
    break;
36660
40529
 
36661
40530
  case 1997:
 
40531
 
 
40532
/* Line 1455 of yacc.c  */
36662
40533
#line 10915 "preproc.y"
36663
 
    { yyval.str = cat_str(3, make_str("NULL,"), yyvsp[0].str, make_str(", NULL")); ;}
 
40534
    { (yyval.str) = cat_str(3, make_str("NULL,"), (yyvsp[(2) - (2)].str), make_str(", NULL")); ;}
36664
40535
    break;
36665
40536
 
36666
40537
  case 1998:
 
40538
 
 
40539
/* Line 1455 of yacc.c  */
36667
40540
#line 10917 "preproc.y"
36668
 
    { yyval.str = cat2_str(yyvsp[0].str, make_str(", NULL, NULL, NULL")); ;}
 
40541
    { (yyval.str) = cat2_str((yyvsp[(2) - (2)].str), make_str(", NULL, NULL, NULL")); ;}
36669
40542
    break;
36670
40543
 
36671
40544
  case 1999:
 
40545
 
 
40546
/* Line 1455 of yacc.c  */
36672
40547
#line 10921 "preproc.y"
36673
40548
    {
36674
40549
                        /* old style: dbname[@server][:port] */
36675
 
                        if (strlen(yyvsp[-1].str) > 0 && *(yyvsp[-1].str) != '@')
36676
 
                                mmerror(PARSE_ERROR, ET_ERROR, "expected \"@\", found \"%s\"", yyvsp[-1].str);
 
40550
                        if (strlen((yyvsp[(2) - (3)].str)) > 0 && *((yyvsp[(2) - (3)].str)) != '@')
 
40551
                                mmerror(PARSE_ERROR, ET_ERROR, "expected \"@\", found \"%s\"", (yyvsp[(2) - (3)].str));
36677
40552
                        
36678
40553
                        /* C strings need to be handled differently */
36679
 
                        if (yyvsp[-2].str[0] == '\"')
36680
 
                                yyval.str = yyvsp[-2].str;
 
40554
                        if ((yyvsp[(1) - (3)].str)[0] == '\"')
 
40555
                                (yyval.str) = (yyvsp[(1) - (3)].str);
36681
40556
                        else
36682
 
                                yyval.str = make3_str(make_str("\""), make3_str(yyvsp[-2].str, yyvsp[-1].str, yyvsp[0].str), make_str("\""));
 
40557
                                (yyval.str) = make3_str(make_str("\""), make3_str((yyvsp[(1) - (3)].str), (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str)), make_str("\""));
36683
40558
                ;}
36684
40559
    break;
36685
40560
 
36686
40561
  case 2000:
 
40562
 
 
40563
/* Line 1455 of yacc.c  */
36687
40564
#line 10933 "preproc.y"
36688
40565
    {
36689
40566
                        /* new style: <tcp|unix>:postgresql://server[:port][/dbname] */
36690
 
                        if (strncmp(yyvsp[-6].str, "unix:postgresql", strlen("unix:postgresql")) != 0 && strncmp(yyvsp[-6].str, "tcp:postgresql", strlen("tcp:postgresql")) != 0)
 
40567
                        if (strncmp((yyvsp[(1) - (7)].str), "unix:postgresql", strlen("unix:postgresql")) != 0 && strncmp((yyvsp[(1) - (7)].str), "tcp:postgresql", strlen("tcp:postgresql")) != 0)
36691
40568
                                mmerror(PARSE_ERROR, ET_ERROR, "only protocols \"tcp\" and \"unix\" and database type \"postgresql\" are supported");
36692
40569
 
36693
 
                        if (strncmp(yyvsp[-4].str, "//", strlen("//")) != 0)
36694
 
                                mmerror(PARSE_ERROR, ET_ERROR, "expected \"://\", found \"%s\"", yyvsp[-4].str);
36695
 
 
36696
 
                        if (strncmp(yyvsp[-6].str, "unix", strlen("unix")) == 0 &&
36697
 
                                strncmp(yyvsp[-4].str + strlen("//"), "localhost", strlen("localhost")) != 0 &&
36698
 
                                strncmp(yyvsp[-4].str + strlen("//"), "127.0.0.1", strlen("127.0.0.1")) != 0)
36699
 
                                mmerror(PARSE_ERROR, ET_ERROR, "Unix-domain sockets only work on \"localhost\" but not on \"%s\"", yyvsp[-4].str + strlen("//"));
36700
 
 
36701
 
                        yyval.str = make3_str(make3_str(make_str("\""), yyvsp[-6].str, make_str(":")), yyvsp[-4].str, make3_str(make3_str(yyvsp[-3].str, make_str("/"), yyvsp[-1].str), yyvsp[0].str, make_str("\"")));
 
40570
                        if (strncmp((yyvsp[(3) - (7)].str), "//", strlen("//")) != 0)
 
40571
                                mmerror(PARSE_ERROR, ET_ERROR, "expected \"://\", found \"%s\"", (yyvsp[(3) - (7)].str));
 
40572
 
 
40573
                        if (strncmp((yyvsp[(1) - (7)].str), "unix", strlen("unix")) == 0 &&
 
40574
                                strncmp((yyvsp[(3) - (7)].str) + strlen("//"), "localhost", strlen("localhost")) != 0 &&
 
40575
                                strncmp((yyvsp[(3) - (7)].str) + strlen("//"), "127.0.0.1", strlen("127.0.0.1")) != 0)
 
40576
                                mmerror(PARSE_ERROR, ET_ERROR, "Unix-domain sockets only work on \"localhost\" but not on \"%s\"", (yyvsp[(3) - (7)].str) + strlen("//"));
 
40577
 
 
40578
                        (yyval.str) = make3_str(make3_str(make_str("\""), (yyvsp[(1) - (7)].str), make_str(":")), (yyvsp[(3) - (7)].str), make3_str(make3_str((yyvsp[(4) - (7)].str), make_str("/"), (yyvsp[(6) - (7)].str)),   (yyvsp[(7) - (7)].str), make_str("\"")));
36702
40579
                ;}
36703
40580
    break;
36704
40581
 
36705
40582
  case 2001:
 
40583
 
 
40584
/* Line 1455 of yacc.c  */
36706
40585
#line 10949 "preproc.y"
36707
40586
    {
36708
 
                        yyval.str = yyvsp[0].str;
 
40587
                        (yyval.str) = (yyvsp[(1) - (1)].str);
36709
40588
                ;}
36710
40589
    break;
36711
40590
 
36712
40591
  case 2002:
 
40592
 
 
40593
/* Line 1455 of yacc.c  */
36713
40594
#line 10953 "preproc.y"
36714
40595
    {
36715
40596
                        /* We can only process double quoted strings not single quotes ones,
36716
40597
                         * so we change the quotes.
36717
40598
                         * Note, that the rule for ecpg_sconst adds these single quotes. */
36718
 
                        yyvsp[0].str[0] = '\"';
36719
 
                        yyvsp[0].str[strlen(yyvsp[0].str)-1] = '\"';
36720
 
                        yyval.str = yyvsp[0].str;
 
40599
                        (yyvsp[(1) - (1)].str)[0] = '\"';
 
40600
                        (yyvsp[(1) - (1)].str)[strlen((yyvsp[(1) - (1)].str))-1] = '\"';
 
40601
                        (yyval.str) = (yyvsp[(1) - (1)].str);
36721
40602
                ;}
36722
40603
    break;
36723
40604
 
36724
40605
  case 2003:
 
40606
 
 
40607
/* Line 1455 of yacc.c  */
36725
40608
#line 10963 "preproc.y"
36726
 
    { yyval.str = yyvsp[0].str; ;}
 
40609
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
36727
40610
    break;
36728
40611
 
36729
40612
  case 2004:
 
40613
 
 
40614
/* Line 1455 of yacc.c  */
36730
40615
#line 10964 "preproc.y"
36731
 
    { yyval.str = EMPTY; ;}
 
40616
    { (yyval.str) = EMPTY; ;}
36732
40617
    break;
36733
40618
 
36734
40619
  case 2005:
 
40620
 
 
40621
/* Line 1455 of yacc.c  */
36735
40622
#line 10968 "preproc.y"
36736
40623
    {
36737
 
                        if (strcmp(yyvsp[0].str, "postgresql") != 0 && strcmp(yyvsp[0].str, "postgres") != 0)
36738
 
                                mmerror(PARSE_ERROR, ET_ERROR, "expected \"postgresql\", found \"%s\"", yyvsp[0].str);
36739
 
 
36740
 
                        if (strcmp(yyvsp[-1].str, "tcp") != 0 && strcmp(yyvsp[-1].str, "unix") != 0)
36741
 
                                mmerror(PARSE_ERROR, ET_ERROR, "invalid connection type: %s", yyvsp[-1].str);
36742
 
 
36743
 
                        yyval.str = make3_str(yyvsp[-1].str, make_str(":"), yyvsp[0].str);
 
40624
                        if (strcmp((yyvsp[(2) - (2)].str), "postgresql") != 0 && strcmp((yyvsp[(2) - (2)].str), "postgres") != 0)
 
40625
                                mmerror(PARSE_ERROR, ET_ERROR, "expected \"postgresql\", found \"%s\"", (yyvsp[(2) - (2)].str));
 
40626
 
 
40627
                        if (strcmp((yyvsp[(1) - (2)].str), "tcp") != 0 && strcmp((yyvsp[(1) - (2)].str), "unix") != 0)
 
40628
                                mmerror(PARSE_ERROR, ET_ERROR, "invalid connection type: %s", (yyvsp[(1) - (2)].str));
 
40629
 
 
40630
                        (yyval.str) = make3_str((yyvsp[(1) - (2)].str), make_str(":"), (yyvsp[(2) - (2)].str));
36744
40631
                ;}
36745
40632
    break;
36746
40633
 
36747
40634
  case 2006:
 
40635
 
 
40636
/* Line 1455 of yacc.c  */
36748
40637
#line 10980 "preproc.y"
36749
40638
    {
36750
 
                        if (strcmp(yyvsp[-1].str, "@") != 0 && strcmp(yyvsp[-1].str, "//") != 0)
36751
 
                                mmerror(PARSE_ERROR, ET_ERROR, "expected \"@\" or \"://\", found \"%s\"", yyvsp[-1].str);
 
40639
                        if (strcmp((yyvsp[(1) - (2)].str), "@") != 0 && strcmp((yyvsp[(1) - (2)].str), "//") != 0)
 
40640
                                mmerror(PARSE_ERROR, ET_ERROR, "expected \"@\" or \"://\", found \"%s\"", (yyvsp[(1) - (2)].str));
36752
40641
 
36753
 
                        yyval.str = make2_str(yyvsp[-1].str, yyvsp[0].str);
 
40642
                        (yyval.str) = make2_str((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str));
36754
40643
                ;}
36755
40644
    break;
36756
40645
 
36757
40646
  case 2007:
 
40647
 
 
40648
/* Line 1455 of yacc.c  */
36758
40649
#line 10988 "preproc.y"
36759
 
    { yyval.str = yyvsp[0].str; ;}
 
40650
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
36760
40651
    break;
36761
40652
 
36762
40653
  case 2008:
 
40654
 
 
40655
/* Line 1455 of yacc.c  */
36763
40656
#line 10989 "preproc.y"
36764
 
    { yyval.str = EMPTY; ;}
 
40657
    { (yyval.str) = EMPTY; ;}
36765
40658
    break;
36766
40659
 
36767
40660
  case 2009:
 
40661
 
 
40662
/* Line 1455 of yacc.c  */
36768
40663
#line 10992 "preproc.y"
36769
 
    { yyval.str = yyvsp[0].str; ;}
 
40664
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
36770
40665
    break;
36771
40666
 
36772
40667
  case 2010:
 
40668
 
 
40669
/* Line 1455 of yacc.c  */
36773
40670
#line 10993 "preproc.y"
36774
 
    { yyval.str = make3_str(yyvsp[-2].str, make_str("."), yyvsp[0].str); ;}
 
40671
    { (yyval.str) = make3_str((yyvsp[(1) - (3)].str), make_str("."), (yyvsp[(3) - (3)].str)); ;}
36775
40672
    break;
36776
40673
 
36777
40674
  case 2011:
 
40675
 
 
40676
/* Line 1455 of yacc.c  */
36778
40677
#line 10994 "preproc.y"
36779
 
    { yyval.str = make_name(); ;}
 
40678
    { (yyval.str) = make_name(); ;}
36780
40679
    break;
36781
40680
 
36782
40681
  case 2012:
 
40682
 
 
40683
/* Line 1455 of yacc.c  */
36783
40684
#line 10997 "preproc.y"
36784
 
    { yyval.str = make2_str(make_str(":"), yyvsp[0].str); ;}
 
40685
    { (yyval.str) = make2_str(make_str(":"), (yyvsp[(2) - (2)].str)); ;}
36785
40686
    break;
36786
40687
 
36787
40688
  case 2013:
 
40689
 
 
40690
/* Line 1455 of yacc.c  */
36788
40691
#line 10998 "preproc.y"
36789
 
    { yyval.str = EMPTY; ;}
 
40692
    { (yyval.str) = EMPTY; ;}
36790
40693
    break;
36791
40694
 
36792
40695
  case 2014:
 
40696
 
 
40697
/* Line 1455 of yacc.c  */
36793
40698
#line 11001 "preproc.y"
36794
 
    { yyval.str = yyvsp[0].str; ;}
 
40699
    { (yyval.str) = (yyvsp[(2) - (2)].str); ;}
36795
40700
    break;
36796
40701
 
36797
40702
  case 2015:
 
40703
 
 
40704
/* Line 1455 of yacc.c  */
36798
40705
#line 11002 "preproc.y"
36799
 
    { yyval.str = make_str("NULL"); ;}
 
40706
    { (yyval.str) = make_str("NULL"); ;}
36800
40707
    break;
36801
40708
 
36802
40709
  case 2016:
 
40710
 
 
40711
/* Line 1455 of yacc.c  */
36803
40712
#line 11005 "preproc.y"
36804
 
    { yyval.str = yyvsp[0].str; ;}
 
40713
    { (yyval.str) = (yyvsp[(2) - (2)].str); ;}
36805
40714
    break;
36806
40715
 
36807
40716
  case 2017:
 
40717
 
 
40718
/* Line 1455 of yacc.c  */
36808
40719
#line 11006 "preproc.y"
36809
 
    { yyval.str = make_str("NULL, NULL"); ;}
 
40720
    { (yyval.str) = make_str("NULL, NULL"); ;}
36810
40721
    break;
36811
40722
 
36812
40723
  case 2018:
 
40724
 
 
40725
/* Line 1455 of yacc.c  */
36813
40726
#line 11010 "preproc.y"
36814
 
    { yyval.str = cat2_str(yyvsp[0].str, make_str(", NULL")); ;}
 
40727
    { (yyval.str) = cat2_str((yyvsp[(1) - (1)].str), make_str(", NULL")); ;}
36815
40728
    break;
36816
40729
 
36817
40730
  case 2019:
 
40731
 
 
40732
/* Line 1455 of yacc.c  */
36818
40733
#line 11012 "preproc.y"
36819
 
    { yyval.str = cat_str(3, yyvsp[-2].str, make_str(","), yyvsp[0].str); ;}
 
40734
    { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str(","), (yyvsp[(3) - (3)].str)); ;}
36820
40735
    break;
36821
40736
 
36822
40737
  case 2020:
 
40738
 
 
40739
/* Line 1455 of yacc.c  */
36823
40740
#line 11014 "preproc.y"
36824
 
    { yyval.str = cat_str(3, yyvsp[-3].str, make_str(","), yyvsp[0].str); ;}
 
40741
    { (yyval.str) = cat_str(3, (yyvsp[(1) - (4)].str), make_str(","), (yyvsp[(4) - (4)].str)); ;}
36825
40742
    break;
36826
40743
 
36827
40744
  case 2021:
 
40745
 
 
40746
/* Line 1455 of yacc.c  */
36828
40747
#line 11016 "preproc.y"
36829
 
    { yyval.str = cat_str(3, yyvsp[-2].str, make_str(","), yyvsp[0].str); ;}
 
40748
    { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str(","), (yyvsp[(3) - (3)].str)); ;}
36830
40749
    break;
36831
40750
 
36832
40751
  case 2022:
 
40752
 
 
40753
/* Line 1455 of yacc.c  */
36833
40754
#line 11020 "preproc.y"
36834
40755
    {
36835
 
                        if (yyvsp[0].str[0] == '\"')
36836
 
                                yyval.str = yyvsp[0].str;
 
40756
                        if ((yyvsp[(1) - (1)].str)[0] == '\"')
 
40757
                                (yyval.str) = (yyvsp[(1) - (1)].str);
36837
40758
                        else
36838
 
                                yyval.str = make3_str(make_str("\""), yyvsp[0].str, make_str("\""));
 
40759
                                (yyval.str) = make3_str(make_str("\""), (yyvsp[(1) - (1)].str), make_str("\""));
36839
40760
                ;}
36840
40761
    break;
36841
40762
 
36842
40763
  case 2023:
 
40764
 
 
40765
/* Line 1455 of yacc.c  */
36843
40766
#line 11027 "preproc.y"
36844
40767
    {
36845
 
                        if (yyvsp[0].str[0] == '\"')
36846
 
                                yyval.str = yyvsp[0].str;
 
40768
                        if ((yyvsp[(1) - (1)].str)[0] == '\"')
 
40769
                                (yyval.str) = (yyvsp[(1) - (1)].str);
36847
40770
                        else
36848
 
                                yyval.str = make3_str(make_str("\""), yyvsp[0].str, make_str("\""));
 
40771
                                (yyval.str) = make3_str(make_str("\""), (yyvsp[(1) - (1)].str), make_str("\""));
36849
40772
                ;}
36850
40773
    break;
36851
40774
 
36852
40775
  case 2024:
 
40776
 
 
40777
/* Line 1455 of yacc.c  */
36853
40778
#line 11034 "preproc.y"
36854
40779
    {
36855
40780
                        enum ECPGttype type = argsinsert->variable->type->type;
36860
40785
 
36861
40786
                        /* handle varchars */
36862
40787
                        if (type == ECPGt_varchar)
36863
 
                                yyval.str = make2_str(mm_strdup(argsinsert->variable->name), make_str(".arr"));
 
40788
                                (yyval.str) = make2_str(mm_strdup(argsinsert->variable->name), make_str(".arr"));
36864
40789
                        else
36865
 
                                yyval.str = mm_strdup(argsinsert->variable->name);
 
40790
                                (yyval.str) = mm_strdup(argsinsert->variable->name);
36866
40791
                ;}
36867
40792
    break;
36868
40793
 
36869
40794
  case 2025:
 
40795
 
 
40796
/* Line 1455 of yacc.c  */
36870
40797
#line 11050 "preproc.y"
36871
40798
    {
36872
40799
                        /* check if we have a string variable */
36873
 
                        struct variable *p = find_variable(yyvsp[0].str);
 
40800
                        struct variable *p = find_variable((yyvsp[(1) - (1)].str));
36874
40801
                        enum ECPGttype type = p->type->type;
36875
40802
 
36876
40803
                        /* If we have just one character this is not a string */
36886
40813
                                {
36887
40814
                                        case ECPGt_char:
36888
40815
                                        case ECPGt_unsigned_char:
36889
 
                                                yyval.str = yyvsp[0].str;
 
40816
                                                (yyval.str) = (yyvsp[(1) - (1)].str);
36890
40817
                                                break;
36891
40818
                                        case ECPGt_varchar:
36892
 
                                                yyval.str = make2_str(yyvsp[0].str, make_str(".arr"));
 
40819
                                                (yyval.str) = make2_str((yyvsp[(1) - (1)].str), make_str(".arr"));
36893
40820
                                                break;
36894
40821
                                        default:
36895
40822
                                                mmerror(PARSE_ERROR, ET_ERROR, "invalid data type");
36896
 
                                                yyval.str = yyvsp[0].str;
 
40823
                                                (yyval.str) = (yyvsp[(1) - (1)].str);
36897
40824
                                                break;
36898
40825
                                }
36899
40826
                        }
36901
40828
    break;
36902
40829
 
36903
40830
  case 2026:
 
40831
 
 
40832
/* Line 1455 of yacc.c  */
36904
40833
#line 11083 "preproc.y"
36905
40834
    {
36906
 
                        if (strlen(yyvsp[-1].str) == 0)
 
40835
                        if (strlen((yyvsp[(1) - (2)].str)) == 0)
36907
40836
                                mmerror(PARSE_ERROR, ET_ERROR, "incomplete statement");
36908
40837
 
36909
 
                        if (strcmp(yyvsp[-1].str, "?") != 0)
36910
 
                                mmerror(PARSE_ERROR, ET_ERROR, "unrecognized token \"%s\"", yyvsp[-1].str);
 
40838
                        if (strcmp((yyvsp[(1) - (2)].str), "?") != 0)
 
40839
                                mmerror(PARSE_ERROR, ET_ERROR, "unrecognized token \"%s\"", (yyvsp[(1) - (2)].str));
36911
40840
 
36912
 
                        yyval.str = make2_str(make_str("?"), yyvsp[0].str);
 
40841
                        (yyval.str) = make2_str(make_str("?"), (yyvsp[(2) - (2)].str));
36913
40842
                ;}
36914
40843
    break;
36915
40844
 
36916
40845
  case 2027:
 
40846
 
 
40847
/* Line 1455 of yacc.c  */
36917
40848
#line 11092 "preproc.y"
36918
 
    { yyval.str = EMPTY; ;}
 
40849
    { (yyval.str) = EMPTY; ;}
36919
40850
    break;
36920
40851
 
36921
40852
  case 2028:
 
40853
 
 
40854
/* Line 1455 of yacc.c  */
36922
40855
#line 11096 "preproc.y"
36923
 
    { yyval.str = make2_str(yyvsp[-1].str, yyvsp[0].str); ;}
 
40856
    { (yyval.str) = make2_str((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); ;}
36924
40857
    break;
36925
40858
 
36926
40859
  case 2029:
 
40860
 
 
40861
/* Line 1455 of yacc.c  */
36927
40862
#line 11098 "preproc.y"
36928
40863
    {
36929
 
                                if (strlen(yyvsp[-1].str) == 0)
 
40864
                                if (strlen((yyvsp[(3) - (4)].str)) == 0)
36930
40865
                                        mmerror(PARSE_ERROR, ET_ERROR, "incomplete statement");
36931
40866
 
36932
 
                                if (strcmp(yyvsp[-1].str, "&") != 0)
36933
 
                                        mmerror(PARSE_ERROR, ET_ERROR, "unrecognized token \"%s\"", yyvsp[-1].str);
 
40867
                                if (strcmp((yyvsp[(3) - (4)].str), "&") != 0)
 
40868
                                        mmerror(PARSE_ERROR, ET_ERROR, "unrecognized token \"%s\"", (yyvsp[(3) - (4)].str));
36934
40869
 
36935
 
                                yyval.str = cat_str(3, make2_str(yyvsp[-3].str, yyvsp[-2].str), yyvsp[-1].str, yyvsp[0].str);
 
40870
                                (yyval.str) = cat_str(3, make2_str((yyvsp[(1) - (4)].str), (yyvsp[(2) - (4)].str)), (yyvsp[(3) - (4)].str), (yyvsp[(4) - (4)].str));
36936
40871
                        ;}
36937
40872
    break;
36938
40873
 
36939
40874
  case 2030:
 
40875
 
 
40876
/* Line 1455 of yacc.c  */
36940
40877
#line 11110 "preproc.y"
36941
 
    { yyval.str = EMPTY; ;}
 
40878
    { (yyval.str) = EMPTY; ;}
36942
40879
    break;
36943
40880
 
36944
40881
  case 2031:
 
40882
 
 
40883
/* Line 1455 of yacc.c  */
36945
40884
#line 11112 "preproc.y"
36946
 
    { yyval.str = make2_str(make_str("="), yyvsp[0].str); ;}
 
40885
    { (yyval.str) = make2_str(make_str("="), (yyvsp[(2) - (2)].str)); ;}
36947
40886
    break;
36948
40887
 
36949
40888
  case 2032:
 
40889
 
 
40890
/* Line 1455 of yacc.c  */
36950
40891
#line 11114 "preproc.y"
36951
 
    { yyval.str = make2_str(make_str("="), yyvsp[0].str); ;}
 
40892
    { (yyval.str) = make2_str(make_str("="), (yyvsp[(2) - (2)].str)); ;}
36952
40893
    break;
36953
40894
 
36954
40895
  case 2033:
 
40896
 
 
40897
/* Line 1455 of yacc.c  */
36955
40898
#line 11116 "preproc.y"
36956
 
    { yyval.str = make2_str(make_str("="), yyvsp[0].str); ;}
 
40899
    { (yyval.str) = make2_str(make_str("="), (yyvsp[(2) - (2)].str)); ;}
36957
40900
    break;
36958
40901
 
36959
40902
  case 2034:
 
40903
 
 
40904
/* Line 1455 of yacc.c  */
36960
40905
#line 11119 "preproc.y"
36961
40906
    {
36962
 
                                        if (yyvsp[0].str[0] == '\"' && yyvsp[0].str[strlen(yyvsp[0].str)-1] == '\"') /* already quoted? */
36963
 
                                                yyval.str = yyvsp[0].str;
 
40907
                                        if ((yyvsp[(1) - (1)].str)[0] == '\"' && (yyvsp[(1) - (1)].str)[strlen((yyvsp[(1) - (1)].str))-1] == '\"') /* already quoted? */
 
40908
                                                (yyval.str) = (yyvsp[(1) - (1)].str);
36964
40909
                                        else /* not quoted => convert to lowercase */
36965
40910
                                        {
36966
40911
                                                int i;
36967
40912
 
36968
 
                                                for (i = 0; i< strlen(yyvsp[0].str); i++)
36969
 
                                                        yyvsp[0].str[i] = tolower((unsigned char) yyvsp[0].str[i]);
 
40913
                                                for (i = 0; i< strlen((yyvsp[(1) - (1)].str)); i++)
 
40914
                                                        (yyvsp[(1) - (1)].str)[i] = tolower((unsigned char) (yyvsp[(1) - (1)].str)[i]);
36970
40915
 
36971
 
                                                yyval.str = make3_str(make_str("\""), yyvsp[0].str, make_str("\""));
 
40916
                                                (yyval.str) = make3_str(make_str("\""), (yyvsp[(1) - (1)].str), make_str("\""));
36972
40917
                                        }
36973
40918
                                ;}
36974
40919
    break;
36975
40920
 
36976
40921
  case 2035:
 
40922
 
 
40923
/* Line 1455 of yacc.c  */
36977
40924
#line 11132 "preproc.y"
36978
 
    { yyval.str = yyvsp[0].str; ;}
 
40925
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
36979
40926
    break;
36980
40927
 
36981
40928
  case 2036:
 
40929
 
 
40930
/* Line 1455 of yacc.c  */
36982
40931
#line 11140 "preproc.y"
36983
40932
    {
36984
40933
                        struct cursor *ptr, *this;
36987
40936
 
36988
40937
                        for (ptr = cur; ptr != NULL; ptr = ptr->next)
36989
40938
                        {
36990
 
                                if (strcmp(yyvsp[-5].str, ptr->name) == 0)
 
40939
                                if (strcmp((yyvsp[(2) - (7)].str), ptr->name) == 0)
36991
40940
                                        /* re-definition is a bug */
36992
 
                                        mmerror(PARSE_ERROR, ET_ERROR, "cursor \"%s\" is already defined", yyvsp[-5].str);
 
40941
                                        mmerror(PARSE_ERROR, ET_ERROR, "cursor \"%s\" is already defined", (yyvsp[(2) - (7)].str));
36993
40942
                        }
36994
40943
 
36995
40944
                        this = (struct cursor *) mm_alloc(sizeof(struct cursor));
36996
40945
 
36997
40946
                        /* initial definition */
36998
40947
                        this->next = cur;
36999
 
                        this->name = yyvsp[-5].str;
 
40948
                        this->name = (yyvsp[(2) - (7)].str);
37000
40949
                        this->connection = connection;
37001
 
                        this->command =  cat_str(6, make_str("declare"), mm_strdup(yyvsp[-5].str), yyvsp[-4].str, make_str("cursor"), yyvsp[-2].str, make_str("for $1"));
 
40950
                        this->command =  cat_str(6, make_str("declare"), mm_strdup((yyvsp[(2) - (7)].str)), (yyvsp[(3) - (7)].str), make_str("cursor"), (yyvsp[(5) - (7)].str), make_str("for $1"));
37002
40951
                        this->argsresult = NULL;
37003
40952
 
37004
40953
                        thisquery->type = &ecpg_query;
37005
40954
                        thisquery->brace_level = 0;
37006
40955
                        thisquery->next = NULL;
37007
 
                        thisquery->name = (char *) mm_alloc(sizeof("ECPGprepared_statement(, , __LINE__)") + strlen(con) + strlen(yyvsp[0].str));
37008
 
                        sprintf(thisquery->name, "ECPGprepared_statement(%s, %s, __LINE__)", con, yyvsp[0].str);
 
40956
                        thisquery->name = (char *) mm_alloc(sizeof("ECPGprepared_statement(, , __LINE__)") + strlen(con) + strlen((yyvsp[(7) - (7)].str)));
 
40957
                        sprintf(thisquery->name, "ECPGprepared_statement(%s, %s, __LINE__)", con, (yyvsp[(7) - (7)].str));
37009
40958
 
37010
40959
                        this->argsinsert = NULL;
37011
40960
                        add_variable_to_head(&(this->argsinsert), thisquery, &no_indicator);
37012
40961
 
37013
40962
                        cur = this;
37014
40963
 
37015
 
                        yyval.str = cat_str(3, make_str("/*"), mm_strdup(this->command), make_str("*/"));
 
40964
                        (yyval.str) = cat_str(3, make_str("/*"), mm_strdup(this->command), make_str("*/"));
37016
40965
                ;}
37017
40966
    break;
37018
40967
 
37019
40968
  case 2037:
 
40969
 
 
40970
/* Line 1455 of yacc.c  */
37020
40971
#line 11177 "preproc.y"
37021
40972
    { 
37022
40973
                          /* execute immediate means prepare the statement and
37023
40974
                           * immediately execute it */
37024
 
                          yyval.str = yyvsp[0].str;
 
40975
                          (yyval.str) = (yyvsp[(3) - (3)].str);
37025
40976
                        ;}
37026
40977
    break;
37027
40978
 
37028
40979
  case 2039:
 
40980
 
 
40981
/* Line 1455 of yacc.c  */
37029
40982
#line 11187 "preproc.y"
37030
 
    { yyval.str = yyvsp[0].str; ;}
 
40983
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
37031
40984
    break;
37032
40985
 
37033
40986
  case 2040:
 
40987
 
 
40988
/* Line 1455 of yacc.c  */
37034
40989
#line 11188 "preproc.y"
37035
 
    { yyval.str = yyvsp[0].str; ;}
 
40990
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
37036
40991
    break;
37037
40992
 
37038
40993
  case 2041:
 
40994
 
 
40995
/* Line 1455 of yacc.c  */
37039
40996
#line 11191 "preproc.y"
37040
 
    { yyval.str = yyvsp[0].str; ;}
 
40997
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
37041
40998
    break;
37042
40999
 
37043
41000
  case 2042:
 
41001
 
 
41002
/* Line 1455 of yacc.c  */
37044
41003
#line 11193 "preproc.y"
37045
 
    { yyval.str = yyvsp[0].str; ;}
 
41004
    { (yyval.str) = (yyvsp[(2) - (2)].str); ;}
37046
41005
    break;
37047
41006
 
37048
41007
  case 2043:
 
41008
 
 
41009
/* Line 1455 of yacc.c  */
37049
41010
#line 11194 "preproc.y"
37050
 
    { yyval.str = EMPTY; ;}
 
41011
    { (yyval.str) = EMPTY; ;}
37051
41012
    break;
37052
41013
 
37053
41014
  case 2044:
 
41015
 
 
41016
/* Line 1455 of yacc.c  */
37054
41017
#line 11197 "preproc.y"
37055
 
    { yyval.str = yyvsp[0].str; ;}
 
41018
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
37056
41019
    break;
37057
41020
 
37058
41021
  case 2045:
 
41022
 
 
41023
/* Line 1455 of yacc.c  */
37059
41024
#line 11198 "preproc.y"
37060
 
    { yyval.str = make_str("year to minute"); ;}
 
41025
    { (yyval.str) = make_str("year to minute"); ;}
37061
41026
    break;
37062
41027
 
37063
41028
  case 2046:
 
41029
 
 
41030
/* Line 1455 of yacc.c  */
37064
41031
#line 11199 "preproc.y"
37065
 
    { yyval.str = make_str("year to second"); ;}
 
41032
    { (yyval.str) = make_str("year to second"); ;}
37066
41033
    break;
37067
41034
 
37068
41035
  case 2047:
 
41036
 
 
41037
/* Line 1455 of yacc.c  */
37069
41038
#line 11200 "preproc.y"
37070
 
    { yyval.str = make_str("day to day"); ;}
 
41039
    { (yyval.str) = make_str("day to day"); ;}
37071
41040
    break;
37072
41041
 
37073
41042
  case 2048:
 
41043
 
 
41044
/* Line 1455 of yacc.c  */
37074
41045
#line 11201 "preproc.y"
37075
 
    { yyval.str = make_str("month to month"); ;}
 
41046
    { (yyval.str) = make_str("month to month"); ;}
37076
41047
    break;
37077
41048
 
37078
41049
  case 2049:
 
41050
 
 
41051
/* Line 1455 of yacc.c  */
37079
41052
#line 11208 "preproc.y"
37080
41053
    { fputs("/* exec sql begin declare section */", yyout); ;}
37081
41054
    break;
37082
41055
 
37083
41056
  case 2050:
 
41057
 
 
41058
/* Line 1455 of yacc.c  */
37084
41059
#line 11210 "preproc.y"
37085
41060
    {
37086
 
                        fprintf(yyout, "%s/* exec sql end declare section */", yyvsp[-1].str);
37087
 
                        free(yyvsp[-1].str);
 
41061
                        fprintf(yyout, "%s/* exec sql end declare section */", (yyvsp[(3) - (4)].str));
 
41062
                        free((yyvsp[(3) - (4)].str));
37088
41063
                        output_line_number();
37089
41064
                ;}
37090
41065
    break;
37091
41066
 
37092
41067
  case 2051:
 
41068
 
 
41069
/* Line 1455 of yacc.c  */
37093
41070
#line 11217 "preproc.y"
37094
41071
    {;}
37095
41072
    break;
37096
41073
 
37097
41074
  case 2052:
 
41075
 
 
41076
/* Line 1455 of yacc.c  */
37098
41077
#line 11219 "preproc.y"
37099
41078
    {;}
37100
41079
    break;
37101
41080
 
37102
41081
  case 2053:
 
41082
 
 
41083
/* Line 1455 of yacc.c  */
37103
41084
#line 11221 "preproc.y"
37104
 
    { yyval.str = EMPTY; ;}
 
41085
    { (yyval.str) = EMPTY; ;}
37105
41086
    break;
37106
41087
 
37107
41088
  case 2054:
 
41089
 
 
41090
/* Line 1455 of yacc.c  */
37108
41091
#line 11222 "preproc.y"
37109
 
    { yyval.str = yyvsp[0].str; ;}
 
41092
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
37110
41093
    break;
37111
41094
 
37112
41095
  case 2055:
 
41096
 
 
41097
/* Line 1455 of yacc.c  */
37113
41098
#line 11223 "preproc.y"
37114
 
    { yyval.str = yyvsp[0].str; ;}
 
41099
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
37115
41100
    break;
37116
41101
 
37117
41102
  case 2056:
 
41103
 
 
41104
/* Line 1455 of yacc.c  */
37118
41105
#line 11226 "preproc.y"
37119
 
    { yyval.str = yyvsp[0].str; ;}
 
41106
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
37120
41107
    break;
37121
41108
 
37122
41109
  case 2057:
 
41110
 
 
41111
/* Line 1455 of yacc.c  */
37123
41112
#line 11227 "preproc.y"
37124
 
    { yyval.str = yyvsp[0].str; ;}
 
41113
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
37125
41114
    break;
37126
41115
 
37127
41116
  case 2058:
 
41117
 
 
41118
/* Line 1455 of yacc.c  */
37128
41119
#line 11228 "preproc.y"
37129
 
    { yyval.str = cat2_str(yyvsp[-1].str, yyvsp[0].str); ;}
 
41120
    { (yyval.str) = cat2_str((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); ;}
37130
41121
    break;
37131
41122
 
37132
41123
  case 2059:
 
41124
 
 
41125
/* Line 1455 of yacc.c  */
37133
41126
#line 11229 "preproc.y"
37134
 
    { yyval.str = cat2_str(yyvsp[-1].str, yyvsp[0].str); ;}
 
41127
    { (yyval.str) = cat2_str((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); ;}
37135
41128
    break;
37136
41129
 
37137
41130
  case 2060:
 
41131
 
 
41132
/* Line 1455 of yacc.c  */
37138
41133
#line 11230 "preproc.y"
37139
 
    { yyval.str = cat2_str(yyvsp[-1].str, yyvsp[0].str); ;}
 
41134
    { (yyval.str) = cat2_str((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); ;}
37140
41135
    break;
37141
41136
 
37142
41137
  case 2061:
 
41138
 
 
41139
/* Line 1455 of yacc.c  */
37143
41140
#line 11233 "preproc.y"
37144
 
    { yyval.str = yyvsp[0].str; ;}
 
41141
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
37145
41142
    break;
37146
41143
 
37147
41144
  case 2062:
 
41145
 
 
41146
/* Line 1455 of yacc.c  */
37148
41147
#line 11234 "preproc.y"
37149
 
    { yyval.str = cat2_str(yyvsp[-1].str, yyvsp[0].str); ;}
 
41148
    { (yyval.str) = cat2_str((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); ;}
37150
41149
    break;
37151
41150
 
37152
41151
  case 2063:
 
41152
 
 
41153
/* Line 1455 of yacc.c  */
37153
41154
#line 11238 "preproc.y"
37154
41155
    {
37155
41156
                /* reset this variable so we see if there was */
37159
41160
    break;
37160
41161
 
37161
41162
  case 2064:
 
41163
 
 
41164
/* Line 1455 of yacc.c  */
37162
41165
#line 11244 "preproc.y"
37163
41166
    {
37164
 
                add_typedef(yyvsp[-2].str, yyvsp[-1].index.index1, yyvsp[-1].index.index2, yyvsp[-4].type.type_enum, yyvsp[-4].type.type_dimension, yyvsp[-4].type.type_index, initializer, *yyvsp[-3].str ? 1 : 0);
 
41167
                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);
37165
41168
 
37166
 
                fprintf(yyout, "typedef %s %s %s %s;\n", yyvsp[-4].type.type_str, *yyvsp[-3].str ? "*" : "", yyvsp[-2].str, yyvsp[-1].index.str);
 
41169
                fprintf(yyout, "typedef %s %s %s %s;\n", (yyvsp[(3) - (7)].type).type_str, *(yyvsp[(4) - (7)].str) ? "*" : "", (yyvsp[(5) - (7)].str), (yyvsp[(6) - (7)].index).str);
37167
41170
                output_line_number();
37168
 
                yyval.str = make_str("");
 
41171
                (yyval.str) = make_str("");
37169
41172
        ;}
37170
41173
    break;
37171
41174
 
37172
41175
  case 2065:
 
41176
 
 
41177
/* Line 1455 of yacc.c  */
37173
41178
#line 11254 "preproc.y"
37174
41179
    {
37175
 
                        actual_type[struct_level].type_enum = yyvsp[0].type.type_enum;
37176
 
                        actual_type[struct_level].type_dimension = yyvsp[0].type.type_dimension;
37177
 
                        actual_type[struct_level].type_index = yyvsp[0].type.type_index;
37178
 
                        actual_type[struct_level].type_sizeof = yyvsp[0].type.type_sizeof;
 
41180
                        actual_type[struct_level].type_enum = (yyvsp[(2) - (2)].type).type_enum;
 
41181
                        actual_type[struct_level].type_dimension = (yyvsp[(2) - (2)].type).type_dimension;
 
41182
                        actual_type[struct_level].type_index = (yyvsp[(2) - (2)].type).type_index;
 
41183
                        actual_type[struct_level].type_sizeof = (yyvsp[(2) - (2)].type).type_sizeof;
37179
41184
 
37180
41185
                        actual_startline[struct_level] = hashline_number();
37181
41186
                ;}
37182
41187
    break;
37183
41188
 
37184
41189
  case 2066:
 
41190
 
 
41191
/* Line 1455 of yacc.c  */
37185
41192
#line 11263 "preproc.y"
37186
41193
    {
37187
 
                        yyval.str = cat_str(5, actual_startline[struct_level], yyvsp[-4].str, yyvsp[-3].type.type_str, yyvsp[-1].str, make_str(";\n"));
 
41194
                        (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"));
37188
41195
                ;}
37189
41196
    break;
37190
41197
 
37191
41198
  case 2067:
 
41199
 
 
41200
/* Line 1455 of yacc.c  */
37192
41201
#line 11267 "preproc.y"
37193
41202
    {
37194
 
                        actual_type[struct_level].type_enum = yyvsp[0].type.type_enum;
37195
 
                        actual_type[struct_level].type_dimension = yyvsp[0].type.type_dimension;
37196
 
                        actual_type[struct_level].type_index = yyvsp[0].type.type_index;
37197
 
                        actual_type[struct_level].type_sizeof = yyvsp[0].type.type_sizeof;
 
41203
                        actual_type[struct_level].type_enum = (yyvsp[(1) - (1)].type).type_enum;
 
41204
                        actual_type[struct_level].type_dimension = (yyvsp[(1) - (1)].type).type_dimension;
 
41205
                        actual_type[struct_level].type_index = (yyvsp[(1) - (1)].type).type_index;
 
41206
                        actual_type[struct_level].type_sizeof = (yyvsp[(1) - (1)].type).type_sizeof;
37198
41207
 
37199
41208
                        actual_startline[struct_level] = hashline_number();
37200
41209
                ;}
37201
41210
    break;
37202
41211
 
37203
41212
  case 2068:
 
41213
 
 
41214
/* Line 1455 of yacc.c  */
37204
41215
#line 11276 "preproc.y"
37205
41216
    {
37206
 
                        yyval.str = cat_str(4, actual_startline[struct_level], yyvsp[-3].type.type_str, yyvsp[-1].str, make_str(";\n"));
 
41217
                        (yyval.str) = cat_str(4, actual_startline[struct_level], (yyvsp[(1) - (4)].type).type_str, (yyvsp[(3) - (4)].str), make_str(";\n"));
37207
41218
                ;}
37208
41219
    break;
37209
41220
 
37210
41221
  case 2069:
 
41222
 
 
41223
/* Line 1455 of yacc.c  */
37211
41224
#line 11280 "preproc.y"
37212
41225
    {
37213
 
                        yyval.str = cat2_str(yyvsp[-1].str, make_str(";"));
 
41226
                        (yyval.str) = cat2_str((yyvsp[(1) - (2)].str), make_str(";"));
37214
41227
                ;}
37215
41228
    break;
37216
41229
 
37217
41230
  case 2070:
 
41231
 
 
41232
/* Line 1455 of yacc.c  */
37218
41233
#line 11285 "preproc.y"
37219
 
    { yyval.str =cat2_str(make_str(":"), yyvsp[0].str); ;}
 
41234
    { (yyval.str) =cat2_str(make_str(":"), (yyvsp[(2) - (2)].str)); ;}
37220
41235
    break;
37221
41236
 
37222
41237
  case 2071:
 
41238
 
 
41239
/* Line 1455 of yacc.c  */
37223
41240
#line 11286 "preproc.y"
37224
 
    { yyval.str = EMPTY; ;}
 
41241
    { (yyval.str) = EMPTY; ;}
37225
41242
    break;
37226
41243
 
37227
41244
  case 2072:
 
41245
 
 
41246
/* Line 1455 of yacc.c  */
37228
41247
#line 11290 "preproc.y"
37229
 
    {yyval.str = cat2_str (yyvsp[-1].str, yyvsp[0].str); ;}
 
41248
    {(yyval.str) = cat2_str ((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); ;}
37230
41249
    break;
37231
41250
 
37232
41251
  case 2073:
 
41252
 
 
41253
/* Line 1455 of yacc.c  */
37233
41254
#line 11291 "preproc.y"
37234
 
    {yyval.str = yyvsp[0].str; ;}
 
41255
    {(yyval.str) = (yyvsp[(1) - (1)].str); ;}
37235
41256
    break;
37236
41257
 
37237
41258
  case 2074:
 
41259
 
 
41260
/* Line 1455 of yacc.c  */
37238
41261
#line 11292 "preproc.y"
37239
 
    {yyval.str = yyvsp[0].str; ;}
 
41262
    {(yyval.str) = (yyvsp[(1) - (1)].str); ;}
37240
41263
    break;
37241
41264
 
37242
41265
  case 2075:
 
41266
 
 
41267
/* Line 1455 of yacc.c  */
37243
41268
#line 11295 "preproc.y"
37244
 
    { yyval.str = make_str("extern"); ;}
 
41269
    { (yyval.str) = make_str("extern"); ;}
37245
41270
    break;
37246
41271
 
37247
41272
  case 2076:
 
41273
 
 
41274
/* Line 1455 of yacc.c  */
37248
41275
#line 11296 "preproc.y"
37249
 
    { yyval.str = make_str("static"); ;}
 
41276
    { (yyval.str) = make_str("static"); ;}
37250
41277
    break;
37251
41278
 
37252
41279
  case 2077:
 
41280
 
 
41281
/* Line 1455 of yacc.c  */
37253
41282
#line 11297 "preproc.y"
37254
 
    { yyval.str = make_str("register"); ;}
 
41283
    { (yyval.str) = make_str("register"); ;}
37255
41284
    break;
37256
41285
 
37257
41286
  case 2078:
 
41287
 
 
41288
/* Line 1455 of yacc.c  */
37258
41289
#line 11298 "preproc.y"
37259
 
    { yyval.str = make_str("auto"); ;}
 
41290
    { (yyval.str) = make_str("auto"); ;}
37260
41291
    break;
37261
41292
 
37262
41293
  case 2079:
 
41294
 
 
41295
/* Line 1455 of yacc.c  */
37263
41296
#line 11301 "preproc.y"
37264
 
    { yyval.str = make_str("const"); ;}
 
41297
    { (yyval.str) = make_str("const"); ;}
37265
41298
    break;
37266
41299
 
37267
41300
  case 2080:
 
41301
 
 
41302
/* Line 1455 of yacc.c  */
37268
41303
#line 11302 "preproc.y"
37269
 
    { yyval.str = make_str("volatile"); ;}
 
41304
    { (yyval.str) = make_str("volatile"); ;}
37270
41305
    break;
37271
41306
 
37272
41307
  case 2081:
 
41308
 
 
41309
/* Line 1455 of yacc.c  */
37273
41310
#line 11306 "preproc.y"
37274
41311
    {
37275
 
                        yyval.type.type_enum = yyvsp[0].type_enum;
37276
 
                        yyval.type.type_str = mm_strdup(ecpg_type_name(yyvsp[0].type_enum));
37277
 
                        yyval.type.type_dimension = make_str("-1");
37278
 
                        yyval.type.type_index = make_str("-1");
37279
 
                        yyval.type.type_sizeof = NULL;
 
41312
                        (yyval.type).type_enum = (yyvsp[(1) - (1)].type_enum);
 
41313
                        (yyval.type).type_str = mm_strdup(ecpg_type_name((yyvsp[(1) - (1)].type_enum)));
 
41314
                        (yyval.type).type_dimension = make_str("-1");
 
41315
                        (yyval.type).type_index = make_str("-1");
 
41316
                        (yyval.type).type_sizeof = NULL;
37280
41317
                ;}
37281
41318
    break;
37282
41319
 
37283
41320
  case 2082:
 
41321
 
 
41322
/* Line 1455 of yacc.c  */
37284
41323
#line 11314 "preproc.y"
37285
41324
    {
37286
 
                        yyval.type.type_str = yyvsp[0].str;
37287
 
                        yyval.type.type_dimension = make_str("-1");
37288
 
                        yyval.type.type_index = make_str("-1");
 
41325
                        (yyval.type).type_str = (yyvsp[(1) - (1)].str);
 
41326
                        (yyval.type).type_dimension = make_str("-1");
 
41327
                        (yyval.type).type_index = make_str("-1");
37289
41328
 
37290
 
                        if (strncmp(yyvsp[0].str, "struct", sizeof("struct")-1) == 0)
 
41329
                        if (strncmp((yyvsp[(1) - (1)].str), "struct", sizeof("struct")-1) == 0)
37291
41330
                        {
37292
 
                                yyval.type.type_enum = ECPGt_struct;
37293
 
                                yyval.type.type_sizeof = ECPGstruct_sizeof;
 
41331
                                (yyval.type).type_enum = ECPGt_struct;
 
41332
                                (yyval.type).type_sizeof = ECPGstruct_sizeof;
37294
41333
                        }
37295
41334
                        else
37296
41335
                        {
37297
 
                                yyval.type.type_enum = ECPGt_union;
37298
 
                                yyval.type.type_sizeof = NULL;
 
41336
                                (yyval.type).type_enum = ECPGt_union;
 
41337
                                (yyval.type).type_sizeof = NULL;
37299
41338
                        }
37300
41339
                ;}
37301
41340
    break;
37302
41341
 
37303
41342
  case 2083:
 
41343
 
 
41344
/* Line 1455 of yacc.c  */
37304
41345
#line 11331 "preproc.y"
37305
41346
    {
37306
 
                        yyval.type.type_str = yyvsp[0].str;
37307
 
                        yyval.type.type_enum = ECPGt_int;
37308
 
                        yyval.type.type_dimension = make_str("-1");
37309
 
                        yyval.type.type_index = make_str("-1");
37310
 
                        yyval.type.type_sizeof = NULL;
 
41347
                        (yyval.type).type_str = (yyvsp[(1) - (1)].str);
 
41348
                        (yyval.type).type_enum = ECPGt_int;
 
41349
                        (yyval.type).type_dimension = make_str("-1");
 
41350
                        (yyval.type).type_index = make_str("-1");
 
41351
                        (yyval.type).type_sizeof = NULL;
37311
41352
                ;}
37312
41353
    break;
37313
41354
 
37314
41355
  case 2084:
 
41356
 
 
41357
/* Line 1455 of yacc.c  */
37315
41358
#line 11339 "preproc.y"
37316
41359
    {
37317
 
                        if (strcmp(yyvsp[-4].str, "numeric") == 0)
 
41360
                        if (strcmp((yyvsp[(1) - (5)].str), "numeric") == 0)
37318
41361
                        {
37319
 
                                yyval.type.type_enum = ECPGt_numeric;
37320
 
                                yyval.type.type_str = make_str("numeric");
 
41362
                                (yyval.type).type_enum = ECPGt_numeric;
 
41363
                                (yyval.type).type_str = make_str("numeric");
37321
41364
                        }
37322
 
                        else if (strcmp(yyvsp[-4].str, "decimal") == 0)
 
41365
                        else if (strcmp((yyvsp[(1) - (5)].str), "decimal") == 0)
37323
41366
                        {
37324
 
                                yyval.type.type_enum = ECPGt_decimal;
37325
 
                                yyval.type.type_str = make_str("decimal");
 
41367
                                (yyval.type).type_enum = ECPGt_decimal;
 
41368
                                (yyval.type).type_str = make_str("decimal");
37326
41369
                        }
37327
41370
                        else
37328
41371
                        {
37329
41372
                                mmerror(PARSE_ERROR, ET_ERROR, "only data types numeric and decimal have precision/scale argument");
37330
 
                                yyval.type.type_enum = ECPGt_numeric;
37331
 
                                yyval.type.type_str = make_str("numeric");
 
41373
                                (yyval.type).type_enum = ECPGt_numeric;
 
41374
                                (yyval.type).type_str = make_str("numeric");
37332
41375
                        }
37333
41376
 
37334
 
                        yyval.type.type_dimension = make_str("-1");
37335
 
                        yyval.type.type_index = make_str("-1");
37336
 
                        yyval.type.type_sizeof = NULL;
 
41377
                        (yyval.type).type_dimension = make_str("-1");
 
41378
                        (yyval.type).type_index = make_str("-1");
 
41379
                        (yyval.type).type_sizeof = NULL;
37337
41380
                ;}
37338
41381
    break;
37339
41382
 
37340
41383
  case 2085:
 
41384
 
 
41385
/* Line 1455 of yacc.c  */
37341
41386
#line 11362 "preproc.y"
37342
41387
    {
37343
 
                        if (strlen(yyvsp[0].str) != 0 && strcmp (yyvsp[-1].str, "datetime") != 0 && strcmp (yyvsp[-1].str, "interval") != 0)
 
41388
                        if (strlen((yyvsp[(2) - (2)].str)) != 0 && strcmp ((yyvsp[(1) - (2)].str), "datetime") != 0 && strcmp ((yyvsp[(1) - (2)].str), "interval") != 0)
37344
41389
                                mmerror (PARSE_ERROR, ET_ERROR, "interval specification not allowed here");
37345
41390
 
37346
41391
                        /*
37347
41392
                         * Check for type names that the SQL grammar treats as
37348
41393
                         * unreserved keywords
37349
41394
                         */
37350
 
                        if (strcmp(yyvsp[-1].str, "varchar") == 0)
37351
 
                        {
37352
 
                                yyval.type.type_enum = ECPGt_varchar;
37353
 
                                yyval.type.type_str = EMPTY; /*make_str("varchar");*/
37354
 
                                yyval.type.type_dimension = make_str("-1");
37355
 
                                yyval.type.type_index = make_str("-1");
37356
 
                                yyval.type.type_sizeof = NULL;
37357
 
                        }
37358
 
                        else if (strcmp(yyvsp[-1].str, "float") == 0)
37359
 
                        {
37360
 
                                yyval.type.type_enum = ECPGt_float;
37361
 
                                yyval.type.type_str = make_str("float");
37362
 
                                yyval.type.type_dimension = make_str("-1");
37363
 
                                yyval.type.type_index = make_str("-1");
37364
 
                                yyval.type.type_sizeof = NULL;
37365
 
                        }
37366
 
                        else if (strcmp(yyvsp[-1].str, "double") == 0)
37367
 
                        {
37368
 
                                yyval.type.type_enum = ECPGt_double;
37369
 
                                yyval.type.type_str = make_str("double");
37370
 
                                yyval.type.type_dimension = make_str("-1");
37371
 
                                yyval.type.type_index = make_str("-1");
37372
 
                                yyval.type.type_sizeof = NULL;
37373
 
                        }
37374
 
                        else if (strcmp(yyvsp[-1].str, "numeric") == 0)
37375
 
                        {
37376
 
                                yyval.type.type_enum = ECPGt_numeric;
37377
 
                                yyval.type.type_str = make_str("numeric");
37378
 
                                yyval.type.type_dimension = make_str("-1");
37379
 
                                yyval.type.type_index = make_str("-1");
37380
 
                                yyval.type.type_sizeof = NULL;
37381
 
                        }
37382
 
                        else if (strcmp(yyvsp[-1].str, "decimal") == 0)
37383
 
                        {
37384
 
                                yyval.type.type_enum = ECPGt_decimal;
37385
 
                                yyval.type.type_str = make_str("decimal");
37386
 
                                yyval.type.type_dimension = make_str("-1");
37387
 
                                yyval.type.type_index = make_str("-1");
37388
 
                                yyval.type.type_sizeof = NULL;
37389
 
                        }
37390
 
                        else if (strcmp(yyvsp[-1].str, "date") == 0)
37391
 
                        {
37392
 
                                yyval.type.type_enum = ECPGt_date;
37393
 
                                yyval.type.type_str = make_str("date");
37394
 
                                yyval.type.type_dimension = make_str("-1");
37395
 
                                yyval.type.type_index = make_str("-1");
37396
 
                                yyval.type.type_sizeof = NULL;
37397
 
                        }
37398
 
                        else if (strcmp(yyvsp[-1].str, "timestamp") == 0)
37399
 
                        {
37400
 
                                yyval.type.type_enum = ECPGt_timestamp;
37401
 
                                yyval.type.type_str = make_str("timestamp");
37402
 
                                yyval.type.type_dimension = make_str("-1");
37403
 
                                yyval.type.type_index = make_str("-1");
37404
 
                                yyval.type.type_sizeof = NULL;
37405
 
                        }
37406
 
                        else if (strcmp(yyvsp[-1].str, "interval") == 0)
37407
 
                        {
37408
 
                                yyval.type.type_enum = ECPGt_interval;
37409
 
                                yyval.type.type_str = make_str("interval");
37410
 
                                yyval.type.type_dimension = make_str("-1");
37411
 
                                yyval.type.type_index = make_str("-1");
37412
 
                                yyval.type.type_sizeof = NULL;
37413
 
                        }
37414
 
                        else if (strcmp(yyvsp[-1].str, "datetime") == 0)
37415
 
                        {
37416
 
                                yyval.type.type_enum = ECPGt_timestamp;
37417
 
                                yyval.type.type_str = make_str("timestamp");
37418
 
                                yyval.type.type_dimension = make_str("-1");
37419
 
                                yyval.type.type_index = make_str("-1");
37420
 
                                yyval.type.type_sizeof = NULL;
 
41395
                        if (strcmp((yyvsp[(1) - (2)].str), "varchar") == 0)
 
41396
                        {
 
41397
                                (yyval.type).type_enum = ECPGt_varchar;
 
41398
                                (yyval.type).type_str = EMPTY; /*make_str("varchar");*/
 
41399
                                (yyval.type).type_dimension = make_str("-1");
 
41400
                                (yyval.type).type_index = make_str("-1");
 
41401
                                (yyval.type).type_sizeof = NULL;
 
41402
                        }
 
41403
                        else if (strcmp((yyvsp[(1) - (2)].str), "float") == 0)
 
41404
                        {
 
41405
                                (yyval.type).type_enum = ECPGt_float;
 
41406
                                (yyval.type).type_str = make_str("float");
 
41407
                                (yyval.type).type_dimension = make_str("-1");
 
41408
                                (yyval.type).type_index = make_str("-1");
 
41409
                                (yyval.type).type_sizeof = NULL;
 
41410
                        }
 
41411
                        else if (strcmp((yyvsp[(1) - (2)].str), "double") == 0)
 
41412
                        {
 
41413
                                (yyval.type).type_enum = ECPGt_double;
 
41414
                                (yyval.type).type_str = make_str("double");
 
41415
                                (yyval.type).type_dimension = make_str("-1");
 
41416
                                (yyval.type).type_index = make_str("-1");
 
41417
                                (yyval.type).type_sizeof = NULL;
 
41418
                        }
 
41419
                        else if (strcmp((yyvsp[(1) - (2)].str), "numeric") == 0)
 
41420
                        {
 
41421
                                (yyval.type).type_enum = ECPGt_numeric;
 
41422
                                (yyval.type).type_str = make_str("numeric");
 
41423
                                (yyval.type).type_dimension = make_str("-1");
 
41424
                                (yyval.type).type_index = make_str("-1");
 
41425
                                (yyval.type).type_sizeof = NULL;
 
41426
                        }
 
41427
                        else if (strcmp((yyvsp[(1) - (2)].str), "decimal") == 0)
 
41428
                        {
 
41429
                                (yyval.type).type_enum = ECPGt_decimal;
 
41430
                                (yyval.type).type_str = make_str("decimal");
 
41431
                                (yyval.type).type_dimension = make_str("-1");
 
41432
                                (yyval.type).type_index = make_str("-1");
 
41433
                                (yyval.type).type_sizeof = NULL;
 
41434
                        }
 
41435
                        else if (strcmp((yyvsp[(1) - (2)].str), "date") == 0)
 
41436
                        {
 
41437
                                (yyval.type).type_enum = ECPGt_date;
 
41438
                                (yyval.type).type_str = make_str("date");
 
41439
                                (yyval.type).type_dimension = make_str("-1");
 
41440
                                (yyval.type).type_index = make_str("-1");
 
41441
                                (yyval.type).type_sizeof = NULL;
 
41442
                        }
 
41443
                        else if (strcmp((yyvsp[(1) - (2)].str), "timestamp") == 0)
 
41444
                        {
 
41445
                                (yyval.type).type_enum = ECPGt_timestamp;
 
41446
                                (yyval.type).type_str = make_str("timestamp");
 
41447
                                (yyval.type).type_dimension = make_str("-1");
 
41448
                                (yyval.type).type_index = make_str("-1");
 
41449
                                (yyval.type).type_sizeof = NULL;
 
41450
                        }
 
41451
                        else if (strcmp((yyvsp[(1) - (2)].str), "interval") == 0)
 
41452
                        {
 
41453
                                (yyval.type).type_enum = ECPGt_interval;
 
41454
                                (yyval.type).type_str = make_str("interval");
 
41455
                                (yyval.type).type_dimension = make_str("-1");
 
41456
                                (yyval.type).type_index = make_str("-1");
 
41457
                                (yyval.type).type_sizeof = NULL;
 
41458
                        }
 
41459
                        else if (strcmp((yyvsp[(1) - (2)].str), "datetime") == 0)
 
41460
                        {
 
41461
                                (yyval.type).type_enum = ECPGt_timestamp;
 
41462
                                (yyval.type).type_str = make_str("timestamp");
 
41463
                                (yyval.type).type_dimension = make_str("-1");
 
41464
                                (yyval.type).type_index = make_str("-1");
 
41465
                                (yyval.type).type_sizeof = NULL;
37421
41466
                        }
37422
41467
                        else
37423
41468
                        {
37424
41469
                                /* this is for typedef'ed types */
37425
 
                                struct typedefs *this = get_typedef(yyvsp[-1].str);
 
41470
                                struct typedefs *this = get_typedef((yyvsp[(1) - (2)].str));
37426
41471
 
37427
 
                                yyval.type.type_str = (this->type->type_enum == ECPGt_varchar) ? EMPTY : mm_strdup(this->name);
37428
 
                                yyval.type.type_enum = this->type->type_enum;
37429
 
                                yyval.type.type_dimension = this->type->type_dimension;
37430
 
                                yyval.type.type_index = this->type->type_index;
 
41472
                                (yyval.type).type_str = (this->type->type_enum == ECPGt_varchar) ? EMPTY : mm_strdup(this->name);
 
41473
                                (yyval.type).type_enum = this->type->type_enum;
 
41474
                                (yyval.type).type_dimension = this->type->type_dimension;
 
41475
                                (yyval.type).type_index = this->type->type_index;
37431
41476
                                if (this->type->type_sizeof && strlen(this->type->type_sizeof) != 0)
37432
 
                                        yyval.type.type_sizeof = this->type->type_sizeof;
 
41477
                                        (yyval.type).type_sizeof = this->type->type_sizeof;
37433
41478
                                else 
37434
 
                                        yyval.type.type_sizeof = cat_str(3, make_str("sizeof("), mm_strdup(this->name), make_str(")"));
 
41479
                                        (yyval.type).type_sizeof = cat_str(3, make_str("sizeof("), mm_strdup(this->name), make_str(")"));
37435
41480
 
37436
41481
                                struct_member_list[struct_level] = ECPGstruct_member_dup(this->struct_member_list);
37437
41482
                        }
37439
41484
    break;
37440
41485
 
37441
41486
  case 2086:
 
41487
 
 
41488
/* Line 1455 of yacc.c  */
37442
41489
#line 11460 "preproc.y"
37443
41490
    {
37444
41491
                        /* this is for named structs/unions */
37445
41492
                        char *name;
37446
41493
                        struct typedefs *this;
37447
 
                        bool forward = (forward_name != NULL && strcmp(yyvsp[0].struct_union.symbol, forward_name) == 0 && strcmp(yyvsp[0].struct_union.su, "struct") == 0);
 
41494
                        bool forward = (forward_name != NULL && strcmp((yyvsp[(1) - (1)].struct_union).symbol, forward_name) == 0 && strcmp((yyvsp[(1) - (1)].struct_union).su, "struct") == 0);
37448
41495
 
37449
 
                        name = cat2_str(yyvsp[0].struct_union.su, yyvsp[0].struct_union.symbol);
 
41496
                        name = cat2_str((yyvsp[(1) - (1)].struct_union).su, (yyvsp[(1) - (1)].struct_union).symbol);
37450
41497
                        /* Do we have a forward definition? */
37451
41498
                        if (!forward)
37452
41499
                        {
37453
41500
                                /* No */
37454
41501
 
37455
41502
                                this = get_typedef(name);
37456
 
                                yyval.type.type_str = mm_strdup(this->name);
37457
 
                                yyval.type.type_enum = this->type->type_enum;
37458
 
                                yyval.type.type_dimension = this->type->type_dimension;
37459
 
                                yyval.type.type_index = this->type->type_index;
37460
 
                                yyval.type.type_sizeof = this->type->type_sizeof;
 
41503
                                (yyval.type).type_str = mm_strdup(this->name);
 
41504
                                (yyval.type).type_enum = this->type->type_enum;
 
41505
                                (yyval.type).type_dimension = this->type->type_dimension;
 
41506
                                (yyval.type).type_index = this->type->type_index;
 
41507
                                (yyval.type).type_sizeof = this->type->type_sizeof;
37461
41508
                                struct_member_list[struct_level] = ECPGstruct_member_dup(this->struct_member_list);
37462
41509
                                free(name);
37463
41510
                        }
37464
41511
                        else
37465
41512
                        {
37466
 
                                yyval.type.type_str = name;
37467
 
                                yyval.type.type_enum = ECPGt_long;
37468
 
                                yyval.type.type_dimension = make_str("-1");
37469
 
                                yyval.type.type_index = make_str("-1");
37470
 
                                yyval.type.type_sizeof = make_str("");
 
41513
                                (yyval.type).type_str = name;
 
41514
                                (yyval.type).type_enum = ECPGt_long;
 
41515
                                (yyval.type).type_dimension = make_str("-1");
 
41516
                                (yyval.type).type_index = make_str("-1");
 
41517
                                (yyval.type).type_sizeof = make_str("");
37471
41518
                                struct_member_list[struct_level] = NULL;
37472
41519
                        }
37473
41520
                ;}
37474
41521
    break;
37475
41522
 
37476
41523
  case 2087:
 
41524
 
 
41525
/* Line 1455 of yacc.c  */
37477
41526
#line 11494 "preproc.y"
37478
 
    { yyval.str = cat_str(3, make_str("enum"), yyvsp[-1].str, yyvsp[0].str); ;}
 
41527
    { (yyval.str) = cat_str(3, make_str("enum"), (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str)); ;}
37479
41528
    break;
37480
41529
 
37481
41530
  case 2088:
 
41531
 
 
41532
/* Line 1455 of yacc.c  */
37482
41533
#line 11496 "preproc.y"
37483
 
    { yyval.str = cat2_str(make_str("enum"), yyvsp[0].str); ;}
 
41534
    { (yyval.str) = cat2_str(make_str("enum"), (yyvsp[(2) - (2)].str)); ;}
37484
41535
    break;
37485
41536
 
37486
41537
  case 2089:
 
41538
 
 
41539
/* Line 1455 of yacc.c  */
37487
41540
#line 11498 "preproc.y"
37488
 
    { yyval.str = cat2_str(make_str("enum"), yyvsp[0].str); ;}
 
41541
    { (yyval.str) = cat2_str(make_str("enum"), (yyvsp[(2) - (2)].str)); ;}
37489
41542
    break;
37490
41543
 
37491
41544
  case 2090:
 
41545
 
 
41546
/* Line 1455 of yacc.c  */
37492
41547
#line 11502 "preproc.y"
37493
 
    { yyval.str = cat_str(3, make_str("{"), yyvsp[-1].str, make_str("}")); ;}
 
41548
    { (yyval.str) = cat_str(3, make_str("{"), (yyvsp[(2) - (3)].str), make_str("}")); ;}
37494
41549
    break;
37495
41550
 
37496
41551
  case 2091:
 
41552
 
 
41553
/* Line 1455 of yacc.c  */
37497
41554
#line 11505 "preproc.y"
37498
41555
    {
37499
41556
                        struct_member_list[struct_level++] = NULL;
37500
41557
                        if (struct_level >= STRUCT_DEPTH)
37501
41558
                                 mmerror(PARSE_ERROR, ET_ERROR, "too many levels in nested structure/union definition");
37502
 
                        forward_name = mm_strdup(yyvsp[0].struct_union.symbol);
 
41559
                        forward_name = mm_strdup((yyvsp[(1) - (1)].struct_union).symbol);
37503
41560
                ;}
37504
41561
    break;
37505
41562
 
37506
41563
  case 2092:
 
41564
 
 
41565
/* Line 1455 of yacc.c  */
37507
41566
#line 11512 "preproc.y"
37508
41567
    {
37509
41568
                        struct typedefs *ptr, *this;
37512
41571
                        ECPGfree_struct_member(struct_member_list[struct_level]);
37513
41572
                        struct_member_list[struct_level] = NULL;
37514
41573
                        struct_level--;
37515
 
                        if (strncmp(yyvsp[-4].struct_union.su, "struct", sizeof("struct")-1) == 0)
 
41574
                        if (strncmp((yyvsp[(1) - (5)].struct_union).su, "struct", sizeof("struct")-1) == 0)
37516
41575
                                su_type.type_enum = ECPGt_struct;
37517
41576
                        else
37518
41577
                                su_type.type_enum = ECPGt_union;
37519
 
                        su_type.type_str = cat2_str(yyvsp[-4].struct_union.su, yyvsp[-4].struct_union.symbol);
 
41578
                        su_type.type_str = cat2_str((yyvsp[(1) - (5)].struct_union).su, (yyvsp[(1) - (5)].struct_union).symbol);
37520
41579
                        free(forward_name);
37521
41580
                        forward_name = NULL;
37522
41581
 
37544
41603
                        this->struct_member_list = struct_member_list[struct_level];
37545
41604
 
37546
41605
                        types = this;
37547
 
                        yyval.str = cat_str(4, su_type.type_str, make_str("{"), yyvsp[-1].str, make_str("}"));
 
41606
                        (yyval.str) = cat_str(4, su_type.type_str, make_str("{"), (yyvsp[(4) - (5)].str), make_str("}"));
37548
41607
                ;}
37549
41608
    break;
37550
41609
 
37551
41610
  case 2093:
 
41611
 
 
41612
/* Line 1455 of yacc.c  */
37552
41613
#line 11555 "preproc.y"
37553
 
    { yyval.str = yyvsp[0].str; ;}
 
41614
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
37554
41615
    break;
37555
41616
 
37556
41617
  case 2094:
 
41618
 
 
41619
/* Line 1455 of yacc.c  */
37557
41620
#line 11557 "preproc.y"
37558
41621
    {
37559
41622
                        struct_member_list[struct_level++] = NULL;
37563
41626
    break;
37564
41627
 
37565
41628
  case 2095:
 
41629
 
 
41630
/* Line 1455 of yacc.c  */
37566
41631
#line 11563 "preproc.y"
37567
41632
    {
37568
41633
                        ECPGfree_struct_member(struct_member_list[struct_level]);
37569
41634
                        struct_member_list[struct_level] = NULL;
37570
41635
                        struct_level--;
37571
 
                        yyval.str = cat_str(4, yyvsp[-4].str, make_str("{"), yyvsp[-1].str, make_str("}"));
 
41636
                        (yyval.str) = cat_str(4, (yyvsp[(1) - (5)].str), make_str("{"), (yyvsp[(4) - (5)].str), make_str("}"));
37572
41637
                ;}
37573
41638
    break;
37574
41639
 
37575
41640
  case 2096:
 
41641
 
 
41642
/* Line 1455 of yacc.c  */
37576
41643
#line 11572 "preproc.y"
37577
41644
    {
37578
 
                        yyval.struct_union.su = make_str("struct");
37579
 
                        yyval.struct_union.symbol = yyvsp[0].str;
37580
 
                        ECPGstruct_sizeof = cat_str(3, make_str("sizeof("), cat2_str(mm_strdup(yyval.struct_union.su), mm_strdup(yyval.struct_union.symbol)), make_str(")"));
 
41645
                        (yyval.struct_union).su = make_str("struct");
 
41646
                        (yyval.struct_union).symbol = (yyvsp[(2) - (2)].str);
 
41647
                        ECPGstruct_sizeof = cat_str(3, make_str("sizeof("), cat2_str(mm_strdup((yyval.struct_union).su), mm_strdup((yyval.struct_union).symbol)), make_str(")"));
37581
41648
                ;}
37582
41649
    break;
37583
41650
 
37584
41651
  case 2097:
 
41652
 
 
41653
/* Line 1455 of yacc.c  */
37585
41654
#line 11578 "preproc.y"
37586
41655
    {
37587
 
                        yyval.struct_union.su = make_str("union");
37588
 
                        yyval.struct_union.symbol = yyvsp[0].str;
 
41656
                        (yyval.struct_union).su = make_str("union");
 
41657
                        (yyval.struct_union).symbol = (yyvsp[(2) - (2)].str);
37589
41658
                ;}
37590
41659
    break;
37591
41660
 
37592
41661
  case 2098:
 
41662
 
 
41663
/* Line 1455 of yacc.c  */
37593
41664
#line 11585 "preproc.y"
37594
41665
    {
37595
41666
                        ECPGstruct_sizeof = make_str(""); /* This must not be NULL to distinguish from simple types. */
37596
 
                        yyval.str = make_str("struct");
 
41667
                        (yyval.str) = make_str("struct");
37597
41668
                ;}
37598
41669
    break;
37599
41670
 
37600
41671
  case 2099:
 
41672
 
 
41673
/* Line 1455 of yacc.c  */
37601
41674
#line 11589 "preproc.y"
37602
 
    { yyval.str = make_str("union"); ;}
 
41675
    { (yyval.str) = make_str("union"); ;}
37603
41676
    break;
37604
41677
 
37605
41678
  case 2100:
 
41679
 
 
41680
/* Line 1455 of yacc.c  */
37606
41681
#line 11592 "preproc.y"
37607
 
    { yyval.type_enum=yyvsp[0].type_enum; ;}
 
41682
    { (yyval.type_enum)=(yyvsp[(1) - (1)].type_enum); ;}
37608
41683
    break;
37609
41684
 
37610
41685
  case 2101:
 
41686
 
 
41687
/* Line 1455 of yacc.c  */
37611
41688
#line 11593 "preproc.y"
37612
 
    { yyval.type_enum=yyvsp[0].type_enum; ;}
 
41689
    { (yyval.type_enum)=(yyvsp[(2) - (2)].type_enum); ;}
37613
41690
    break;
37614
41691
 
37615
41692
  case 2102:
 
41693
 
 
41694
/* Line 1455 of yacc.c  */
37616
41695
#line 11596 "preproc.y"
37617
 
    { yyval.type_enum = ECPGt_unsigned_short; ;}
 
41696
    { (yyval.type_enum) = ECPGt_unsigned_short; ;}
37618
41697
    break;
37619
41698
 
37620
41699
  case 2103:
 
41700
 
 
41701
/* Line 1455 of yacc.c  */
37621
41702
#line 11597 "preproc.y"
37622
 
    { yyval.type_enum = ECPGt_unsigned_short; ;}
 
41703
    { (yyval.type_enum) = ECPGt_unsigned_short; ;}
37623
41704
    break;
37624
41705
 
37625
41706
  case 2104:
 
41707
 
 
41708
/* Line 1455 of yacc.c  */
37626
41709
#line 11598 "preproc.y"
37627
 
    { yyval.type_enum = ECPGt_unsigned_int; ;}
 
41710
    { (yyval.type_enum) = ECPGt_unsigned_int; ;}
37628
41711
    break;
37629
41712
 
37630
41713
  case 2105:
 
41714
 
 
41715
/* Line 1455 of yacc.c  */
37631
41716
#line 11599 "preproc.y"
37632
 
    { yyval.type_enum = ECPGt_unsigned_int; ;}
 
41717
    { (yyval.type_enum) = ECPGt_unsigned_int; ;}
37633
41718
    break;
37634
41719
 
37635
41720
  case 2106:
 
41721
 
 
41722
/* Line 1455 of yacc.c  */
37636
41723
#line 11600 "preproc.y"
37637
 
    { yyval.type_enum = ECPGt_unsigned_long; ;}
 
41724
    { (yyval.type_enum) = ECPGt_unsigned_long; ;}
37638
41725
    break;
37639
41726
 
37640
41727
  case 2107:
 
41728
 
 
41729
/* Line 1455 of yacc.c  */
37641
41730
#line 11601 "preproc.y"
37642
 
    { yyval.type_enum = ECPGt_unsigned_long; ;}
 
41731
    { (yyval.type_enum) = ECPGt_unsigned_long; ;}
37643
41732
    break;
37644
41733
 
37645
41734
  case 2108:
 
41735
 
 
41736
/* Line 1455 of yacc.c  */
37646
41737
#line 11603 "preproc.y"
37647
41738
    {
37648
41739
#ifdef HAVE_LONG_LONG_INT_64
37649
 
                        yyval.type_enum = ECPGt_unsigned_long_long;
 
41740
                        (yyval.type_enum) = ECPGt_unsigned_long_long;
37650
41741
#else
37651
 
                        yyval.type_enum = ECPGt_unsigned_long;
 
41742
                        (yyval.type_enum) = ECPGt_unsigned_long;
37652
41743
#endif
37653
41744
                ;}
37654
41745
    break;
37655
41746
 
37656
41747
  case 2109:
 
41748
 
 
41749
/* Line 1455 of yacc.c  */
37657
41750
#line 11611 "preproc.y"
37658
41751
    {
37659
41752
#ifdef HAVE_LONG_LONG_INT_64
37660
 
                        yyval.type_enum = ECPGt_unsigned_long_long;
 
41753
                        (yyval.type_enum) = ECPGt_unsigned_long_long;
37661
41754
#else
37662
 
                        yyval.type_enum = ECPGt_unsigned_long;
 
41755
                        (yyval.type_enum) = ECPGt_unsigned_long;
37663
41756
#endif
37664
41757
                ;}
37665
41758
    break;
37666
41759
 
37667
41760
  case 2110:
 
41761
 
 
41762
/* Line 1455 of yacc.c  */
37668
41763
#line 11618 "preproc.y"
37669
 
    { yyval.type_enum = ECPGt_unsigned_char; ;}
 
41764
    { (yyval.type_enum) = ECPGt_unsigned_char; ;}
37670
41765
    break;
37671
41766
 
37672
41767
  case 2111:
 
41768
 
 
41769
/* Line 1455 of yacc.c  */
37673
41770
#line 11621 "preproc.y"
37674
 
    { yyval.type_enum = ECPGt_short; ;}
 
41771
    { (yyval.type_enum) = ECPGt_short; ;}
37675
41772
    break;
37676
41773
 
37677
41774
  case 2112:
 
41775
 
 
41776
/* Line 1455 of yacc.c  */
37678
41777
#line 11622 "preproc.y"
37679
 
    { yyval.type_enum = ECPGt_short; ;}
 
41778
    { (yyval.type_enum) = ECPGt_short; ;}
37680
41779
    break;
37681
41780
 
37682
41781
  case 2113:
 
41782
 
 
41783
/* Line 1455 of yacc.c  */
37683
41784
#line 11623 "preproc.y"
37684
 
    { yyval.type_enum = ECPGt_int; ;}
 
41785
    { (yyval.type_enum) = ECPGt_int; ;}
37685
41786
    break;
37686
41787
 
37687
41788
  case 2114:
 
41789
 
 
41790
/* Line 1455 of yacc.c  */
37688
41791
#line 11624 "preproc.y"
37689
 
    { yyval.type_enum = ECPGt_long; ;}
 
41792
    { (yyval.type_enum) = ECPGt_long; ;}
37690
41793
    break;
37691
41794
 
37692
41795
  case 2115:
 
41796
 
 
41797
/* Line 1455 of yacc.c  */
37693
41798
#line 11625 "preproc.y"
37694
 
    { yyval.type_enum = ECPGt_long; ;}
 
41799
    { (yyval.type_enum) = ECPGt_long; ;}
37695
41800
    break;
37696
41801
 
37697
41802
  case 2116:
 
41803
 
 
41804
/* Line 1455 of yacc.c  */
37698
41805
#line 11627 "preproc.y"
37699
41806
    {
37700
41807
#ifdef HAVE_LONG_LONG_INT_64
37701
 
                        yyval.type_enum = ECPGt_long_long;
 
41808
                        (yyval.type_enum) = ECPGt_long_long;
37702
41809
#else
37703
 
                        yyval.type_enum = ECPGt_long;
 
41810
                        (yyval.type_enum) = ECPGt_long;
37704
41811
#endif
37705
41812
                ;}
37706
41813
    break;
37707
41814
 
37708
41815
  case 2117:
 
41816
 
 
41817
/* Line 1455 of yacc.c  */
37709
41818
#line 11635 "preproc.y"
37710
41819
    {
37711
41820
#ifdef HAVE_LONG_LONG_INT_64
37712
 
                        yyval.type_enum = ECPGt_long_long;
 
41821
                        (yyval.type_enum) = ECPGt_long_long;
37713
41822
#else
37714
 
                        yyval.type_enum = ECPGt_long;
 
41823
                        (yyval.type_enum) = ECPGt_long;
37715
41824
#endif
37716
41825
                ;}
37717
41826
    break;
37718
41827
 
37719
41828
  case 2118:
 
41829
 
 
41830
/* Line 1455 of yacc.c  */
37720
41831
#line 11642 "preproc.y"
37721
 
    { yyval.type_enum = ECPGt_bool; ;}
 
41832
    { (yyval.type_enum) = ECPGt_bool; ;}
37722
41833
    break;
37723
41834
 
37724
41835
  case 2119:
 
41836
 
 
41837
/* Line 1455 of yacc.c  */
37725
41838
#line 11643 "preproc.y"
37726
 
    { yyval.type_enum = ECPGt_char; ;}
 
41839
    { (yyval.type_enum) = ECPGt_char; ;}
37727
41840
    break;
37728
41841
 
37729
41842
  case 2120:
 
41843
 
 
41844
/* Line 1455 of yacc.c  */
37730
41845
#line 11644 "preproc.y"
37731
 
    { yyval.type_enum = ECPGt_double; ;}
 
41846
    { (yyval.type_enum) = ECPGt_double; ;}
37732
41847
    break;
37733
41848
 
37734
41849
  case 2123:
 
41850
 
 
41851
/* Line 1455 of yacc.c  */
37735
41852
#line 11652 "preproc.y"
37736
 
    { yyval.str = yyvsp[0].str; ;}
 
41853
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
37737
41854
    break;
37738
41855
 
37739
41856
  case 2124:
 
41857
 
 
41858
/* Line 1455 of yacc.c  */
37740
41859
#line 11654 "preproc.y"
37741
 
    { yyval.str = cat_str(3, yyvsp[-2].str, make_str(","), yyvsp[0].str); ;}
 
41860
    { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str(","), (yyvsp[(3) - (3)].str)); ;}
37742
41861
    break;
37743
41862
 
37744
41863
  case 2125:
 
41864
 
 
41865
/* Line 1455 of yacc.c  */
37745
41866
#line 11658 "preproc.y"
37746
41867
    {
37747
41868
                        struct ECPGtype * type;
37748
 
                        char *dimension = yyvsp[-2].index.index1; /* dimension of array */
37749
 
                        char *length = yyvsp[-2].index.index2;    /* length of string */
 
41869
                        char *dimension = (yyvsp[(3) - (5)].index).index1; /* dimension of array */
 
41870
                        char *length = (yyvsp[(3) - (5)].index).index2;    /* length of string */
37750
41871
                        char dim[14L];
37751
41872
                        char *vcn;
37752
41873
 
37753
 
                        adjust_array(actual_type[struct_level].type_enum, &dimension, &length, actual_type[struct_level].type_dimension, actual_type[struct_level].type_index, strlen(yyvsp[-4].str), false);
 
41874
                        adjust_array(actual_type[struct_level].type_enum, &dimension, &length, actual_type[struct_level].type_dimension, actual_type[struct_level].type_index, strlen((yyvsp[(1) - (5)].str)), false);
37754
41875
 
37755
41876
                        switch (actual_type[struct_level].type_enum)
37756
41877
                        {
37761
41882
                                        else
37762
41883
                                                type = ECPGmake_array_type(ECPGmake_struct_type(struct_member_list[struct_level], actual_type[struct_level].type_enum, actual_type[struct_level].type_sizeof), dimension);
37763
41884
 
37764
 
                                        yyval.str = cat_str(5, yyvsp[-4].str, mm_strdup(yyvsp[-3].str), yyvsp[-2].index.str, yyvsp[-1].str, yyvsp[0].str);
 
41885
                                        (yyval.str) = cat_str(5, (yyvsp[(1) - (5)].str), mm_strdup((yyvsp[(2) - (5)].str)), (yyvsp[(3) - (5)].index).str, (yyvsp[(4) - (5)].str), (yyvsp[(5) - (5)].str));
37765
41886
                                        break;
37766
41887
 
37767
41888
                                case ECPGt_varchar:
37779
41900
                                                mmerror(PARSE_ERROR, ET_ERROR, "pointers to varchar are not implemented");
37780
41901
 
37781
41902
                                        /* make sure varchar struct name is unique by adding linenumer of its definition */
37782
 
                                        vcn = (char *) mm_alloc(strlen(yyvsp[-3].str) + sizeof(int) * CHAR_BIT * 10 / 3);
37783
 
                                        sprintf(vcn, "%s_%d", yyvsp[-3].str, yylineno);
 
41903
                                        vcn = (char *) mm_alloc(strlen((yyvsp[(2) - (5)].str)) + sizeof(int) * CHAR_BIT * 10 / 3);
 
41904
                                        sprintf(vcn, "%s_%d", (yyvsp[(2) - (5)].str), yylineno);
37784
41905
                                        if (strcmp(dimension, "0") == 0)
37785
 
                                                yyval.str = cat_str(7, make2_str(make_str(" struct varchar_"), vcn), make_str(" { int len; char arr["), mm_strdup(length), make_str("]; } *"), mm_strdup(yyvsp[-3].str), yyvsp[-1].str, yyvsp[0].str);
 
41906
                                                (yyval.str) = cat_str(7, make2_str(make_str(" struct varchar_"), vcn), make_str(" { int len; char arr["), mm_strdup(length), make_str("]; } *"), mm_strdup((yyvsp[(2) - (5)].str)), (yyvsp[(4) - (5)].str), (yyvsp[(5) - (5)].str));
37786
41907
                                        else
37787
 
                                                yyval.str = cat_str(8, make2_str(make_str(" struct varchar_"), vcn), make_str(" { int len; char arr["), mm_strdup(length), make_str("]; } "), mm_strdup(yyvsp[-3].str), mm_strdup(dim), yyvsp[-1].str, yyvsp[0].str);
 
41908
                                                (yyval.str) = cat_str(8, make2_str(make_str(" struct varchar_"), vcn), make_str(" { int len; char arr["), mm_strdup(length), make_str("]; } "), mm_strdup((yyvsp[(2) - (5)].str)), mm_strdup(dim), (yyvsp[(4) - (5)].str), (yyvsp[(5) - (5)].str));
37788
41909
                                        break;
37789
41910
 
37790
41911
                                case ECPGt_char:
37791
41912
                                case ECPGt_unsigned_char:
37792
41913
                                        if (atoi(dimension) == -1)
37793
41914
                                        {
37794
 
                                                int i = strlen(yyvsp[0].str);
 
41915
                                                int i = strlen((yyvsp[(5) - (5)].str));
37795
41916
 
37796
41917
                                                if (atoi(length) == -1 && i > 0) /* char <var>[] = "string" */
37797
41918
                                                {
37798
41919
                                                        /* if we have an initializer but no string size set, let's use the initializer's length */
37799
41920
                                                        free(length);
37800
41921
                                                        length = mm_alloc(i+sizeof("sizeof()"));
37801
 
                                                        sprintf(length, "sizeof(%s)", yyvsp[0].str+2);
 
41922
                                                        sprintf(length, "sizeof(%s)", (yyvsp[(5) - (5)].str)+2);
37802
41923
                                                }
37803
41924
                                                type = ECPGmake_simple_type(actual_type[struct_level].type_enum, length, 0);
37804
41925
                                        }
37805
41926
                                        else
37806
41927
                                                type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, length, 0), dimension);
37807
41928
 
37808
 
                                        yyval.str = cat_str(5, yyvsp[-4].str, mm_strdup(yyvsp[-3].str), yyvsp[-2].index.str, yyvsp[-1].str, yyvsp[0].str);
 
41929
                                        (yyval.str) = cat_str(5, (yyvsp[(1) - (5)].str), mm_strdup((yyvsp[(2) - (5)].str)), (yyvsp[(3) - (5)].index).str, (yyvsp[(4) - (5)].str), (yyvsp[(5) - (5)].str));
37809
41930
                                        break;
37810
41931
 
37811
41932
                                default:
37814
41935
                                        else
37815
41936
                                                type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, make_str("1"), 0), dimension);
37816
41937
 
37817
 
                                        yyval.str = cat_str(5, yyvsp[-4].str, mm_strdup(yyvsp[-3].str), yyvsp[-2].index.str, yyvsp[-1].str, yyvsp[0].str);
 
41938
                                        (yyval.str) = cat_str(5, (yyvsp[(1) - (5)].str), mm_strdup((yyvsp[(2) - (5)].str)), (yyvsp[(3) - (5)].index).str, (yyvsp[(4) - (5)].str), (yyvsp[(5) - (5)].str));
37818
41939
                                        break;
37819
41940
                        }
37820
41941
 
37821
41942
                        if (struct_level == 0)
37822
 
                                new_variable(yyvsp[-3].str, type, braces_open);
 
41943
                                new_variable((yyvsp[(2) - (5)].str), type, braces_open);
37823
41944
                        else
37824
 
                                ECPGmake_struct_member(yyvsp[-3].str, type, &(struct_member_list[struct_level - 1]));
 
41945
                                ECPGmake_struct_member((yyvsp[(2) - (5)].str), type, &(struct_member_list[struct_level - 1]));
37825
41946
 
37826
 
                        free(yyvsp[-3].str);
 
41947
                        free((yyvsp[(2) - (5)].str));
37827
41948
                ;}
37828
41949
    break;
37829
41950
 
37830
41951
  case 2126:
 
41952
 
 
41953
/* Line 1455 of yacc.c  */
37831
41954
#line 11743 "preproc.y"
37832
 
    { yyval.str = EMPTY; ;}
 
41955
    { (yyval.str) = EMPTY; ;}
37833
41956
    break;
37834
41957
 
37835
41958
  case 2127:
 
41959
 
 
41960
/* Line 1455 of yacc.c  */
37836
41961
#line 11745 "preproc.y"
37837
41962
    {
37838
41963
                        initializer = 1;
37839
 
                        yyval.str = cat2_str(make_str("="), yyvsp[0].str);
 
41964
                        (yyval.str) = cat2_str(make_str("="), (yyvsp[(2) - (2)].str));
37840
41965
                ;}
37841
41966
    break;
37842
41967
 
37843
41968
  case 2128:
 
41969
 
 
41970
/* Line 1455 of yacc.c  */
37844
41971
#line 11751 "preproc.y"
37845
 
    { yyval.str = EMPTY; ;}
 
41972
    { (yyval.str) = EMPTY; ;}
37846
41973
    break;
37847
41974
 
37848
41975
  case 2129:
 
41976
 
 
41977
/* Line 1455 of yacc.c  */
37849
41978
#line 11752 "preproc.y"
37850
 
    { yyval.str = make_str("*"); ;}
 
41979
    { (yyval.str) = make_str("*"); ;}
37851
41980
    break;
37852
41981
 
37853
41982
  case 2130:
 
41983
 
 
41984
/* Line 1455 of yacc.c  */
37854
41985
#line 11753 "preproc.y"
37855
 
    { yyval.str = make_str("**"); ;}
 
41986
    { (yyval.str) = make_str("**"); ;}
37856
41987
    break;
37857
41988
 
37858
41989
  case 2131:
 
41990
 
 
41991
/* Line 1455 of yacc.c  */
37859
41992
#line 11760 "preproc.y"
37860
41993
    {
37861
41994
                        /* this is only supported for compatibility */
37862
 
                        yyval.str = cat_str(3, make_str("/* declare statement"), yyvsp[0].str, make_str("*/"));
 
41995
                        (yyval.str) = cat_str(3, make_str("/* declare statement"), (yyvsp[(3) - (3)].str), make_str("*/"));
37863
41996
                ;}
37864
41997
    break;
37865
41998
 
37866
41999
  case 2132:
 
42000
 
 
42001
/* Line 1455 of yacc.c  */
37867
42002
#line 11768 "preproc.y"
37868
 
    { yyval.str = yyvsp[0].str; ;}
 
42003
    { (yyval.str) = (yyvsp[(2) - (2)].str); ;}
37869
42004
    break;
37870
42005
 
37871
42006
  case 2133:
 
42007
 
 
42008
/* Line 1455 of yacc.c  */
37872
42009
#line 11771 "preproc.y"
37873
 
    { yyval.str = yyvsp[0].str; ;}
 
42010
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
37874
42011
    break;
37875
42012
 
37876
42013
  case 2134:
 
42014
 
 
42015
/* Line 1455 of yacc.c  */
37877
42016
#line 11772 "preproc.y"
37878
 
    { yyval.str = make_str("\"CURRENT\""); ;}
 
42017
    { (yyval.str) = make_str("\"CURRENT\""); ;}
37879
42018
    break;
37880
42019
 
37881
42020
  case 2135:
 
42021
 
 
42022
/* Line 1455 of yacc.c  */
37882
42023
#line 11773 "preproc.y"
37883
 
    { yyval.str = make_str("\"ALL\""); ;}
 
42024
    { (yyval.str) = make_str("\"ALL\""); ;}
37884
42025
    break;
37885
42026
 
37886
42027
  case 2136:
 
42028
 
 
42029
/* Line 1455 of yacc.c  */
37887
42030
#line 11774 "preproc.y"
37888
 
    { yyval.str = make_str("\"CURRENT\""); ;}
 
42031
    { (yyval.str) = make_str("\"CURRENT\""); ;}
37889
42032
    break;
37890
42033
 
37891
42034
  case 2137:
 
42035
 
 
42036
/* Line 1455 of yacc.c  */
37892
42037
#line 11777 "preproc.y"
37893
 
    { yyval.str = make3_str(make_str("\""), yyvsp[0].str, make_str("\"")); ;}
 
42038
    { (yyval.str) = make3_str(make_str("\""), (yyvsp[(1) - (1)].str), make_str("\"")); ;}
37894
42039
    break;
37895
42040
 
37896
42041
  case 2138:
 
42042
 
 
42043
/* Line 1455 of yacc.c  */
37897
42044
#line 11778 "preproc.y"
37898
 
    { yyval.str = make_str("\"DEFAULT\""); ;}
 
42045
    { (yyval.str) = make_str("\"DEFAULT\""); ;}
37899
42046
    break;
37900
42047
 
37901
42048
  case 2139:
 
42049
 
 
42050
/* Line 1455 of yacc.c  */
37902
42051
#line 11779 "preproc.y"
37903
 
    { yyval.str = yyvsp[0].str; ;}
 
42052
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
37904
42053
    break;
37905
42054
 
37906
42055
  case 2140:
 
42056
 
 
42057
/* Line 1455 of yacc.c  */
37907
42058
#line 11783 "preproc.y"
37908
 
    { yyval.str = yyvsp[0].str; ;}
 
42059
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
37909
42060
    break;
37910
42061
 
37911
42062
  case 2141:
 
42063
 
 
42064
/* Line 1455 of yacc.c  */
37912
42065
#line 11785 "preproc.y"
37913
 
    { yyval.str = make3_str(make_str("\""), yyvsp[0].str, make_str("\"")); ;}
 
42066
    { (yyval.str) = make3_str(make_str("\""), (yyvsp[(1) - (1)].str), make_str("\"")); ;}
37914
42067
    break;
37915
42068
 
37916
42069
  case 2142:
 
42070
 
 
42071
/* Line 1455 of yacc.c  */
37917
42072
#line 11792 "preproc.y"
37918
 
    { yyval.str = yyvsp[0].str; ;}
 
42073
    { (yyval.str) = (yyvsp[(2) - (2)].str); ;}
37919
42074
    break;
37920
42075
 
37921
42076
  case 2143:
 
42077
 
 
42078
/* Line 1455 of yacc.c  */
37922
42079
#line 11793 "preproc.y"
37923
 
    { yyval.str = make_str("all"); ;}
 
42080
    { (yyval.str) = make_str("all"); ;}
37924
42081
    break;
37925
42082
 
37926
42083
  case 2144:
 
42084
 
 
42085
/* Line 1455 of yacc.c  */
37927
42086
#line 11799 "preproc.y"
37928
 
    { yyval.str = yyvsp[-1].str; ;}
 
42087
    { (yyval.str) = (yyvsp[(2) - (3)].str); ;}
37929
42088
    break;
37930
42089
 
37931
42090
  case 2145:
 
42091
 
 
42092
/* Line 1455 of yacc.c  */
37932
42093
#line 11801 "preproc.y"
37933
 
    { yyval.str = EMPTY; ;}
 
42094
    { (yyval.str) = EMPTY; ;}
37934
42095
    break;
37935
42096
 
37936
42097
  case 2146:
 
42098
 
 
42099
/* Line 1455 of yacc.c  */
37937
42100
#line 11802 "preproc.y"
37938
 
    { yyval.str = yyvsp[0].str; ;}
 
42101
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
37939
42102
    break;
37940
42103
 
37941
42104
  case 2147:
 
42105
 
 
42106
/* Line 1455 of yacc.c  */
37942
42107
#line 11805 "preproc.y"
37943
 
    { yyval.str = EMPTY; ;}
 
42108
    { (yyval.str) = EMPTY; ;}
37944
42109
    break;
37945
42110
 
37946
42111
  case 2148:
 
42112
 
 
42113
/* Line 1455 of yacc.c  */
37947
42114
#line 11806 "preproc.y"
37948
 
    { yyval.str = yyvsp[0].str; ;}
 
42115
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
37949
42116
    break;
37950
42117
 
37951
42118
  case 2149:
 
42119
 
 
42120
/* Line 1455 of yacc.c  */
37952
42121
#line 11810 "preproc.y"
37953
42122
    {
37954
 
                        add_variable_to_head(&argsinsert, descriptor_variable(yyvsp[0].str,0), &no_indicator);
37955
 
                        yyval.str = EMPTY;
 
42123
                        add_variable_to_head(&argsinsert, descriptor_variable((yyvsp[(4) - (4)].str),0), &no_indicator);
 
42124
                        (yyval.str) = EMPTY;
37956
42125
                ;}
37957
42126
    break;
37958
42127
 
37959
42128
  case 2150:
 
42129
 
 
42130
/* Line 1455 of yacc.c  */
37960
42131
#line 11817 "preproc.y"
37961
42132
    {
37962
 
                        add_variable_to_head(&argsresult, descriptor_variable(yyvsp[0].str,1), &no_indicator);
37963
 
                        yyval.str = EMPTY;
 
42133
                        add_variable_to_head(&argsresult, descriptor_variable((yyvsp[(4) - (4)].str),1), &no_indicator);
 
42134
                        (yyval.str) = EMPTY;
37964
42135
                ;}
37965
42136
    break;
37966
42137
 
37967
42138
  case 2155:
 
42139
 
 
42140
/* Line 1455 of yacc.c  */
37968
42141
#line 11828 "preproc.y"
37969
42142
    {
37970
42143
                        char *length = mm_alloc(32);
37971
42144
 
37972
 
                        sprintf(length, "%d", (int) strlen(yyvsp[0].str));
37973
 
                        add_variable_to_head(&argsinsert, new_variable(yyvsp[0].str, ECPGmake_simple_type(ECPGt_const, length, 0), 0), &no_indicator);
 
42145
                        sprintf(length, "%d", (int) strlen((yyvsp[(1) - (1)].str)));
 
42146
                        add_variable_to_head(&argsinsert, new_variable((yyvsp[(1) - (1)].str), ECPGmake_simple_type(ECPGt_const, length, 0), 0), &no_indicator);
37974
42147
                ;}
37975
42148
    break;
37976
42149
 
37977
42150
  case 2156:
 
42151
 
 
42152
/* Line 1455 of yacc.c  */
37978
42153
#line 11834 "preproc.y"
37979
 
    { yyval.str = EMPTY; ;}
 
42154
    { (yyval.str) = EMPTY; ;}
37980
42155
    break;
37981
42156
 
37982
42157
  case 2157:
 
42158
 
 
42159
/* Line 1455 of yacc.c  */
37983
42160
#line 11835 "preproc.y"
37984
 
    { yyval.str = EMPTY; ;}
 
42161
    { (yyval.str) = EMPTY; ;}
37985
42162
    break;
37986
42163
 
37987
42164
  case 2158:
 
42165
 
 
42166
/* Line 1455 of yacc.c  */
37988
42167
#line 11838 "preproc.y"
37989
 
    { yyval.str = yyvsp[0].str; ;}
 
42168
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
37990
42169
    break;
37991
42170
 
37992
42171
  case 2159:
 
42172
 
 
42173
/* Line 1455 of yacc.c  */
37993
42174
#line 11839 "preproc.y"
37994
 
    { yyval.str = cat_str(2, make_str("+"), yyvsp[0].str); ;}
 
42175
    { (yyval.str) = cat_str(2, make_str("+"), (yyvsp[(2) - (2)].str)); ;}
37995
42176
    break;
37996
42177
 
37997
42178
  case 2160:
 
42179
 
 
42180
/* Line 1455 of yacc.c  */
37998
42181
#line 11840 "preproc.y"
37999
 
    { yyval.str = cat_str(2, make_str("-"), yyvsp[0].str); ;}
 
42182
    { (yyval.str) = cat_str(2, make_str("-"), (yyvsp[(2) - (2)].str)); ;}
38000
42183
    break;
38001
42184
 
38002
42185
  case 2161:
 
42186
 
 
42187
/* Line 1455 of yacc.c  */
38003
42188
#line 11841 "preproc.y"
38004
 
    { yyval.str = yyvsp[0].str; ;}
 
42189
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38005
42190
    break;
38006
42191
 
38007
42192
  case 2162:
 
42193
 
 
42194
/* Line 1455 of yacc.c  */
38008
42195
#line 11842 "preproc.y"
38009
 
    { yyval.str = cat_str(2, make_str("+"), yyvsp[0].str); ;}
 
42196
    { (yyval.str) = cat_str(2, make_str("+"), (yyvsp[(2) - (2)].str)); ;}
38010
42197
    break;
38011
42198
 
38012
42199
  case 2163:
 
42200
 
 
42201
/* Line 1455 of yacc.c  */
38013
42202
#line 11843 "preproc.y"
38014
 
    { yyval.str = cat_str(2, make_str("-"), yyvsp[0].str); ;}
 
42203
    { (yyval.str) = cat_str(2, make_str("-"), (yyvsp[(2) - (2)].str)); ;}
38015
42204
    break;
38016
42205
 
38017
42206
  case 2164:
 
42207
 
 
42208
/* Line 1455 of yacc.c  */
38018
42209
#line 11844 "preproc.y"
38019
 
    { yyval.str = yyvsp[0].str; ;}
 
42210
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38020
42211
    break;
38021
42212
 
38022
42213
  case 2165:
 
42214
 
 
42215
/* Line 1455 of yacc.c  */
38023
42216
#line 11845 "preproc.y"
38024
 
    { yyval.str = yyvsp[0].str; ;}
 
42217
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38025
42218
    break;
38026
42219
 
38027
42220
  case 2166:
 
42221
 
 
42222
/* Line 1455 of yacc.c  */
38028
42223
#line 11846 "preproc.y"
38029
 
    { yyval.str = yyvsp[0].str; ;}
 
42224
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38030
42225
    break;
38031
42226
 
38032
42227
  case 2167:
 
42228
 
 
42229
/* Line 1455 of yacc.c  */
38033
42230
#line 11853 "preproc.y"
38034
42231
    {
38035
42232
                const char *con = connection ? connection : "NULL";
38036
42233
                mmerror(PARSE_ERROR, ET_WARNING, "using unsupported DESCRIBE statement");
38037
 
                yyval.str = (char *) mm_alloc(sizeof("1, ECPGprepared_statement(, \"\", __LINE__)") + strlen(con) + strlen(yyvsp[-1].str));
38038
 
                sprintf(yyval.str, "1, ECPGprepared_statement(%s, \"%s\", __LINE__)", con, yyvsp[-1].str);
 
42234
                (yyval.str) = (char *) mm_alloc(sizeof("1, ECPGprepared_statement(, \"\", __LINE__)") + strlen(con) + strlen((yyvsp[(3) - (4)].str)));
 
42235
                sprintf((yyval.str), "1, ECPGprepared_statement(%s, \"%s\", __LINE__)", con, (yyvsp[(3) - (4)].str));
38039
42236
        ;}
38040
42237
    break;
38041
42238
 
38042
42239
  case 2168:
 
42240
 
 
42241
/* Line 1455 of yacc.c  */
38043
42242
#line 11860 "preproc.y"
38044
42243
    {
38045
42244
                const char *con = connection ? connection : "NULL";
38046
42245
                mmerror(PARSE_ERROR, ET_WARNING, "using unsupported DESCRIBE statement");
38047
 
                yyval.str = (char *) mm_alloc(sizeof("0, ECPGprepared_statement(, \"\", __LINE__)") + strlen(con) + strlen(yyvsp[-1].str));
38048
 
                sprintf(yyval.str, "0, ECPGprepared_statement(%s, \"%s\", __LINE__)", con, yyvsp[-1].str);
 
42246
                (yyval.str) = (char *) mm_alloc(sizeof("0, ECPGprepared_statement(, \"\", __LINE__)") + strlen(con) + strlen((yyvsp[(3) - (4)].str)));
 
42247
                sprintf((yyval.str), "0, ECPGprepared_statement(%s, \"%s\", __LINE__)", con, (yyvsp[(3) - (4)].str));
38049
42248
        ;}
38050
42249
    break;
38051
42250
 
38052
42251
  case 2169:
 
42252
 
 
42253
/* Line 1455 of yacc.c  */
38053
42254
#line 11867 "preproc.y"
38054
42255
    {
38055
42256
                const char *con = connection ? connection : "NULL";
38056
42257
                mmerror(PARSE_ERROR, ET_WARNING, "using unsupported DESCRIBE statement");
38057
 
                yyval.str = (char *) mm_alloc(sizeof("0, ECPGprepared_statement(, \"\", __LINE__)") + strlen(con) + strlen(yyvsp[-1].str));
38058
 
                sprintf(yyval.str, "0, ECPGprepared_statement(%s, \"%s\", __LINE__)", con, yyvsp[-1].str);
 
42258
                (yyval.str) = (char *) mm_alloc(sizeof("0, ECPGprepared_statement(, \"\", __LINE__)") + strlen(con) + strlen((yyvsp[(3) - (4)].str)));
 
42259
                sprintf((yyval.str), "0, ECPGprepared_statement(%s, \"%s\", __LINE__)", con, (yyvsp[(3) - (4)].str));
38059
42260
        ;}
38060
42261
    break;
38061
42262
 
38062
42263
  case 2170:
 
42264
 
 
42265
/* Line 1455 of yacc.c  */
38063
42266
#line 11875 "preproc.y"
38064
 
    { yyval.str = make_str("output"); ;}
 
42267
    { (yyval.str) = make_str("output"); ;}
38065
42268
    break;
38066
42269
 
38067
42270
  case 2171:
 
42271
 
 
42272
/* Line 1455 of yacc.c  */
38068
42273
#line 11876 "preproc.y"
38069
 
    { yyval.str = EMPTY; ;}
 
42274
    { (yyval.str) = EMPTY; ;}
38070
42275
    break;
38071
42276
 
38072
42277
  case 2172:
 
42278
 
 
42279
/* Line 1455 of yacc.c  */
38073
42280
#line 11889 "preproc.y"
38074
42281
    {
38075
 
                        add_descriptor(yyvsp[0].str,connection);
38076
 
                        yyval.str = yyvsp[0].str;
 
42282
                        add_descriptor((yyvsp[(3) - (3)].str),connection);
 
42283
                        (yyval.str) = (yyvsp[(3) - (3)].str);
38077
42284
                ;}
38078
42285
    break;
38079
42286
 
38080
42287
  case 2173:
 
42288
 
 
42289
/* Line 1455 of yacc.c  */
38081
42290
#line 11900 "preproc.y"
38082
42291
    {
38083
 
                        drop_descriptor(yyvsp[0].str,connection);
38084
 
                        yyval.str = yyvsp[0].str;
 
42292
                        drop_descriptor((yyvsp[(3) - (3)].str),connection);
 
42293
                        (yyval.str) = (yyvsp[(3) - (3)].str);
38085
42294
                ;}
38086
42295
    break;
38087
42296
 
38088
42297
  case 2174:
 
42298
 
 
42299
/* Line 1455 of yacc.c  */
38089
42300
#line 11911 "preproc.y"
38090
 
    {  yyval.str = yyvsp[-1].str; ;}
 
42301
    {  (yyval.str) = (yyvsp[(3) - (4)].str); ;}
38091
42302
    break;
38092
42303
 
38093
42304
  case 2177:
 
42305
 
 
42306
/* Line 1455 of yacc.c  */
38094
42307
#line 11919 "preproc.y"
38095
 
    { push_assignment(yyvsp[-2].str, yyvsp[0].dtype_enum); ;}
 
42308
    { push_assignment((yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].dtype_enum)); ;}
38096
42309
    break;
38097
42310
 
38098
42311
  case 2178:
 
42312
 
 
42313
/* Line 1455 of yacc.c  */
38099
42314
#line 11924 "preproc.y"
38100
 
    { yyval.str = yyvsp[-1].str; ;}
 
42315
    { (yyval.str) = (yyvsp[(3) - (4)].str); ;}
38101
42316
    break;
38102
42317
 
38103
42318
  case 2181:
 
42319
 
 
42320
/* Line 1455 of yacc.c  */
38104
42321
#line 11932 "preproc.y"
38105
42322
    {
38106
 
                        push_assignment(yyvsp[0].str, yyvsp[-2].dtype_enum);
 
42323
                        push_assignment((yyvsp[(3) - (3)].str), (yyvsp[(1) - (3)].dtype_enum));
38107
42324
                ;}
38108
42325
    break;
38109
42326
 
38110
42327
  case 2182:
 
42328
 
 
42329
/* Line 1455 of yacc.c  */
38111
42330
#line 11938 "preproc.y"
38112
42331
    {
38113
42332
                        char *length = mm_alloc(sizeof(int) * CHAR_BIT * 10 / 3);
38114
42333
 
38115
 
                        sprintf(length, "%d", (int) strlen(yyvsp[0].str));
38116
 
                        new_variable(yyvsp[0].str, ECPGmake_simple_type(ECPGt_const, length, 0), 0);
38117
 
                        yyval.str = yyvsp[0].str;
 
42334
                        sprintf(length, "%d", (int) strlen((yyvsp[(1) - (1)].str)));
 
42335
                        new_variable((yyvsp[(1) - (1)].str), ECPGmake_simple_type(ECPGt_const, length, 0), 0);
 
42336
                        (yyval.str) = (yyvsp[(1) - (1)].str);
38118
42337
                ;}
38119
42338
    break;
38120
42339
 
38121
42340
  case 2183:
 
42341
 
 
42342
/* Line 1455 of yacc.c  */
38122
42343
#line 11945 "preproc.y"
38123
 
    { yyval.str = yyvsp[0].str; ;}
 
42344
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38124
42345
    break;
38125
42346
 
38126
42347
  case 2184:
 
42348
 
 
42349
/* Line 1455 of yacc.c  */
38127
42350
#line 11948 "preproc.y"
38128
 
    { yyval.dtype_enum = ECPGd_count; ;}
 
42351
    { (yyval.dtype_enum) = ECPGd_count; ;}
38129
42352
    break;
38130
42353
 
38131
42354
  case 2185:
 
42355
 
 
42356
/* Line 1455 of yacc.c  */
38132
42357
#line 11956 "preproc.y"
38133
 
    {  yyval.descriptor.str = yyvsp[-1].str; yyval.descriptor.name = yyvsp[-3].str; ;}
 
42358
    {  (yyval.descriptor).str = (yyvsp[(5) - (6)].str); (yyval.descriptor).name = (yyvsp[(3) - (6)].str); ;}
38134
42359
    break;
38135
42360
 
38136
42361
  case 2188:
 
42362
 
 
42363
/* Line 1455 of yacc.c  */
38137
42364
#line 11963 "preproc.y"
38138
 
    { push_assignment(yyvsp[-2].str, yyvsp[0].dtype_enum); ;}
 
42365
    { push_assignment((yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].dtype_enum)); ;}
38139
42366
    break;
38140
42367
 
38141
42368
  case 2189:
 
42369
 
 
42370
/* Line 1455 of yacc.c  */
38142
42371
#line 11967 "preproc.y"
38143
 
    {  yyval.descriptor.str = yyvsp[-1].str; yyval.descriptor.name = yyvsp[-3].str; ;}
 
42372
    {  (yyval.descriptor).str = (yyvsp[(5) - (6)].str); (yyval.descriptor).name = (yyvsp[(3) - (6)].str); ;}
38144
42373
    break;
38145
42374
 
38146
42375
  case 2192:
 
42376
 
 
42377
/* Line 1455 of yacc.c  */
38147
42378
#line 11975 "preproc.y"
38148
42379
    {
38149
 
                        push_assignment(yyvsp[0].str, yyvsp[-2].dtype_enum);
 
42380
                        push_assignment((yyvsp[(3) - (3)].str), (yyvsp[(1) - (3)].dtype_enum));
38150
42381
                ;}
38151
42382
    break;
38152
42383
 
38153
42384
  case 2193:
 
42385
 
 
42386
/* Line 1455 of yacc.c  */
38154
42387
#line 11981 "preproc.y"
38155
42388
    {
38156
42389
                        char *length = mm_alloc(sizeof(int) * CHAR_BIT * 10 / 3);
38157
42390
 
38158
 
                        sprintf(length, "%d", (int) strlen(yyvsp[0].str));
38159
 
                        new_variable(yyvsp[0].str, ECPGmake_simple_type(ECPGt_const, length, 0), 0);
38160
 
                        yyval.str = yyvsp[0].str;
 
42391
                        sprintf(length, "%d", (int) strlen((yyvsp[(1) - (1)].str)));
 
42392
                        new_variable((yyvsp[(1) - (1)].str), ECPGmake_simple_type(ECPGt_const, length, 0), 0);
 
42393
                        (yyval.str) = (yyvsp[(1) - (1)].str);
38161
42394
                ;}
38162
42395
    break;
38163
42396
 
38164
42397
  case 2194:
 
42398
 
 
42399
/* Line 1455 of yacc.c  */
38165
42400
#line 11988 "preproc.y"
38166
 
    { yyval.str = yyvsp[0].str; ;}
 
42401
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38167
42402
    break;
38168
42403
 
38169
42404
  case 2195:
 
42405
 
 
42406
/* Line 1455 of yacc.c  */
38170
42407
#line 11990 "preproc.y"
38171
42408
    {
38172
42409
                        char *length = mm_alloc(sizeof(int) * CHAR_BIT * 10 / 3);
38173
 
                        char *var = cat2_str(make_str("-"), yyvsp[0].str);
 
42410
                        char *var = cat2_str(make_str("-"), (yyvsp[(2) - (2)].str));
38174
42411
 
38175
42412
                        sprintf(length, "%d", (int) strlen(var));
38176
42413
                        new_variable(var, ECPGmake_simple_type(ECPGt_const, length, 0), 0);
38177
 
                        yyval.str = var;
 
42414
                        (yyval.str) = var;
38178
42415
                ;}
38179
42416
    break;
38180
42417
 
38181
42418
  case 2196:
 
42419
 
 
42420
/* Line 1455 of yacc.c  */
38182
42421
#line 11999 "preproc.y"
38183
42422
    {
38184
42423
                        char *length = mm_alloc(sizeof(int) * CHAR_BIT * 10 / 3);
38185
 
                        char *var = cat2_str(make_str("-"), yyvsp[0].str);
 
42424
                        char *var = cat2_str(make_str("-"), (yyvsp[(2) - (2)].str));
38186
42425
 
38187
42426
                        sprintf(length, "%d", (int) strlen(var));
38188
42427
                        new_variable(var, ECPGmake_simple_type(ECPGt_const, length, 0), 0);
38189
 
                        yyval.str = var;
 
42428
                        (yyval.str) = var;
38190
42429
                ;}
38191
42430
    break;
38192
42431
 
38193
42432
  case 2197:
 
42433
 
 
42434
/* Line 1455 of yacc.c  */
38194
42435
#line 12008 "preproc.y"
38195
42436
    {
38196
42437
                        char *length = mm_alloc(sizeof(int) * CHAR_BIT * 10 / 3);
38197
 
                        char *var = yyvsp[0].str + 1;
 
42438
                        char *var = (yyvsp[(1) - (1)].str) + 1;
38198
42439
 
38199
42440
                        var[strlen(var) - 1] = '\0';
38200
42441
                        sprintf(length, "%d", (int) strlen(var));
38201
42442
                        new_variable(var, ECPGmake_simple_type(ECPGt_const, length, 0), 0);
38202
 
                        yyval.str = var;
 
42443
                        (yyval.str) = var;
38203
42444
                ;}
38204
42445
    break;
38205
42446
 
38206
42447
  case 2198:
 
42448
 
 
42449
/* Line 1455 of yacc.c  */
38207
42450
#line 12019 "preproc.y"
38208
 
    { yyval.dtype_enum = ECPGd_cardinality; ;}
 
42451
    { (yyval.dtype_enum) = ECPGd_cardinality; ;}
38209
42452
    break;
38210
42453
 
38211
42454
  case 2199:
 
42455
 
 
42456
/* Line 1455 of yacc.c  */
38212
42457
#line 12020 "preproc.y"
38213
 
    { yyval.dtype_enum = ECPGd_data; ;}
 
42458
    { (yyval.dtype_enum) = ECPGd_data; ;}
38214
42459
    break;
38215
42460
 
38216
42461
  case 2200:
 
42462
 
 
42463
/* Line 1455 of yacc.c  */
38217
42464
#line 12021 "preproc.y"
38218
 
    { yyval.dtype_enum = ECPGd_di_code; ;}
 
42465
    { (yyval.dtype_enum) = ECPGd_di_code; ;}
38219
42466
    break;
38220
42467
 
38221
42468
  case 2201:
 
42469
 
 
42470
/* Line 1455 of yacc.c  */
38222
42471
#line 12022 "preproc.y"
38223
 
    { yyval.dtype_enum = ECPGd_di_precision; ;}
 
42472
    { (yyval.dtype_enum) = ECPGd_di_precision; ;}
38224
42473
    break;
38225
42474
 
38226
42475
  case 2202:
 
42476
 
 
42477
/* Line 1455 of yacc.c  */
38227
42478
#line 12023 "preproc.y"
38228
 
    { yyval.dtype_enum = ECPGd_indicator; ;}
 
42479
    { (yyval.dtype_enum) = ECPGd_indicator; ;}
38229
42480
    break;
38230
42481
 
38231
42482
  case 2203:
 
42483
 
 
42484
/* Line 1455 of yacc.c  */
38232
42485
#line 12024 "preproc.y"
38233
 
    { yyval.dtype_enum = ECPGd_key_member; ;}
 
42486
    { (yyval.dtype_enum) = ECPGd_key_member; ;}
38234
42487
    break;
38235
42488
 
38236
42489
  case 2204:
 
42490
 
 
42491
/* Line 1455 of yacc.c  */
38237
42492
#line 12025 "preproc.y"
38238
 
    { yyval.dtype_enum = ECPGd_length; ;}
 
42493
    { (yyval.dtype_enum) = ECPGd_length; ;}
38239
42494
    break;
38240
42495
 
38241
42496
  case 2205:
 
42497
 
 
42498
/* Line 1455 of yacc.c  */
38242
42499
#line 12026 "preproc.y"
38243
 
    { yyval.dtype_enum = ECPGd_name; ;}
 
42500
    { (yyval.dtype_enum) = ECPGd_name; ;}
38244
42501
    break;
38245
42502
 
38246
42503
  case 2206:
 
42504
 
 
42505
/* Line 1455 of yacc.c  */
38247
42506
#line 12027 "preproc.y"
38248
 
    { yyval.dtype_enum = ECPGd_nullable; ;}
 
42507
    { (yyval.dtype_enum) = ECPGd_nullable; ;}
38249
42508
    break;
38250
42509
 
38251
42510
  case 2207:
 
42511
 
 
42512
/* Line 1455 of yacc.c  */
38252
42513
#line 12028 "preproc.y"
38253
 
    { yyval.dtype_enum = ECPGd_octet; ;}
 
42514
    { (yyval.dtype_enum) = ECPGd_octet; ;}
38254
42515
    break;
38255
42516
 
38256
42517
  case 2208:
 
42518
 
 
42519
/* Line 1455 of yacc.c  */
38257
42520
#line 12029 "preproc.y"
38258
 
    { yyval.dtype_enum = ECPGd_precision; ;}
 
42521
    { (yyval.dtype_enum) = ECPGd_precision; ;}
38259
42522
    break;
38260
42523
 
38261
42524
  case 2209:
 
42525
 
 
42526
/* Line 1455 of yacc.c  */
38262
42527
#line 12030 "preproc.y"
38263
 
    { yyval.dtype_enum = ECPGd_length; ;}
 
42528
    { (yyval.dtype_enum) = ECPGd_length; ;}
38264
42529
    break;
38265
42530
 
38266
42531
  case 2210:
 
42532
 
 
42533
/* Line 1455 of yacc.c  */
38267
42534
#line 12031 "preproc.y"
38268
 
    { yyval.dtype_enum = ECPGd_ret_octet; ;}
 
42535
    { (yyval.dtype_enum) = ECPGd_ret_octet; ;}
38269
42536
    break;
38270
42537
 
38271
42538
  case 2211:
 
42539
 
 
42540
/* Line 1455 of yacc.c  */
38272
42541
#line 12032 "preproc.y"
38273
 
    { yyval.dtype_enum = ECPGd_scale; ;}
 
42542
    { (yyval.dtype_enum) = ECPGd_scale; ;}
38274
42543
    break;
38275
42544
 
38276
42545
  case 2212:
 
42546
 
 
42547
/* Line 1455 of yacc.c  */
38277
42548
#line 12033 "preproc.y"
38278
 
    { yyval.dtype_enum = ECPGd_type; ;}
 
42549
    { (yyval.dtype_enum) = ECPGd_type; ;}
38279
42550
    break;
38280
42551
 
38281
42552
  case 2213:
 
42553
 
 
42554
/* Line 1455 of yacc.c  */
38282
42555
#line 12040 "preproc.y"
38283
 
    { yyval.str = yyvsp[0].str; ;}
 
42556
    { (yyval.str) = (yyvsp[(4) - (4)].str); ;}
38284
42557
    break;
38285
42558
 
38286
42559
  case 2214:
 
42560
 
 
42561
/* Line 1455 of yacc.c  */
38287
42562
#line 12041 "preproc.y"
38288
 
    { yyval.str = yyvsp[0].str; ;}
 
42563
    { (yyval.str) = (yyvsp[(4) - (4)].str); ;}
38289
42564
    break;
38290
42565
 
38291
42566
  case 2215:
 
42567
 
 
42568
/* Line 1455 of yacc.c  */
38292
42569
#line 12044 "preproc.y"
38293
 
    { yyval.str = make_str("on"); ;}
 
42570
    { (yyval.str) = make_str("on"); ;}
38294
42571
    break;
38295
42572
 
38296
42573
  case 2216:
 
42574
 
 
42575
/* Line 1455 of yacc.c  */
38297
42576
#line 12045 "preproc.y"
38298
 
    { yyval.str = make_str("off"); ;}
 
42577
    { (yyval.str) = make_str("off"); ;}
38299
42578
    break;
38300
42579
 
38301
42580
  case 2217:
 
42581
 
 
42582
/* Line 1455 of yacc.c  */
38302
42583
#line 12052 "preproc.y"
38303
 
    { yyval.str = yyvsp[0].str; ;}
 
42584
    { (yyval.str) = (yyvsp[(4) - (4)].str); ;}
38304
42585
    break;
38305
42586
 
38306
42587
  case 2218:
 
42588
 
 
42589
/* Line 1455 of yacc.c  */
38307
42590
#line 12053 "preproc.y"
38308
 
    { yyval.str = yyvsp[0].str; ;}
 
42591
    { (yyval.str) = (yyvsp[(4) - (4)].str); ;}
38309
42592
    break;
38310
42593
 
38311
42594
  case 2219:
 
42595
 
 
42596
/* Line 1455 of yacc.c  */
38312
42597
#line 12054 "preproc.y"
38313
 
    { yyval.str = yyvsp[0].str; ;}
 
42598
    { (yyval.str) = (yyvsp[(3) - (3)].str); ;}
38314
42599
    break;
38315
42600
 
38316
42601
  case 2220:
 
42602
 
 
42603
/* Line 1455 of yacc.c  */
38317
42604
#line 12061 "preproc.y"
38318
42605
    {
38319
42606
                        /* reset this variable so we see if there was */
38323
42610
    break;
38324
42611
 
38325
42612
  case 2221:
 
42613
 
 
42614
/* Line 1455 of yacc.c  */
38326
42615
#line 12067 "preproc.y"
38327
42616
    {
38328
 
                        add_typedef(yyvsp[-4].str, yyvsp[-1].index.index1, yyvsp[-1].index.index2, yyvsp[-2].type.type_enum, yyvsp[-2].type.type_dimension, yyvsp[-2].type.type_index, initializer, *yyvsp[0].str ? 1 : 0);
 
42617
                        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);
38329
42618
 
38330
42619
                        if (auto_create_c == false)
38331
 
                                yyval.str = cat_str(7, make_str("/* exec sql type"), mm_strdup(yyvsp[-4].str), make_str("is"), mm_strdup(yyvsp[-2].type.type_str), mm_strdup(yyvsp[-1].index.str), yyvsp[0].str, make_str("*/"));
 
42620
                                (yyval.str) = cat_str(7, make_str("/* exec sql type"), mm_strdup((yyvsp[(3) - (7)].str)), make_str("is"), mm_strdup((yyvsp[(5) - (7)].type).type_str), mm_strdup((yyvsp[(6) - (7)].index).str), (yyvsp[(7) - (7)].str), make_str("*/"));
38332
42621
                        else
38333
 
                                yyval.str = cat_str(6, make_str("typedef "), mm_strdup(yyvsp[-2].type.type_str), *yyvsp[0].str?make_str("*"):make_str(""), mm_strdup(yyvsp[-1].index.str), mm_strdup(yyvsp[-4].str), make_str(";"));
 
42622
                                (yyval.str) = cat_str(6, make_str("typedef "), mm_strdup((yyvsp[(5) - (7)].type).type_str), *(yyvsp[(7) - (7)].str)?make_str("*"):make_str(""), mm_strdup((yyvsp[(6) - (7)].index).str), mm_strdup((yyvsp[(3) - (7)].str)), make_str(";"));
38334
42623
                ;}
38335
42624
    break;
38336
42625
 
38337
42626
  case 2222:
 
42627
 
 
42628
/* Line 1455 of yacc.c  */
38338
42629
#line 12077 "preproc.y"
38339
 
    { yyval.str = make_str("reference"); ;}
 
42630
    { (yyval.str) = make_str("reference"); ;}
38340
42631
    break;
38341
42632
 
38342
42633
  case 2223:
 
42634
 
 
42635
/* Line 1455 of yacc.c  */
38343
42636
#line 12078 "preproc.y"
38344
 
    { yyval.str = EMPTY; ;}
 
42637
    { (yyval.str) = EMPTY; ;}
38345
42638
    break;
38346
42639
 
38347
42640
  case 2224:
 
42641
 
 
42642
/* Line 1455 of yacc.c  */
38348
42643
#line 12085 "preproc.y"
38349
42644
    {
38350
42645
                        /* reset this variable so we see if there was */
38354
42649
    break;
38355
42650
 
38356
42651
  case 2225:
 
42652
 
 
42653
/* Line 1455 of yacc.c  */
38357
42654
#line 12091 "preproc.y"
38358
42655
    {
38359
 
                        struct variable *p = find_variable(yyvsp[-4].str);
38360
 
                        char *dimension = yyvsp[-1].index.index1;
38361
 
                        char *length = yyvsp[-1].index.index2;
 
42656
                        struct variable *p = find_variable((yyvsp[(3) - (7)].str));
 
42657
                        char *dimension = (yyvsp[(6) - (7)].index).index1;
 
42658
                        char *length = (yyvsp[(6) - (7)].index).index2;
38362
42659
                        struct ECPGtype * type;
38363
42660
 
38364
 
                        if ((yyvsp[-2].type.type_enum == ECPGt_struct ||
38365
 
                                 yyvsp[-2].type.type_enum == ECPGt_union) &&
 
42661
                        if (((yyvsp[(5) - (7)].type).type_enum == ECPGt_struct ||
 
42662
                                 (yyvsp[(5) - (7)].type).type_enum == ECPGt_union) &&
38366
42663
                                initializer == 1)
38367
42664
                                mmerror(PARSE_ERROR, ET_ERROR, "initializer not allowed in EXEC SQL VAR command");
38368
42665
                        else
38369
42666
                        {
38370
 
                                adjust_array(yyvsp[-2].type.type_enum, &dimension, &length, yyvsp[-2].type.type_dimension, yyvsp[-2].type.type_index, *yyvsp[0].str?1:0, false);
 
42667
                                adjust_array((yyvsp[(5) - (7)].type).type_enum, &dimension, &length, (yyvsp[(5) - (7)].type).type_dimension, (yyvsp[(5) - (7)].type).type_index, *(yyvsp[(7) - (7)].str)?1:0, false);
38371
42668
 
38372
 
                                switch (yyvsp[-2].type.type_enum)
 
42669
                                switch ((yyvsp[(5) - (7)].type).type_enum)
38373
42670
                                {
38374
42671
                                        case ECPGt_struct:
38375
42672
                                        case ECPGt_union:
38376
42673
                                                if (atoi(dimension) < 0)
38377
 
                                                        type = ECPGmake_struct_type(struct_member_list[struct_level], yyvsp[-2].type.type_enum, yyvsp[-2].type.type_sizeof);
 
42674
                                                        type = ECPGmake_struct_type(struct_member_list[struct_level], (yyvsp[(5) - (7)].type).type_enum, (yyvsp[(5) - (7)].type).type_sizeof);
38378
42675
                                                else
38379
 
                                                        type = ECPGmake_array_type(ECPGmake_struct_type(struct_member_list[struct_level], yyvsp[-2].type.type_enum,yyvsp[-2].type.type_sizeof), dimension);
 
42676
                                                        type = ECPGmake_array_type(ECPGmake_struct_type(struct_member_list[struct_level], (yyvsp[(5) - (7)].type).type_enum,(yyvsp[(5) - (7)].type).type_sizeof), dimension);
38380
42677
                                                break;
38381
42678
 
38382
42679
                                        case ECPGt_varchar:
38383
42680
                                                if (atoi(dimension) == -1)
38384
 
                                                        type = ECPGmake_simple_type(yyvsp[-2].type.type_enum, length, 0);
 
42681
                                                        type = ECPGmake_simple_type((yyvsp[(5) - (7)].type).type_enum, length, 0);
38385
42682
                                                else
38386
 
                                                        type = ECPGmake_array_type(ECPGmake_simple_type(yyvsp[-2].type.type_enum, length, 0), dimension);
 
42683
                                                        type = ECPGmake_array_type(ECPGmake_simple_type((yyvsp[(5) - (7)].type).type_enum, length, 0), dimension);
38387
42684
                                                break;
38388
42685
 
38389
42686
                                        case ECPGt_char:
38390
42687
                                        case ECPGt_unsigned_char:
38391
42688
                                                if (atoi(dimension) == -1)
38392
 
                                                        type = ECPGmake_simple_type(yyvsp[-2].type.type_enum, length, 0);
 
42689
                                                        type = ECPGmake_simple_type((yyvsp[(5) - (7)].type).type_enum, length, 0);
38393
42690
                                                else
38394
 
                                                        type = ECPGmake_array_type(ECPGmake_simple_type(yyvsp[-2].type.type_enum, length, 0), dimension);
 
42691
                                                        type = ECPGmake_array_type(ECPGmake_simple_type((yyvsp[(5) - (7)].type).type_enum, length, 0), dimension);
38395
42692
                                                break;
38396
42693
 
38397
42694
                                        default:
38399
42696
                                                        mmerror(PARSE_ERROR, ET_ERROR, "multidimensional arrays for simple data types are not supported");
38400
42697
 
38401
42698
                                                if (atoi(dimension) < 0)
38402
 
                                                        type = ECPGmake_simple_type(yyvsp[-2].type.type_enum, make_str("1"), 0);
 
42699
                                                        type = ECPGmake_simple_type((yyvsp[(5) - (7)].type).type_enum, make_str("1"), 0);
38403
42700
                                                else
38404
 
                                                        type = ECPGmake_array_type(ECPGmake_simple_type(yyvsp[-2].type.type_enum, make_str("1"), 0), dimension);
 
42701
                                                        type = ECPGmake_array_type(ECPGmake_simple_type((yyvsp[(5) - (7)].type).type_enum, make_str("1"), 0), dimension);
38405
42702
                                                break;
38406
42703
                                }
38407
42704
 
38409
42706
                                p->type = type;
38410
42707
                        }
38411
42708
 
38412
 
                        yyval.str = cat_str(7, make_str("/* exec sql var"), mm_strdup(yyvsp[-4].str), make_str("is"), mm_strdup(yyvsp[-2].type.type_str), mm_strdup(yyvsp[-1].index.str), yyvsp[0].str, make_str("*/"));
 
42709
                        (yyval.str) = cat_str(7, make_str("/* exec sql var"), mm_strdup((yyvsp[(3) - (7)].str)), make_str("is"), mm_strdup((yyvsp[(5) - (7)].type).type_str), mm_strdup((yyvsp[(6) - (7)].index).str), (yyvsp[(7) - (7)].str), make_str("*/"));
38413
42710
                ;}
38414
42711
    break;
38415
42712
 
38416
42713
  case 2226:
 
42714
 
 
42715
/* Line 1455 of yacc.c  */
38417
42716
#line 12154 "preproc.y"
38418
42717
    {
38419
 
                        when_error.code = yyvsp[0].action.code;
38420
 
                        when_error.command = yyvsp[0].action.command;
38421
 
                        yyval.str = cat_str(3, make_str("/* exec sql whenever sqlerror "), yyvsp[0].action.str, make_str("; */"));
 
42718
                        when_error.code = (yyvsp[(3) - (3)].action).code;
 
42719
                        when_error.command = (yyvsp[(3) - (3)].action).command;
 
42720
                        (yyval.str) = cat_str(3, make_str("/* exec sql whenever sqlerror "), (yyvsp[(3) - (3)].action).str, make_str("; */"));
38422
42721
                ;}
38423
42722
    break;
38424
42723
 
38425
42724
  case 2227:
 
42725
 
 
42726
/* Line 1455 of yacc.c  */
38426
42727
#line 12160 "preproc.y"
38427
42728
    {
38428
 
                        when_nf.code = yyvsp[0].action.code;
38429
 
                        when_nf.command = yyvsp[0].action.command;
38430
 
                        yyval.str = cat_str(3, make_str("/* exec sql whenever not found "), yyvsp[0].action.str, make_str("; */"));
 
42729
                        when_nf.code = (yyvsp[(4) - (4)].action).code;
 
42730
                        when_nf.command = (yyvsp[(4) - (4)].action).command;
 
42731
                        (yyval.str) = cat_str(3, make_str("/* exec sql whenever not found "), (yyvsp[(4) - (4)].action).str, make_str("; */"));
38431
42732
                ;}
38432
42733
    break;
38433
42734
 
38434
42735
  case 2228:
 
42736
 
 
42737
/* Line 1455 of yacc.c  */
38435
42738
#line 12166 "preproc.y"
38436
42739
    {
38437
 
                        when_warn.code = yyvsp[0].action.code;
38438
 
                        when_warn.command = yyvsp[0].action.command;
38439
 
                        yyval.str = cat_str(3, make_str("/* exec sql whenever sql_warning "), yyvsp[0].action.str, make_str("; */"));
 
42740
                        when_warn.code = (yyvsp[(3) - (3)].action).code;
 
42741
                        when_warn.command = (yyvsp[(3) - (3)].action).command;
 
42742
                        (yyval.str) = cat_str(3, make_str("/* exec sql whenever sql_warning "), (yyvsp[(3) - (3)].action).str, make_str("; */"));
38440
42743
                ;}
38441
42744
    break;
38442
42745
 
38443
42746
  case 2229:
 
42747
 
 
42748
/* Line 1455 of yacc.c  */
38444
42749
#line 12174 "preproc.y"
38445
42750
    {
38446
 
                        yyval.action.code = W_NOTHING;
38447
 
                        yyval.action.command = NULL;
38448
 
                        yyval.action.str = make_str("continue");
 
42751
                        (yyval.action).code = W_NOTHING;
 
42752
                        (yyval.action).command = NULL;
 
42753
                        (yyval.action).str = make_str("continue");
38449
42754
                ;}
38450
42755
    break;
38451
42756
 
38452
42757
  case 2230:
 
42758
 
 
42759
/* Line 1455 of yacc.c  */
38453
42760
#line 12180 "preproc.y"
38454
42761
    {
38455
 
                        yyval.action.code = W_SQLPRINT;
38456
 
                        yyval.action.command = NULL;
38457
 
                        yyval.action.str = make_str("sqlprint");
 
42762
                        (yyval.action).code = W_SQLPRINT;
 
42763
                        (yyval.action).command = NULL;
 
42764
                        (yyval.action).str = make_str("sqlprint");
38458
42765
                ;}
38459
42766
    break;
38460
42767
 
38461
42768
  case 2231:
 
42769
 
 
42770
/* Line 1455 of yacc.c  */
38462
42771
#line 12186 "preproc.y"
38463
42772
    {
38464
 
                        yyval.action.code = W_STOP;
38465
 
                        yyval.action.command = NULL;
38466
 
                        yyval.action.str = make_str("stop");
 
42773
                        (yyval.action).code = W_STOP;
 
42774
                        (yyval.action).command = NULL;
 
42775
                        (yyval.action).str = make_str("stop");
38467
42776
                ;}
38468
42777
    break;
38469
42778
 
38470
42779
  case 2232:
 
42780
 
 
42781
/* Line 1455 of yacc.c  */
38471
42782
#line 12192 "preproc.y"
38472
42783
    {
38473
 
                        yyval.action.code = W_GOTO;
38474
 
                        yyval.action.command = strdup(yyvsp[0].str);
38475
 
                        yyval.action.str = cat2_str(make_str("goto "), yyvsp[0].str);
 
42784
                        (yyval.action).code = W_GOTO;
 
42785
                        (yyval.action).command = strdup((yyvsp[(2) - (2)].str));
 
42786
                        (yyval.action).str = cat2_str(make_str("goto "), (yyvsp[(2) - (2)].str));
38476
42787
                ;}
38477
42788
    break;
38478
42789
 
38479
42790
  case 2233:
 
42791
 
 
42792
/* Line 1455 of yacc.c  */
38480
42793
#line 12198 "preproc.y"
38481
42794
    {
38482
 
                        yyval.action.code = W_GOTO;
38483
 
                        yyval.action.command = strdup(yyvsp[0].str);
38484
 
                        yyval.action.str = cat2_str(make_str("goto "), yyvsp[0].str);
 
42795
                        (yyval.action).code = W_GOTO;
 
42796
                        (yyval.action).command = strdup((yyvsp[(3) - (3)].str));
 
42797
                        (yyval.action).str = cat2_str(make_str("goto "), (yyvsp[(3) - (3)].str));
38485
42798
                ;}
38486
42799
    break;
38487
42800
 
38488
42801
  case 2234:
 
42802
 
 
42803
/* Line 1455 of yacc.c  */
38489
42804
#line 12204 "preproc.y"
38490
42805
    {
38491
 
                        yyval.action.code = W_DO;
38492
 
                        yyval.action.command = cat_str(4, yyvsp[-3].str, make_str("("), yyvsp[-1].str, make_str(")"));
38493
 
                        yyval.action.str = cat2_str(make_str("do"), mm_strdup(yyval.action.command));
 
42806
                        (yyval.action).code = W_DO;
 
42807
                        (yyval.action).command = cat_str(4, (yyvsp[(2) - (5)].str), make_str("("), (yyvsp[(4) - (5)].str), make_str(")"));
 
42808
                        (yyval.action).str = cat2_str(make_str("do"), mm_strdup((yyval.action).command));
38494
42809
                ;}
38495
42810
    break;
38496
42811
 
38497
42812
  case 2235:
 
42813
 
 
42814
/* Line 1455 of yacc.c  */
38498
42815
#line 12210 "preproc.y"
38499
42816
    {
38500
 
                        yyval.action.code = W_BREAK;
38501
 
                        yyval.action.command = NULL;
38502
 
                        yyval.action.str = make_str("break");
 
42817
                        (yyval.action).code = W_BREAK;
 
42818
                        (yyval.action).command = NULL;
 
42819
                        (yyval.action).str = make_str("break");
38503
42820
                ;}
38504
42821
    break;
38505
42822
 
38506
42823
  case 2236:
 
42824
 
 
42825
/* Line 1455 of yacc.c  */
38507
42826
#line 12216 "preproc.y"
38508
42827
    {
38509
 
                        yyval.action.code = W_DO;
38510
 
                        yyval.action.command = cat_str(4, yyvsp[-3].str, make_str("("), yyvsp[-1].str, make_str(")"));
38511
 
                        yyval.action.str = cat2_str(make_str("call"), mm_strdup(yyval.action.command));
 
42828
                        (yyval.action).code = W_DO;
 
42829
                        (yyval.action).command = cat_str(4, (yyvsp[(2) - (5)].str), make_str("("), (yyvsp[(4) - (5)].str), make_str(")"));
 
42830
                        (yyval.action).str = cat2_str(make_str("call"), mm_strdup((yyval.action).command));
38512
42831
                ;}
38513
42832
    break;
38514
42833
 
38515
42834
  case 2237:
 
42835
 
 
42836
/* Line 1455 of yacc.c  */
38516
42837
#line 12222 "preproc.y"
38517
42838
    {
38518
 
                        yyval.action.code = W_DO;
38519
 
                        yyval.action.command = cat2_str(yyvsp[0].str, make_str("()"));
38520
 
                        yyval.action.str = cat2_str(make_str("call"), mm_strdup(yyval.action.command));
 
42839
                        (yyval.action).code = W_DO;
 
42840
                        (yyval.action).command = cat2_str((yyvsp[(2) - (2)].str), make_str("()"));
 
42841
                        (yyval.action).str = cat2_str(make_str("call"), mm_strdup((yyval.action).command));
38521
42842
                ;}
38522
42843
    break;
38523
42844
 
38524
42845
  case 2238:
 
42846
 
 
42847
/* Line 1455 of yacc.c  */
38525
42848
#line 12232 "preproc.y"
38526
 
    { yyval.str = yyvsp[0].str; ;}
 
42849
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38527
42850
    break;
38528
42851
 
38529
42852
  case 2239:
 
42853
 
 
42854
/* Line 1455 of yacc.c  */
38530
42855
#line 12233 "preproc.y"
38531
 
    { yyval.str = yyvsp[0].str; ;}
 
42856
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38532
42857
    break;
38533
42858
 
38534
42859
  case 2240:
 
42860
 
 
42861
/* Line 1455 of yacc.c  */
38535
42862
#line 12236 "preproc.y"
38536
 
    { yyval.str = make_str("break"); ;}
 
42863
    { (yyval.str) = make_str("break"); ;}
38537
42864
    break;
38538
42865
 
38539
42866
  case 2241:
 
42867
 
 
42868
/* Line 1455 of yacc.c  */
38540
42869
#line 12237 "preproc.y"
38541
 
    { yyval.str = make_str("call"); ;}
 
42870
    { (yyval.str) = make_str("call"); ;}
38542
42871
    break;
38543
42872
 
38544
42873
  case 2242:
 
42874
 
 
42875
/* Line 1455 of yacc.c  */
38545
42876
#line 12238 "preproc.y"
38546
 
    { yyval.str = make_str("cardinality"); ;}
 
42877
    { (yyval.str) = make_str("cardinality"); ;}
38547
42878
    break;
38548
42879
 
38549
42880
  case 2243:
 
42881
 
 
42882
/* Line 1455 of yacc.c  */
38550
42883
#line 12239 "preproc.y"
38551
 
    { yyval.str = make_str("count"); ;}
 
42884
    { (yyval.str) = make_str("count"); ;}
38552
42885
    break;
38553
42886
 
38554
42887
  case 2244:
 
42888
 
 
42889
/* Line 1455 of yacc.c  */
38555
42890
#line 12240 "preproc.y"
38556
 
    { yyval.str = make_str("datetime_interval_code"); ;}
 
42891
    { (yyval.str) = make_str("datetime_interval_code"); ;}
38557
42892
    break;
38558
42893
 
38559
42894
  case 2245:
 
42895
 
 
42896
/* Line 1455 of yacc.c  */
38560
42897
#line 12241 "preproc.y"
38561
 
    { yyval.str = make_str("datetime_interval_precision"); ;}
 
42898
    { (yyval.str) = make_str("datetime_interval_precision"); ;}
38562
42899
    break;
38563
42900
 
38564
42901
  case 2246:
 
42902
 
 
42903
/* Line 1455 of yacc.c  */
38565
42904
#line 12242 "preproc.y"
38566
 
    { yyval.str = make_str("found"); ;}
 
42905
    { (yyval.str) = make_str("found"); ;}
38567
42906
    break;
38568
42907
 
38569
42908
  case 2247:
 
42909
 
 
42910
/* Line 1455 of yacc.c  */
38570
42911
#line 12243 "preproc.y"
38571
 
    { yyval.str = make_str("go"); ;}
 
42912
    { (yyval.str) = make_str("go"); ;}
38572
42913
    break;
38573
42914
 
38574
42915
  case 2248:
 
42916
 
 
42917
/* Line 1455 of yacc.c  */
38575
42918
#line 12244 "preproc.y"
38576
 
    { yyval.str = make_str("goto"); ;}
 
42919
    { (yyval.str) = make_str("goto"); ;}
38577
42920
    break;
38578
42921
 
38579
42922
  case 2249:
 
42923
 
 
42924
/* Line 1455 of yacc.c  */
38580
42925
#line 12245 "preproc.y"
38581
 
    { yyval.str = make_str("identified"); ;}
 
42926
    { (yyval.str) = make_str("identified"); ;}
38582
42927
    break;
38583
42928
 
38584
42929
  case 2250:
 
42930
 
 
42931
/* Line 1455 of yacc.c  */
38585
42932
#line 12246 "preproc.y"
38586
 
    { yyval.str = make_str("indicator"); ;}
 
42933
    { (yyval.str) = make_str("indicator"); ;}
38587
42934
    break;
38588
42935
 
38589
42936
  case 2251:
 
42937
 
 
42938
/* Line 1455 of yacc.c  */
38590
42939
#line 12247 "preproc.y"
38591
 
    { yyval.str = make_str("key_member"); ;}
 
42940
    { (yyval.str) = make_str("key_member"); ;}
38592
42941
    break;
38593
42942
 
38594
42943
  case 2252:
 
42944
 
 
42945
/* Line 1455 of yacc.c  */
38595
42946
#line 12248 "preproc.y"
38596
 
    { yyval.str = make_str("length"); ;}
 
42947
    { (yyval.str) = make_str("length"); ;}
38597
42948
    break;
38598
42949
 
38599
42950
  case 2253:
 
42951
 
 
42952
/* Line 1455 of yacc.c  */
38600
42953
#line 12249 "preproc.y"
38601
 
    { yyval.str = make_str("nullable"); ;}
 
42954
    { (yyval.str) = make_str("nullable"); ;}
38602
42955
    break;
38603
42956
 
38604
42957
  case 2254:
 
42958
 
 
42959
/* Line 1455 of yacc.c  */
38605
42960
#line 12250 "preproc.y"
38606
 
    { yyval.str = make_str("octet_length"); ;}
 
42961
    { (yyval.str) = make_str("octet_length"); ;}
38607
42962
    break;
38608
42963
 
38609
42964
  case 2255:
 
42965
 
 
42966
/* Line 1455 of yacc.c  */
38610
42967
#line 12251 "preproc.y"
38611
 
    { yyval.str = make_str("returned_length"); ;}
 
42968
    { (yyval.str) = make_str("returned_length"); ;}
38612
42969
    break;
38613
42970
 
38614
42971
  case 2256:
 
42972
 
 
42973
/* Line 1455 of yacc.c  */
38615
42974
#line 12252 "preproc.y"
38616
 
    { yyval.str = make_str("returned_octet_length"); ;}
 
42975
    { (yyval.str) = make_str("returned_octet_length"); ;}
38617
42976
    break;
38618
42977
 
38619
42978
  case 2257:
 
42979
 
 
42980
/* Line 1455 of yacc.c  */
38620
42981
#line 12253 "preproc.y"
38621
 
    { yyval.str = make_str("scale"); ;}
 
42982
    { (yyval.str) = make_str("scale"); ;}
38622
42983
    break;
38623
42984
 
38624
42985
  case 2258:
 
42986
 
 
42987
/* Line 1455 of yacc.c  */
38625
42988
#line 12254 "preproc.y"
38626
 
    { yyval.str = make_str("section"); ;}
 
42989
    { (yyval.str) = make_str("section"); ;}
38627
42990
    break;
38628
42991
 
38629
42992
  case 2259:
 
42993
 
 
42994
/* Line 1455 of yacc.c  */
38630
42995
#line 12255 "preproc.y"
38631
 
    { yyval.str = make_str("sql"); ;}
 
42996
    { (yyval.str) = make_str("sql"); ;}
38632
42997
    break;
38633
42998
 
38634
42999
  case 2260:
 
43000
 
 
43001
/* Line 1455 of yacc.c  */
38635
43002
#line 12256 "preproc.y"
38636
 
    { yyval.str = make_str("sqlerror"); ;}
 
43003
    { (yyval.str) = make_str("sqlerror"); ;}
38637
43004
    break;
38638
43005
 
38639
43006
  case 2261:
 
43007
 
 
43008
/* Line 1455 of yacc.c  */
38640
43009
#line 12257 "preproc.y"
38641
 
    { yyval.str = make_str("sqlprint"); ;}
 
43010
    { (yyval.str) = make_str("sqlprint"); ;}
38642
43011
    break;
38643
43012
 
38644
43013
  case 2262:
 
43014
 
 
43015
/* Line 1455 of yacc.c  */
38645
43016
#line 12258 "preproc.y"
38646
 
    { yyval.str = make_str("sqlwarning"); ;}
 
43017
    { (yyval.str) = make_str("sqlwarning"); ;}
38647
43018
    break;
38648
43019
 
38649
43020
  case 2263:
 
43021
 
 
43022
/* Line 1455 of yacc.c  */
38650
43023
#line 12259 "preproc.y"
38651
 
    { yyval.str = make_str("stop"); ;}
 
43024
    { (yyval.str) = make_str("stop"); ;}
38652
43025
    break;
38653
43026
 
38654
43027
  case 2264:
 
43028
 
 
43029
/* Line 1455 of yacc.c  */
38655
43030
#line 12262 "preproc.y"
38656
 
    { yyval.str = make_str("connect"); ;}
 
43031
    { (yyval.str) = make_str("connect"); ;}
38657
43032
    break;
38658
43033
 
38659
43034
  case 2265:
 
43035
 
 
43036
/* Line 1455 of yacc.c  */
38660
43037
#line 12263 "preproc.y"
38661
 
    { yyval.str = make_str("describe"); ;}
 
43038
    { (yyval.str) = make_str("describe"); ;}
38662
43039
    break;
38663
43040
 
38664
43041
  case 2266:
 
43042
 
 
43043
/* Line 1455 of yacc.c  */
38665
43044
#line 12264 "preproc.y"
38666
 
    { yyval.str = make_str("disconnect"); ;}
 
43045
    { (yyval.str) = make_str("disconnect"); ;}
38667
43046
    break;
38668
43047
 
38669
43048
  case 2267:
 
43049
 
 
43050
/* Line 1455 of yacc.c  */
38670
43051
#line 12265 "preproc.y"
38671
 
    { yyval.str = make_str("open"); ;}
 
43052
    { (yyval.str) = make_str("open"); ;}
38672
43053
    break;
38673
43054
 
38674
43055
  case 2268:
 
43056
 
 
43057
/* Line 1455 of yacc.c  */
38675
43058
#line 12266 "preproc.y"
38676
 
    { yyval.str = make_str("var"); ;}
 
43059
    { (yyval.str) = make_str("var"); ;}
38677
43060
    break;
38678
43061
 
38679
43062
  case 2269:
 
43063
 
 
43064
/* Line 1455 of yacc.c  */
38680
43065
#line 12267 "preproc.y"
38681
 
    { yyval.str = make_str("whenever"); ;}
 
43066
    { (yyval.str) = make_str("whenever"); ;}
38682
43067
    break;
38683
43068
 
38684
43069
  case 2270:
 
43070
 
 
43071
/* Line 1455 of yacc.c  */
38685
43072
#line 12271 "preproc.y"
38686
 
    { yyval.str = make_str("bool"); ;}
 
43073
    { (yyval.str) = make_str("bool"); ;}
38687
43074
    break;
38688
43075
 
38689
43076
  case 2271:
 
43077
 
 
43078
/* Line 1455 of yacc.c  */
38690
43079
#line 12272 "preproc.y"
38691
 
    { yyval.str = make_str("long"); ;}
 
43080
    { (yyval.str) = make_str("long"); ;}
38692
43081
    break;
38693
43082
 
38694
43083
  case 2272:
 
43084
 
 
43085
/* Line 1455 of yacc.c  */
38695
43086
#line 12273 "preproc.y"
38696
 
    { yyval.str = make_str("output"); ;}
 
43087
    { (yyval.str) = make_str("output"); ;}
38697
43088
    break;
38698
43089
 
38699
43090
  case 2273:
 
43091
 
 
43092
/* Line 1455 of yacc.c  */
38700
43093
#line 12274 "preproc.y"
38701
 
    { yyval.str = make_str("short"); ;}
 
43094
    { (yyval.str) = make_str("short"); ;}
38702
43095
    break;
38703
43096
 
38704
43097
  case 2274:
 
43098
 
 
43099
/* Line 1455 of yacc.c  */
38705
43100
#line 12275 "preproc.y"
38706
 
    { yyval.str = make_str("struct"); ;}
 
43101
    { (yyval.str) = make_str("struct"); ;}
38707
43102
    break;
38708
43103
 
38709
43104
  case 2275:
 
43105
 
 
43106
/* Line 1455 of yacc.c  */
38710
43107
#line 12276 "preproc.y"
38711
 
    { yyval.str = make_str("signed"); ;}
 
43108
    { (yyval.str) = make_str("signed"); ;}
38712
43109
    break;
38713
43110
 
38714
43111
  case 2276:
 
43112
 
 
43113
/* Line 1455 of yacc.c  */
38715
43114
#line 12277 "preproc.y"
38716
 
    { yyval.str = make_str("unsigned"); ;}
 
43115
    { (yyval.str) = make_str("unsigned"); ;}
38717
43116
    break;
38718
43117
 
38719
43118
  case 2277:
 
43119
 
 
43120
/* Line 1455 of yacc.c  */
38720
43121
#line 12280 "preproc.y"
38721
 
    { yyval.str = yyvsp[0].str; ;}
 
43122
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38722
43123
    break;
38723
43124
 
38724
43125
  case 2278:
 
43126
 
 
43127
/* Line 1455 of yacc.c  */
38725
43128
#line 12283 "preproc.y"
38726
 
    { yyval.str = yyvsp[0].str; ;}
 
43129
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38727
43130
    break;
38728
43131
 
38729
43132
  case 2279:
 
43133
 
 
43134
/* Line 1455 of yacc.c  */
38730
43135
#line 12284 "preproc.y"
38731
 
    { yyval.str = yyvsp[0].str; ;}
 
43136
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38732
43137
    break;
38733
43138
 
38734
43139
  case 2280:
 
43140
 
 
43141
/* Line 1455 of yacc.c  */
38735
43142
#line 12285 "preproc.y"
38736
 
    { yyval.str = yyvsp[0].str; ;}
 
43143
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38737
43144
    break;
38738
43145
 
38739
43146
  case 2281:
 
43147
 
 
43148
/* Line 1455 of yacc.c  */
38740
43149
#line 12286 "preproc.y"
38741
 
    { yyval.str = yyvsp[0].str; ;}
 
43150
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38742
43151
    break;
38743
43152
 
38744
43153
  case 2282:
 
43154
 
 
43155
/* Line 1455 of yacc.c  */
38745
43156
#line 12287 "preproc.y"
38746
 
    { yyval.str = yyvsp[0].str; ;}
 
43157
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38747
43158
    break;
38748
43159
 
38749
43160
  case 2283:
 
43161
 
 
43162
/* Line 1455 of yacc.c  */
38750
43163
#line 12288 "preproc.y"
38751
 
    { yyval.str = yyvsp[0].str; ;}
 
43164
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38752
43165
    break;
38753
43166
 
38754
43167
  case 2284:
 
43168
 
 
43169
/* Line 1455 of yacc.c  */
38755
43170
#line 12289 "preproc.y"
38756
 
    { yyval.str = make_str("char"); ;}
 
43171
    { (yyval.str) = make_str("char"); ;}
38757
43172
    break;
38758
43173
 
38759
43174
  case 2285:
 
43175
 
 
43176
/* Line 1455 of yacc.c  */
38760
43177
#line 12290 "preproc.y"
38761
 
    { yyval.str = make_str("values"); ;}
 
43178
    { (yyval.str) = make_str("values"); ;}
38762
43179
    break;
38763
43180
 
38764
43181
  case 2286:
 
43182
 
 
43183
/* Line 1455 of yacc.c  */
38765
43184
#line 12303 "preproc.y"
38766
 
    { yyval.str = yyvsp[0].str; ;}
 
43185
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38767
43186
    break;
38768
43187
 
38769
43188
  case 2287:
 
43189
 
 
43190
/* Line 1455 of yacc.c  */
38770
43191
#line 12304 "preproc.y"
38771
 
    { yyval.str = yyvsp[0].str; ;}
 
43192
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38772
43193
    break;
38773
43194
 
38774
43195
  case 2288:
 
43196
 
 
43197
/* Line 1455 of yacc.c  */
38775
43198
#line 12305 "preproc.y"
38776
 
    { yyval.str = yyvsp[0].str; ;}
 
43199
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38777
43200
    break;
38778
43201
 
38779
43202
  case 2289:
 
43203
 
 
43204
/* Line 1455 of yacc.c  */
38780
43205
#line 12306 "preproc.y"
38781
 
    { yyval.str = yyvsp[0].str; ;}
 
43206
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38782
43207
    break;
38783
43208
 
38784
43209
  case 2290:
 
43210
 
 
43211
/* Line 1455 of yacc.c  */
38785
43212
#line 12307 "preproc.y"
38786
 
    { yyval.str = yyvsp[0].str; ;}
 
43213
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38787
43214
    break;
38788
43215
 
38789
43216
  case 2291:
 
43217
 
 
43218
/* Line 1455 of yacc.c  */
38790
43219
#line 12308 "preproc.y"
38791
 
    { yyval.str = make_str("char"); ;}
 
43220
    { (yyval.str) = make_str("char"); ;}
38792
43221
    break;
38793
43222
 
38794
43223
  case 2292:
 
43224
 
 
43225
/* Line 1455 of yacc.c  */
38795
43226
#line 12309 "preproc.y"
38796
 
    { yyval.str = make_str("values"); ;}
 
43227
    { (yyval.str) = make_str("values"); ;}
38797
43228
    break;
38798
43229
 
38799
43230
  case 2293:
 
43231
 
 
43232
/* Line 1455 of yacc.c  */
38800
43233
#line 12314 "preproc.y"
38801
 
    { yyval.str = yyvsp[0].str; ;}
 
43234
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38802
43235
    break;
38803
43236
 
38804
43237
  case 2294:
 
43238
 
 
43239
/* Line 1455 of yacc.c  */
38805
43240
#line 12315 "preproc.y"
38806
 
    { yyval.str = yyvsp[0].str; ;}
 
43241
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38807
43242
    break;
38808
43243
 
38809
43244
  case 2295:
 
43245
 
 
43246
/* Line 1455 of yacc.c  */
38810
43247
#line 12316 "preproc.y"
38811
 
    { yyval.str = yyvsp[0].str; ;}
 
43248
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38812
43249
    break;
38813
43250
 
38814
43251
  case 2296:
 
43252
 
 
43253
/* Line 1455 of yacc.c  */
38815
43254
#line 12317 "preproc.y"
38816
 
    { yyval.str = yyvsp[0].str; ;}
 
43255
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38817
43256
    break;
38818
43257
 
38819
43258
  case 2297:
 
43259
 
 
43260
/* Line 1455 of yacc.c  */
38820
43261
#line 12318 "preproc.y"
38821
 
    { yyval.str = yyvsp[0].str; ;}
 
43262
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38822
43263
    break;
38823
43264
 
38824
43265
  case 2298:
 
43266
 
 
43267
/* Line 1455 of yacc.c  */
38825
43268
#line 12319 "preproc.y"
38826
 
    { yyval.str = yyvsp[0].str; ;}
 
43269
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38827
43270
    break;
38828
43271
 
38829
43272
  case 2299:
 
43273
 
 
43274
/* Line 1455 of yacc.c  */
38830
43275
#line 12325 "preproc.y"
38831
 
    { yyval.str = yyvsp[0].str; ;}
 
43276
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38832
43277
    break;
38833
43278
 
38834
43279
  case 2300:
 
43280
 
 
43281
/* Line 1455 of yacc.c  */
38835
43282
#line 12326 "preproc.y"
38836
 
    { yyval.str = yyvsp[0].str; ;}
 
43283
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38837
43284
    break;
38838
43285
 
38839
43286
  case 2301:
 
43287
 
 
43288
/* Line 1455 of yacc.c  */
38840
43289
#line 12327 "preproc.y"
38841
 
    { yyval.str = make_str("char"); ;}
 
43290
    { (yyval.str) = make_str("char"); ;}
38842
43291
    break;
38843
43292
 
38844
43293
  case 2302:
 
43294
 
 
43295
/* Line 1455 of yacc.c  */
38845
43296
#line 12328 "preproc.y"
38846
 
    { yyval.str = make_str("current"); ;}
 
43297
    { (yyval.str) = make_str("current"); ;}
38847
43298
    break;
38848
43299
 
38849
43300
  case 2303:
 
43301
 
 
43302
/* Line 1455 of yacc.c  */
38850
43303
#line 12329 "preproc.y"
38851
 
    { yyval.str = make_str("input"); ;}
 
43304
    { (yyval.str) = make_str("input"); ;}
38852
43305
    break;
38853
43306
 
38854
43307
  case 2304:
 
43308
 
 
43309
/* Line 1455 of yacc.c  */
38855
43310
#line 12330 "preproc.y"
38856
 
    { yyval.str = make_str("int"); ;}
 
43311
    { (yyval.str) = make_str("int"); ;}
38857
43312
    break;
38858
43313
 
38859
43314
  case 2305:
 
43315
 
 
43316
/* Line 1455 of yacc.c  */
38860
43317
#line 12331 "preproc.y"
38861
 
    { yyval.str = make_str("to"); ;}
 
43318
    { (yyval.str) = make_str("to"); ;}
38862
43319
    break;
38863
43320
 
38864
43321
  case 2306:
 
43322
 
 
43323
/* Line 1455 of yacc.c  */
38865
43324
#line 12332 "preproc.y"
38866
 
    { yyval.str = make_str("union"); ;}
 
43325
    { (yyval.str) = make_str("union"); ;}
38867
43326
    break;
38868
43327
 
38869
43328
  case 2307:
 
43329
 
 
43330
/* Line 1455 of yacc.c  */
38870
43331
#line 12333 "preproc.y"
38871
 
    { yyval.str = make_str("values"); ;}
 
43332
    { (yyval.str) = make_str("values"); ;}
38872
43333
    break;
38873
43334
 
38874
43335
  case 2308:
 
43336
 
 
43337
/* Line 1455 of yacc.c  */
38875
43338
#line 12334 "preproc.y"
38876
 
    { yyval.str = yyvsp[0].str; ;}
 
43339
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38877
43340
    break;
38878
43341
 
38879
43342
  case 2309:
 
43343
 
 
43344
/* Line 1455 of yacc.c  */
38880
43345
#line 12335 "preproc.y"
38881
 
    { yyval.str = yyvsp[0].str; ;}
 
43346
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38882
43347
    break;
38883
43348
 
38884
43349
  case 2310:
 
43350
 
 
43351
/* Line 1455 of yacc.c  */
38885
43352
#line 12338 "preproc.y"
38886
 
    { yyval.str = yyvsp[0].str; ;}
 
43353
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38887
43354
    break;
38888
43355
 
38889
43356
  case 2311:
 
43357
 
 
43358
/* Line 1455 of yacc.c  */
38890
43359
#line 12339 "preproc.y"
38891
 
    { yyval.str = yyvsp[0].str; ;}
 
43360
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38892
43361
    break;
38893
43362
 
38894
43363
  case 2312:
 
43364
 
 
43365
/* Line 1455 of yacc.c  */
38895
43366
#line 12340 "preproc.y"
38896
 
    { yyval.str = yyvsp[0].str; ;}
 
43367
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38897
43368
    break;
38898
43369
 
38899
43370
  case 2313:
 
43371
 
 
43372
/* Line 1455 of yacc.c  */
38900
43373
#line 12341 "preproc.y"
38901
 
    { yyval.str = yyvsp[0].str; ;}
 
43374
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38902
43375
    break;
38903
43376
 
38904
43377
  case 2314:
 
43378
 
 
43379
/* Line 1455 of yacc.c  */
38905
43380
#line 12342 "preproc.y"
38906
 
    { yyval.str = make_str("connection"); ;}
 
43381
    { (yyval.str) = make_str("connection"); ;}
38907
43382
    break;
38908
43383
 
38909
43384
  case 2315:
 
43385
 
 
43386
/* Line 1455 of yacc.c  */
38910
43387
#line 12345 "preproc.y"
38911
 
    { yyval.str = yyvsp[0].str; ;}
 
43388
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38912
43389
    break;
38913
43390
 
38914
43391
  case 2316:
 
43392
 
 
43393
/* Line 1455 of yacc.c  */
38915
43394
#line 12346 "preproc.y"
38916
 
    { yyval.str = yyvsp[0].str; ;}
 
43395
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38917
43396
    break;
38918
43397
 
38919
43398
  case 2317:
 
43399
 
 
43400
/* Line 1455 of yacc.c  */
38920
43401
#line 12347 "preproc.y"
38921
 
    { yyval.str = yyvsp[0].str; ;}
 
43402
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38922
43403
    break;
38923
43404
 
38924
43405
  case 2318:
 
43406
 
 
43407
/* Line 1455 of yacc.c  */
38925
43408
#line 12348 "preproc.y"
38926
 
    { yyval.str = yyvsp[0].str; ;}
 
43409
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38927
43410
    break;
38928
43411
 
38929
43412
  case 2319:
 
43413
 
 
43414
/* Line 1455 of yacc.c  */
38930
43415
#line 12351 "preproc.y"
38931
 
    { yyval.str = make_str("auto"); ;}
 
43416
    { (yyval.str) = make_str("auto"); ;}
38932
43417
    break;
38933
43418
 
38934
43419
  case 2320:
 
43420
 
 
43421
/* Line 1455 of yacc.c  */
38935
43422
#line 12352 "preproc.y"
38936
 
    { yyval.str = make_str("const"); ;}
 
43423
    { (yyval.str) = make_str("const"); ;}
38937
43424
    break;
38938
43425
 
38939
43426
  case 2321:
 
43427
 
 
43428
/* Line 1455 of yacc.c  */
38940
43429
#line 12353 "preproc.y"
38941
 
    { yyval.str = make_str("extern"); ;}
 
43430
    { (yyval.str) = make_str("extern"); ;}
38942
43431
    break;
38943
43432
 
38944
43433
  case 2322:
 
43434
 
 
43435
/* Line 1455 of yacc.c  */
38945
43436
#line 12354 "preproc.y"
38946
 
    { yyval.str = make_str("register"); ;}
 
43437
    { (yyval.str) = make_str("register"); ;}
38947
43438
    break;
38948
43439
 
38949
43440
  case 2323:
 
43441
 
 
43442
/* Line 1455 of yacc.c  */
38950
43443
#line 12355 "preproc.y"
38951
 
    { yyval.str = make_str("static"); ;}
 
43444
    { (yyval.str) = make_str("static"); ;}
38952
43445
    break;
38953
43446
 
38954
43447
  case 2324:
 
43448
 
 
43449
/* Line 1455 of yacc.c  */
38955
43450
#line 12356 "preproc.y"
38956
 
    { yyval.str = make_str("typedef"); ;}
 
43451
    { (yyval.str) = make_str("typedef"); ;}
38957
43452
    break;
38958
43453
 
38959
43454
  case 2325:
 
43455
 
 
43456
/* Line 1455 of yacc.c  */
38960
43457
#line 12357 "preproc.y"
38961
 
    { yyval.str = make_str("volatile"); ;}
 
43458
    { (yyval.str) = make_str("volatile"); ;}
38962
43459
    break;
38963
43460
 
38964
43461
  case 2326:
 
43462
 
 
43463
/* Line 1455 of yacc.c  */
38965
43464
#line 12374 "preproc.y"
38966
 
    { yyval.str = yyvsp[0].str; ;}
 
43465
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38967
43466
    break;
38968
43467
 
38969
43468
  case 2327:
 
43469
 
 
43470
/* Line 1455 of yacc.c  */
38970
43471
#line 12375 "preproc.y"
38971
 
    { yyval.str = yyvsp[0].str; ;}
 
43472
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
38972
43473
    break;
38973
43474
 
38974
43475
  case 2328:
 
43476
 
 
43477
/* Line 1455 of yacc.c  */
38975
43478
#line 12376 "preproc.y"
38976
 
    { yyval.str = make_str("connection"); ;}
 
43479
    { (yyval.str) = make_str("connection"); ;}
38977
43480
    break;
38978
43481
 
38979
43482
  case 2329:
 
43483
 
 
43484
/* Line 1455 of yacc.c  */
38980
43485
#line 12379 "preproc.y"
38981
 
    { yyval.str = make_str("day"); ;}
 
43486
    { (yyval.str) = make_str("day"); ;}
38982
43487
    break;
38983
43488
 
38984
43489
  case 2330:
 
43490
 
 
43491
/* Line 1455 of yacc.c  */
38985
43492
#line 12380 "preproc.y"
38986
 
    { yyval.str = make_str("hour"); ;}
 
43493
    { (yyval.str) = make_str("hour"); ;}
38987
43494
    break;
38988
43495
 
38989
43496
  case 2331:
 
43497
 
 
43498
/* Line 1455 of yacc.c  */
38990
43499
#line 12381 "preproc.y"
38991
 
    { yyval.str = make_str("minute"); ;}
 
43500
    { (yyval.str) = make_str("minute"); ;}
38992
43501
    break;
38993
43502
 
38994
43503
  case 2332:
 
43504
 
 
43505
/* Line 1455 of yacc.c  */
38995
43506
#line 12382 "preproc.y"
38996
 
    { yyval.str = make_str("month"); ;}
 
43507
    { (yyval.str) = make_str("month"); ;}
38997
43508
    break;
38998
43509
 
38999
43510
  case 2333:
 
43511
 
 
43512
/* Line 1455 of yacc.c  */
39000
43513
#line 12383 "preproc.y"
39001
 
    { yyval.str = make_str("second"); ;}
 
43514
    { (yyval.str) = make_str("second"); ;}
39002
43515
    break;
39003
43516
 
39004
43517
  case 2334:
 
43518
 
 
43519
/* Line 1455 of yacc.c  */
39005
43520
#line 12384 "preproc.y"
39006
 
    { yyval.str = make_str("year"); ;}
 
43521
    { (yyval.str) = make_str("year"); ;}
39007
43522
    break;
39008
43523
 
39009
43524
  case 2337:
 
43525
 
 
43526
/* Line 1455 of yacc.c  */
39010
43527
#line 12391 "preproc.y"
39011
43528
    {
39012
43529
                                reset_variables();
39015
43532
    break;
39016
43533
 
39017
43534
  case 2338:
 
43535
 
 
43536
/* Line 1455 of yacc.c  */
39018
43537
#line 12397 "preproc.y"
39019
 
    { yyval.str = EMPTY; ;}
 
43538
    { (yyval.str) = EMPTY; ;}
39020
43539
    break;
39021
43540
 
39022
43541
  case 2339:
 
43542
 
 
43543
/* Line 1455 of yacc.c  */
39023
43544
#line 12398 "preproc.y"
39024
 
    { yyval.str = yyvsp[0].str; ;}
 
43545
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39025
43546
    break;
39026
43547
 
39027
43548
  case 2340:
 
43549
 
 
43550
/* Line 1455 of yacc.c  */
39028
43551
#line 12402 "preproc.y"
39029
 
    { add_variable_to_head(&argsresult, find_variable(yyvsp[-1].str), find_variable(yyvsp[0].str)); ;}
 
43552
    { add_variable_to_head(&argsresult, find_variable((yyvsp[(1) - (2)].str)), find_variable((yyvsp[(2) - (2)].str))); ;}
39030
43553
    break;
39031
43554
 
39032
43555
  case 2341:
 
43556
 
 
43557
/* Line 1455 of yacc.c  */
39033
43558
#line 12404 "preproc.y"
39034
 
    { add_variable_to_head(&argsresult, find_variable(yyvsp[0].str), &no_indicator); ;}
 
43559
    { add_variable_to_head(&argsresult, find_variable((yyvsp[(1) - (1)].str)), &no_indicator); ;}
39035
43560
    break;
39036
43561
 
39037
43562
  case 2342:
 
43563
 
 
43564
/* Line 1455 of yacc.c  */
39038
43565
#line 12409 "preproc.y"
39039
43566
    {
39040
 
                        if (find_variable(yyvsp[0].str)->type->type == ECPGt_array)
 
43567
                        if (find_variable((yyvsp[(2) - (2)].str))->type->type == ECPGt_array)
39041
43568
                                mmerror(PARSE_ERROR, ET_ERROR, "arrays of indicators are not allowed on input");
39042
43569
 
39043
 
                        add_variable_to_head(&argsinsert, find_variable(yyvsp[-1].str), find_variable(yyvsp[0].str));
39044
 
                        yyval.str = create_questionmarks(yyvsp[-1].str, false);
 
43570
                        add_variable_to_head(&argsinsert, find_variable((yyvsp[(1) - (2)].str)), find_variable((yyvsp[(2) - (2)].str)));
 
43571
                        (yyval.str) = create_questionmarks((yyvsp[(1) - (2)].str), false);
39045
43572
                ;}
39046
43573
    break;
39047
43574
 
39048
43575
  case 2343:
 
43576
 
 
43577
/* Line 1455 of yacc.c  */
39049
43578
#line 12419 "preproc.y"
39050
43579
    {
39051
 
                        add_variable_to_head(&argsinsert, find_variable(yyvsp[0].str), &no_indicator);
39052
 
                        yyval.str = create_questionmarks(yyvsp[0].str, false);
 
43580
                        add_variable_to_head(&argsinsert, find_variable((yyvsp[(1) - (1)].str)), &no_indicator);
 
43581
                        (yyval.str) = create_questionmarks((yyvsp[(1) - (1)].str), false);
39053
43582
                ;}
39054
43583
    break;
39055
43584
 
39056
43585
  case 2344:
 
43586
 
 
43587
/* Line 1455 of yacc.c  */
39057
43588
#line 12425 "preproc.y"
39058
 
    { check_indicator((find_variable(yyvsp[0].str))->type); yyval.str = yyvsp[0].str; ;}
 
43589
    { check_indicator((find_variable((yyvsp[(1) - (1)].str)))->type); (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39059
43590
    break;
39060
43591
 
39061
43592
  case 2345:
 
43593
 
 
43594
/* Line 1455 of yacc.c  */
39062
43595
#line 12426 "preproc.y"
39063
 
    { check_indicator((find_variable(yyvsp[0].str))->type); yyval.str = yyvsp[0].str; ;}
 
43596
    { check_indicator((find_variable((yyvsp[(2) - (2)].str)))->type); (yyval.str) = (yyvsp[(2) - (2)].str); ;}
39064
43597
    break;
39065
43598
 
39066
43599
  case 2346:
 
43600
 
 
43601
/* Line 1455 of yacc.c  */
39067
43602
#line 12427 "preproc.y"
39068
 
    { check_indicator((find_variable(yyvsp[0].str))->type); yyval.str = yyvsp[0].str; ;}
 
43603
    { check_indicator((find_variable((yyvsp[(2) - (2)].str)))->type); (yyval.str) = (yyvsp[(2) - (2)].str); ;}
39069
43604
    break;
39070
43605
 
39071
43606
  case 2347:
 
43607
 
 
43608
/* Line 1455 of yacc.c  */
39072
43609
#line 12431 "preproc.y"
39073
43610
    {
39074
43611
                        /* As long as multidimensional arrays are not implemented we have to check for those here */
39075
 
                        char *ptr = yyvsp[0].str;
 
43612
                        char *ptr = (yyvsp[(1) - (1)].str);
39076
43613
                        int brace_open=0, brace = false;
39077
43614
 
39078
43615
                        for (; *ptr; ptr++)
39098
43635
                                                        break;
39099
43636
                                }
39100
43637
                        }
39101
 
                        yyval.str = yyvsp[0].str;
 
43638
                        (yyval.str) = (yyvsp[(1) - (1)].str);
39102
43639
                ;}
39103
43640
    break;
39104
43641
 
39105
43642
  case 2348:
 
43643
 
 
43644
/* Line 1455 of yacc.c  */
39106
43645
#line 12463 "preproc.y"
39107
 
    { yyval.str = make_name(); ;}
 
43646
    { (yyval.str) = make_name(); ;}
39108
43647
    break;
39109
43648
 
39110
43649
  case 2349:
 
43650
 
 
43651
/* Line 1455 of yacc.c  */
39111
43652
#line 12465 "preproc.y"
39112
 
    { yyval.str = make_name(); ;}
 
43653
    { (yyval.str) = make_name(); ;}
39113
43654
    break;
39114
43655
 
39115
43656
  case 2350:
 
43657
 
 
43658
/* Line 1455 of yacc.c  */
39116
43659
#line 12467 "preproc.y"
39117
 
    { yyval.str = make_name(); ;}
 
43660
    { (yyval.str) = make_name(); ;}
39118
43661
    break;
39119
43662
 
39120
43663
  case 2351:
 
43664
 
 
43665
/* Line 1455 of yacc.c  */
39121
43666
#line 12471 "preproc.y"
39122
43667
    {
39123
43668
                        /* could have been input as '' or $$ */
39124
 
                        yyval.str = (char *)mm_alloc(strlen(yyvsp[0].str) + 3);
39125
 
                        yyval.str[0]='\'';
39126
 
                        strcpy(yyval.str+1, yyvsp[0].str);
39127
 
                        yyval.str[strlen(yyvsp[0].str)+1]='\'';
39128
 
                        yyval.str[strlen(yyvsp[0].str)+2]='\0';
39129
 
                        free(yyvsp[0].str);
 
43669
                        (yyval.str) = (char *)mm_alloc(strlen((yyvsp[(1) - (1)].str)) + 3);
 
43670
                        (yyval.str)[0]='\'';
 
43671
                        strcpy((yyval.str)+1, (yyvsp[(1) - (1)].str));
 
43672
                        (yyval.str)[strlen((yyvsp[(1) - (1)].str))+1]='\'';
 
43673
                        (yyval.str)[strlen((yyvsp[(1) - (1)].str))+2]='\0';
 
43674
                        free((yyvsp[(1) - (1)].str));
39130
43675
                ;}
39131
43676
    break;
39132
43677
 
39133
43678
  case 2352:
 
43679
 
 
43680
/* Line 1455 of yacc.c  */
39134
43681
#line 12481 "preproc.y"
39135
43682
    {
39136
 
                        yyval.str = (char *)mm_alloc(strlen(yyvsp[0].str) + 4);
39137
 
                        yyval.str[0]='E';
39138
 
                        yyval.str[1]='\'';
39139
 
                        strcpy(yyval.str+2, yyvsp[0].str);
39140
 
                        yyval.str[strlen(yyvsp[0].str)+2]='\'';
39141
 
                        yyval.str[strlen(yyvsp[0].str)+3]='\0';
39142
 
                        free(yyvsp[0].str);
 
43683
                        (yyval.str) = (char *)mm_alloc(strlen((yyvsp[(1) - (1)].str)) + 4);
 
43684
                        (yyval.str)[0]='E';
 
43685
                        (yyval.str)[1]='\'';
 
43686
                        strcpy((yyval.str)+2, (yyvsp[(1) - (1)].str));
 
43687
                        (yyval.str)[strlen((yyvsp[(1) - (1)].str))+2]='\'';
 
43688
                        (yyval.str)[strlen((yyvsp[(1) - (1)].str))+3]='\0';
 
43689
                        free((yyvsp[(1) - (1)].str));
39143
43690
                ;}
39144
43691
    break;
39145
43692
 
39146
43693
  case 2353:
 
43694
 
 
43695
/* Line 1455 of yacc.c  */
39147
43696
#line 12491 "preproc.y"
39148
43697
    {
39149
 
                        yyval.str = (char *)mm_alloc(strlen(yyvsp[0].str) + 4);
39150
 
                        yyval.str[0]='N';
39151
 
                        yyval.str[1]='\'';
39152
 
                        strcpy(yyval.str+2, yyvsp[0].str);
39153
 
                        yyval.str[strlen(yyvsp[0].str)+2]='\'';
39154
 
                        yyval.str[strlen(yyvsp[0].str)+3]='\0';
39155
 
                        free(yyvsp[0].str);
 
43698
                        (yyval.str) = (char *)mm_alloc(strlen((yyvsp[(1) - (1)].str)) + 4);
 
43699
                        (yyval.str)[0]='N';
 
43700
                        (yyval.str)[1]='\'';
 
43701
                        strcpy((yyval.str)+2, (yyvsp[(1) - (1)].str));
 
43702
                        (yyval.str)[strlen((yyvsp[(1) - (1)].str))+2]='\'';
 
43703
                        (yyval.str)[strlen((yyvsp[(1) - (1)].str))+3]='\0';
 
43704
                        free((yyvsp[(1) - (1)].str));
39156
43705
                ;}
39157
43706
    break;
39158
43707
 
39159
43708
  case 2354:
 
43709
 
 
43710
/* Line 1455 of yacc.c  */
39160
43711
#line 12500 "preproc.y"
39161
 
    { yyval.str = yyvsp[0].str; ;}
 
43712
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39162
43713
    break;
39163
43714
 
39164
43715
  case 2355:
 
43716
 
 
43717
/* Line 1455 of yacc.c  */
39165
43718
#line 12501 "preproc.y"
39166
 
    { yyval.str = yyvsp[0].str; ;}
 
43719
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39167
43720
    break;
39168
43721
 
39169
43722
  case 2356:
 
43723
 
 
43724
/* Line 1455 of yacc.c  */
39170
43725
#line 12504 "preproc.y"
39171
 
    { yyval.str = make_name(); ;}
 
43726
    { (yyval.str) = make_name(); ;}
39172
43727
    break;
39173
43728
 
39174
43729
  case 2357:
 
43730
 
 
43731
/* Line 1455 of yacc.c  */
39175
43732
#line 12506 "preproc.y"
39176
 
    { yyval.str = make_name(); ;}
 
43733
    { (yyval.str) = make_name(); ;}
39177
43734
    break;
39178
43735
 
39179
43736
  case 2358:
 
43737
 
 
43738
/* Line 1455 of yacc.c  */
39180
43739
#line 12507 "preproc.y"
39181
 
    { yyval.str = make3_str(make_str("\""), yyvsp[0].str, make_str("\"")); ;}
 
43740
    { (yyval.str) = make3_str(make_str("\""), (yyvsp[(1) - (1)].str), make_str("\"")); ;}
39182
43741
    break;
39183
43742
 
39184
43743
  case 2359:
 
43744
 
 
43745
/* Line 1455 of yacc.c  */
39185
43746
#line 12508 "preproc.y"
39186
 
    { yyval.str = yyvsp[0].str; ;}
 
43747
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39187
43748
    break;
39188
43749
 
39189
43750
  case 2360:
 
43751
 
 
43752
/* Line 1455 of yacc.c  */
39190
43753
#line 12512 "preproc.y"
39191
 
    { yyval.str = make3_str(make_str("\""), yyvsp[0].str, make_str("\"")); ;}
 
43754
    { (yyval.str) = make3_str(make_str("\""), (yyvsp[(1) - (1)].str), make_str("\"")); ;}
39192
43755
    break;
39193
43756
 
39194
43757
  case 2361:
 
43758
 
 
43759
/* Line 1455 of yacc.c  */
39195
43760
#line 12514 "preproc.y"
39196
 
    { yyval.str = make3_str(make_str("("), yyvsp[0].str, make_str(")")); ;}
 
43761
    { (yyval.str) = make3_str(make_str("("), (yyvsp[(1) - (1)].str), make_str(")")); ;}
39197
43762
    break;
39198
43763
 
39199
43764
  case 2362:
 
43765
 
 
43766
/* Line 1455 of yacc.c  */
39200
43767
#line 12521 "preproc.y"
39201
 
    { yyval.str = yyvsp[0].str; ;}
 
43768
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39202
43769
    break;
39203
43770
 
39204
43771
  case 2363:
 
43772
 
 
43773
/* Line 1455 of yacc.c  */
39205
43774
#line 12522 "preproc.y"
39206
 
    { yyval.str = make_str("()"); ;}
 
43775
    { (yyval.str) = make_str("()"); ;}
39207
43776
    break;
39208
43777
 
39209
43778
  case 2364:
 
43779
 
 
43780
/* Line 1455 of yacc.c  */
39210
43781
#line 12524 "preproc.y"
39211
 
    { yyval.str = cat_str(3, make_str("("), yyvsp[-1].str, make_str(")")); ;}
 
43782
    { (yyval.str) = cat_str(3, make_str("("), (yyvsp[(2) - (3)].str), make_str(")")); ;}
39212
43783
    break;
39213
43784
 
39214
43785
  case 2365:
 
43786
 
 
43787
/* Line 1455 of yacc.c  */
39215
43788
#line 12527 "preproc.y"
39216
 
    { yyval.str = yyvsp[0].str; ;}
 
43789
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39217
43790
    break;
39218
43791
 
39219
43792
  case 2366:
 
43793
 
 
43794
/* Line 1455 of yacc.c  */
39220
43795
#line 12529 "preproc.y"
39221
 
    { yyval.str = cat2_str(yyvsp[-1].str, yyvsp[0].str); ;}
 
43796
    { (yyval.str) = cat2_str((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); ;}
39222
43797
    break;
39223
43798
 
39224
43799
  case 2367:
 
43800
 
 
43801
/* Line 1455 of yacc.c  */
39225
43802
#line 12532 "preproc.y"
39226
 
    { yyval.str = yyvsp[0].str; ;}
 
43803
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39227
43804
    break;
39228
43805
 
39229
43806
  case 2368:
 
43807
 
 
43808
/* Line 1455 of yacc.c  */
39230
43809
#line 12533 "preproc.y"
39231
 
    { yyval.str = cat_str(3, yyvsp[-2].str, make_str(","), yyvsp[0].str); ;}
 
43810
    { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str(","), (yyvsp[(3) - (3)].str)); ;}
39232
43811
    break;
39233
43812
 
39234
43813
  case 2369:
 
43814
 
 
43815
/* Line 1455 of yacc.c  */
39235
43816
#line 12536 "preproc.y"
39236
 
    { yyval.str = yyvsp[0].str; ;}
 
43817
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39237
43818
    break;
39238
43819
 
39239
43820
  case 2370:
 
43821
 
 
43822
/* Line 1455 of yacc.c  */
39240
43823
#line 12537 "preproc.y"
39241
 
    { yyval.str = cat_str(3, make_str("{"), yyvsp[-1].str, make_str("}")); ;}
 
43824
    { (yyval.str) = cat_str(3, make_str("{"), (yyvsp[(2) - (3)].str), make_str("}")); ;}
39242
43825
    break;
39243
43826
 
39244
43827
  case 2371:
 
43828
 
 
43829
/* Line 1455 of yacc.c  */
39245
43830
#line 12540 "preproc.y"
39246
 
    { yyval.str = yyvsp[0].str; ;}
 
43831
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39247
43832
    break;
39248
43833
 
39249
43834
  case 2372:
 
43835
 
 
43836
/* Line 1455 of yacc.c  */
39250
43837
#line 12541 "preproc.y"
39251
 
    { yyval.str = make_str("("); ;}
 
43838
    { (yyval.str) = make_str("("); ;}
39252
43839
    break;
39253
43840
 
39254
43841
  case 2373:
 
43842
 
 
43843
/* Line 1455 of yacc.c  */
39255
43844
#line 12542 "preproc.y"
39256
 
    { yyval.str = make_str(")"); ;}
 
43845
    { (yyval.str) = make_str(")"); ;}
39257
43846
    break;
39258
43847
 
39259
43848
  case 2374:
 
43849
 
 
43850
/* Line 1455 of yacc.c  */
39260
43851
#line 12543 "preproc.y"
39261
 
    { yyval.str = make_str(","); ;}
 
43852
    { (yyval.str) = make_str(","); ;}
39262
43853
    break;
39263
43854
 
39264
43855
  case 2375:
 
43856
 
 
43857
/* Line 1455 of yacc.c  */
39265
43858
#line 12544 "preproc.y"
39266
 
    { yyval.str = make_str(";"); ;}
 
43859
    { (yyval.str) = make_str(";"); ;}
39267
43860
    break;
39268
43861
 
39269
43862
  case 2376:
 
43863
 
 
43864
/* Line 1455 of yacc.c  */
39270
43865
#line 12547 "preproc.y"
39271
 
    { yyval.str = yyvsp[0].str; ;}
 
43866
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39272
43867
    break;
39273
43868
 
39274
43869
  case 2377:
 
43870
 
 
43871
/* Line 1455 of yacc.c  */
39275
43872
#line 12548 "preproc.y"
39276
 
    { yyval.str = yyvsp[0].str; ;}
 
43873
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39277
43874
    break;
39278
43875
 
39279
43876
  case 2378:
 
43877
 
 
43878
/* Line 1455 of yacc.c  */
39280
43879
#line 12549 "preproc.y"
39281
 
    { yyval.str = yyvsp[0].str; ;}
 
43880
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39282
43881
    break;
39283
43882
 
39284
43883
  case 2379:
 
43884
 
 
43885
/* Line 1455 of yacc.c  */
39285
43886
#line 12550 "preproc.y"
39286
 
    { yyval.str = yyvsp[0].str; ;}
 
43887
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39287
43888
    break;
39288
43889
 
39289
43890
  case 2380:
 
43891
 
 
43892
/* Line 1455 of yacc.c  */
39290
43893
#line 12551 "preproc.y"
39291
 
    { yyval.str = make_str("*"); ;}
 
43894
    { (yyval.str) = make_str("*"); ;}
39292
43895
    break;
39293
43896
 
39294
43897
  case 2381:
 
43898
 
 
43899
/* Line 1455 of yacc.c  */
39295
43900
#line 12552 "preproc.y"
39296
 
    { yyval.str = make_str("+"); ;}
 
43901
    { (yyval.str) = make_str("+"); ;}
39297
43902
    break;
39298
43903
 
39299
43904
  case 2382:
 
43905
 
 
43906
/* Line 1455 of yacc.c  */
39300
43907
#line 12553 "preproc.y"
39301
 
    { yyval.str = make_str("-"); ;}
 
43908
    { (yyval.str) = make_str("-"); ;}
39302
43909
    break;
39303
43910
 
39304
43911
  case 2383:
 
43912
 
 
43913
/* Line 1455 of yacc.c  */
39305
43914
#line 12554 "preproc.y"
39306
 
    { yyval.str = make_str("/"); ;}
 
43915
    { (yyval.str) = make_str("/"); ;}
39307
43916
    break;
39308
43917
 
39309
43918
  case 2384:
 
43919
 
 
43920
/* Line 1455 of yacc.c  */
39310
43921
#line 12555 "preproc.y"
39311
 
    { yyval.str = make_str("%"); ;}
 
43922
    { (yyval.str) = make_str("%"); ;}
39312
43923
    break;
39313
43924
 
39314
43925
  case 2385:
 
43926
 
 
43927
/* Line 1455 of yacc.c  */
39315
43928
#line 12556 "preproc.y"
39316
 
    { yyval.str = make_str("NULL"); ;}
 
43929
    { (yyval.str) = make_str("NULL"); ;}
39317
43930
    break;
39318
43931
 
39319
43932
  case 2386:
 
43933
 
 
43934
/* Line 1455 of yacc.c  */
39320
43935
#line 12557 "preproc.y"
39321
 
    { yyval.str = make_str("+="); ;}
 
43936
    { (yyval.str) = make_str("+="); ;}
39322
43937
    break;
39323
43938
 
39324
43939
  case 2387:
 
43940
 
 
43941
/* Line 1455 of yacc.c  */
39325
43942
#line 12558 "preproc.y"
39326
 
    { yyval.str = make_str("&&"); ;}
 
43943
    { (yyval.str) = make_str("&&"); ;}
39327
43944
    break;
39328
43945
 
39329
43946
  case 2388:
 
43947
 
 
43948
/* Line 1455 of yacc.c  */
39330
43949
#line 12559 "preproc.y"
39331
 
    { yyval.str = make_name(); ;}
 
43950
    { (yyval.str) = make_name(); ;}
39332
43951
    break;
39333
43952
 
39334
43953
  case 2389:
 
43954
 
 
43955
/* Line 1455 of yacc.c  */
39335
43956
#line 12560 "preproc.y"
39336
 
    { yyval.str = make_str("auto"); ;}
 
43957
    { (yyval.str) = make_str("auto"); ;}
39337
43958
    break;
39338
43959
 
39339
43960
  case 2390:
 
43961
 
 
43962
/* Line 1455 of yacc.c  */
39340
43963
#line 12561 "preproc.y"
39341
 
    { yyval.str = make_str("const"); ;}
 
43964
    { (yyval.str) = make_str("const"); ;}
39342
43965
    break;
39343
43966
 
39344
43967
  case 2391:
 
43968
 
 
43969
/* Line 1455 of yacc.c  */
39345
43970
#line 12562 "preproc.y"
39346
 
    { yyval.str = make_str("--"); ;}
 
43971
    { (yyval.str) = make_str("--"); ;}
39347
43972
    break;
39348
43973
 
39349
43974
  case 2392:
 
43975
 
 
43976
/* Line 1455 of yacc.c  */
39350
43977
#line 12563 "preproc.y"
39351
 
    { yyval.str = make_str("/="); ;}
 
43978
    { (yyval.str) = make_str("/="); ;}
39352
43979
    break;
39353
43980
 
39354
43981
  case 2393:
 
43982
 
 
43983
/* Line 1455 of yacc.c  */
39355
43984
#line 12564 "preproc.y"
39356
 
    { yyval.str = make_str(".*"); ;}
 
43985
    { (yyval.str) = make_str(".*"); ;}
39357
43986
    break;
39358
43987
 
39359
43988
  case 2394:
 
43989
 
 
43990
/* Line 1455 of yacc.c  */
39360
43991
#line 12565 "preproc.y"
39361
 
    { yyval.str = make_str("=="); ;}
 
43992
    { (yyval.str) = make_str("=="); ;}
39362
43993
    break;
39363
43994
 
39364
43995
  case 2395:
 
43996
 
 
43997
/* Line 1455 of yacc.c  */
39365
43998
#line 12566 "preproc.y"
39366
 
    { yyval.str = make_str("extern"); ;}
 
43999
    { (yyval.str) = make_str("extern"); ;}
39367
44000
    break;
39368
44001
 
39369
44002
  case 2396:
 
44003
 
 
44004
/* Line 1455 of yacc.c  */
39370
44005
#line 12567 "preproc.y"
39371
 
    { yyval.str = make_str("++"); ;}
 
44006
    { (yyval.str) = make_str("++"); ;}
39372
44007
    break;
39373
44008
 
39374
44009
  case 2397:
 
44010
 
 
44011
/* Line 1455 of yacc.c  */
39375
44012
#line 12568 "preproc.y"
39376
 
    { yyval.str = make_str("<<"); ;}
 
44013
    { (yyval.str) = make_str("<<"); ;}
39377
44014
    break;
39378
44015
 
39379
44016
  case 2398:
 
44017
 
 
44018
/* Line 1455 of yacc.c  */
39380
44019
#line 12569 "preproc.y"
39381
 
    { yyval.str = make_str("->"); ;}
 
44020
    { (yyval.str) = make_str("->"); ;}
39382
44021
    break;
39383
44022
 
39384
44023
  case 2399:
 
44024
 
 
44025
/* Line 1455 of yacc.c  */
39385
44026
#line 12570 "preproc.y"
39386
 
    { yyval.str = make_str("->*"); ;}
 
44027
    { (yyval.str) = make_str("->*"); ;}
39387
44028
    break;
39388
44029
 
39389
44030
  case 2400:
 
44031
 
 
44032
/* Line 1455 of yacc.c  */
39390
44033
#line 12571 "preproc.y"
39391
 
    { yyval.str = make_str("%="); ;}
 
44034
    { (yyval.str) = make_str("%="); ;}
39392
44035
    break;
39393
44036
 
39394
44037
  case 2401:
 
44038
 
 
44039
/* Line 1455 of yacc.c  */
39395
44040
#line 12572 "preproc.y"
39396
 
    { yyval.str = make_str("*="); ;}
 
44041
    { (yyval.str) = make_str("*="); ;}
39397
44042
    break;
39398
44043
 
39399
44044
  case 2402:
 
44045
 
 
44046
/* Line 1455 of yacc.c  */
39400
44047
#line 12573 "preproc.y"
39401
 
    { yyval.str = make_str("!="); ;}
 
44048
    { (yyval.str) = make_str("!="); ;}
39402
44049
    break;
39403
44050
 
39404
44051
  case 2403:
 
44052
 
 
44053
/* Line 1455 of yacc.c  */
39405
44054
#line 12574 "preproc.y"
39406
 
    { yyval.str = make_str("||"); ;}
 
44055
    { (yyval.str) = make_str("||"); ;}
39407
44056
    break;
39408
44057
 
39409
44058
  case 2404:
 
44059
 
 
44060
/* Line 1455 of yacc.c  */
39410
44061
#line 12575 "preproc.y"
39411
 
    { yyval.str = make_str("register"); ;}
 
44062
    { (yyval.str) = make_str("register"); ;}
39412
44063
    break;
39413
44064
 
39414
44065
  case 2405:
 
44066
 
 
44067
/* Line 1455 of yacc.c  */
39415
44068
#line 12576 "preproc.y"
39416
 
    { yyval.str = make_str(">>"); ;}
 
44069
    { (yyval.str) = make_str(">>"); ;}
39417
44070
    break;
39418
44071
 
39419
44072
  case 2406:
 
44073
 
 
44074
/* Line 1455 of yacc.c  */
39420
44075
#line 12577 "preproc.y"
39421
 
    { yyval.str = make_str("static"); ;}
 
44076
    { (yyval.str) = make_str("static"); ;}
39422
44077
    break;
39423
44078
 
39424
44079
  case 2407:
 
44080
 
 
44081
/* Line 1455 of yacc.c  */
39425
44082
#line 12578 "preproc.y"
39426
 
    { yyval.str = make_str("-="); ;}
 
44083
    { (yyval.str) = make_str("-="); ;}
39427
44084
    break;
39428
44085
 
39429
44086
  case 2408:
 
44087
 
 
44088
/* Line 1455 of yacc.c  */
39430
44089
#line 12579 "preproc.y"
39431
 
    { yyval.str = make_str("typedef"); ;}
 
44090
    { (yyval.str) = make_str("typedef"); ;}
39432
44091
    break;
39433
44092
 
39434
44093
  case 2409:
 
44094
 
 
44095
/* Line 1455 of yacc.c  */
39435
44096
#line 12580 "preproc.y"
39436
 
    { yyval.str = make_str("volatile"); ;}
 
44097
    { (yyval.str) = make_str("volatile"); ;}
39437
44098
    break;
39438
44099
 
39439
44100
  case 2410:
 
44101
 
 
44102
/* Line 1455 of yacc.c  */
39440
44103
#line 12581 "preproc.y"
39441
 
    { yyval.str = make_str("bool"); ;}
 
44104
    { (yyval.str) = make_str("bool"); ;}
39442
44105
    break;
39443
44106
 
39444
44107
  case 2411:
 
44108
 
 
44109
/* Line 1455 of yacc.c  */
39445
44110
#line 12582 "preproc.y"
39446
 
    { yyval.str = make_str("enum"); ;}
 
44111
    { (yyval.str) = make_str("enum"); ;}
39447
44112
    break;
39448
44113
 
39449
44114
  case 2412:
 
44115
 
 
44116
/* Line 1455 of yacc.c  */
39450
44117
#line 12583 "preproc.y"
39451
 
    { yyval.str = make_str("hour"); ;}
 
44118
    { (yyval.str) = make_str("hour"); ;}
39452
44119
    break;
39453
44120
 
39454
44121
  case 2413:
 
44122
 
 
44123
/* Line 1455 of yacc.c  */
39455
44124
#line 12584 "preproc.y"
39456
 
    { yyval.str = make_str("int"); ;}
 
44125
    { (yyval.str) = make_str("int"); ;}
39457
44126
    break;
39458
44127
 
39459
44128
  case 2414:
 
44129
 
 
44130
/* Line 1455 of yacc.c  */
39460
44131
#line 12585 "preproc.y"
39461
 
    { yyval.str = make_str("long"); ;}
 
44132
    { (yyval.str) = make_str("long"); ;}
39462
44133
    break;
39463
44134
 
39464
44135
  case 2415:
 
44136
 
 
44137
/* Line 1455 of yacc.c  */
39465
44138
#line 12586 "preproc.y"
39466
 
    { yyval.str = make_str("minute"); ;}
 
44139
    { (yyval.str) = make_str("minute"); ;}
39467
44140
    break;
39468
44141
 
39469
44142
  case 2416:
 
44143
 
 
44144
/* Line 1455 of yacc.c  */
39470
44145
#line 12587 "preproc.y"
39471
 
    { yyval.str = make_str("month"); ;}
 
44146
    { (yyval.str) = make_str("month"); ;}
39472
44147
    break;
39473
44148
 
39474
44149
  case 2417:
 
44150
 
 
44151
/* Line 1455 of yacc.c  */
39475
44152
#line 12588 "preproc.y"
39476
 
    { yyval.str = make_str("second"); ;}
 
44153
    { (yyval.str) = make_str("second"); ;}
39477
44154
    break;
39478
44155
 
39479
44156
  case 2418:
 
44157
 
 
44158
/* Line 1455 of yacc.c  */
39480
44159
#line 12589 "preproc.y"
39481
 
    { yyval.str = make_str("short"); ;}
 
44160
    { (yyval.str) = make_str("short"); ;}
39482
44161
    break;
39483
44162
 
39484
44163
  case 2419:
 
44164
 
 
44165
/* Line 1455 of yacc.c  */
39485
44166
#line 12590 "preproc.y"
39486
 
    { yyval.str = make_str("signed"); ;}
 
44167
    { (yyval.str) = make_str("signed"); ;}
39487
44168
    break;
39488
44169
 
39489
44170
  case 2420:
 
44171
 
 
44172
/* Line 1455 of yacc.c  */
39490
44173
#line 12591 "preproc.y"
39491
 
    { yyval.str = make_str("struct"); ;}
 
44174
    { (yyval.str) = make_str("struct"); ;}
39492
44175
    break;
39493
44176
 
39494
44177
  case 2421:
 
44178
 
 
44179
/* Line 1455 of yacc.c  */
39495
44180
#line 12592 "preproc.y"
39496
 
    { yyval.str = make_str("unsigned"); ;}
 
44181
    { (yyval.str) = make_str("unsigned"); ;}
39497
44182
    break;
39498
44183
 
39499
44184
  case 2422:
 
44185
 
 
44186
/* Line 1455 of yacc.c  */
39500
44187
#line 12593 "preproc.y"
39501
 
    { yyval.str = make_str("year"); ;}
 
44188
    { (yyval.str) = make_str("year"); ;}
39502
44189
    break;
39503
44190
 
39504
44191
  case 2423:
 
44192
 
 
44193
/* Line 1455 of yacc.c  */
39505
44194
#line 12594 "preproc.y"
39506
 
    { yyval.str = make_str("char"); ;}
 
44195
    { (yyval.str) = make_str("char"); ;}
39507
44196
    break;
39508
44197
 
39509
44198
  case 2424:
 
44199
 
 
44200
/* Line 1455 of yacc.c  */
39510
44201
#line 12595 "preproc.y"
39511
 
    { yyval.str = make_str("float"); ;}
 
44202
    { (yyval.str) = make_str("float"); ;}
39512
44203
    break;
39513
44204
 
39514
44205
  case 2425:
 
44206
 
 
44207
/* Line 1455 of yacc.c  */
39515
44208
#line 12596 "preproc.y"
39516
 
    { yyval.str = make_str("to"); ;}
 
44209
    { (yyval.str) = make_str("to"); ;}
39517
44210
    break;
39518
44211
 
39519
44212
  case 2426:
 
44213
 
 
44214
/* Line 1455 of yacc.c  */
39520
44215
#line 12597 "preproc.y"
39521
 
    { yyval.str = make_str("union"); ;}
 
44216
    { (yyval.str) = make_str("union"); ;}
39522
44217
    break;
39523
44218
 
39524
44219
  case 2427:
 
44220
 
 
44221
/* Line 1455 of yacc.c  */
39525
44222
#line 12598 "preproc.y"
39526
 
    { yyval.str = make_str("varchar"); ;}
 
44223
    { (yyval.str) = make_str("varchar"); ;}
39527
44224
    break;
39528
44225
 
39529
44226
  case 2428:
 
44227
 
 
44228
/* Line 1455 of yacc.c  */
39530
44229
#line 12599 "preproc.y"
39531
 
    { yyval.str = make_str("["); ;}
 
44230
    { (yyval.str) = make_str("["); ;}
39532
44231
    break;
39533
44232
 
39534
44233
  case 2429:
 
44234
 
 
44235
/* Line 1455 of yacc.c  */
39535
44236
#line 12600 "preproc.y"
39536
 
    { yyval.str = make_str("]"); ;}
 
44237
    { (yyval.str) = make_str("]"); ;}
39537
44238
    break;
39538
44239
 
39539
44240
  case 2430:
 
44241
 
 
44242
/* Line 1455 of yacc.c  */
39540
44243
#line 12601 "preproc.y"
39541
 
    { yyval.str = make_str("="); ;}
 
44244
    { (yyval.str) = make_str("="); ;}
39542
44245
    break;
39543
44246
 
39544
44247
  case 2431:
 
44248
 
 
44249
/* Line 1455 of yacc.c  */
39545
44250
#line 12602 "preproc.y"
39546
 
    { yyval.str = make_str(":"); ;}
 
44251
    { (yyval.str) = make_str(":"); ;}
39547
44252
    break;
39548
44253
 
39549
44254
  case 2432:
 
44255
 
 
44256
/* Line 1455 of yacc.c  */
39550
44257
#line 12605 "preproc.y"
39551
 
    { yyval.str = yyvsp[0].str; ;}
 
44258
    { (yyval.str) = (yyvsp[(2) - (2)].str); ;}
39552
44259
    break;
39553
44260
 
39554
44261
  case 2433:
 
44262
 
 
44263
/* Line 1455 of yacc.c  */
39555
44264
#line 12606 "preproc.y"
39556
 
    { yyval.str = yyvsp[0].str; ;}
 
44265
    { (yyval.str) = (yyvsp[(3) - (3)].str); ;}
39557
44266
    break;
39558
44267
 
39559
44268
  case 2434:
 
44269
 
 
44270
/* Line 1455 of yacc.c  */
39560
44271
#line 12607 "preproc.y"
39561
 
    { yyval.str = make_str("all"); ;}
 
44272
    { (yyval.str) = make_str("all"); ;}
39562
44273
    break;
39563
44274
 
39564
44275
  case 2435:
 
44276
 
 
44277
/* Line 1455 of yacc.c  */
39565
44278
#line 12608 "preproc.y"
39566
 
    { yyval.str = make_str("all"); ;}
 
44279
    { (yyval.str) = make_str("all"); ;}
39567
44280
    break;
39568
44281
 
39569
44282
  case 2436:
 
44283
 
 
44284
/* Line 1455 of yacc.c  */
39570
44285
#line 12611 "preproc.y"
39571
 
    { yyval.str = yyvsp[0].str; ;}
 
44286
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39572
44287
    break;
39573
44288
 
39574
44289
  case 2437:
 
44290
 
 
44291
/* Line 1455 of yacc.c  */
39575
44292
#line 12612 "preproc.y"
39576
 
    { yyval.str = cat_str(3, make_str("("), yyvsp[-1].str, make_str(")")); ;}
 
44293
    { (yyval.str) = cat_str(3, make_str("("), (yyvsp[(2) - (3)].str), make_str(")")); ;}
39577
44294
    break;
39578
44295
 
39579
44296
  case 2438:
 
44297
 
 
44298
/* Line 1455 of yacc.c  */
39580
44299
#line 12613 "preproc.y"
39581
 
    { yyval.str = cat_str(3, yyvsp[-2].str, make_str("+"), yyvsp[0].str); ;}
 
44300
    { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str("+"), (yyvsp[(3) - (3)].str)); ;}
39582
44301
    break;
39583
44302
 
39584
44303
  case 2439:
 
44304
 
 
44305
/* Line 1455 of yacc.c  */
39585
44306
#line 12614 "preproc.y"
39586
 
    { yyval.str = cat_str(3, yyvsp[-2].str, make_str("-"), yyvsp[0].str); ;}
 
44307
    { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str("-"), (yyvsp[(3) - (3)].str)); ;}
39587
44308
    break;
39588
44309
 
39589
44310
  case 2440:
 
44311
 
 
44312
/* Line 1455 of yacc.c  */
39590
44313
#line 12615 "preproc.y"
39591
 
    { yyval.str = cat_str(3, yyvsp[-2].str, make_str("*"), yyvsp[0].str); ;}
 
44314
    { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str("*"), (yyvsp[(3) - (3)].str)); ;}
39592
44315
    break;
39593
44316
 
39594
44317
  case 2441:
 
44318
 
 
44319
/* Line 1455 of yacc.c  */
39595
44320
#line 12616 "preproc.y"
39596
 
    { yyval.str = cat_str(3, yyvsp[-2].str, make_str("/"), yyvsp[0].str); ;}
 
44321
    { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str("/"), (yyvsp[(3) - (3)].str)); ;}
39597
44322
    break;
39598
44323
 
39599
44324
  case 2442:
 
44325
 
 
44326
/* Line 1455 of yacc.c  */
39600
44327
#line 12617 "preproc.y"
39601
 
    { yyval.str = cat_str(3, yyvsp[-2].str, make_str("%"), yyvsp[0].str); ;}
 
44328
    { (yyval.str) = cat_str(3, (yyvsp[(1) - (3)].str), make_str("%"), (yyvsp[(3) - (3)].str)); ;}
39602
44329
    break;
39603
44330
 
39604
44331
  case 2443:
 
44332
 
 
44333
/* Line 1455 of yacc.c  */
39605
44334
#line 12618 "preproc.y"
39606
 
    { yyval.str = yyvsp[0].str; ;}
 
44335
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39607
44336
    break;
39608
44337
 
39609
44338
  case 2444:
 
44339
 
 
44340
/* Line 1455 of yacc.c  */
39610
44341
#line 12619 "preproc.y"
39611
 
    { yyval.str = yyvsp[0].str; ;}
 
44342
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39612
44343
    break;
39613
44344
 
39614
44345
  case 2445:
 
44346
 
 
44347
/* Line 1455 of yacc.c  */
39615
44348
#line 12622 "preproc.y"
39616
 
    { yyval.str = EMPTY; ;}
 
44349
    { (yyval.str) = EMPTY; ;}
39617
44350
    break;
39618
44351
 
39619
44352
  case 2446:
 
44353
 
 
44354
/* Line 1455 of yacc.c  */
39620
44355
#line 12623 "preproc.y"
39621
 
    { yyval.str = EMPTY; ;}
 
44356
    { (yyval.str) = EMPTY; ;}
39622
44357
    break;
39623
44358
 
39624
44359
  case 2447:
 
44360
 
 
44361
/* Line 1455 of yacc.c  */
39625
44362
#line 12624 "preproc.y"
39626
 
    { yyval.str = EMPTY; ;}
 
44363
    { (yyval.str) = EMPTY; ;}
39627
44364
    break;
39628
44365
 
39629
44366
  case 2448:
 
44367
 
 
44368
/* Line 1455 of yacc.c  */
39630
44369
#line 12625 "preproc.y"
39631
 
    { yyval.str = EMPTY; ;}
 
44370
    { (yyval.str) = EMPTY; ;}
39632
44371
    break;
39633
44372
 
39634
44373
  case 2449:
 
44374
 
 
44375
/* Line 1455 of yacc.c  */
39635
44376
#line 12626 "preproc.y"
39636
 
    { yyval.str = EMPTY; ;}
 
44377
    { (yyval.str) = EMPTY; ;}
39637
44378
    break;
39638
44379
 
39639
44380
  case 2450:
 
44381
 
 
44382
/* Line 1455 of yacc.c  */
39640
44383
#line 12629 "preproc.y"
39641
 
    { yyval.str = EMPTY; ;}
 
44384
    { (yyval.str) = EMPTY; ;}
39642
44385
    break;
39643
44386
 
39644
44387
  case 2451:
 
44388
 
 
44389
/* Line 1455 of yacc.c  */
39645
44390
#line 12630 "preproc.y"
39646
 
    { yyval.str = yyvsp[0].str; ;}
 
44391
    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
39647
44392
    break;
39648
44393
 
39649
44394
 
 
44395
 
 
44396
/* Line 1455 of yacc.c  */
 
44397
#line 44398 "preproc.c"
 
44398
      default: break;
39650
44399
    }
39651
 
 
39652
 
/* Line 991 of yacc.c.  */
39653
 
#line 39653 "preproc.c"
39654
 
 
39655
 
  yyvsp -= yylen;
39656
 
  yyssp -= yylen;
39657
 
  yylsp -= yylen;
39658
 
 
 
44400
  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
 
44401
 
 
44402
  YYPOPSTACK (yylen);
 
44403
  yylen = 0;
39659
44404
  YY_STACK_PRINT (yyss, yyssp);
39660
44405
 
39661
44406
  *++yyvsp = yyval;
39684
44429
  if (!yyerrstatus)
39685
44430
    {
39686
44431
      ++yynerrs;
39687
 
#if YYERROR_VERBOSE
39688
 
      yyn = yypact[yystate];
39689
 
 
39690
 
      if (YYPACT_NINF < yyn && yyn < YYLAST)
39691
 
        {
39692
 
          YYSIZE_T yysize = 0;
39693
 
          int yytype = YYTRANSLATE (yychar);
39694
 
          char *yymsg;
39695
 
          int yyx, yycount;
39696
 
 
39697
 
          yycount = 0;
39698
 
          /* Start YYX at -YYN if negative to avoid negative indexes in
39699
 
             YYCHECK.  */
39700
 
          for (yyx = yyn < 0 ? -yyn : 0;
39701
 
               yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
39702
 
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
39703
 
              yysize += yystrlen (yytname[yyx]) + 15, yycount++;
39704
 
          yysize += yystrlen ("syntax error, unexpected ") + 1;
39705
 
          yysize += yystrlen (yytname[yytype]);
39706
 
          yymsg = (char *) YYSTACK_ALLOC (yysize);
39707
 
          if (yymsg != 0)
39708
 
            {
39709
 
              char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
39710
 
              yyp = yystpcpy (yyp, yytname[yytype]);
39711
 
 
39712
 
              if (yycount < 5)
39713
 
                {
39714
 
                  yycount = 0;
39715
 
                  for (yyx = yyn < 0 ? -yyn : 0;
39716
 
                       yyx < (int) (sizeof (yytname) / sizeof (char *));
39717
 
                       yyx++)
39718
 
                    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
39719
 
                      {
39720
 
                        const char *yyq = ! yycount ? ", expecting " : " or ";
39721
 
                        yyp = yystpcpy (yyp, yyq);
39722
 
                        yyp = yystpcpy (yyp, yytname[yyx]);
39723
 
                        yycount++;
39724
 
                      }
39725
 
                }
39726
 
              yyerror (yymsg);
 
44432
#if ! YYERROR_VERBOSE
 
44433
      yyerror (YY_("syntax error"));
 
44434
#else
 
44435
      {
 
44436
        YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
 
44437
        if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
 
44438
          {
 
44439
            YYSIZE_T yyalloc = 2 * yysize;
 
44440
            if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
 
44441
              yyalloc = YYSTACK_ALLOC_MAXIMUM;
 
44442
            if (yymsg != yymsgbuf)
39727
44443
              YYSTACK_FREE (yymsg);
39728
 
            }
39729
 
          else
39730
 
            yyerror ("syntax error; also virtual memory exhausted");
39731
 
        }
39732
 
      else
39733
 
#endif /* YYERROR_VERBOSE */
39734
 
        yyerror ("syntax error");
 
44444
            yymsg = (char *) YYSTACK_ALLOC (yyalloc);
 
44445
            if (yymsg)
 
44446
              yymsg_alloc = yyalloc;
 
44447
            else
 
44448
              {
 
44449
                yymsg = yymsgbuf;
 
44450
                yymsg_alloc = sizeof yymsgbuf;
 
44451
              }
 
44452
          }
 
44453
 
 
44454
        if (0 < yysize && yysize <= yymsg_alloc)
 
44455
          {
 
44456
            (void) yysyntax_error (yymsg, yystate, yychar);
 
44457
            yyerror (yymsg);
 
44458
          }
 
44459
        else
 
44460
          {
 
44461
            yyerror (YY_("syntax error"));
 
44462
            if (yysize != 0)
 
44463
              goto yyexhaustedlab;
 
44464
          }
 
44465
      }
 
44466
#endif
39735
44467
    }
39736
44468
 
39737
 
  yylerrsp = yylsp;
 
44469
  yyerror_range[0] = yylloc;
39738
44470
 
39739
44471
  if (yyerrstatus == 3)
39740
44472
    {
39741
44473
      /* If just tried and failed to reuse lookahead token after an
39742
44474
         error, discard it.  */
39743
44475
 
39744
 
      /* Return failure if at end of input.  */
39745
 
      if (yychar == YYEOF)
39746
 
        {
39747
 
          /* Pop the error token.  */
39748
 
          YYPOPSTACK;
39749
 
          /* Pop the rest of the stack.  */
39750
 
          while (yyss < yyssp)
39751
 
            {
39752
 
              YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
39753
 
              yydestruct (yystos[*yyssp], yyvsp, yylsp);
39754
 
              YYPOPSTACK;
39755
 
            }
39756
 
          YYABORT;
39757
 
        }
39758
 
 
39759
 
      YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
39760
 
      yydestruct (yytoken, &yylval, &yylloc);
39761
 
      yychar = YYEMPTY;
39762
 
      *++yylerrsp = yylloc;
 
44476
      if (yychar <= YYEOF)
 
44477
        {
 
44478
          /* Return failure if at end of input.  */
 
44479
          if (yychar == YYEOF)
 
44480
            YYABORT;
 
44481
        }
 
44482
      else
 
44483
        {
 
44484
          yydestruct ("Error: discarding",
 
44485
                      yytoken, &yylval, &yylloc);
 
44486
          yychar = YYEMPTY;
 
44487
        }
39763
44488
    }
39764
44489
 
39765
44490
  /* Else will try to reuse lookahead token after shifting the error
39766
44491
     token.  */
39767
 
  goto yyerrlab2;
39768
 
 
39769
 
 
39770
 
/*----------------------------------------------------.
39771
 
| yyerrlab1 -- error raised explicitly by an action.  |
39772
 
`----------------------------------------------------*/
 
44492
  goto yyerrlab1;
 
44493
 
 
44494
 
 
44495
/*---------------------------------------------------.
 
44496
| yyerrorlab -- error raised explicitly by YYERROR.  |
 
44497
`---------------------------------------------------*/
 
44498
yyerrorlab:
 
44499
 
 
44500
  /* Pacify compilers like GCC when the user code never invokes
 
44501
     YYERROR and the label yyerrorlab therefore never appears in user
 
44502
     code.  */
 
44503
  if (/*CONSTCOND*/ 0)
 
44504
     goto yyerrorlab;
 
44505
 
 
44506
  yyerror_range[0] = yylsp[1-yylen];
 
44507
  /* Do not reclaim the symbols of the rule which action triggered
 
44508
     this YYERROR.  */
 
44509
  YYPOPSTACK (yylen);
 
44510
  yylen = 0;
 
44511
  YY_STACK_PRINT (yyss, yyssp);
 
44512
  yystate = *yyssp;
 
44513
  goto yyerrlab1;
 
44514
 
 
44515
 
 
44516
/*-------------------------------------------------------------.
 
44517
| yyerrlab1 -- common code for both syntax error and YYERROR.  |
 
44518
`-------------------------------------------------------------*/
39773
44519
yyerrlab1:
39774
 
 
39775
 
  /* Suppress GCC warning that yyerrlab1 is unused when no action
39776
 
     invokes YYERROR.  */
39777
 
#if defined (__GNUC_MINOR__) && 2093 <= (__GNUC__ * 1000 + __GNUC_MINOR__)
39778
 
  __attribute__ ((__unused__))
39779
 
#endif
39780
 
 
39781
 
  yylerrsp = yylsp;
39782
 
  *++yylerrsp = yyloc;
39783
 
  goto yyerrlab2;
39784
 
 
39785
 
 
39786
 
/*---------------------------------------------------------------.
39787
 
| yyerrlab2 -- pop states until the error token can be shifted.  |
39788
 
`---------------------------------------------------------------*/
39789
 
yyerrlab2:
39790
44520
  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
39791
44521
 
39792
44522
  for (;;)
39807
44537
      if (yyssp == yyss)
39808
44538
        YYABORT;
39809
44539
 
39810
 
      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
39811
 
      yydestruct (yystos[yystate], yyvsp, yylsp);
39812
 
      yyvsp--;
39813
 
      yystate = *--yyssp;
39814
 
      yylsp--;
 
44540
      yyerror_range[0] = *yylsp;
 
44541
      yydestruct ("Error: popping",
 
44542
                  yystos[yystate], yyvsp, yylsp);
 
44543
      YYPOPSTACK (1);
 
44544
      yystate = *yyssp;
39815
44545
      YY_STACK_PRINT (yyss, yyssp);
39816
44546
    }
39817
44547
 
39818
 
  if (yyn == YYFINAL)
39819
 
    YYACCEPT;
39820
 
 
39821
 
  YYDPRINTF ((stderr, "Shifting error token, "));
39822
 
 
39823
44548
  *++yyvsp = yylval;
39824
 
  YYLLOC_DEFAULT (yyloc, yylsp, (yylerrsp - yylsp));
 
44549
 
 
44550
  yyerror_range[1] = yylloc;
 
44551
  /* Using YYLLOC is tempting, but would change the location of
 
44552
     the lookahead.  YYLOC is available though.  */
 
44553
  YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
39825
44554
  *++yylsp = yyloc;
39826
44555
 
 
44556
  /* Shift the error token.  */
 
44557
  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
 
44558
 
39827
44559
  yystate = yyn;
39828
44560
  goto yynewstate;
39829
44561
 
39842
44574
  yyresult = 1;
39843
44575
  goto yyreturn;
39844
44576
 
39845
 
#ifndef yyoverflow
39846
 
/*----------------------------------------------.
39847
 
| yyoverflowlab -- parser overflow comes here.  |
39848
 
`----------------------------------------------*/
39849
 
yyoverflowlab:
39850
 
  yyerror ("parser stack overflow");
 
44577
#if !defined(yyoverflow) || YYERROR_VERBOSE
 
44578
/*-------------------------------------------------.
 
44579
| yyexhaustedlab -- memory exhaustion comes here.  |
 
44580
`-------------------------------------------------*/
 
44581
yyexhaustedlab:
 
44582
  yyerror (YY_("memory exhausted"));
39851
44583
  yyresult = 2;
39852
44584
  /* Fall through.  */
39853
44585
#endif
39854
44586
 
39855
44587
yyreturn:
 
44588
  if (yychar != YYEMPTY)
 
44589
     yydestruct ("Cleanup: discarding lookahead",
 
44590
                 yytoken, &yylval, &yylloc);
 
44591
  /* Do not reclaim the symbols of the rule which action triggered
 
44592
     this YYABORT or YYACCEPT.  */
 
44593
  YYPOPSTACK (yylen);
 
44594
  YY_STACK_PRINT (yyss, yyssp);
 
44595
  while (yyssp != yyss)
 
44596
    {
 
44597
      yydestruct ("Cleanup: popping",
 
44598
                  yystos[*yyssp], yyvsp, yylsp);
 
44599
      YYPOPSTACK (1);
 
44600
    }
39856
44601
#ifndef yyoverflow
39857
44602
  if (yyss != yyssa)
39858
44603
    YYSTACK_FREE (yyss);
39859
44604
#endif
39860
 
  return yyresult;
 
44605
#if YYERROR_VERBOSE
 
44606
  if (yymsg != yymsgbuf)
 
44607
    YYSTACK_FREE (yymsg);
 
44608
#endif
 
44609
  /* Make sure YYID is used.  */
 
44610
  return YYID (yyresult);
39861
44611
}
39862
44612
 
39863
44613
 
 
44614
 
 
44615
/* Line 1675 of yacc.c  */
39864
44616
#line 12633 "preproc.y"
39865
44617
 
39866
44618