NCBI C++ ToolKit
query_parser_bison.tab.c
Go to the documentation of this file.

Go to the SVN repository for this file.

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
10  it under the terms of the GNU General Public License as published by
11  the Free Software Foundation, either version 3 of the License, or
12  (at your option) any later version.
13 
14  This program is distributed in the hope that it will be useful,
15  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  GNU General Public License for more details.
18 
19  You should have received a copy of the GNU General Public License
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. */
37 
38 /* All symbols defined below should begin with yy or YY, to avoid
39  infringing on user name space. This should be done even for local
40  variables, as they might otherwise be expanded by user macros.
41  There are some unavoidable exceptions within include files to
42  define necessary library symbols; they are noted "INFRINGES ON
43  USER NAME SPACE" below. */
44 
45 /* Identify Bison output. */
46 #define YYBISON 1
47 
48 /* Bison version. */
49 #define YYBISON_VERSION "2.4.1"
50 
51 /* Skeleton name. */
52 #define YYSKELETON_NAME "yacc.c"
53 
54 /* Pure parsers. */
55 #define YYPURE 1
56 
57 /* Push parsers. */
58 #define YYPUSH 0
59 
60 /* Pull parsers. */
61 #define YYPULL 1
62 
63 /* Using locations. */
64 #define YYLSP_NEEDED 0
65 
66 /* Substitute the variable and function names. */
67 #define yyparse ncbi_q_parse
68 #define yylex ncbi_q_lex
69 #define yyerror ncbi_q_error
70 #define yylval ncbi_q_lval
71 #define yychar ncbi_q_char
72 #define yydebug ncbi_q_debug
73 #define yynerrs ncbi_q_nerrs
74 
75 
76 /* Copy the first part of user declarations. */
77 
78 /* Line 189 of yacc.c */
79 #line 33 "query_parser_bison.y"
80 
81 
82 #define YYSTYPE CQueryParseTree::TNode*
83 #define YYPARSE_PARAM parm
84 #define YYLEX_PARAM parm
85 #define YYMAXDEPTH 100000
86 
87 #define YYDEBUG 1
88 #define YYERROR_VERBOSE 1
89 
90 
91 /// Add child node(s) to the parent
92 /// @internal
93 ///
94 inline static
95 void QTreeAddNode(void* parm,
99 {
100  if (node1)
101  rnode->AddNode(node1);
102  if (node2)
103  rnode->AddNode(node2);
104 
105  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
106  env->AttachQueryTree(rnode);
107  env->ForgetPoolNodes(node1, node2);
108 }
109 
110 
111 /// Add node to a list if parser environment is in the list parsing context
112 /// @internal
113 ///
114 inline static
115 void AddFunc_Arg(void* parm,
117 {
118  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
119  CQueryParseTree::TNode* func_node = env->GetContext();
120 
121  if (func_node) {
122  func_node->AddNode(node);
123  }
124  env->ForgetPoolNodes(node, 0);
125 }
126 
127 inline static
128 void AddIn_Arg(void* parm,
130 {
131  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
132  CQueryParseTree::TNode* in_node = env->GetIN_Context();
133 
134  if (in_node) {
135  in_node->AddNode(node);
136  }
137  env->ForgetPoolNodes(node, 0);
138 }
139 
140 
141 
142 /* Line 189 of yacc.c */
143 #line 144 "query_parser_bison.tab.c"
144 
145 /* Enabling traces. */
146 #ifndef YYDEBUG
147 # define YYDEBUG 0
148 #endif
149 
150 /* Enabling verbose error messages. */
151 #ifdef YYERROR_VERBOSE
152 # undef YYERROR_VERBOSE
153 # define YYERROR_VERBOSE 1
154 #else
155 # define YYERROR_VERBOSE 0
156 #endif
157 
158 /* Enabling the token table. */
159 #ifndef YYTOKEN_TABLE
160 # define YYTOKEN_TABLE 0
161 #endif
162 
163 
164 /* Tokens. */
165 #ifndef YYTOKENTYPE
166 # define YYTOKENTYPE
167  /* Put the tokens into the symbol table, so that GDB and other debuggers
168  know about them. */
169  enum yytokentype {
170  IDENT = 258,
171  STRING = 259,
172  NUM_INT = 260,
173  SELECT = 261,
174  FROM = 262,
175  WHERE = 263,
176  FUNCTION = 264,
177  AND = 265,
178  NOT = 266,
179  OR = 267,
180  SUB = 268,
181  XOR = 269,
182  RANGE = 270,
183  EQ = 271,
184  NOTEQ = 272,
185  GT = 273,
186  GE = 274,
187  LT = 275,
188  LE = 276,
189  BETWEEN = 277,
190  NOT_BETWEEN = 278,
191  LIKE = 279,
192  NOT_LIKE = 280,
193  IN = 281,
194  NOT_IN = 282
195  };
196 #endif
197 
198 
199 
200 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
201 typedef int YYSTYPE;
202 # define YYSTYPE_IS_TRIVIAL 1
203 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
204 # define YYSTYPE_IS_DECLARED 1
205 #endif
206 
207 
208 /* Copy the second part of user declarations. */
209 
210 
211 /* Line 264 of yacc.c */
212 #line 213 "query_parser_bison.tab.c"
213 
214 #ifdef short
215 # undef short
216 #endif
217 
218 #ifdef YYTYPE_UINT8
219 typedef YYTYPE_UINT8 yytype_uint8;
220 #else
221 typedef unsigned char yytype_uint8;
222 #endif
223 
224 #ifdef YYTYPE_INT8
225 typedef YYTYPE_INT8 yytype_int8;
226 #elif (defined __STDC__ || defined __C99__FUNC__ \
227  || defined __cplusplus || defined _MSC_VER)
228 typedef signed char yytype_int8;
229 #else
230 typedef short int yytype_int8;
231 #endif
232 
233 #ifdef YYTYPE_UINT16
234 typedef YYTYPE_UINT16 yytype_uint16;
235 #else
236 typedef unsigned short int yytype_uint16;
237 #endif
238 
239 #ifdef YYTYPE_INT16
240 typedef YYTYPE_INT16 yytype_int16;
241 #else
242 typedef short int yytype_int16;
243 #endif
244 
245 #ifndef YYSIZE_T
246 # ifdef __SIZE_TYPE__
247 # define YYSIZE_T __SIZE_TYPE__
248 # elif defined size_t
249 # define YYSIZE_T size_t
250 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
251  || defined __cplusplus || defined _MSC_VER)
252 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
253 # define YYSIZE_T size_t
254 # else
255 # define YYSIZE_T unsigned int
256 # endif
257 #endif
258 
259 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
260 
261 #ifndef YY_
262 # if YYENABLE_NLS
263 # if ENABLE_NLS
264 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
265 # define YY_(msgid) dgettext ("bison-runtime", msgid)
266 # endif
267 # endif
268 # ifndef YY_
269 # define YY_(msgid) msgid
270 # endif
271 #endif
272 
273 /* Suppress unused-variable warnings by "using" E. */
274 #if ! defined lint || defined __GNUC__
275 # define YYUSE(e) ((void) (e))
276 #else
277 # define YYUSE(e) /* empty */
278 #endif
279 
280 /* Identity function, used to suppress warnings about constant conditions. */
281 #ifndef lint
282 # define YYID(n) (n)
283 #else
284 #if (defined __STDC__ || defined __C99__FUNC__ \
285  || defined __cplusplus || defined _MSC_VER)
286 static int
287 YYID (int yyi)
288 #else
289 static int
290 YYID (yyi)
291  int yyi;
292 #endif
293 {
294  return yyi;
295 }
296 #endif
297 
298 #if ! defined yyoverflow || YYERROR_VERBOSE
299 
300 /* The parser invokes alloca or malloc; define the necessary symbols. */
301 
302 # ifdef YYSTACK_USE_ALLOCA
303 # if YYSTACK_USE_ALLOCA
304 # ifdef __GNUC__
305 # define YYSTACK_ALLOC __builtin_alloca
306 # elif defined __BUILTIN_VA_ARG_INCR
307 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
308 # elif defined _AIX
309 # define YYSTACK_ALLOC __alloca
310 # elif defined _MSC_VER
311 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
312 # define alloca _alloca
313 # else
314 # define YYSTACK_ALLOC alloca
315 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
316  || defined __cplusplus || defined _MSC_VER)
317 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
318 # ifndef _STDLIB_H
319 # define _STDLIB_H 1
320 # endif
321 # endif
322 # endif
323 # endif
324 # endif
325 
326 # ifdef YYSTACK_ALLOC
327  /* Pacify GCC's `empty if-body' warning. */
328 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
329 # ifndef YYSTACK_ALLOC_MAXIMUM
330  /* The OS might guarantee only one guard page at the bottom of the stack,
331  and a page size can be as small as 4096 bytes. So we cannot safely
332  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
333  to allow for a few compiler-allocated temporary stack slots. */
334 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
335 # endif
336 # else
337 # define YYSTACK_ALLOC YYMALLOC
338 # define YYSTACK_FREE YYFREE
339 # ifndef YYSTACK_ALLOC_MAXIMUM
340 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
341 # endif
342 # if (defined __cplusplus && ! defined _STDLIB_H \
343  && ! ((defined YYMALLOC || defined malloc) \
344  && (defined YYFREE || defined free)))
345 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
346 # ifndef _STDLIB_H
347 # define _STDLIB_H 1
348 # endif
349 # endif
350 # ifndef YYMALLOC
351 # define YYMALLOC malloc
352 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
353  || defined __cplusplus || defined _MSC_VER)
354 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
355 # endif
356 # endif
357 # ifndef YYFREE
358 # define YYFREE free
359 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
360  || defined __cplusplus || defined _MSC_VER)
361 void free (void *); /* INFRINGES ON USER NAME SPACE */
362 # endif
363 # endif
364 # endif
365 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
366 
367 
368 #if (! defined yyoverflow \
369  && (! defined __cplusplus \
370  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
371 
372 /* A type that is properly aligned for any stack member. */
373 union yyalloc
374 {
377 };
378 
379 /* The size of the maximum gap between one aligned stack and the next. */
380 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
381 
382 /* The size of an array large to enough to hold all stacks, each with
383  N elements. */
384 # define YYSTACK_BYTES(N) \
385  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
386  + YYSTACK_GAP_MAXIMUM)
387 
388 /* Copy COUNT objects from FROM to TO. The source and destination do
389  not overlap. */
390 # ifndef YYCOPY
391 # if defined __GNUC__ && 1 < __GNUC__
392 # define YYCOPY(To, From, Count) \
393  __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
394 # else
395 # define YYCOPY(To, From, Count) \
396  do \
397  { \
398  YYSIZE_T yyi; \
399  for (yyi = 0; yyi < (Count); yyi++) \
400  (To)[yyi] = (From)[yyi]; \
401  } \
402  while (YYID (0))
403 # endif
404 # endif
405 
406 /* Relocate STACK from its old location to the new one. The
407  local variables YYSIZE and YYSTACKSIZE give the old and new number of
408  elements in the stack, and YYPTR gives the new location of the
409  stack. Advance YYPTR to a properly aligned location for the next
410  stack. */
411 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
412  do \
413  { \
414  YYSIZE_T yynewbytes; \
415  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
416  Stack = &yyptr->Stack_alloc; \
417  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
418  yyptr += yynewbytes / sizeof (*yyptr); \
419  } \
420  while (YYID (0))
421 
422 #endif
423 
424 /* YYFINAL -- State number of the termination state. */
425 #define YYFINAL 25
426 /* YYLAST -- Last index in YYTABLE. */
427 #define YYLAST 589
428 
429 /* YYNTOKENS -- Number of terminals. */
430 #define YYNTOKENS 31
431 /* YYNNTS -- Number of nonterminals. */
432 #define YYNNTS 11
433 /* YYNRULES -- Number of rules. */
434 #define YYNRULES 53
435 /* YYNRULES -- Number of states. */
436 #define YYNSTATES 96
437 
438 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
439 #define YYUNDEFTOK 2
440 #define YYMAXUTOK 282
441 
442 #define YYTRANSLATE(YYX) \
443  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
444 
445 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
446 static const yytype_uint8 yytranslate[] =
447 {
448  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
449  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
450  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
451  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
452  28, 29, 2, 2, 30, 2, 2, 2, 2, 2,
453  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
454  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
455  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
456  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
457  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
458  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
459  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
460  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
461  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
462  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
463  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
464  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
465  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
466  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
467  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
468  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
469  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
470  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
471  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
472  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
473  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
474  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
475  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
476  25, 26, 27
477 };
478 
479 #if YYDEBUG
480 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
481  YYRHS. */
482 static const yytype_uint8 yyprhs[] =
483 {
484  0, 0, 3, 5, 7, 13, 14, 17, 22, 26,
485  28, 32, 34, 36, 38, 40, 42, 46, 48, 52,
486  54, 56, 58, 60, 63, 66, 70, 74, 78, 82,
487  86, 92, 98, 102, 106, 110, 116, 122, 126, 130,
488  134, 138, 142, 146, 149, 152, 155, 158, 161, 165,
489  169, 173, 177, 181
490 };
491 
492 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
493 static const yytype_int8 yyrhs[] =
494 {
495  32, 0, -1, 41, -1, 33, -1, 6, 36, 7,
496  36, 34, -1, -1, 8, 41, -1, 9, 28, 39,
497  29, -1, 9, 28, 29, -1, 37, -1, 36, 30,
498  37, -1, 5, -1, 4, -1, 3, -1, 35, -1,
499  37, -1, 38, 30, 37, -1, 41, -1, 39, 30,
500  41, -1, 38, -1, 33, -1, 37, -1, 35, -1,
501  4, 3, -1, 41, 41, -1, 28, 41, 29, -1,
502  41, 10, 41, -1, 41, 13, 41, -1, 41, 12,
503  41, -1, 41, 14, 41, -1, 37, 22, 37, 10,
504  37, -1, 37, 23, 37, 10, 37, -1, 41, 15,
505  41, -1, 37, 24, 37, -1, 37, 25, 37, -1,
506  37, 26, 28, 40, 29, -1, 37, 27, 28, 40,
507  29, -1, 41, 16, 41, -1, 41, 17, 41, -1,
508  41, 18, 41, -1, 41, 19, 41, -1, 41, 20,
509  41, -1, 41, 21, 41, -1, 11, 41, -1, 1,
510  4, -1, 1, 3, -1, 1, 5, -1, 41, 1,
511  -1, 28, 41, 1, -1, 41, 12, 1, -1, 41,
512  14, 1, -1, 41, 11, 1, -1, 41, 10, 1,
513  -1, 41, 13, 1, -1
514 };
515 
516 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
517 static const yytype_uint16 yyrline[] =
518 {
519  0, 128, 128, 129, 136, 176, 180, 190, 199, 210,
520  214, 226, 231, 236, 240, 247, 251, 259, 263, 272,
521  274, 278, 283, 288, 296, 307, 317, 322, 327, 332,
522  337, 350, 364, 369, 374, 379, 390, 401, 406, 410,
523  414, 418, 422, 433, 442, 451, 460, 469, 481, 491,
524  501, 511, 521, 531
525 };
526 #endif
527 
528 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
529 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
530  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
531 static const char *const yytname[] =
532 {
533  "$end", "error", "$undefined", "IDENT", "STRING", "NUM_INT", "SELECT",
534  "FROM", "WHERE", "FUNCTION", "AND", "NOT", "OR", "SUB", "XOR", "RANGE",
535  "EQ", "NOTEQ", "GT", "GE", "LT", "LE", "BETWEEN", "NOT_BETWEEN", "LIKE",
536  "NOT_LIKE", "IN", "NOT_IN", "'('", "')'", "','", "$accept", "input",
537  "select_clause", "opt_where", "functional", "obj_list", "scalar_value",
538  "scalar_list", "exp_list", "in_sub_expr", "exp", 0
539 };
540 #endif
541 
542 # ifdef YYPRINT
543 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
544  token YYLEX-NUM. */
545 static const yytype_uint16 yytoknum[] =
546 {
547  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
548  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
549  275, 276, 277, 278, 279, 280, 281, 282, 40, 41,
550  44
551 };
552 # endif
553 
554 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
555 static const yytype_uint8 yyr1[] =
556 {
557  0, 31, 32, 32, 33, 34, 34, 35, 35, 36,
558  36, 37, 37, 37, 37, 38, 38, 39, 39, 40,
559  40, 41, 41, 41, 41, 41, 41, 41, 41, 41,
560  41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
561  41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
562  41, 41, 41, 41
563 };
564 
565 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
566 static const yytype_uint8 yyr2[] =
567 {
568  0, 2, 1, 1, 5, 0, 2, 4, 3, 1,
569  3, 1, 1, 1, 1, 1, 3, 1, 3, 1,
570  1, 1, 1, 2, 2, 3, 3, 3, 3, 3,
571  5, 5, 3, 3, 3, 5, 5, 3, 3, 3,
572  3, 3, 3, 2, 2, 2, 2, 2, 3, 3,
573  3, 3, 3, 3
574 };
575 
576 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
577  STATE-NUM when YYTABLE doesn't specify something else to do. Zero
578  means the default is an error. */
579 static const yytype_uint8 yydefact[] =
580 {
581  0, 0, 13, 12, 11, 0, 0, 0, 0, 0,
582  3, 14, 21, 0, 45, 44, 46, 23, 12, 14,
583  0, 9, 0, 0, 0, 1, 0, 0, 0, 0,
584  0, 0, 47, 0, 0, 0, 0, 0, 0, 0,
585  0, 0, 0, 0, 0, 0, 0, 0, 8, 0,
586  0, 47, 25, 0, 0, 33, 34, 0, 0, 52,
587  0, 51, 49, 0, 53, 0, 50, 0, 0, 0,
588  0, 0, 0, 0, 0, 5, 10, 7, 0, 0,
589  0, 20, 15, 19, 0, 0, 0, 4, 0, 30,
590  31, 0, 35, 36, 0, 16
591 };
592 
593 /* YYDEFGOTO[NTERM-NUM]. */
594 static const yytype_int8 yydefgoto[] =
595 {
596  -1, 9, 81, 87, 11, 20, 12, 83, 49, 84,
597  45
598 };
599 
600 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
601  STATE-NUM. */
602 #define YYPACT_NINF -26
603 static const yytype_int16 yypact[] =
604 {
605  503, 46, -26, -1, -26, 62, -19, 512, 512, 14,
606  -26, -26, 71, 461, -26, -26, -26, -26, -26, -26,
607  -6, -26, 59, 109, 482, -26, 62, 62, 62, 62,
608  -11, -7, 46, 521, 532, 541, 550, 561, 512, 512,
609  512, 512, 512, 512, 512, 131, 62, 62, -26, -25,
610  395, 15, -26, 13, 16, -26, -26, 7, 7, 46,
611  153, 46, 46, 175, 46, 197, 46, 219, 241, 263,
612  285, 307, 329, 351, 373, -5, -26, -26, 512, 62,
613  62, -26, -26, 2, 17, 27, 512, -26, 417, -26,
614  -26, 62, -26, -26, 439, -26
615 };
616 
617 /* YYPGOTO[NTERM-NUM]. */
618 static const yytype_int8 yypgoto[] =
619 {
620  -26, -26, 57, -26, 1, 23, 26, -26, -26, 3,
621  0
622 };
623 
624 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
625  positive, shift that token. If negative, reduce the rule which
626  number is the opposite. If zero, do what YYDEFACT says.
627  If YYTABLE_NINF, syntax error. */
628 #define YYTABLE_NINF -49
629 static const yytype_int8 yytable[] =
630 {
631  13, 46, 17, 86, 77, 78, 19, 23, 24, 22,
632  2, 18, 4, 5, 25, -48, 6, 57, 14, 15,
633  16, 58, 50, 79, 47, 47, 80, 19, 19, 19,
634  19, 21, 91, 60, 23, 63, 65, 67, 68, 69,
635  70, 71, 72, 73, 74, -48, 92, 19, 19, 14,
636  15, 16, 53, 54, 55, 56, 93, 10, 19, 19,
637  1, 85, 2, 3, 4, 2, 18, 4, 6, 75,
638  7, 6, 21, 76, 0, 0, 0, 0, 88, 0,
639  19, 19, 0, 82, 82, 0, 94, 8, 48, 0,
640  0, 0, 19, 26, 27, 28, 29, 30, 31, 0,
641  0, 0, 0, 0, 0, 89, 90, 0, 0, -43,
642  32, 0, 2, 3, 4, 0, 0, 95, 6, -43,
643  -43, 35, 36, 37, 38, 39, 40, 41, 42, 43,
644  44, -24, 32, 0, 2, 3, 4, 8, -43, -43,
645  6, 33, 34, 35, 36, 37, 38, 39, 40, 41,
646  42, 43, 44, -26, 32, 0, 2, 3, 4, 8,
647  -24, -24, 6, -26, 34, 35, 36, 37, 38, 39,
648  40, 41, 42, 43, 44, -28, 32, 0, 2, 3,
649  4, 8, -26, -26, 6, -28, -28, -28, 36, 37,
650  38, 39, 40, 41, 42, 43, 44, -27, 32, 0,
651  2, 3, 4, 8, -28, -28, 6, -27, -27, -27,
652  -27, 37, 38, 39, 40, 41, 42, 43, 44, -29,
653  32, 0, 2, 3, 4, 8, -27, -27, 6, -29,
654  -29, -29, -29, -29, 38, 39, 40, 41, 42, 43,
655  44, -32, 32, 0, 2, 3, 4, 8, -29, -29,
656  6, -32, -32, -32, -32, -32, -32, 39, 40, 41,
657  42, 43, 44, -37, 32, 0, 2, 3, 4, 8,
658  -32, -32, 6, -37, -37, -37, -37, -37, -37, -37,
659  40, 41, 42, 43, 44, -38, 32, 0, 2, 3,
660  4, 8, -37, -37, 6, -38, -38, -38, -38, -38,
661  -38, -38, -38, 41, 42, 43, 44, -39, 32, 0,
662  2, 3, 4, 8, -38, -38, 6, -39, -39, -39,
663  -39, -39, -39, -39, -39, -39, 42, 43, 44, -40,
664  32, 0, 2, 3, 4, 8, -39, -39, 6, -40,
665  -40, -40, -40, -40, -40, -40, -40, -40, -40, 43,
666  44, -41, 32, 0, 2, 3, 4, 8, -40, -40,
667  6, -41, -41, -41, -41, -41, -41, -41, -41, -41,
668  -41, -41, 44, -42, 32, 0, 2, 3, 4, 8,
669  -41, -41, 6, -42, -42, -42, -42, -42, -42, -42,
670  -42, -42, -42, -42, -42, 0, 32, 0, 2, 3,
671  4, 8, -42, -42, 6, 33, 34, 35, 36, 37,
672  38, 39, 40, 41, 42, 43, 44, 0, 32, 0,
673  2, 3, 4, 8, -17, -17, 6, 33, 34, 35,
674  36, 37, 38, 39, 40, 41, 42, 43, 44, -6,
675  32, 0, 2, 3, 4, 8, -18, -18, 6, 33,
676  34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
677  44, -2, 32, 0, 2, 3, 4, 8, -6, 0,
678  6, 33, 34, 35, 36, 37, 38, 39, 40, 41,
679  42, 43, 44, 51, 0, 2, 3, 4, 0, 8,
680  0, 6, 33, 34, 35, 36, 37, 38, 39, 40,
681  41, 42, 43, 44, 1, 0, 2, 3, 4, 5,
682  8, 52, 6, 1, 7, 2, 3, 4, 0, 0,
683  0, 6, 59, 7, 2, 3, 4, 0, 0, 0,
684  6, 8, 7, 61, 0, 2, 3, 4, 0, 0,
685  8, 6, 62, 7, 2, 3, 4, 0, 0, 8,
686  6, 64, 7, 2, 3, 4, 0, 0, 0, 6,
687  8, 7, 66, 0, 2, 3, 4, 0, 0, 8,
688  6, 0, 7, 0, 0, 0, 0, 0, 8, 0,
689  0, 0, 0, 0, 0, 0, 0, 0, 0, 8
690 };
691 
692 static const yytype_int8 yycheck[] =
693 {
694  0, 7, 3, 8, 29, 30, 5, 7, 8, 28,
695  3, 4, 5, 6, 0, 0, 9, 28, 3, 4,
696  5, 28, 22, 10, 30, 30, 10, 26, 27, 28,
697  29, 5, 30, 33, 34, 35, 36, 37, 38, 39,
698  40, 41, 42, 43, 44, 30, 29, 46, 47, 3,
699  4, 5, 26, 27, 28, 29, 29, 0, 57, 58,
700  1, 58, 3, 4, 5, 3, 4, 5, 9, 46,
701  11, 9, 46, 47, -1, -1, -1, -1, 78, -1,
702  79, 80, -1, 57, 58, -1, 86, 28, 29, -1,
703  -1, -1, 91, 22, 23, 24, 25, 26, 27, -1,
704  -1, -1, -1, -1, -1, 79, 80, -1, -1, 0,
705  1, -1, 3, 4, 5, -1, -1, 91, 9, 10,
706  11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
707  21, 0, 1, -1, 3, 4, 5, 28, 29, 30,
708  9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
709  19, 20, 21, 0, 1, -1, 3, 4, 5, 28,
710  29, 30, 9, 10, 11, 12, 13, 14, 15, 16,
711  17, 18, 19, 20, 21, 0, 1, -1, 3, 4,
712  5, 28, 29, 30, 9, 10, 11, 12, 13, 14,
713  15, 16, 17, 18, 19, 20, 21, 0, 1, -1,
714  3, 4, 5, 28, 29, 30, 9, 10, 11, 12,
715  13, 14, 15, 16, 17, 18, 19, 20, 21, 0,
716  1, -1, 3, 4, 5, 28, 29, 30, 9, 10,
717  11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
718  21, 0, 1, -1, 3, 4, 5, 28, 29, 30,
719  9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
720  19, 20, 21, 0, 1, -1, 3, 4, 5, 28,
721  29, 30, 9, 10, 11, 12, 13, 14, 15, 16,
722  17, 18, 19, 20, 21, 0, 1, -1, 3, 4,
723  5, 28, 29, 30, 9, 10, 11, 12, 13, 14,
724  15, 16, 17, 18, 19, 20, 21, 0, 1, -1,
725  3, 4, 5, 28, 29, 30, 9, 10, 11, 12,
726  13, 14, 15, 16, 17, 18, 19, 20, 21, 0,
727  1, -1, 3, 4, 5, 28, 29, 30, 9, 10,
728  11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
729  21, 0, 1, -1, 3, 4, 5, 28, 29, 30,
730  9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
731  19, 20, 21, 0, 1, -1, 3, 4, 5, 28,
732  29, 30, 9, 10, 11, 12, 13, 14, 15, 16,
733  17, 18, 19, 20, 21, -1, 1, -1, 3, 4,
734  5, 28, 29, 30, 9, 10, 11, 12, 13, 14,
735  15, 16, 17, 18, 19, 20, 21, -1, 1, -1,
736  3, 4, 5, 28, 29, 30, 9, 10, 11, 12,
737  13, 14, 15, 16, 17, 18, 19, 20, 21, 0,
738  1, -1, 3, 4, 5, 28, 29, 30, 9, 10,
739  11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
740  21, 0, 1, -1, 3, 4, 5, 28, 29, -1,
741  9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
742  19, 20, 21, 1, -1, 3, 4, 5, -1, 28,
743  -1, 9, 10, 11, 12, 13, 14, 15, 16, 17,
744  18, 19, 20, 21, 1, -1, 3, 4, 5, 6,
745  28, 29, 9, 1, 11, 3, 4, 5, -1, -1,
746  -1, 9, 1, 11, 3, 4, 5, -1, -1, -1,
747  9, 28, 11, 1, -1, 3, 4, 5, -1, -1,
748  28, 9, 1, 11, 3, 4, 5, -1, -1, 28,
749  9, 1, 11, 3, 4, 5, -1, -1, -1, 9,
750  28, 11, 1, -1, 3, 4, 5, -1, -1, 28,
751  9, -1, 11, -1, -1, -1, -1, -1, 28, -1,
752  -1, -1, -1, -1, -1, -1, -1, -1, -1, 28
753 };
754 
755 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
756  symbol of state STATE-NUM. */
757 static const yytype_uint8 yystos[] =
758 {
759  0, 1, 3, 4, 5, 6, 9, 11, 28, 32,
760  33, 35, 37, 41, 3, 4, 5, 3, 4, 35,
761  36, 37, 28, 41, 41, 0, 22, 23, 24, 25,
762  26, 27, 1, 10, 11, 12, 13, 14, 15, 16,
763  17, 18, 19, 20, 21, 41, 7, 30, 29, 39,
764  41, 1, 29, 37, 37, 37, 37, 28, 28, 1,
765  41, 1, 1, 41, 1, 41, 1, 41, 41, 41,
766  41, 41, 41, 41, 41, 36, 37, 29, 30, 10,
767  10, 33, 37, 38, 40, 40, 8, 34, 41, 37,
768  37, 30, 29, 29, 41, 37
769 };
770 
771 #define yyerrok (yyerrstatus = 0)
772 #define yyclearin (yychar = YYEMPTY)
773 #define YYEMPTY (-2)
774 #define YYEOF 0
775 
776 #define YYACCEPT goto yyacceptlab
777 #define YYABORT goto yyabortlab
778 #define YYERROR goto yyerrorlab
779 
780 
781 /* Like YYERROR except do call yyerror. This remains here temporarily
782  to ease the transition to the new meaning of YYERROR, for GCC.
783  Once GCC version 2 has supplanted version 1, this can go. */
784 
785 #define YYFAIL goto yyerrlab
786 
787 #define YYRECOVERING() (!!yyerrstatus)
788 
789 #define YYBACKUP(Token, Value) \
790 do \
791  if (yychar == YYEMPTY && yylen == 1) \
792  { \
793  yychar = (Token); \
794  yylval = (Value); \
795  yytoken = YYTRANSLATE (yychar); \
796  YYPOPSTACK (1); \
797  goto yybackup; \
798  } \
799  else \
800  { \
801  yyerror (YY_("syntax error: cannot back up")); \
802  YYERROR; \
803  } \
804 while (YYID (0))
805 
806 
807 #define YYTERROR 1
808 #define YYERRCODE 256
809 
810 
811 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
812  If N is 0, then set CURRENT to the empty location which ends
813  the previous symbol: RHS[0] (always defined). */
814 
815 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
816 #ifndef YYLLOC_DEFAULT
817 # define YYLLOC_DEFAULT(Current, Rhs, N) \
818  do \
819  if (YYID (N)) \
820  { \
821  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
822  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
823  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
824  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
825  } \
826  else \
827  { \
828  (Current).first_line = (Current).last_line = \
829  YYRHSLOC (Rhs, 0).last_line; \
830  (Current).first_column = (Current).last_column = \
831  YYRHSLOC (Rhs, 0).last_column; \
832  } \
833  while (YYID (0))
834 #endif
835 
836 
837 /* YY_LOCATION_PRINT -- Print the location on the stream.
838  This macro was not mandated originally: define only if we know
839  we won't break user code: when these are the locations we know. */
840 
841 #ifndef YY_LOCATION_PRINT
842 # if YYLTYPE_IS_TRIVIAL
843 # define YY_LOCATION_PRINT(File, Loc) \
844  fprintf (File, "%d.%d-%d.%d", \
845  (Loc).first_line, (Loc).first_column, \
846  (Loc).last_line, (Loc).last_column)
847 # else
848 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
849 # endif
850 #endif
851 
852 
853 /* YYLEX -- calling `yylex' with the right arguments. */
854 
855 #ifdef YYLEX_PARAM
856 # define YYLEX yylex (&yylval, YYLEX_PARAM)
857 #else
858 # define YYLEX yylex (&yylval)
859 #endif
860 
861 /* Enable debugging if requested. */
862 #if YYDEBUG
863 
864 # ifndef YYFPRINTF
865 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
866 # define YYFPRINTF fprintf
867 # endif
868 
869 # define YYDPRINTF(Args) \
870 do { \
871  if (yydebug) \
872  YYFPRINTF Args; \
873 } while (YYID (0))
874 
875 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
876 do { \
877  if (yydebug) \
878  { \
879  YYFPRINTF (stderr, "%s ", Title); \
880  yy_symbol_print (stderr, \
881  Type, Value); \
882  YYFPRINTF (stderr, "\n"); \
883  } \
884 } while (YYID (0))
885 
886 
887 /*--------------------------------.
888 | Print this symbol on YYOUTPUT. |
889 `--------------------------------*/
890 
891 /*ARGSUSED*/
892 #if (defined __STDC__ || defined __C99__FUNC__ \
893  || defined __cplusplus || defined _MSC_VER)
894 static void
895 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
896 #else
897 static void
898 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
899  FILE *yyoutput;
900  int yytype;
901  YYSTYPE const * const yyvaluep;
902 #endif
903 {
904  if (!yyvaluep)
905  return;
906 # ifdef YYPRINT
907  if (yytype < YYNTOKENS)
908  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
909 # else
910  YYUSE (yyoutput);
911 # endif
912  switch (yytype)
913  {
914  default:
915  break;
916  }
917 }
918 
919 
920 /*--------------------------------.
921 | Print this symbol on YYOUTPUT. |
922 `--------------------------------*/
923 
924 #if (defined __STDC__ || defined __C99__FUNC__ \
925  || defined __cplusplus || defined _MSC_VER)
926 static void
927 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
928 #else
929 static void
930 yy_symbol_print (yyoutput, yytype, yyvaluep)
931  FILE *yyoutput;
932  int yytype;
933  YYSTYPE const * const yyvaluep;
934 #endif
935 {
936  if (yytype < YYNTOKENS)
937  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
938  else
939  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
940 
941  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
942  YYFPRINTF (yyoutput, ")");
943 }
944 
945 /*------------------------------------------------------------------.
946 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
947 | TOP (included). |
948 `------------------------------------------------------------------*/
949 
950 #if (defined __STDC__ || defined __C99__FUNC__ \
951  || defined __cplusplus || defined _MSC_VER)
952 static void
953 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
954 #else
955 static void
956 yy_stack_print (yybottom, yytop)
957  yytype_int16 *yybottom;
958  yytype_int16 *yytop;
959 #endif
960 {
961  YYFPRINTF (stderr, "Stack now");
962  for (; yybottom <= yytop; yybottom++)
963  {
964  int yybot = *yybottom;
965  YYFPRINTF (stderr, " %d", yybot);
966  }
967  YYFPRINTF (stderr, "\n");
968 }
969 
970 # define YY_STACK_PRINT(Bottom, Top) \
971 do { \
972  if (yydebug) \
973  yy_stack_print ((Bottom), (Top)); \
974 } while (YYID (0))
975 
976 
977 /*------------------------------------------------.
978 | Report that the YYRULE is going to be reduced. |
979 `------------------------------------------------*/
980 
981 #if (defined __STDC__ || defined __C99__FUNC__ \
982  || defined __cplusplus || defined _MSC_VER)
983 static void
984 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
985 #else
986 static void
987 yy_reduce_print (yyvsp, yyrule)
988  YYSTYPE *yyvsp;
989  int yyrule;
990 #endif
991 {
992  int yynrhs = yyr2[yyrule];
993  int yyi;
994  unsigned long int yylno = yyrline[yyrule];
995  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
996  yyrule - 1, yylno);
997  /* The symbols being reduced. */
998  for (yyi = 0; yyi < yynrhs; yyi++)
999  {
1000  YYFPRINTF (stderr, " $%d = ", yyi + 1);
1001  yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1002  &(yyvsp[(yyi + 1) - (yynrhs)])
1003  );
1004  YYFPRINTF (stderr, "\n");
1005  }
1006 }
1007 
1008 # define YY_REDUCE_PRINT(Rule) \
1009 do { \
1010  if (yydebug) \
1011  yy_reduce_print (yyvsp, Rule); \
1012 } while (YYID (0))
1013 
1014 /* Nonzero means print parse trace. It is left uninitialized so that
1015  multiple parsers can coexist. */
1017 #else /* !YYDEBUG */
1018 # define YYDPRINTF(Args)
1019 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1020 # define YY_STACK_PRINT(Bottom, Top)
1021 # define YY_REDUCE_PRINT(Rule)
1022 #endif /* !YYDEBUG */
1023 
1024 
1025 /* YYINITDEPTH -- initial size of the parser's stacks. */
1026 #ifndef YYINITDEPTH
1027 # define YYINITDEPTH 200
1028 #endif
1029 
1030 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1031  if the built-in stack extension method is used).
1032 
1033  Do not make this value too large; the results are undefined if
1034  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1035  evaluated with infinite-precision integer arithmetic. */
1036 
1037 #ifndef YYMAXDEPTH
1038 # define YYMAXDEPTH 10000
1039 #endif
1040 
1041 ␌
1042 
1043 #if YYERROR_VERBOSE
1044 
1045 # ifndef yystrlen
1046 # if defined __GLIBC__ && defined _STRING_H
1047 # define yystrlen strlen
1048 # else
1049 /* Return the length of YYSTR. */
1050 #if (defined __STDC__ || defined __C99__FUNC__ \
1051  || defined __cplusplus || defined _MSC_VER)
1052 static YYSIZE_T
1053 yystrlen (const char *yystr)
1054 #else
1055 static YYSIZE_T
1056 yystrlen (yystr)
1057  const char *yystr;
1058 #endif
1059 {
1060  YYSIZE_T yylen;
1061  for (yylen = 0; yystr[yylen]; yylen++)
1062  continue;
1063  return yylen;
1064 }
1065 # endif
1066 # endif
1067 
1068 # ifndef yystpcpy
1069 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1070 # define yystpcpy stpcpy
1071 # else
1072 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1073  YYDEST. */
1074 #if (defined __STDC__ || defined __C99__FUNC__ \
1075  || defined __cplusplus || defined _MSC_VER)
1076 static char *
1077 yystpcpy (char *yydest, const char *yysrc)
1078 #else
1079 static char *
1080 yystpcpy (yydest, yysrc)
1081  char *yydest;
1082  const char *yysrc;
1083 #endif
1084 {
1085  char *yyd = yydest;
1086  const char *yys = yysrc;
1087 
1088  while ((*yyd++ = *yys++) != '\0')
1089  continue;
1090 
1091  return yyd - 1;
1092 }
1093 # endif
1094 # endif
1095 
1096 # ifndef yytnamerr
1097 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1098  quotes and backslashes, so that it's suitable for yyerror. The
1099  heuristic is that double-quoting is unnecessary unless the string
1100  contains an apostrophe, a comma, or backslash (other than
1101  backslash-backslash). YYSTR is taken from yytname. If YYRES is
1102  null, do not copy; instead, return the length of what the result
1103  would have been. */
1104 static YYSIZE_T
1105 yytnamerr (char *yyres, const char *yystr)
1106 {
1107  if (*yystr == '"')
1108  {
1109  YYSIZE_T yyn = 0;
1110  char const *yyp = yystr;
1111 
1112  for (;;)
1113  switch (*++yyp)
1114  {
1115  case '\'':
1116  case ',':
1117  goto do_not_strip_quotes;
1118 
1119  case '\\':
1120  if (*++yyp != '\\')
1121  goto do_not_strip_quotes;
1122  /* Fall through. */
1123  default:
1124  if (yyres)
1125  yyres[yyn] = *yyp;
1126  yyn++;
1127  break;
1128 
1129  case '"':
1130  if (yyres)
1131  yyres[yyn] = '\0';
1132  return yyn;
1133  }
1134  do_not_strip_quotes: ;
1135  }
1136 
1137  if (! yyres)
1138  return yystrlen (yystr);
1139 
1140  return yystpcpy (yyres, yystr) - yyres;
1141 }
1142 # endif
1143 
1144 /* Copy into YYRESULT an error message about the unexpected token
1145  YYCHAR while in state YYSTATE. Return the number of bytes copied,
1146  including the terminating null byte. If YYRESULT is null, do not
1147  copy anything; just return the number of bytes that would be
1148  copied. As a special case, return 0 if an ordinary "syntax error"
1149  message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1150  size calculation. */
1151 static YYSIZE_T
1152 yysyntax_error (char *yyresult, int yystate, int yychar)
1153 {
1154  int yyn = yypact[yystate];
1155 
1156  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1157  return 0;
1158  else
1159  {
1160  int yytype = YYTRANSLATE (yychar);
1161  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1162  YYSIZE_T yysize = yysize0;
1163  YYSIZE_T yysize1;
1164  int yysize_overflow = 0;
1165  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1166  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1167  int yyx;
1168 
1169 # if 0
1170  /* This is so xgettext sees the translatable formats that are
1171  constructed on the fly. */
1172  YY_("syntax error, unexpected %s");
1173  YY_("syntax error, unexpected %s, expecting %s");
1174  YY_("syntax error, unexpected %s, expecting %s or %s");
1175  YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1176  YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1177 # endif
1178  char *yyfmt;
1179  char const *yyf;
1180  static char const yyunexpected[] = "syntax error, unexpected %s";
1181  static char const yyexpecting[] = ", expecting %s";
1182  static char const yyor[] = " or %s";
1183  char yyformat[sizeof yyunexpected
1184  + sizeof yyexpecting - 1
1185  + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1186  * (sizeof yyor - 1))];
1187  char const *yyprefix = yyexpecting;
1188 
1189  /* Start YYX at -YYN if negative to avoid negative indexes in
1190  YYCHECK. */
1191  int yyxbegin = yyn < 0 ? -yyn : 0;
1192 
1193  /* Stay within bounds of both yycheck and yytname. */
1194  int yychecklim = YYLAST - yyn + 1;
1195  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1196  int yycount = 1;
1197 
1198  yyarg[0] = yytname[yytype];
1199  yyfmt = yystpcpy (yyformat, yyunexpected);
1200 
1201  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1202  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1203  {
1204  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1205  {
1206  yycount = 1;
1207  yysize = yysize0;
1208  yyformat[sizeof yyunexpected - 1] = '\0';
1209  break;
1210  }
1211  yyarg[yycount++] = yytname[yyx];
1212  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1213  yysize_overflow |= (yysize1 < yysize);
1214  yysize = yysize1;
1215  yyfmt = yystpcpy (yyfmt, yyprefix);
1216  yyprefix = yyor;
1217  }
1218 
1219  yyf = YY_(yyformat);
1220  yysize1 = yysize + yystrlen (yyf);
1221  yysize_overflow |= (yysize1 < yysize);
1222  yysize = yysize1;
1223 
1224  if (yysize_overflow)
1225  return YYSIZE_MAXIMUM;
1226 
1227  if (yyresult)
1228  {
1229  /* Avoid sprintf, as that infringes on the user's name space.
1230  Don't have undefined behavior even if the translation
1231  produced a string with the wrong number of "%s"s. */
1232  char *yyp = yyresult;
1233  int yyi = 0;
1234  while ((*yyp = *yyf) != '\0')
1235  {
1236  if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1237  {
1238  yyp += yytnamerr (yyp, yyarg[yyi++]);
1239  yyf += 2;
1240  }
1241  else
1242  {
1243  yyp++;
1244  yyf++;
1245  }
1246  }
1247  }
1248  return yysize;
1249  }
1250 }
1251 #endif /* YYERROR_VERBOSE */
1252 ␌
1253 
1254 /*-----------------------------------------------.
1255 | Release the memory associated to this symbol. |
1256 `-----------------------------------------------*/
1257 
1258 /*ARGSUSED*/
1259 #if (defined __STDC__ || defined __C99__FUNC__ \
1260  || defined __cplusplus || defined _MSC_VER)
1261 static void
1262 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1263 #else
1264 static void
1265 yydestruct (yymsg, yytype, yyvaluep)
1266  const char *yymsg;
1267  int yytype;
1268  YYSTYPE *yyvaluep;
1269 #endif
1270 {
1271  YYUSE (yyvaluep);
1272 
1273  if (!yymsg)
1274  yymsg = "Deleting";
1275  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1276 
1277  switch (yytype)
1278  {
1279 
1280  default:
1281  break;
1282  }
1283 }
1284 
1285 /* Prevent warnings from -Wmissing-prototypes. */
1286 #ifdef YYPARSE_PARAM
1287 #if defined __STDC__ || defined __cplusplus
1288 int yyparse (void *YYPARSE_PARAM);
1289 #else
1290 int yyparse ();
1291 #endif
1292 #else /* ! YYPARSE_PARAM */
1293 #if defined __STDC__ || defined __cplusplus
1294 int yyparse (void);
1295 #else
1296 int yyparse ();
1297 #endif
1298 #endif /* ! YYPARSE_PARAM */
1299 
1300 
1301 
1302 
1303 
1304 /*-------------------------.
1305 | yyparse or yypush_parse. |
1306 `-------------------------*/
1307 
1308 #ifdef YYPARSE_PARAM
1309 #if (defined __STDC__ || defined __C99__FUNC__ \
1310  || defined __cplusplus || defined _MSC_VER)
1311 int
1312 yyparse (void *YYPARSE_PARAM)
1313 #else
1314 int
1316  void *YYPARSE_PARAM;
1317 #endif
1318 #else /* ! YYPARSE_PARAM */
1319 #if (defined __STDC__ || defined __C99__FUNC__ \
1320  || defined __cplusplus || defined _MSC_VER)
1321 int
1322 yyparse (void)
1323 #else
1324 int
1325 yyparse ()
1326 
1327 #endif
1328 #endif
1329 {
1330 /* The lookahead symbol. */
1331 int yychar;
1332 
1333 /* The semantic value of the lookahead symbol. */
1334 YYSTYPE yylval;
1335 
1336  /* Number of syntax errors so far. */
1337  int yynerrs;
1338 
1339  int yystate;
1340  /* Number of tokens to shift before error messages enabled. */
1341  int yyerrstatus;
1342 
1343  /* The stacks and their tools:
1344  `yyss': related to states.
1345  `yyvs': related to semantic values.
1346 
1347  Refer to the stacks thru separate pointers, to allow yyoverflow
1348  to reallocate them elsewhere. */
1349 
1350  /* The state stack. */
1351  yytype_int16 yyssa[YYINITDEPTH];
1352  yytype_int16 *yyss;
1353  yytype_int16 *yyssp;
1354 
1355  /* The semantic value stack. */
1356  YYSTYPE yyvsa[YYINITDEPTH];
1357  YYSTYPE *yyvs;
1358  YYSTYPE *yyvsp;
1359 
1360  YYSIZE_T yystacksize;
1361 
1362  int yyn;
1363  int yyresult;
1364  /* Lookahead token as an internal (translated) token number. */
1365  int yytoken;
1366  /* The variables used to return semantic value and location from the
1367  action routines. */
1368  YYSTYPE yyval;
1369 
1370 #if YYERROR_VERBOSE
1371  /* Buffer for error messages, and its allocated size. */
1372  char yymsgbuf[128];
1373  char *yymsg = yymsgbuf;
1374  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1375 #endif
1376 
1377 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1378 
1379  /* The number of symbols on the RHS of the reduced rule.
1380  Keep to zero when no symbol should be popped. */
1381  int yylen = 0;
1382 
1383  yytoken = 0;
1384  yyss = yyssa;
1385  yyvs = yyvsa;
1386  yystacksize = YYINITDEPTH;
1387 
1388  YYDPRINTF ((stderr, "Starting parse\n"));
1389 
1390  yystate = 0;
1391  yyerrstatus = 0;
1392  yynerrs = 0;
1393  yychar = YYEMPTY; /* Cause a token to be read. */
1394 
1395  /* Initialize stack pointers.
1396  Waste one element of value and location stack
1397  so that they stay on the same level as the state stack.
1398  The wasted elements are never initialized. */
1399  yyssp = yyss;
1400  yyvsp = yyvs;
1401 
1402  goto yysetstate;
1403 
1404 /*------------------------------------------------------------.
1405 | yynewstate -- Push a new state, which is found in yystate. |
1406 `------------------------------------------------------------*/
1407  yynewstate:
1408  /* In all cases, when you get here, the value and location stacks
1409  have just been pushed. So pushing a state here evens the stacks. */
1410  yyssp++;
1411 
1412  yysetstate:
1413  *yyssp = yystate;
1414 
1415  if (yyss + yystacksize - 1 <= yyssp)
1416  {
1417  /* Get the current used size of the three stacks, in elements. */
1418  YYSIZE_T yysize = yyssp - yyss + 1;
1419 
1420 #ifdef yyoverflow
1421  {
1422  /* Give user a chance to reallocate the stack. Use copies of
1423  these so that the &'s don't force the real ones into
1424  memory. */
1425  YYSTYPE *yyvs1 = yyvs;
1426  yytype_int16 *yyss1 = yyss;
1427 
1428  /* Each stack pointer address is followed by the size of the
1429  data in use in that stack, in bytes. This used to be a
1430  conditional around just the two extra args, but that might
1431  be undefined if yyoverflow is a macro. */
1432  yyoverflow (YY_("memory exhausted"),
1433  &yyss1, yysize * sizeof (*yyssp),
1434  &yyvs1, yysize * sizeof (*yyvsp),
1435  &yystacksize);
1436 
1437  yyss = yyss1;
1438  yyvs = yyvs1;
1439  }
1440 #else /* no yyoverflow */
1441 # ifndef YYSTACK_RELOCATE
1442  goto yyexhaustedlab;
1443 # else
1444  /* Extend the stack our own way. */
1445  if (YYMAXDEPTH <= yystacksize)
1446  goto yyexhaustedlab;
1447  yystacksize *= 2;
1448  if (YYMAXDEPTH < yystacksize)
1449  yystacksize = YYMAXDEPTH;
1450 
1451  {
1452  yytype_int16 *yyss1 = yyss;
1453  union yyalloc *yyptr =
1454  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1455  if (! yyptr)
1456  goto yyexhaustedlab;
1459 # undef YYSTACK_RELOCATE
1460  if (yyss1 != yyssa)
1461  YYSTACK_FREE (yyss1);
1462  }
1463 # endif
1464 #endif /* no yyoverflow */
1465 
1466  yyssp = yyss + yysize - 1;
1467  yyvsp = yyvs + yysize - 1;
1468 
1469  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1470  (unsigned long int) yystacksize));
1471 
1472  if (yyss + yystacksize - 1 <= yyssp)
1473  YYABORT;
1474  }
1475 
1476  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1477 
1478  if (yystate == YYFINAL)
1479  YYACCEPT;
1480 
1481  goto yybackup;
1482 
1483 /*-----------.
1484 | yybackup. |
1485 `-----------*/
1486 yybackup:
1487 
1488  /* Do appropriate processing given the current state. Read a
1489  lookahead token if we need one and don't already have one. */
1490 
1491  /* First try to decide what to do without reference to lookahead token. */
1492  yyn = yypact[yystate];
1493  if (yyn == YYPACT_NINF)
1494  goto yydefault;
1495 
1496  /* Not known => get a lookahead token if don't already have one. */
1497 
1498  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1499  if (yychar == YYEMPTY)
1500  {
1501  YYDPRINTF ((stderr, "Reading a token: "));
1502  yychar = YYLEX;
1503  }
1504 
1505  if (yychar <= YYEOF)
1506  {
1507  yychar = yytoken = YYEOF;
1508  YYDPRINTF ((stderr, "Now at end of input.\n"));
1509  }
1510  else
1511  {
1512  yytoken = YYTRANSLATE (yychar);
1513  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1514  }
1515 
1516  /* If the proper action on seeing token YYTOKEN is to reduce or to
1517  detect an error, take that action. */
1518  yyn += yytoken;
1519  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1520  goto yydefault;
1521  yyn = yytable[yyn];
1522  if (yyn <= 0)
1523  {
1524  if (yyn == 0 || yyn == YYTABLE_NINF)
1525  goto yyerrlab;
1526  yyn = -yyn;
1527  goto yyreduce;
1528  }
1529 
1530  /* Count tokens shifted since error; after three, turn off error
1531  status. */
1532  if (yyerrstatus)
1533  yyerrstatus--;
1534 
1535  /* Shift the lookahead token. */
1536  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1537 
1538  /* Discard the shifted token. */
1539  yychar = YYEMPTY;
1540 
1541  yystate = yyn;
1542  *++yyvsp = yylval;
1543 
1544  goto yynewstate;
1545 
1546 
1547 /*-----------------------------------------------------------.
1548 | yydefault -- do the default action for the current state. |
1549 `-----------------------------------------------------------*/
1550 yydefault:
1551  yyn = yydefact[yystate];
1552  if (yyn == 0)
1553  goto yyerrlab;
1554  goto yyreduce;
1555 
1556 
1557 /*-----------------------------.
1558 | yyreduce -- Do a reduction. |
1559 `-----------------------------*/
1560 yyreduce:
1561  /* yyn is the number of a rule to reduce with. */
1562  yylen = yyr2[yyn];
1563 
1564  /* If YYLEN is nonzero, implement the default value of the action:
1565  `$$ = $1'.
1566 
1567  Otherwise, the following line sets YYVAL to garbage.
1568  This behavior is undocumented and Bison
1569  users should not rely upon it. Assigning to YYVAL
1570  unconditionally makes the parser a bit smaller, and it avoids a
1571  GCC warning that YYVAL may be used uninitialized. */
1572  yyval = yyvsp[1-yylen];
1573 
1574 
1575  YY_REDUCE_PRINT (yyn);
1576  switch (yyn)
1577  {
1578  case 4:
1579 
1580 /* Line 1455 of yacc.c */
1581 #line 137 "query_parser_bison.y"
1582  {
1583  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
1584 
1585  /* create a pseudo node to isolate select list in a dedicated subtree */
1586  //CQueryParseTree::TNode* qnode = 0;
1587  //qnode = env->QTree().CreateNode(CQueryParseNode::eList, 0, 0, "LIST");
1588  //qnode->MoveSubnodes($2);
1589  CQueryParseTree::TNode* qnode = env->GetContext();
1590  if (qnode) {
1591  qnode->InsertNode(qnode->SubNodeBegin(), (yyvsp[(2) - (5)]));
1592  }
1593 
1594  //$1->InsertNode($1->SubNodeBegin(),qnode);
1595 
1596  (yyvsp[(1) - (5)])->AddNode((yyvsp[(3) - (5)]));
1597  (yyvsp[(3) - (5)])->MoveSubnodes((yyvsp[(4) - (5)]));
1598  (yyvsp[(3) - (5)])->InsertNode((yyvsp[(3) - (5)])->SubNodeBegin(), (yyvsp[(4) - (5)]));
1599  if ((yyvsp[(5) - (5)])) {
1600  (yyvsp[(1) - (5)])->AddNode((yyvsp[(5) - (5)]));
1601  }
1602 
1603  env->ForgetPoolNode((yyvsp[(1) - (5)]));
1604  env->ForgetPoolNode((yyvsp[(2) - (5)]));
1605  env->ForgetPoolNode((yyvsp[(3) - (5)]));
1606  env->ForgetPoolNode((yyvsp[(4) - (5)]));
1607  env->ForgetPoolNode((yyvsp[(5) - (5)]));
1608 
1609  env->SetSELECT_Context(0);
1610  env->SetContext(0);
1611  env->SetFROM_Context(0);
1612 
1613  (yyval) = (yyvsp[(1) - (5)]);
1614  env->AttachQueryTree((yyval));
1615 
1616  ;}
1617  break;
1618 
1619  case 5:
1620 
1621 /* Line 1455 of yacc.c */
1622 #line 176 "query_parser_bison.y"
1623  {
1624  (yyval)=0;
1625  ;}
1626  break;
1627 
1628  case 6:
1629 
1630 /* Line 1455 of yacc.c */
1631 #line 181 "query_parser_bison.y"
1632  {
1633  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
1634  (yyvsp[(1) - (2)])->AddNode((yyvsp[(2) - (2)]));
1635  env->ForgetPoolNode((yyvsp[(2) - (2)]));
1636  (yyval) = (yyvsp[(1) - (2)]);
1637  ;}
1638  break;
1639 
1640  case 7:
1641 
1642 /* Line 1455 of yacc.c */
1643 #line 191 "query_parser_bison.y"
1644  {
1645  (yyval) = (yyvsp[(1) - (4)]);
1646  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
1647  env->AttachQueryTree((yyval));
1648  (yyval)->InsertNode((yyval)->SubNodeBegin(), (yyvsp[(3) - (4)]));
1649  env->SetContext(0);
1650  env->ForgetPoolNodes((yyvsp[(1) - (4)]), (yyvsp[(3) - (4)]));
1651  ;}
1652  break;
1653 
1654  case 8:
1655 
1656 /* Line 1455 of yacc.c */
1657 #line 200 "query_parser_bison.y"
1658  {
1659  (yyval) = (yyvsp[(1) - (3)]);
1660  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
1661  env->AttachQueryTree((yyval));
1662  env->SetContext(0);
1663  env->ForgetPoolNode((yyvsp[(1) - (3)]));
1664  ;}
1665  break;
1666 
1667  case 9:
1668 
1669 /* Line 1455 of yacc.c */
1670 #line 211 "query_parser_bison.y"
1671  {
1672  (yyval) = (yyvsp[(1) - (1)]);
1673  ;}
1674  break;
1675 
1676  case 10:
1677 
1678 /* Line 1455 of yacc.c */
1679 #line 215 "query_parser_bison.y"
1680  {
1681  (yyval) = (yyvsp[(1) - (3)]);
1682  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
1683  AddFunc_Arg(parm, (yyvsp[(3) - (3)]));
1684  //$$->AddNode($3);
1685  env->ForgetPoolNode((yyvsp[(3) - (3)]));
1686  ;}
1687  break;
1688 
1689  case 11:
1690 
1691 /* Line 1455 of yacc.c */
1692 #line 227 "query_parser_bison.y"
1693  {
1694  (yyval) = (yyvsp[(1) - (1)]);
1695  ;}
1696  break;
1697 
1698  case 12:
1699 
1700 /* Line 1455 of yacc.c */
1701 #line 232 "query_parser_bison.y"
1702  {
1703  (yyval) = (yyvsp[(1) - (1)]);
1704  ;}
1705  break;
1706 
1707  case 13:
1708 
1709 /* Line 1455 of yacc.c */
1710 #line 237 "query_parser_bison.y"
1711  {
1712  (yyval) = (yyvsp[(1) - (1)]);
1713  ;}
1714  break;
1715 
1716  case 14:
1717 
1718 /* Line 1455 of yacc.c */
1719 #line 241 "query_parser_bison.y"
1720  {
1721  (yyval) = (yyvsp[(1) - (1)]);
1722  ;}
1723  break;
1724 
1725  case 15:
1726 
1727 /* Line 1455 of yacc.c */
1728 #line 248 "query_parser_bison.y"
1729  {
1730  (yyval) = (yyvsp[(1) - (1)]);
1731  ;}
1732  break;
1733 
1734  case 16:
1735 
1736 /* Line 1455 of yacc.c */
1737 #line 252 "query_parser_bison.y"
1738  {
1739  (yyval) = (yyvsp[(1) - (3)]);
1740  AddIn_Arg(parm, (yyvsp[(3) - (3)]));
1741  ;}
1742  break;
1743 
1744  case 17:
1745 
1746 /* Line 1455 of yacc.c */
1747 #line 260 "query_parser_bison.y"
1748  {
1749  (yyval) = (yyvsp[(1) - (1)]);
1750  ;}
1751  break;
1752 
1753  case 18:
1754 
1755 /* Line 1455 of yacc.c */
1756 #line 264 "query_parser_bison.y"
1757  {
1758  (yyval) = (yyvsp[(1) - (3)]);
1759  AddFunc_Arg(parm, (yyvsp[(3) - (3)]));
1760  ;}
1761  break;
1762 
1763  case 21:
1764 
1765 /* Line 1455 of yacc.c */
1766 #line 279 "query_parser_bison.y"
1767  {
1768  (yyval) = (yyvsp[(1) - (1)]);
1769  ;}
1770  break;
1771 
1772  case 22:
1773 
1774 /* Line 1455 of yacc.c */
1775 #line 284 "query_parser_bison.y"
1776  {
1777  (yyval) = (yyvsp[(1) - (1)]);
1778  ;}
1779  break;
1780 
1781  case 23:
1782 
1783 /* Line 1455 of yacc.c */
1784 #line 289 "query_parser_bison.y"
1785  {
1786  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
1787  (yyval) = env->QTree().CreateNode(CQueryParseNode::eFieldSearch, (yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
1788  env->AttachQueryTree((yyval));
1789  env->ForgetPoolNodes((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
1790  ;}
1791  break;
1792 
1793  case 24:
1794 
1795 /* Line 1455 of yacc.c */
1796 #line 297 "query_parser_bison.y"
1797  {
1798  yyerrok;
1799  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
1800  (yyval) = env->QTree().CreateNode(CQueryParseNode::eAnd, (yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
1801  (yyval)->GetValue().SetExplicit(false);
1802  env->AttachQueryTree((yyval));
1803  env->ForgetPoolNodes((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
1804  ;}
1805  break;
1806 
1807  case 25:
1808 
1809 /* Line 1455 of yacc.c */
1810 #line 308 "query_parser_bison.y"
1811  {
1812  (yyval) = (yyvsp[(2) - (3)]);
1813  ;}
1814  break;
1815 
1816  case 26:
1817 
1818 /* Line 1455 of yacc.c */
1819 #line 318 "query_parser_bison.y"
1820  {
1821  QTreeAddNode(parm, (yyval) = (yyvsp[(2) - (3)]), (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)]));
1822  ;}
1823  break;
1824 
1825  case 27:
1826 
1827 /* Line 1455 of yacc.c */
1828 #line 323 "query_parser_bison.y"
1829  {
1830  QTreeAddNode(parm, (yyval) = (yyvsp[(2) - (3)]), (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)]));
1831  ;}
1832  break;
1833 
1834  case 28:
1835 
1836 /* Line 1455 of yacc.c */
1837 #line 328 "query_parser_bison.y"
1838  {
1839  QTreeAddNode(parm, (yyval) = (yyvsp[(2) - (3)]), (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)]));
1840  ;}
1841  break;
1842 
1843  case 29:
1844 
1845 /* Line 1455 of yacc.c */
1846 #line 333 "query_parser_bison.y"
1847  {
1848  QTreeAddNode(parm, (yyval) = (yyvsp[(2) - (3)]), (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)]));
1849  ;}
1850  break;
1851 
1852  case 30:
1853 
1854 /* Line 1455 of yacc.c */
1855 #line 338 "query_parser_bison.y"
1856  {
1857  (yyval) = (yyvsp[(2) - (5)]);
1858  (yyval)->AddNode((yyvsp[(1) - (5)]));
1859  (yyval)->AddNode((yyvsp[(3) - (5)]));
1860  (yyval)->AddNode((yyvsp[(5) - (5)]));
1861 
1862  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
1863  env->AttachQueryTree((yyval));
1864  env->ForgetPoolNodes((yyvsp[(1) - (5)]), (yyvsp[(3) - (5)]));
1865  env->ForgetPoolNodes((yyvsp[(1) - (5)]), (yyvsp[(5) - (5)]));
1866  ;}
1867  break;
1868 
1869  case 31:
1870 
1871 /* Line 1455 of yacc.c */
1872 #line 351 "query_parser_bison.y"
1873  {
1874  (yyval) = (yyvsp[(2) - (5)]);
1875  (yyval)->AddNode((yyvsp[(1) - (5)]));
1876  (yyval)->AddNode((yyvsp[(3) - (5)]));
1877  (yyval)->AddNode((yyvsp[(5) - (5)]));
1878 
1879  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
1880  env->AttachQueryTree((yyval));
1881  env->ForgetPoolNodes((yyvsp[(1) - (5)]), (yyvsp[(3) - (5)]));
1882  env->ForgetPoolNodes((yyvsp[(1) - (5)]), (yyvsp[(5) - (5)]));
1883  ;}
1884  break;
1885 
1886  case 32:
1887 
1888 /* Line 1455 of yacc.c */
1889 #line 365 "query_parser_bison.y"
1890  {
1891  QTreeAddNode(parm, (yyval) = (yyvsp[(2) - (3)]), (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)]));
1892  ;}
1893  break;
1894 
1895  case 33:
1896 
1897 /* Line 1455 of yacc.c */
1898 #line 370 "query_parser_bison.y"
1899  {
1900  QTreeAddNode(parm, (yyval) = (yyvsp[(2) - (3)]), (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)]));
1901  ;}
1902  break;
1903 
1904  case 34:
1905 
1906 /* Line 1455 of yacc.c */
1907 #line 375 "query_parser_bison.y"
1908  {
1909  QTreeAddNode(parm, (yyval) = (yyvsp[(2) - (3)]), (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)]));
1910  ;}
1911  break;
1912 
1913  case 35:
1914 
1915 /* Line 1455 of yacc.c */
1916 #line 380 "query_parser_bison.y"
1917  {
1918  (yyval) = (yyvsp[(2) - (5)]);
1919  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
1920  env->AttachQueryTree((yyval));
1921  env->ForgetPoolNodes((yyvsp[(1) - (5)]), (yyvsp[(4) - (5)]));
1922  (yyval)->InsertNode((yyval)->SubNodeBegin(), (yyvsp[(4) - (5)]));
1923  (yyval)->InsertNode((yyval)->SubNodeBegin(), (yyvsp[(1) - (5)]));
1924  env->SetIN_Context(0);
1925  ;}
1926  break;
1927 
1928  case 36:
1929 
1930 /* Line 1455 of yacc.c */
1931 #line 391 "query_parser_bison.y"
1932  {
1933  (yyval) = (yyvsp[(2) - (5)]);
1934  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
1935  env->AttachQueryTree((yyval));
1936  env->ForgetPoolNodes((yyvsp[(1) - (5)]), (yyvsp[(4) - (5)]));
1937  (yyval)->InsertNode((yyval)->SubNodeBegin(), (yyvsp[(4) - (5)]));
1938  (yyval)->InsertNode((yyval)->SubNodeBegin(), (yyvsp[(1) - (5)]));
1939  env->SetIN_Context(0);
1940  ;}
1941  break;
1942 
1943  case 37:
1944 
1945 /* Line 1455 of yacc.c */
1946 #line 402 "query_parser_bison.y"
1947  {
1948  QTreeAddNode(parm, (yyval) = (yyvsp[(2) - (3)]), (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)]));
1949  ;}
1950  break;
1951 
1952  case 38:
1953 
1954 /* Line 1455 of yacc.c */
1955 #line 407 "query_parser_bison.y"
1956  {
1957  QTreeAddNode(parm, (yyval) = (yyvsp[(2) - (3)]), (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)]));
1958  ;}
1959  break;
1960 
1961  case 39:
1962 
1963 /* Line 1455 of yacc.c */
1964 #line 411 "query_parser_bison.y"
1965  {
1966  QTreeAddNode(parm, (yyval) = (yyvsp[(2) - (3)]), (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)]));
1967  ;}
1968  break;
1969 
1970  case 40:
1971 
1972 /* Line 1455 of yacc.c */
1973 #line 415 "query_parser_bison.y"
1974  {
1975  QTreeAddNode(parm, (yyval) = (yyvsp[(2) - (3)]), (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)]));
1976  ;}
1977  break;
1978 
1979  case 41:
1980 
1981 /* Line 1455 of yacc.c */
1982 #line 419 "query_parser_bison.y"
1983  {
1984  QTreeAddNode(parm, (yyval) = (yyvsp[(2) - (3)]), (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)]));
1985  ;}
1986  break;
1987 
1988  case 42:
1989 
1990 /* Line 1455 of yacc.c */
1991 #line 423 "query_parser_bison.y"
1992  {
1993  QTreeAddNode(parm, (yyval) = (yyvsp[(2) - (3)]), (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)]));
1994  ;}
1995  break;
1996 
1997  case 43:
1998 
1999 /* Line 1455 of yacc.c */
2000 #line 434 "query_parser_bison.y"
2001  {
2002  QTreeAddNode(parm, (yyval) = (yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]), 0);
2003  ;}
2004  break;
2005 
2006  case 44:
2007 
2008 /* Line 1455 of yacc.c */
2009 #line 443 "query_parser_bison.y"
2010  {
2011  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
2012  if (env->GetParserTolerance() == CQueryParseTree::eSyntaxCheck) {
2013  NCBI_THROW(CQueryParseException, eParserError,
2014  "Syntax error.");
2015  }
2016  QTreeAddNode(parm, (yyval) = (yyvsp[(2) - (2)]), 0, 0);
2017  ;}
2018  break;
2019 
2020  case 45:
2021 
2022 /* Line 1455 of yacc.c */
2023 #line 452 "query_parser_bison.y"
2024  {
2025  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
2026  if (env->GetParserTolerance() == CQueryParseTree::eSyntaxCheck) {
2027  NCBI_THROW(CQueryParseException, eParserError,
2028  "Syntax error.");
2029  }
2030  QTreeAddNode(parm, (yyval) = (yyvsp[(2) - (2)]), 0, 0);
2031  ;}
2032  break;
2033 
2034  case 46:
2035 
2036 /* Line 1455 of yacc.c */
2037 #line 461 "query_parser_bison.y"
2038  {
2039  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
2040  if (env->GetParserTolerance() == CQueryParseTree::eSyntaxCheck) {
2041  NCBI_THROW(CQueryParseException, eParserError,
2042  "Syntax error.");
2043  }
2044  QTreeAddNode(parm, (yyval) = (yyvsp[(2) - (2)]), 0, 0);
2045  ;}
2046  break;
2047 
2048  case 47:
2049 
2050 /* Line 1455 of yacc.c */
2051 #line 470 "query_parser_bison.y"
2052  {
2053  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
2054  if (env->GetParserTolerance() == CQueryParseTree::eSyntaxCheck) {
2055  NCBI_THROW(CQueryParseException, eParserError,
2056  "Syntax error.");
2057  }
2058  QTreeAddNode(parm, (yyval) = (yyvsp[(1) - (2)]), 0, 0);
2059  ;}
2060  break;
2061 
2062  case 48:
2063 
2064 /* Line 1455 of yacc.c */
2065 #line 482 "query_parser_bison.y"
2066  {
2067  yyerrok;
2068  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
2069  if (env->GetParserTolerance() == CQueryParseTree::eSyntaxCheck) {
2070  NCBI_THROW(CQueryParseException, eParserError,
2071  "Syntax error. Unbalanced parenthesis");
2072  }
2073  QTreeAddNode(parm, (yyval) = (yyvsp[(2) - (3)]), 0, 0);
2074  ;}
2075  break;
2076 
2077  case 49:
2078 
2079 /* Line 1455 of yacc.c */
2080 #line 492 "query_parser_bison.y"
2081  {
2082  yyerrok;
2083  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
2084  if (env->GetParserTolerance() == CQueryParseTree::eSyntaxCheck) {
2085  NCBI_THROW(CQueryParseException, eParserError,
2086  "Syntax error.");
2087  }
2088  QTreeAddNode(parm, (yyval) = (yyvsp[(1) - (3)]), 0, 0);
2089  ;}
2090  break;
2091 
2092  case 50:
2093 
2094 /* Line 1455 of yacc.c */
2095 #line 502 "query_parser_bison.y"
2096  {
2097  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
2098  if (env->GetParserTolerance() == CQueryParseTree::eSyntaxCheck) {
2099  NCBI_THROW(CQueryParseException, eParserError,
2100  "Syntax error.");
2101  }
2102  yyerrok;
2103  QTreeAddNode(parm, (yyval) = (yyvsp[(1) - (3)]), 0, 0);
2104  ;}
2105  break;
2106 
2107  case 51:
2108 
2109 /* Line 1455 of yacc.c */
2110 #line 512 "query_parser_bison.y"
2111  {
2112  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
2113  if (env->GetParserTolerance() == CQueryParseTree::eSyntaxCheck) {
2114  NCBI_THROW(CQueryParseException, eParserError,
2115  "Syntax error.");
2116  }
2117  yyerrok;
2118  QTreeAddNode(parm, (yyval) = (yyvsp[(1) - (3)]), 0, 0);
2119  ;}
2120  break;
2121 
2122  case 52:
2123 
2124 /* Line 1455 of yacc.c */
2125 #line 522 "query_parser_bison.y"
2126  {
2127  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
2128  if (env->GetParserTolerance() == CQueryParseTree::eSyntaxCheck) {
2129  NCBI_THROW(CQueryParseException, eParserError,
2130  "Syntax error.");
2131  }
2132  yyerrok;
2133  QTreeAddNode(parm, (yyval) = (yyvsp[(1) - (3)]), 0, 0);
2134  ;}
2135  break;
2136 
2137  case 53:
2138 
2139 /* Line 1455 of yacc.c */
2140 #line 532 "query_parser_bison.y"
2141  {
2142  CQueryParserEnv* env = reinterpret_cast<CQueryParserEnv*>(parm);
2143  if (env->GetParserTolerance() == CQueryParseTree::eSyntaxCheck) {
2144  NCBI_THROW(CQueryParseException, eParserError,
2145  "Syntax error.");
2146  }
2147  yyerrok;
2148  QTreeAddNode(parm, (yyval) = (yyvsp[(1) - (3)]), 0, 0);
2149  ;}
2150  break;
2151 
2152 
2153 
2154 /* Line 1455 of yacc.c */
2155 #line 2156 "query_parser_bison.tab.c"
2156  default: break;
2157  }
2158  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2159 
2160  YYPOPSTACK (yylen);
2161  yylen = 0;
2162  YY_STACK_PRINT (yyss, yyssp);
2163 
2164  *++yyvsp = yyval;
2165 
2166  /* Now `shift' the result of the reduction. Determine what state
2167  that goes to, based on the state we popped back to and the rule
2168  number reduced by. */
2169 
2170  yyn = yyr1[yyn];
2171 
2172  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2173  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2174  yystate = yytable[yystate];
2175  else
2176  yystate = yydefgoto[yyn - YYNTOKENS];
2177 
2178  goto yynewstate;
2179 
2180 
2181 /*------------------------------------.
2182 | yyerrlab -- here on detecting error |
2183 `------------------------------------*/
2184 yyerrlab:
2185  /* If not already recovering from an error, report this error. */
2186  if (!yyerrstatus)
2187  {
2188  ++yynerrs;
2189 #if ! YYERROR_VERBOSE
2190  yyerror (YY_("syntax error"));
2191 #else
2192  {
2193  YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
2194  if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
2195  {
2196  YYSIZE_T yyalloc = 2 * yysize;
2197  if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
2199  if (yymsg != yymsgbuf)
2200  YYSTACK_FREE (yymsg);
2201  yymsg = (char *) YYSTACK_ALLOC (yyalloc);
2202  if (yymsg)
2203  yymsg_alloc = yyalloc;
2204  else
2205  {
2206  yymsg = yymsgbuf;
2207  yymsg_alloc = sizeof yymsgbuf;
2208  }
2209  }
2210 
2211  if (0 < yysize && yysize <= yymsg_alloc)
2212  {
2213  (void) yysyntax_error (yymsg, yystate, yychar);
2214  yyerror (yymsg);
2215  }
2216  else
2217  {
2218  yyerror (YY_("syntax error"));
2219  if (yysize != 0)
2220  goto yyexhaustedlab;
2221  }
2222  }
2223 #endif
2224  }
2225 
2226 
2227 
2228  if (yyerrstatus == 3)
2229  {
2230  /* If just tried and failed to reuse lookahead token after an
2231  error, discard it. */
2232 
2233  if (yychar <= YYEOF)
2234  {
2235  /* Return failure if at end of input. */
2236  if (yychar == YYEOF)
2237  YYABORT;
2238  }
2239  else
2240  {
2241  yydestruct ("Error: discarding",
2242  yytoken, &yylval);
2243  yychar = YYEMPTY;
2244  }
2245  }
2246 
2247  /* Else will try to reuse lookahead token after shifting the error
2248  token. */
2249  goto yyerrlab1;
2250 
2251 
2252 /*---------------------------------------------------.
2253 | yyerrorlab -- error raised explicitly by YYERROR. |
2254 `---------------------------------------------------*/
2255 yyerrorlab:
2256 
2257  /* Pacify compilers like GCC when the user code never invokes
2258  YYERROR and the label yyerrorlab therefore never appears in user
2259  code. */
2260  if (/*CONSTCOND*/ 0)
2261  goto yyerrorlab;
2262 
2263  /* Do not reclaim the symbols of the rule which action triggered
2264  this YYERROR. */
2265  YYPOPSTACK (yylen);
2266  yylen = 0;
2267  YY_STACK_PRINT (yyss, yyssp);
2268  yystate = *yyssp;
2269  goto yyerrlab1;
2270 
2271 
2272 /*-------------------------------------------------------------.
2273 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2274 `-------------------------------------------------------------*/
2275 yyerrlab1:
2276  yyerrstatus = 3; /* Each real token shifted decrements this. */
2277 
2278  for (;;)
2279  {
2280  yyn = yypact[yystate];
2281  if (yyn != YYPACT_NINF)
2282  {
2283  yyn += YYTERROR;
2284  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2285  {
2286  yyn = yytable[yyn];
2287  if (0 < yyn)
2288  break;
2289  }
2290  }
2291 
2292  /* Pop the current state because it cannot handle the error token. */
2293  if (yyssp == yyss)
2294  YYABORT;
2295 
2296 
2297  yydestruct ("Error: popping",
2298  yystos[yystate], yyvsp);
2299  YYPOPSTACK (1);
2300  yystate = *yyssp;
2301  YY_STACK_PRINT (yyss, yyssp);
2302  }
2303 
2304  *++yyvsp = yylval;
2305 
2306 
2307  /* Shift the error token. */
2308  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2309 
2310  yystate = yyn;
2311  goto yynewstate;
2312 
2313 
2314 /*-------------------------------------.
2315 | yyacceptlab -- YYACCEPT comes here. |
2316 `-------------------------------------*/
2317 yyacceptlab:
2318  yyresult = 0;
2319  goto yyreturn;
2320 
2321 /*-----------------------------------.
2322 | yyabortlab -- YYABORT comes here. |
2323 `-----------------------------------*/
2324 yyabortlab:
2325  yyresult = 1;
2326  goto yyreturn;
2327 
2328 #if !defined(yyoverflow) || YYERROR_VERBOSE
2329 /*-------------------------------------------------.
2330 | yyexhaustedlab -- memory exhaustion comes here. |
2331 `-------------------------------------------------*/
2332 yyexhaustedlab:
2333  yyerror (YY_("memory exhausted"));
2334  yyresult = 2;
2335  /* Fall through. */
2336 #endif
2337 
2338 yyreturn:
2339  if (yychar != YYEMPTY)
2340  yydestruct ("Cleanup: discarding lookahead",
2341  yytoken, &yylval);
2342  /* Do not reclaim the symbols of the rule which action triggered
2343  this YYABORT or YYACCEPT. */
2344  YYPOPSTACK (yylen);
2345  YY_STACK_PRINT (yyss, yyssp);
2346  while (yyssp != yyss)
2347  {
2348  yydestruct ("Cleanup: popping",
2349  yystos[*yyssp], yyvsp);
2350  YYPOPSTACK (1);
2351  }
2352 #ifndef yyoverflow
2353  if (yyss != yyssa)
2354  YYSTACK_FREE (yyss);
2355 #endif
2356 #if YYERROR_VERBOSE
2357  if (yymsg != yymsgbuf)
2358  YYSTACK_FREE (yymsg);
2359 #endif
2360  /* Make sure YYID is used. */
2361  return YYID (yyresult);
2362 }
2363 
2364 
2365 
2366 /* Line 1675 of yacc.c */
2367 #line 554 "query_parser_bison.y"
2368 
2369 
2370 
Query parser exceptions.
Class passed to Lex/Bison (yylex/yyparse) functions.
Definition: parser.cpp:94
definition of a Culling tree
Definition: ncbi_tree.hpp:100
static HENV env
Definition: transaction2.c:38
#define NCBI_THROW(exception_class, err_code, message)
Generic macro to throw an exception, given the exception class, error code and message string.
Definition: ncbiexpt.hpp:704
@ eSyntaxCheck
Best possible check for errors.
TNodeList_CI SubNodeBegin(void) const
Return first const iterator on subnode list.
Definition: ncbi_tree.hpp:160
void AddNode(TTreeType *subnode)
Add new subnode.
Definition: ncbi_tree.hpp:743
void InsertNode(TNodeList_I it, TTreeType *subnode)
Insert new subnode before the specified location in the subnode list.
Definition: ncbi_tree.hpp:773
yytokentype
Definition: newick.tab.cpp:66
YYSTYPE * yyvaluep
Definition: newick.tab.cpp:731
unsigned short int yytype_uint16
#define YYID(n)
static const yytype_uint8 yyr1[]
#define YYLEX
#define YYMAXDEPTH
#define YYSTACK_FREE
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
#define yyerrok
#define YYPARSE_PARAM
static void yy_stack_print(yytype_int16 *yybottom, yytype_int16 *yytop)
#define YYSTYPE
#define yychar
static const yytype_uint8 yytranslate[]
#define YYEOF
#define YYABORT
#define YYSTACK_BYTES(N)
static const yytype_int8 yycheck[]
static unsigned int yytnamerr(char *yyres, const char *yystr)
static void yy_symbol_value_print(FILE *yyoutput, int yytype, CQueryParseTree::TNode *const *const yyvaluep)
#define YY_REDUCE_PRINT(Rule)
static void AddIn_Arg(void *parm, CQueryParseTree::TNode *node)
#define YYTABLE_NINF
static const yytype_int16 yypact[]
#define YYPACT_NINF
#define YYFINAL
static const yytype_uint16 yyrline[]
static void AddFunc_Arg(void *parm, CQueryParseTree::TNode *node)
Add node to a list if parser environment is in the list parsing context.
#define yyparse
#define yylval
#define YYNTOKENS
unsigned char yytype_uint8
static char * yystpcpy(char *yydest, const char *yysrc)
#define YY_STACK_PRINT(Bottom, Top)
#define YYSIZE_T
#define YYSTACK_ALLOC_MAXIMUM
#define yydebug
static void QTreeAddNode(void *parm, CQueryParseTree::TNode *rnode, CQueryParseTree::TNode *node1, CQueryParseTree::TNode *node2)
Add child node(s) to the parent.
#define YY_(msgid)
static const yytype_int8 yytable[]
#define yynerrs
static unsigned int yysyntax_error(char *yyresult, int yystate, int ncbi_q_char)
static unsigned int yystrlen(char *yystr) const
static const yytype_uint8 yyr2[]
#define YYACCEPT
static void yy_reduce_print(CQueryParseTree::TNode **yyvsp, int yyrule)
#define YYTRANSLATE(YYX)
static const yytype_int8 yyrhs[]
#define YYSIZE_MAXIMUM
static const yytype_uint8 yyprhs[]
static const char *const yytname[]
static const yytype_int8 yypgoto[]
static const yytype_uint8 yystos[]
static void yydestruct(char *yymsg, int yytype, CQueryParseTree::TNode **yyvaluep) const
#define YYTERROR
#define YYPOPSTACK(N)
#define YYUSE(e)
static const yytype_int8 yydefgoto[]
short int yytype_int16
#define YYEMPTY
#define YYLAST
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
#define YYINITDEPTH
#define YYFPRINTF
#define YYSTACK_ALLOC
#define YYDPRINTF(Args)
static const yytype_uint8 yydefact[]
static void yy_symbol_print(FILE *yyoutput, int yytype, CQueryParseTree::TNode *const *const yyvaluep)
#define yyerror
short int yytype_int8
static void AddNode(TaxonomyTreeMap *taxTree, const Sequence *seq, int taxid, const CTaxon2_data *taxData, int parent)
short yyss
Definition: newick.tab.cpp:208
yytype_int16 yyss_alloc
YYSTYPE yyvs
Definition: newick.tab.cpp:209
CQueryParseTree::TNode * yyvs_alloc
void free(voidpf ptr)
voidp malloc(uInt size)
Modified on Sat Apr 13 11:47:05 2024 by modify_doxy.py rev. 669887